Subtle improvements to C coding style

Mostly to address cppcheck's variableScope
Patches limited to soc/picorv32 board_support/marble_soc board_support/zest_soc

Author: ldoolitt

board_support/marble_soc/firmware/marble.c

@@ -142,8 +142,8 @@ bool get_ina219_data(uint8_t i2c_addr, t_ina219_data *data) {
     bool ret = true;
     uint16_t regs[4];
 
-    for (size_t i=1; i<5; i++) {
-        ret &= i2c_read_word(i2c_addr, i, regs+i-1);
+    for (unsigned int i=0; i<4; i++) {
+        ret &= i2c_read_word(i2c_addr, i+1U, regs+i);
     }
     data->vshunt_uV = (int16_t)regs[0] * 10;
     data->vbus_mV = (regs[1] >> 3) * 4;
@@ -163,7 +163,7 @@ void print_xadc_data(uint16_t *data, uint8_t *chans, size_t len) {
     uint16_t scale=1;
     const char * name = "Temp   ";
     const char * unit = " V";
-    for (size_t i=0; i<len; i++) {
+    for (unsigned int i=0; i<len; i++) {
         print_str("XADC   ");
         switch (chans[i]) {
             case XADC_CHAN_TEMP:
@@ -188,7 +188,7 @@ void print_xadc_data(uint16_t *data, uint8_t *chans, size_t len) {
                 unit = " V";
                 break;
             default:
-                printf("  XADC chan %d: %#x\n", i, data[i]);
+                printf("  XADC chan %u: %#x\n", i, data[i]);
         }
         printf("%8s:", name);
         print_dec_fix( data[i]*scale, 12, 2 );
@@ -221,14 +221,14 @@ void print_marble_status(void) {
     get_pca9555_data(I2C_ADR_PCA9555_SFP, &pca9555[0]);
     get_pca9555_data(I2C_ADR_PCA9555_MISC, &pca9555[1]);
 
-    for (size_t i=0; i<2; i++) {
-        printf("INA219 FMC%1d:\n", i+1);
+    for (unsigned int i=0; i<2; i++) {
+        printf("INA219 FMC%1u:\n", i+1U);
         // printf("Vshunt:  %6d uV\n", ina219[i].vshunt_uV);
         printf("power:   %6d mW\n", ina219[i].power_uW / 1000);
         printf("Vbus:    %6d mV\n", ina219[i].vbus_mV);
         printf("current: %6d mA\n", ina219[i].curr_uA / 1000);
 
-        printf("PCA9555 %1d:\n", i+1);
+        printf("PCA9555 %1u:\n", i+1U);
         printf("P0:      %#09b\n", pca9555[i].p0_val);
         printf("P1:      %#09b\n", pca9555[i].p1_val);
     }

board_support/zest_soc/firmware/pn9.c

@@ -13,12 +13,11 @@ int main(int argc, char* argv[]) {
     // uint16_t start = 0x0a9; // step 1617
     // uint16_t p = 0x3e6c;    // step 1617
     uint16_t sr = start;
-    uint8_t newbit;
     for (int i = 1; i <= 512*16; i++) {
         printf("XXX Step=%4d, 16bit: %#06x, state: %#06x\n", i, p, sr);
         p = ((p << 1) | ((sr>>8) & 1)); // shift to parallel
         if (i % 16 == 0) printf("Step=%4d, 16bit: %#06x, state: %#06x\n", i, p, sr);
-        newbit = (((sr >> 8) ^ (sr >> 4)) & 1);
+        uint8_t newbit = (((sr >> 8) ^ (sr >> 4)) & 1);
         sr = ((sr << 1) | newbit) & 0x1ff;
         if (sr == start) printf("PRBS repeats at %d\n", i);
     }

board_support/zest_soc/firmware/zest.c

@@ -88,11 +88,10 @@ void gen_prbs9(uint16_t *buf, size_t len) {
     uint16_t p = 0xce17;
     uint16_t start = 0x016c;
     uint16_t sr = start;
-    uint8_t newbit;
     for (size_t ix = 1; ix <= len*16; ix++) {
         p = ((p << 1) | ((sr>>8) & 1));
         if (ix % 16 == 0) buf[ix/16-1] = p; // store result
-        newbit = (((sr >> 8) ^ (sr >> 4)) & 1);
+        uint8_t newbit = (((sr >> 8) ^ (sr >> 4)) & 1);
         sr = ((sr << 1) | newbit) & 0x1ff;
     }
 }
@@ -116,17 +115,16 @@ bool get_ad9781_seek(void) {
 
 bool align_ad9781(uint8_t* exp_smp) {
     // datasheet page 26, allows multiple expected smp values
-    bool seek, seek_pre;
-    uint8_t smp=0, set=0, hld=0, smp_min=0;
-    uint8_t v_set, v_hld;
+    bool seek, seek_pre=0;
+    uint8_t smp=0, smp_min=0;
     int diff, diff_min=32;
     printf("  %s: AD9781 Alignment:\n", __func__);
     for (smp=0; smp<32; smp++) {
-        v_set = 15;
-        v_hld = 15;
+        uint8_t v_set = 15;
+        uint8_t v_hld = 15;
         set_ad9781_smp(smp);
         debug_printf(" SMP%3d HLD: ", smp);
-        for (hld=0; hld<16; hld++) {
+        for (uint8_t hld=0; hld<16; hld++) {
             set_ad9781_set_hld(0, hld);
             seek = get_ad9781_seek();
             if (hld > 0 && (seek_pre ^ seek)) v_hld = hld;
@@ -135,7 +133,7 @@ bool align_ad9781(uint8_t* exp_smp) {
         }
         debug_printf("%3d\n", v_hld);
         debug_printf("        SET: ");
-        for (set=0; set<16; set++) {
+        for (uint8_t set=0; set<16; set++) {
             set_ad9781_set_hld(set, 0);
             seek = get_ad9781_seek();
             if (set > 0 && (seek_pre ^ seek)) v_set = set;
@@ -400,12 +398,11 @@ void write_zest_regs(zest_dev_t dev, const t_reg32 *regmap, size_t len) {
 
 bool check_zest_regs(zest_dev_t dev, const zest_init_data_t *p_data) {
     bool pass = true;
-    uint32_t temp;
     size_t len = p_data->len;
     t_reg32 *regmap = p_data->regmap;
 
     while ( len-- > 0 ){
-        temp = read_zest_reg(dev, regmap->addr);
+        uint32_t temp = read_zest_reg(dev, regmap->addr);
         pass &= regmap->data == temp;
         debug_printf("SPI_Check: (%#06x, %#08x) %s\n",
                 regmap->addr, temp, pass? "PASS": "FAIL");
@@ -504,13 +501,12 @@ bool init_zest_adcs(uint32_t base, int8_t bitslip_want) {
     // IDELAY scan and ISERDES bitslip alignment process
     uint8_t idelay;
     int bitslips;
-    uint32_t ch_base;
     // 1010 0001 1001 1100, AD9653 DS Table 13, when 0xD=00001100
     uint8_t test_pat[] = {0x9c, 0xa1};  // bytewise
     // uint8_t test_pat[] = {0x16, 0xca};   // bitwise
 
     for (uint8_t chan=0; chan < 2*4; chan++) {
-        ch_base = base + (chan << 16);
+        uint32_t ch_base = base + (chan << 16);
         printf("  ADC %d \n", chan);
         iserdes_reset(ch_base);
 
@@ -548,14 +544,14 @@ void read_amc7823_adcs(void) {
     // ADC7: Volt = 3.3/2 V   regx*2.5
     // ADC8: Temp = 25  C   regx*2.6*0.61 - 273
     uint16_t adc_vals[9];
-    size_t ix;
+    unsigned int ix;
     for (ix=0; ix<9; ix++) {
         adc_vals[ix] = read_zest_reg(ZEST_DEV_AMC7823, ix);
     }
 
     printf("ZEST AMC7823 ADC:\n");
     for (ix=0; ix<9; ix++) {
-        printf("  ADC %d Val: %#06x", ix, adc_vals[ix]);
+        printf("  ADC %u Val: %#06x", ix, adc_vals[ix]);
         if (ix == 8) {
             // printf(" Temp: %.3f [C]\n", (adc_vals[ix] & 0xfff) * 2.6 * 0.61 - 273);
             printf(" Temp:");
@@ -572,7 +568,7 @@ void read_amc7823_adcs(void) {
 
 void read_ad7794_adcs(void) {
     uint32_t adc_vals[6];
-    size_t ix;
+    unsigned int ix;
     printf("ZEST AD7794 ADC:\n");
     for (ix=0; ix<6; ix++) {
         adc_vals[ix] = read_ad7794_channel(ix);
@@ -588,12 +584,11 @@ void dump_zest_adc_regs(void) {
      0x000, 0x001, 0x002, 0x005, 0x008, 0x009, 0x00b, 0x00c,
      0x00d, 0x010, 0x014, 0x015, 0x016, 0x018, 0x019, 0x01a,
      0x01b, 0x01c, 0x021, 0x022, 0x100, 0x101, 0x102, 0x109};
-    uint32_t temp;
 
     for (size_t ix=0; ix<2; ix++) {
         debug_printf("Dump ADC%d registers:\n", ix);
         for (size_t i=0; i<sizeof(addrs)/sizeof(addrs[0]); i++) {
-            temp = read_zest_reg(g_zest_adcs[ix], addrs[i]);
+            uint32_t temp = read_zest_reg(g_zest_adcs[ix], addrs[i]);
             debug_printf("  ADC Reg Dump: (%#06x, %#08x)\n", addrs[i], temp);
         }
     }
@@ -603,19 +598,18 @@ void dump_zest_dac_regs(void) {
     uint32_t addrs[] = {
         0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
         0x0f, 0x10, 0x11, 0x12, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
-    uint32_t temp;
 
     debug_printf("Dump DAC registers:\n");
     for (size_t i=0; i<sizeof(addrs)/sizeof(addrs[0]); i++) {
-        temp = read_zest_reg(ZEST_DEV_AD9781, addrs[i]);
+        uint32_t temp = read_zest_reg(ZEST_DEV_AD9781, addrs[i]);
         debug_printf("  DAC Reg Dump: (%#04x, %#08x)\n", addrs[i], temp);
     }
 }
 
 bool init_zest(uint32_t base, zest_init_t *init_data) {
     bool pass=true;
-    bool p = true;
-    size_t ix;
+    bool p=true;
+    unsigned int ix;
     select_zest_addr(base);
 
     zest_init_data_t *p_lmk01801_data = &(init_data->lmk01801_data);
@@ -697,7 +691,6 @@ bool init_zest(uint32_t base, zest_init_t *init_data) {
     //------------------------------
     // Align clk_div
     //------------------------------
-    p = true;
     for (ix=0; ix<2; ix++) {
         p = check_zest_freq(ix, fcnt_exp[ix]); pass &= p;
         printf("  Clock %s Freq Check: %s.\n",
@@ -735,7 +728,7 @@ bool check_adc_prbs9(void) {
     bool pass=true;
     uint16_t wfm_buf[16];
     uint16_t pn_buf[64];
-    size_t ix;
+    unsigned int ix;
 
     gen_prbs9(pn_buf, 64);
     for (ix=0; ix<64; ix++) {
@@ -756,7 +749,7 @@ bool check_adc_prbs9(void) {
             if (pn_buf[ix] == wfm_buf[0]) {
                 // See gen_prbs9() for starting point of 1504
                 // 1e3 / DSP_FREQ_MHZ / 8 is about 1.1 ns per bit
-                printf("  ADC %d: Found PN9 offset=%d\n", ch, ix+1504);
+                printf("  ADC %d: Found PN9 offset=%u\n", ch, ix+1504);
                 for (size_t iy=1; iy<8; iy++) {
                     pass &= pn_buf[ix+iy] == wfm_buf[iy];
                 }
@@ -781,8 +774,8 @@ void test_adc_pn9(uint8_t len) {
         trigger_waveform(g_base_wfm);
         printf("ADC chan %d waveform:\n", ch);
         read_adc_waveform(wfm_buf, len);
-        for (size_t ix=0; ix<len; ix++) {
-            printf("  ix %2d, dout: %#06x\n",ix, wfm_buf[ix]);
+        for (unsigned int ix=0; ix<len; ix++) {
+            printf("  ix %2u, dout: %#06x\n",ix, wfm_buf[ix]);
         }
     }
     write_zest_reg(ZEST_DEV_AD9653_BOTH, 0xd, 0x0);   // normal ADC

soc/picorv32/firmware/src/ad7193.c

@@ -41,11 +41,8 @@ uint32_t AD7193_GetDataContinuous() {
 }
 
 uint32_t * AD7193_GetDataContinuousArray() {
-    int ix;
-    uint32_t val;
-
-    for (ix = 0; ix < 8; ix++) {
-        val = AD7193_GetDataContinuous();
+    for (int ix = 0; ix < 8; ix++) {
+        uint32_t val = AD7193_GetDataContinuous();
         adcValues[val & 0xf] = val >> 8;
     };
     return adcValues;

soc/picorv32/firmware/src/iserdes.c

@@ -47,11 +47,9 @@ bool iserdes_center_idelay(uint32_t base, uint8_t pattern) {
 
 // return n_bitslip or -1 for failure
 int iserdes_align_bits(uint32_t base, uint8_t pattern) {
-    bool aligned=false;
-
-	iserdes_reset(base);
+    iserdes_reset(base);
     for (int cnt=0; cnt<16; cnt++) {
-        aligned = iserdes_center_idelay(base, pattern);
+        bool aligned = iserdes_center_idelay(base, pattern);
         if (!aligned)
             iserdes_bitslip(base);
         else

soc/picorv32/firmware/src/mdio_soft.c

@@ -31,9 +31,8 @@ void mdio_init(void){
 }
 
 void mdio_tx32(const uint32_t dat) {
-    bool bit;
     for (size_t i=32; i; i--){
-        bit = CHECK_BIT(dat, i-1);
+        bool bit = CHECK_BIT(dat, i-1);
         SET_MDIO(bit);
         MDC0();
         MDC1();
@@ -73,12 +72,11 @@ void mdio_write_reg( uint8_t phyAddr, uint8_t regAddr, uint16_t regVal) {
 uint16_t mdio_read_reg( uint8_t phyAddr, uint8_t regAddr) {
     uint16_t assem = 0;
     uint16_t dat = 0;
-    bool bit;
 
     assem = MDIO_ST<<14 | MDIO_OP_R<<12 | (phyAddr & 0x1f)<<7 | (regAddr & 0x1f)<<2 | 0;
     mdio_start();
     for (size_t i=16; i>2; i-- ){
-        bit = CHECK_BIT(assem, i-1);
+        bool bit = CHECK_BIT(assem, i-1);
         SET_MDIO(bit);
         MDC0();
         MDC1();

soc/picorv32/firmware/src/onewire_soft.c

@@ -202,9 +202,8 @@ bool onewire_search(uint8_t *newAddr)
     uint8_t id_bit_number;
     uint8_t last_zero, rom_byte_number;
     bool    search_result;
-    uint8_t id_bit, cmp_id_bit;
 
-    unsigned char rom_byte_mask, search_direction;
+    unsigned char rom_byte_mask;
 
     // initialize for search
     id_bit_number = 1;
@@ -234,13 +233,14 @@ bool onewire_search(uint8_t *newAddr)
         // loop to do the search
         do {
             // read a bit and its complement
-            id_bit = onewire_bit(1);
-            cmp_id_bit = onewire_bit(1);
+            uint8_t id_bit = onewire_bit(1);
+            uint8_t cmp_id_bit = onewire_bit(1);
 
             // check for no devices on 1-wire
             if ((id_bit == 1) && (cmp_id_bit == 1)) {
                 break;
             } else {
+                unsigned char search_direction;
                 // all devices coupled have 0 or 1
                 if (id_bit != cmp_id_bit) {
                     search_direction = id_bit;  // bit write value for search

soc/picorv32/firmware/src/spi_memio.c

@@ -2,9 +2,9 @@
 #include "spi_memio.h"
 
 static uint8_t memio_rxtx8( uint32_t base_addr, uint8_t val ){
-    uint8_t bitVal, ret = 0;
+    uint8_t ret = 0;
     for (int i=0; i<=7; i++){
-        bitVal = (val&0x80) != 0;
+        uint8_t bitVal = (val&0x80) != 0;
         MEMIO_PIN_SET( base_addr, 0b0001, 0, 0, bitVal );
         MEMIO_PIN_SET( base_addr, 0b0001, 0, 1, bitVal );
         ret = (ret<<1) | ((MEMIO_PIN_GET(base_addr)>>1)&0x01);

soc/picorv32/project/kc705/common/system.c

@@ -42,7 +42,6 @@ void init(void)
 
 int main(void)
 {
-    uint8_t ret;
     uint16_t tempBuff[5];
 
     init();
@@ -97,7 +96,7 @@ int main(void)
     uint8_t i=0;
     g_printTo = P_UART | P_LCD;
     while(1) {
-        ret = i2c_read_regs(I2C_ADR_SFP_2, 96, (uint8_t*)tempBuff, 10);
+        uint8_t ret = i2c_read_regs(I2C_ADR_SFP_2, 96, (uint8_t*)tempBuff, 10);
         if(!ret) {
             print_str("I2C error");
             return -1;

soc/picorv32/test/memio/memio.c

@@ -8,21 +8,21 @@ int main(void)
 	volatile uint32_t *p_memio = (uint32_t *)BASE_MEMIO;
 
 	//-------------------------------
-    // Read in default mode (1x)
-    //-------------------------------
+	// Read in default mode (1x)
+	//-------------------------------
 	for (unsigned i=0; i<11; i++) p_memio[i];
 
 	//-------------------------------
-    // Read in qspi mode (4x)
-    //-------------------------------
-    MEMIO_CFG(BASE_MEMIO, 0, 1, 1, 8);
-    for (unsigned i=0; i<11; i++) p_memio[i];
+	// Read in qspi mode (4x)
+	//-------------------------------
+	MEMIO_CFG(BASE_MEMIO, 0, 1, 1, 8);
+	for (unsigned i=0; i<11; i++) p_memio[i];
 
 	//-------------------------------
-    // Read in qspi DDR mode (8x)
-    //-------------------------------
-    MEMIO_CFG(BASE_MEMIO, 1, 1, 1, 8);
-    for (unsigned i=0; i<11; i++) p_memio[i];
+	// Read in qspi DDR mode (8x)
+	//-------------------------------
+	MEMIO_CFG(BASE_MEMIO, 1, 1, 1, 8);
+	for (unsigned i=0; i<11; i++) p_memio[i];
 
 	return p_memio[1];
 }

soc/picorv32/test/zest/zest_test.c

@@ -4,11 +4,9 @@
 #include "zest.h"
 
 int main(void){
-  int16_t dval;
-  size_t ix;
-  for (ix=0; ix<8; ix++) {
-    dval = read_zest_adc(ix);
-    // printf("ADC chan %d hex : %#06x\n", ix, (uint16_t)dval);
+  for (size_t ix=0; ix<8; ix++) {
+    int16_t dval = read_zest_adc(ix);
+    if (0) printf("ADC chan %ld hex : %#06x\n", (long int) ix, (uint16_t)dval);
   }
   return 0;
 }