From 7465a649c366340ede042d936598343e21799f85 Mon Sep 17 00:00:00 2001 From: Lorenz Meier Date: Sun, 6 Sep 2015 12:07:10 +0200 Subject: [PATCH] STM32 driver: Fix code style --- src/drivers/stm32/adc/adc.cpp | 50 +++-- src/drivers/stm32/drv_hrt.c | 42 +++-- src/drivers/stm32/drv_pwm_servo.c | 40 ++-- src/drivers/stm32/tone_alarm/tone_alarm.cpp | 199 ++++++++++++++------ 4 files changed, 230 insertions(+), 101 deletions(-) diff --git a/src/drivers/stm32/adc/adc.cpp b/src/drivers/stm32/adc/adc.cpp index a6be9d5c24..ab458895a6 100644 --- a/src/drivers/stm32/adc/adc.cpp +++ b/src/drivers/stm32/adc/adc.cpp @@ -115,7 +115,7 @@ protected: private: static const hrt_abstime _tickrate = 10000; /**< 100Hz base rate */ - + hrt_call _call; perf_counter_t _sample_perf; @@ -161,11 +161,13 @@ ADC::ADC(uint32_t channels) : _channel_count++; } } + _samples = new adc_msg_s[_channel_count]; /* prefill the channel numbers in the sample array */ if (_samples != nullptr) { unsigned index = 0; + for (unsigned i = 0; i < 32; i++) { if (channels & (1 << i)) { _samples[index].am_channel = i; @@ -178,8 +180,9 @@ ADC::ADC(uint32_t channels) : ADC::~ADC() { - if (_samples != nullptr) + if (_samples != nullptr) { delete _samples; + } } int @@ -189,8 +192,11 @@ ADC::init() #ifdef ADC_CR2_CAL rCR2 |= ADC_CR2_CAL; usleep(100); - if (rCR2 & ADC_CR2_CAL) + + if (rCR2 & ADC_CR2_CAL) { return -1; + } + #endif /* arbitrarily configure all channels for 55 cycle sample time */ @@ -201,7 +207,7 @@ ADC::init() rCR1 = 0; /* enable the temperature sensor / Vrefint channel if supported*/ - rCR2 = + rCR2 = #ifdef ADC_CR2_TSVREFE /* enable the temperature sensor in CR2 */ ADC_CR2_TSVREFE | @@ -216,7 +222,7 @@ ADC::init() /* configure for a single-channel sequence */ rSQR1 = 0; rSQR2 = 0; - rSQR3 = 0; /* will be updated with the channel each tick */ + rSQR3 = 0; /* will be updated with the channel each tick */ /* power-cycle the ADC and turn it on */ rCR2 &= ~ADC_CR2_ADON; @@ -229,6 +235,7 @@ ADC::init() /* kick off a sample and wait for it to complete */ hrt_abstime now = hrt_absolute_time(); rCR2 |= ADC_CR2_SWSTART; + while (!(rSR & ADC_SR_EOC)) { /* don't wait for more than 500us, since that means something broke - should reset here if we see this */ @@ -256,8 +263,9 @@ ADC::read(file *filp, char *buffer, size_t len) { const size_t maxsize = sizeof(adc_msg_s) * _channel_count; - if (len > maxsize) + if (len > maxsize) { len = maxsize; + } /* block interrupts while copying samples to avoid racing with an update */ irqstate_t flags = irqsave(); @@ -296,8 +304,10 @@ void ADC::_tick() { /* scan the channel set and sample each */ - for (unsigned i = 0; i < _channel_count; i++) + for (unsigned i = 0; i < _channel_count; i++) { _samples[i].am_data = _sample(_samples[i].am_channel); + } + update_system_power(); } @@ -309,6 +319,7 @@ ADC::update_system_power(void) system_power.timestamp = hrt_absolute_time(); system_power.voltage5V_v = 0; + for (unsigned i = 0; i < _channel_count; i++) { if (_samples[i].am_channel == 4) { // it is 2:1 scaled @@ -331,9 +342,11 @@ ADC::update_system_power(void) /* lazily publish */ if (_to_system_power != nullptr) { orb_publish(ORB_ID(system_power), _to_system_power, &system_power); + } else { _to_system_power = orb_advertise(ORB_ID(system_power), &system_power); } + #endif // CONFIG_ARCH_BOARD_PX4FMU_V2 } @@ -343,8 +356,9 @@ ADC::_sample(unsigned channel) perf_begin(_sample_perf); /* clear any previous EOC */ - if (rSR & ADC_SR_EOC) + if (rSR & ADC_SR_EOC) { rSR &= ~ADC_SR_EOC; + } /* run a single conversion right now - should take about 60 cycles (a few microseconds) max */ rSQR3 = channel; @@ -352,6 +366,7 @@ ADC::_sample(unsigned channel) /* wait for the conversion to complete */ hrt_abstime now = hrt_absolute_time(); + while (!(rSR & ADC_SR_EOC)) { /* don't wait for more than 50us, since that means something broke - should reset here if we see this */ @@ -382,20 +397,23 @@ test(void) { int fd = open(ADC0_DEVICE_PATH, O_RDONLY); - if (fd < 0) + + if (fd < 0) { err(1, "can't open ADC device"); + } for (unsigned i = 0; i < 50; i++) { adc_msg_s data[12]; ssize_t count = read(fd, data, sizeof(data)); - if (count < 0) + if (count < 0) { errx(1, "read error"); + } unsigned channels = count / sizeof(data[0]); for (unsigned j = 0; j < channels; j++) { - printf ("%d: %u ", data[j].am_channel, data[j].am_data); + printf("%d: %u ", data[j].am_channel, data[j].am_data); } printf("\n"); @@ -410,11 +428,12 @@ int adc_main(int argc, char *argv[]) { if (g_adc == nullptr) { - /* XXX this hardcodes the default channel set for the board in board_config.h - should be configurable */ - g_adc = new ADC(ADC_CHANNELS); + /* XXX this hardcodes the default channel set for the board in board_config.h - should be configurable */ + g_adc = new ADC(ADC_CHANNELS); - if (g_adc == nullptr) + if (g_adc == nullptr) { errx(1, "couldn't allocate the ADC driver"); + } if (g_adc->init() != OK) { delete g_adc; @@ -423,8 +442,9 @@ adc_main(int argc, char *argv[]) } if (argc > 1) { - if (!strcmp(argv[1], "test")) + if (!strcmp(argv[1], "test")) { test(); + } } exit(0); diff --git a/src/drivers/stm32/drv_hrt.c b/src/drivers/stm32/drv_hrt.c index 74c81b7a0e..ba148c1335 100644 --- a/src/drivers/stm32/drv_hrt.c +++ b/src/drivers/stm32/drv_hrt.c @@ -455,8 +455,9 @@ hrt_ppm_decode(uint32_t status) unsigned i; /* if we missed an edge, we have to give up */ - if (status & SR_OVF_PPM) + if (status & SR_OVF_PPM) { goto error; + } /* how long since the last edge? - this handles counter wrapping implicitely. */ width = count - ppm.last_edge; @@ -464,8 +465,10 @@ hrt_ppm_decode(uint32_t status) #if PPM_DEBUG ppm_edge_history[ppm_edge_next++] = width; - if (ppm_edge_next >= 32) + if (ppm_edge_next >= 32) { ppm_edge_next = 0; + } + #endif /* @@ -501,8 +504,9 @@ hrt_ppm_decode(uint32_t status) } else { /* frame channel count matches expected, let's use it */ if (ppm.next_channel > PPM_MIN_CHANNELS) { - for (i = 0; i < ppm.next_channel; i++) + for (i = 0; i < ppm.next_channel; i++) { ppm_buffer[i] = ppm_temp_buffer[i]; + } ppm_last_valid_decode = hrt_absolute_time(); @@ -527,8 +531,9 @@ hrt_ppm_decode(uint32_t status) case ARM: /* we expect a pulse giving us the first mark */ - if (width < PPM_MIN_PULSE_WIDTH || width > PPM_MAX_PULSE_WIDTH) - goto error; /* pulse was too short or too long */ + if (width < PPM_MIN_PULSE_WIDTH || width > PPM_MAX_PULSE_WIDTH) { + goto error; /* pulse was too short or too long */ + } /* record the mark timing, expect an inactive edge */ ppm.last_mark = ppm.last_edge; @@ -542,8 +547,9 @@ hrt_ppm_decode(uint32_t status) case INACTIVE: /* we expect a short pulse */ - if (width < PPM_MIN_PULSE_WIDTH || width > PPM_MAX_PULSE_WIDTH) - goto error; /* pulse was too short or too long */ + if (width < PPM_MIN_PULSE_WIDTH || width > PPM_MAX_PULSE_WIDTH) { + goto error; /* pulse was too short or too long */ + } /* this edge is not interesting, but now we are ready for the next mark */ ppm.phase = ACTIVE; @@ -557,17 +563,21 @@ hrt_ppm_decode(uint32_t status) #if PPM_DEBUG ppm_pulse_history[ppm_pulse_next++] = interval; - if (ppm_pulse_next >= 32) + if (ppm_pulse_next >= 32) { ppm_pulse_next = 0; + } + #endif /* if the mark-mark timing is out of bounds, abandon the frame */ - if ((interval < PPM_MIN_CHANNEL_VALUE) || (interval > PPM_MAX_CHANNEL_VALUE)) + if ((interval < PPM_MIN_CHANNEL_VALUE) || (interval > PPM_MAX_CHANNEL_VALUE)) { goto error; + } /* if we have room to store the value, do so */ - if (ppm.next_channel < PPM_MAX_CHANNELS) + if (ppm.next_channel < PPM_MAX_CHANNELS) { ppm_temp_buffer[ppm.next_channel++] = interval; + } ppm.phase = INACTIVE; break; @@ -668,8 +678,9 @@ hrt_absolute_time(void) * This simple test is sufficient due to the guarantee that * we are always called at least once per counter period. */ - if (count < last_count) + if (count < last_count) { base_time += HRT_COUNTER_PERIOD; + } /* save the count for next time */ last_count = count; @@ -800,8 +811,9 @@ hrt_call_internal(struct hrt_call *entry, hrt_abstime deadline, hrt_abstime inte queue for the uninitialised entry->link but we don't do anything actually unsafe. */ - if (entry->deadline != 0) + if (entry->deadline != 0) { sq_rem(&entry->link, &callout_queue); + } entry->deadline = deadline; entry->period = interval; @@ -883,11 +895,13 @@ hrt_call_invoke(void) call = (struct hrt_call *)sq_peek(&callout_queue); - if (call == NULL) + if (call == NULL) { break; + } - if (call->deadline > now) + if (call->deadline > now) { break; + } sq_rem(&call->link, &callout_queue); //lldbg("call pop\n"); diff --git a/src/drivers/stm32/drv_pwm_servo.c b/src/drivers/stm32/drv_pwm_servo.c index 77f5387749..3a24f19922 100644 --- a/src/drivers/stm32/drv_pwm_servo.c +++ b/src/drivers/stm32/drv_pwm_servo.c @@ -174,19 +174,22 @@ pwm_channel_init(unsigned channel) int up_pwm_servo_set(unsigned channel, servo_position_t value) { - if (channel >= PWM_SERVO_MAX_CHANNELS) + if (channel >= PWM_SERVO_MAX_CHANNELS) { return -1; + } unsigned timer = pwm_channels[channel].timer_index; /* test timer for validity */ if ((pwm_timers[timer].base == 0) || - (pwm_channels[channel].gpio == 0)) + (pwm_channels[channel].gpio == 0)) { return -1; + } /* configure the channel */ - if (value > 0) + if (value > 0) { value--; + } switch (pwm_channels[channel].timer_channel) { case 1: @@ -215,16 +218,18 @@ up_pwm_servo_set(unsigned channel, servo_position_t value) servo_position_t up_pwm_servo_get(unsigned channel) { - if (channel >= PWM_SERVO_MAX_CHANNELS) + if (channel >= PWM_SERVO_MAX_CHANNELS) { return 0; + } unsigned timer = pwm_channels[channel].timer_index; servo_position_t value = 0; /* test timer for validity */ if ((pwm_timers[timer].base == 0) || - (pwm_channels[channel].timer_channel == 0)) + (pwm_channels[channel].timer_channel == 0)) { return 0; + } /* configure the channel */ switch (pwm_channels[channel].timer_channel) { @@ -253,15 +258,17 @@ up_pwm_servo_init(uint32_t channel_mask) { /* do basic timer initialisation first */ for (unsigned i = 0; i < PWM_SERVO_MAX_TIMERS; i++) { - if (pwm_timers[i].base != 0) + if (pwm_timers[i].base != 0) { pwm_timer_init(i); + } } /* now init channels */ for (unsigned i = 0; i < PWM_SERVO_MAX_CHANNELS; i++) { /* don't do init for disabled channels; this leaves the pin configs alone */ - if (((1 << i) & channel_mask) && (pwm_channels[i].timer_channel != 0)) + if (((1 << i) & channel_mask) && (pwm_channels[i].timer_channel != 0)) { pwm_channel_init(i); + } } return OK; @@ -278,13 +285,17 @@ int up_pwm_servo_set_rate_group_update(unsigned group, unsigned rate) { /* limit update rate to 1..10000Hz; somewhat arbitrary but safe */ - if (rate < 1) - return -ERANGE; - if (rate > 10000) + if (rate < 1) { return -ERANGE; + } - if ((group >= PWM_SERVO_MAX_TIMERS) || (pwm_timers[group].base == 0)) + if (rate > 10000) { + return -ERANGE; + } + + if ((group >= PWM_SERVO_MAX_TIMERS) || (pwm_timers[group].base == 0)) { return ERROR; + } pwm_timer_set_rate(group, rate); @@ -294,8 +305,9 @@ up_pwm_servo_set_rate_group_update(unsigned group, unsigned rate) int up_pwm_servo_set_rate(unsigned rate) { - for (unsigned i = 0; i < PWM_SERVO_MAX_TIMERS; i++) + for (unsigned i = 0; i < PWM_SERVO_MAX_TIMERS; i++) { up_pwm_servo_set_rate_group_update(i, rate); + } return 0; } @@ -306,9 +318,11 @@ up_pwm_servo_get_rate_group(unsigned group) unsigned channels = 0; for (unsigned i = 0; i < PWM_SERVO_MAX_CHANNELS; i++) { - if ((pwm_channels[i].gpio != 0) && (pwm_channels[i].timer_index == group)) + if ((pwm_channels[i].gpio != 0) && (pwm_channels[i].timer_index == group)) { channels |= (1 << i); + } } + return channels; } diff --git a/src/drivers/stm32/tone_alarm/tone_alarm.cpp b/src/drivers/stm32/tone_alarm/tone_alarm.cpp index 4db2b06d5d..55b36f8bb4 100644 --- a/src/drivers/stm32/tone_alarm/tone_alarm.cpp +++ b/src/drivers/stm32/tone_alarm/tone_alarm.cpp @@ -47,16 +47,16 @@ * From Wikibooks: * * PLAY "[string expression]" - * + * * Used to play notes and a score ... The tones are indicated by letters A through G. - * Accidentals are indicated with a "+" or "#" (for sharp) or "-" (for flat) + * Accidentals are indicated with a "+" or "#" (for sharp) or "-" (for flat) * immediately after the note letter. See this example: - * + * * PLAY "C C# C C#" * * Whitespaces are ignored inside the string expression. There are also codes that - * set the duration, octave and tempo. They are all case-insensitive. PLAY executes - * the commands or notes the order in which they appear in the string. Any indicators + * set the duration, octave and tempo. They are all case-insensitive. PLAY executes + * the commands or notes the order in which they appear in the string. Any indicators * that change the properties are effective for the notes following that indicator. * * Ln Sets the duration (length) of the notes. The variable n does not indicate an actual duration @@ -66,15 +66,15 @@ * The shorthand notation of length is also provided for a note. For example, "L4 CDE L8 FG L4 AB" * can be shortened to "L4 CDE F8G8 AB". F and G play as eighth notes while others play as quarter notes. * On Sets the current octave. Valid values for n are 0 through 6. An octave begins with C and ends with B. - * Remember that C- is equivalent to B. + * Remember that C- is equivalent to B. * < > Changes the current octave respectively down or up one level. * Nn Plays a specified note in the seven-octave range. Valid values are from 0 to 84. (0 is a pause.) * Cannot use with sharp and flat. Cannot use with the shorthand notation neither. * MN Stand for Music Normal. Note duration is 7/8ths of the length indicated by Ln. It is the default mode. * ML Stand for Music Legato. Note duration is full length of that indicated by Ln. * MS Stand for Music Staccato. Note duration is 3/4ths of the length indicated by Ln. - * Pn Causes a silence (pause) for the length of note indicated (same as Ln). - * Tn Sets the number of "L4"s per minute (tempo). Valid values are from 32 to 255. The default value is T120. + * Pn Causes a silence (pause) for the length of note indicated (same as Ln). + * Tn Sets the number of "L4"s per minute (tempo). Valid values are from 32 to 255. The default value is T120. * . When placed after a note, it causes the duration of the note to be 3/2 of the set duration. * This is how to get "dotted" notes. "L4 C#." would play C sharp as a dotted quarter note. * It can be used for a pause as well. @@ -283,14 +283,15 @@ public: virtual int ioctl(file *filp, int cmd, unsigned long arg); virtual ssize_t write(file *filp, const char *buffer, size_t len); - inline const char *name(int tune) { + inline const char *name(int tune) + { return _tune_names[tune]; } private: static const unsigned _tune_max = 1024 * 8; // be reasonable about user tunes - const char * _default_tunes[TONE_NUMBER_OF_TUNES]; - const char * _tune_names[TONE_NUMBER_OF_TUNES]; + const char *_default_tunes[TONE_NUMBER_OF_TUNES]; + const char *_tune_names[TONE_NUMBER_OF_TUNES]; static const uint8_t _note_tab[]; unsigned _default_tune_number; // number of currently playing default tune (0 for none) @@ -314,8 +315,8 @@ private: // unsigned note_to_divisor(unsigned note); - // Calculate the duration in microseconds of play and silence for a - // note given the current tempo, length and mode and the number of + // Calculate the duration in microseconds of play and silence for a + // note given the current tempo, length and mode and the number of // dots following in the play string. // unsigned note_duration(unsigned &silence, unsigned note_length, unsigned dots); @@ -422,14 +423,15 @@ ToneAlarm::init() ret = CDev::init(); - if (ret != OK) + if (ret != OK) { return ret; + } /* configure the GPIO to the idle state */ stm32_configgpio(GPIO_TONE_ALARM_IDLE); /* clock/power on our timer */ - modifyreg32(TONE_ALARM_CLOCK_POWER_REG, 0, TONE_ALARM_CLOCK_ENABLE); + modifyreg32(TONE_ALARM_CLOCK_POWER_REG, 0, TONE_ALARM_CLOCK_ENABLE); /* initialise the timer */ rCR1 = 0; @@ -443,7 +445,7 @@ ToneAlarm::init() rDCR = 0; #ifdef rBDTR // If using an advanced timer, you need to activate the output - rBDTR = ATIM_BDTR_MOE; // enable the main output of the advanced timer + rBDTR = ATIM_BDTR_MOE; // enable the main output of the advanced timer #endif /* toggle the CC output each time the count passes 1 */ @@ -478,25 +480,31 @@ ToneAlarm::note_duration(unsigned &silence, unsigned note_length, unsigned dots) { unsigned whole_note_period = (60 * 1000000 * 4) / _tempo; - if (note_length == 0) + if (note_length == 0) { note_length = 1; + } + unsigned note_period = whole_note_period / note_length; switch (_note_mode) { case MODE_NORMAL: silence = note_period / 8; break; + case MODE_STACCATO: silence = note_period / 4; break; + default: case MODE_LEGATO: silence = 0; break; } + note_period -= silence; unsigned dot_extension = note_period / 2; + while (dots--) { note_period += dot_extension; dot_extension /= 2; @@ -510,12 +518,14 @@ ToneAlarm::rest_duration(unsigned rest_length, unsigned dots) { unsigned whole_note_period = (60 * 1000000 * 4) / _tempo; - if (rest_length == 0) + if (rest_length == 0) { rest_length = 1; + } unsigned rest_period = whole_note_period / rest_length; unsigned dot_extension = rest_period / 2; + while (dots--) { rest_period += dot_extension; dot_extension /= 2; @@ -605,115 +615,155 @@ ToneAlarm::next_note() while (note == 0) { // we always need at least one character from the string int c = next_char(); - if (c == 0) + + if (c == 0) { goto tune_end; + } + _next++; switch (c) { case 'L': // select note length _note_length = next_number(); - if (_note_length < 1) + + if (_note_length < 1) { goto tune_error; + } + break; case 'O': // select octave _octave = next_number(); - if (_octave > 6) + + if (_octave > 6) { _octave = 6; + } + break; case '<': // decrease octave - if (_octave > 0) + if (_octave > 0) { _octave--; + } + break; case '>': // increase octave - if (_octave < 6) + if (_octave < 6) { _octave++; + } + break; case 'M': // select inter-note gap c = next_char(); - if (c == 0) + + if (c == 0) { goto tune_error; + } + _next++; + switch (c) { case 'N': _note_mode = MODE_NORMAL; break; + case 'L': _note_mode = MODE_LEGATO; break; + case 'S': _note_mode = MODE_STACCATO; break; + case 'F': _repeat = false; break; + case 'B': _repeat = true; break; + default: goto tune_error; } + break; case 'P': // pause for a note length stop_note(); - hrt_call_after(&_note_call, - (hrt_abstime)rest_duration(next_number(), next_dots()), - (hrt_callout)next_trampoline, - this); + hrt_call_after(&_note_call, + (hrt_abstime)rest_duration(next_number(), next_dots()), + (hrt_callout)next_trampoline, + this); return; case 'T': { // change tempo - unsigned nt = next_number(); + unsigned nt = next_number(); - if ((nt >= 32) && (nt <= 255)) { - _tempo = nt; - } else { - goto tune_error; + if ((nt >= 32) && (nt <= 255)) { + _tempo = nt; + + } else { + goto tune_error; + } + + break; } - break; - } case 'N': // play an arbitrary note note = next_number(); - if (note > 84) + + if (note > 84) { goto tune_error; + } + if (note == 0) { // this is a rest - pause for the current note length hrt_call_after(&_note_call, - (hrt_abstime)rest_duration(_note_length, next_dots()), - (hrt_callout)next_trampoline, - this); - return; + (hrt_abstime)rest_duration(_note_length, next_dots()), + (hrt_callout)next_trampoline, + this); + return; } + break; case 'A'...'G': // play a note in the current octave note = _note_tab[c - 'A'] + (_octave * 12) + 1; c = next_char(); + switch (c) { case '#': // up a semitone case '+': - if (note < 84) + if (note < 84) { note++; + } + _next++; break; + case '-': // down a semitone - if (note > 1) + if (note > 1) { note--; + } + _next++; break; + default: // 0 / no next char here is OK break; } + // shorthand length notation note_length = next_number(); - if (note_length == 0) + + if (note_length == 0) { note_length = _note_length; + } + break; default: @@ -739,12 +789,15 @@ tune_error: // stop (and potentially restart) the tune tune_end: stop_note(); + if (_repeat) { start_tune(_tune); + } else { _tune = nullptr; _default_tune_number = 0; } + return; } @@ -754,6 +807,7 @@ ToneAlarm::next_char() while (isspace(*_next)) { _next++; } + return toupper(*_next); } @@ -765,8 +819,11 @@ ToneAlarm::next_number() for (;;) { c = next_char(); - if (!isdigit(c)) + + if (!isdigit(c)) { return number; + } + _next++; number = (number * 10) + (c - '0'); } @@ -781,6 +838,7 @@ ToneAlarm::next_dots() _next++; dots++; } + return dots; } @@ -814,6 +872,7 @@ ToneAlarm::ioctl(file *filp, int cmd, unsigned long arg) _next = nullptr; _repeat = false; _default_tune_number = 0; + } else { /* always interrupt alarms, unless they are repeating and already playing */ if (!(_repeat && _default_tune_number == arg)) { @@ -822,6 +881,7 @@ ToneAlarm::ioctl(file *filp, int cmd, unsigned long arg) start_tune(_default_tunes[arg]); } } + } else { result = -EINVAL; } @@ -836,8 +896,9 @@ ToneAlarm::ioctl(file *filp, int cmd, unsigned long arg) // irqrestore(flags); /* give it to the superclass if we didn't like it */ - if (result == -ENOTTY) + if (result == -ENOTTY) { result = CDev::ioctl(filp, cmd, arg); + } return result; } @@ -846,8 +907,9 @@ int ToneAlarm::write(file *filp, const char *buffer, size_t len) { // sanity-check the buffer for length and nul-termination - if (len > _tune_max) + if (len > _tune_max) { return -EFBIG; + } // if we have an existing user tune, free it if (_user_tune != nullptr) { @@ -864,13 +926,16 @@ ToneAlarm::write(file *filp, const char *buffer, size_t len) } // if the new tune is empty, we're done - if (buffer[0] == '\0') + if (buffer[0] == '\0') { return OK; + } // allocate a copy of the new tune _user_tune = strndup(buffer, len); - if (_user_tune == nullptr) + + if (_user_tune == nullptr) { return -ENOMEM; + } // and play it start_tune(_user_tune); @@ -893,14 +958,16 @@ play_tune(unsigned tune) fd = open(TONEALARM0_DEVICE_PATH, 0); - if (fd < 0) + if (fd < 0) { err(1, TONEALARM0_DEVICE_PATH); + } ret = ioctl(fd, TONE_SET_ALARM, tune); close(fd); - if (ret != 0) + if (ret != 0) { err(1, "TONE_SET_ALARM"); + } exit(0); } @@ -912,17 +979,21 @@ play_string(const char *str, bool free_buffer) fd = open(TONEALARM0_DEVICE_PATH, O_WRONLY); - if (fd < 0) + if (fd < 0) { err(1, TONEALARM0_DEVICE_PATH); + } ret = write(fd, str, strlen(str) + 1); close(fd); - if (free_buffer) + if (free_buffer) { free((void *)str); + } - if (ret < 0) + if (ret < 0) { err(1, "play tune"); + } + exit(0); } @@ -937,8 +1008,9 @@ tone_alarm_main(int argc, char *argv[]) if (g_dev == nullptr) { g_dev = new ToneAlarm; - if (g_dev == nullptr) + if (g_dev == nullptr) { errx(1, "couldn't allocate the ToneAlarm driver"); + } if (g_dev->init() != OK) { delete g_dev; @@ -953,30 +1025,39 @@ tone_alarm_main(int argc, char *argv[]) play_tune(TONE_STOP_TUNE); } - if (!strcmp(argv1, "stop")) + if (!strcmp(argv1, "stop")) { play_tune(TONE_STOP_TUNE); + } - if ((tune = strtol(argv1, nullptr, 10)) != 0) + if ((tune = strtol(argv1, nullptr, 10)) != 0) { play_tune(tune); + } /* It might be a tune name */ for (tune = 1; tune < TONE_NUMBER_OF_TUNES; tune++) - if (!strcmp(g_dev->name(tune), argv1)) + if (!strcmp(g_dev->name(tune), argv1)) { play_tune(tune); + } /* If it is a file name then load and play it as a string */ if (*argv1 == '/') { FILE *fd = fopen(argv1, "r"); int sz; char *buffer; - if (fd == nullptr) + + if (fd == nullptr) { errx(1, "couldn't open '%s'", argv1); + } + fseek(fd, 0, SEEK_END); sz = ftell(fd); fseek(fd, 0, SEEK_SET); buffer = (char *)malloc(sz + 1); - if (buffer == nullptr) + + if (buffer == nullptr) { errx(1, "not enough memory memory"); + } + fread(buffer, sz, 1, fd); /* terminate the string */ buffer[sz] = 0;