Changeset 8a64320e in mainline for uspace/drv/nic/ar9271/hw.c


Ignore:
Timestamp:
2015-04-23T23:40:14Z (10 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
dcba819
Parents:
09044cb
Message:

pre-merge coding style cleanup and code review

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/nic/ar9271/hw.c

    r09044cb r8a64320e  
    3838#include <nic.h>
    3939#include <ieee80211.h>
    40 
    4140#include "hw.h"
    4241#include "wmi.h"
    4342
    44 /**
    45  * Try to wait for register value repeatedly until timeout is reached.
    46  *
     43/** Try to wait for register value repeatedly until timeout is reached.
     44 *
    4745 * @param ar9271 Device structure.
    4846 * @param offset Registry offset (address) to be read.
    49  * @param mask Mask to apply on read result.
    50  * @param value Required value we are waiting for.
    51  *
    52  * @return EOK if succeed, ETIMEOUT on timeout, negative error code otherwise.
     47 * @param mask   Mask to apply on read result.
     48 * @param value  Required value we are waiting for.
     49 *
     50 * @return EOK if succeed, ETIMEOUT on timeout,
     51 *         negative error code otherwise.
     52 *
    5353 */
    5454static int hw_read_wait(ar9271_t *ar9271, uint32_t offset, uint32_t mask,
    55         uint32_t value)
    56 {
    57         uint32_t result;
    58        
    59         for(size_t i = 0; i < HW_WAIT_LOOPS; i++) {
     55    uint32_t value)
     56{
     57        for (size_t i = 0; i < HW_WAIT_LOOPS; i++) {
    6058                udelay(HW_WAIT_TIME_US);
    61 
     59               
     60                uint32_t result;
    6261                wmi_reg_read(ar9271->htc_device, offset, &result);
    63                 if((result & mask) == value) {
     62                if ((result & mask) == value)
    6463                        return EOK;
    65                 }
    6664        }
    6765       
    … …  
    7472                {
    7573                        .offset = AR9271_RTC_FORCE_WAKE,
    76                         .value = AR9271_RTC_FORCE_WAKE_ENABLE | 
    77                                 AR9271_RTC_FORCE_WAKE_ON_INT
     74                        .value = AR9271_RTC_FORCE_WAKE_ENABLE |
     75                            AR9271_RTC_FORCE_WAKE_ON_INT
    7876                },
    7977                {
    … …  
    8886       
    8987        wmi_reg_buffer_write(ar9271->htc_device, buffer,
    90                 sizeof(buffer) / sizeof(wmi_reg_t));
     88            sizeof(buffer) / sizeof(wmi_reg_t));
    9189       
    9290        udelay(2);
    … …  
    9593        wmi_reg_write(ar9271->htc_device, AR9271_RTC_RESET, 1);
    9694       
    97         int rc = hw_read_wait(ar9271, 
    98                 AR9271_RTC_STATUS,
    99                 AR9271_RTC_STATUS_MASK,
    100                 AR9271_RTC_STATUS_ON);
    101         if(rc != EOK) {
     95        int rc = hw_read_wait(ar9271,
     96            AR9271_RTC_STATUS,
     97            AR9271_RTC_STATUS_MASK,
     98            AR9271_RTC_STATUS_ON);
     99        if (rc != EOK) {
    102100                usb_log_error("Failed to wait for RTC wake up register.\n");
    103101                return rc;
    … …  
    111109        uint32_t reset_value = AR9271_RTC_RC_MAC_WARM;
    112110       
    113         if(cold) {
     111        if (cold)
    114112                reset_value |= AR9271_RTC_RC_MAC_COLD;
    115         }
    116113       
    117114        wmi_reg_t buffer[] = {
    118115                {
    119116                        .offset = AR9271_RTC_FORCE_WAKE,
    120                         .value = AR9271_RTC_FORCE_WAKE_ENABLE | 
    121                                 AR9271_RTC_FORCE_WAKE_ON_INT
     117                        .value = AR9271_RTC_FORCE_WAKE_ENABLE |
     118                            AR9271_RTC_FORCE_WAKE_ON_INT
    122119                },
    123120                {
    … …  
    131128        };
    132129       
    133         wmi_reg_buffer_write(ar9271->htc_device, buffer, 
    134                 sizeof(buffer) / sizeof(wmi_reg_t));
     130        wmi_reg_buffer_write(ar9271->htc_device, buffer,
     131            sizeof(buffer) / sizeof(wmi_reg_t));
    135132       
    136133        udelay(100);
    … …  
    139136       
    140137        int rc = hw_read_wait(ar9271, AR9271_RTC_RC, AR9271_RTC_RC_MASK, 0);
    141         if(rc != EOK) {
     138        if (rc != EOK) {
    142139                usb_log_error("Failed to wait for RTC RC register.\n");
    143140                return rc;
    … …  
    145142       
    146143        wmi_reg_write(ar9271->htc_device, AR9271_RC, 0);
    147         wmi_reg_clear_bit(ar9271->htc_device, AR9271_STATION_ID1, 
    148                 AR9271_STATION_ID1_POWER_SAVING);
     144        wmi_reg_clear_bit(ar9271->htc_device, AR9271_STATION_ID1,
     145            AR9271_STATION_ID1_POWER_SAVING);
    149146       
    150147        return EOK;
    … …  
    156153        nic_address_t ar9271_address;
    157154       
    158         for(int i = 0; i < 3; i++) {
    159                 wmi_reg_read(ar9271->htc_device,
    160                         AR9271_EEPROM_MAC_ADDR_START + i*4,
    161                         &value);
     155        for (unsigned int i = 0; i < 3; i++) {
     156                wmi_reg_read(ar9271->htc_device,
     157                    AR9271_EEPROM_MAC_ADDR_START + i * 4, &value);
    162158               
    163159                uint16_t two_bytes = uint16_t_be2host(value);
    … …  
    169165       
    170166        int rc = nic_report_address(nic, &ar9271_address);
    171         if(rc != EOK) {
     167        if (rc != EOK) {
    172168                usb_log_error("Failed to report NIC HW address.\n");
    173169                return rc;
    … …  
    179175static int hw_gpio_set_output(ar9271_t *ar9271, uint32_t gpio, uint32_t type)
    180176{
    181         uint32_t address, gpio_shift, temp;
    182        
    183         if(gpio > 11) {
     177        uint32_t address;
     178       
     179        if (gpio > 11)
    184180                address = AR9271_GPIO_OUT_MUX3;
    185         } else if(gpio > 5) {
     181        else if (gpio > 5)
    186182                address = AR9271_GPIO_OUT_MUX2;
    187         } else {
     183        else
    188184                address = AR9271_GPIO_OUT_MUX1;
    189         }
    190        
    191         gpio_shift = (gpio % 6) * 5;
    192        
     185       
     186        uint32_t gpio_shift = (gpio % 6) * 5;
     187       
     188        uint32_t temp;
    193189        wmi_reg_read(ar9271->htc_device, address, &temp);
    194 
    195         temp = ((temp & 0x1F0) << 1) | (temp & ~0x1F0);
     190       
     191        temp = ((temp & 0x1f0) << 1) | (temp & ~0x1f0);
    196192        temp &= ~(0x1f << gpio_shift);
    197193        temp |= (type << gpio_shift);
    198 
     194       
    199195        wmi_reg_write(ar9271->htc_device, address, temp);
    200196       
    … …  
    202198       
    203199        wmi_reg_set_clear_bit(ar9271->htc_device, AR9271_GPIO_OE_OUT,
    204                 AR9271_GPIO_OE_OUT_ALWAYS << gpio_shift,
    205                 AR9271_GPIO_OE_OUT_ALWAYS << gpio_shift);
     200            AR9271_GPIO_OE_OUT_ALWAYS << gpio_shift,
     201            AR9271_GPIO_OE_OUT_ALWAYS << gpio_shift);
    206202       
    207203        return EOK;
    … …  
    211207{
    212208        wmi_reg_set_clear_bit(ar9271->htc_device, AR9271_GPIO_IN_OUT,
    213                 (~value & 1) << gpio, 1 << gpio);
    214         return EOK;
    215 }
    216 
    217 /**
    218  * Hardware init procedure of AR9271 device.
    219  *
     209            (~value & 1) << gpio, 1 << gpio);
     210        return EOK;
     211}
     212
     213/**Hardware init procedure of AR9271 device.
     214 *
    220215 * @param ar9271 Device structure.
    221  * 
     216 *
    222217 * @return EOK if succeed, negative error code otherwise.
     218 *
    223219 */
    224220static int hw_init_proc(ar9271_t *ar9271)
    225221{
    226222        int rc = hw_reset_power_on(ar9271);
    227         if(rc != EOK) {
     223        if (rc != EOK) {
    228224                usb_log_error("Failed to HW reset power on.\n");
    229225                return rc;
    … …  
    231227       
    232228        rc = hw_set_reset(ar9271, false);
    233         if(rc != EOK) {
     229        if (rc != EOK) {
    234230                usb_log_error("Failed to HW warm reset.\n");
    235231                return rc;
    … …  
    237233       
    238234        rc = hw_addr_init(ar9271);
    239         if(rc != EOK) {
     235        if (rc != EOK) {
    240236                usb_log_error("Failed to init HW addr.\n");
    241237                return rc;
    … …  
    247243static int hw_init_led(ar9271_t *ar9271)
    248244{
    249         int rc = hw_gpio_set_output(ar9271, AR9271_LED_PIN, 
    250                 AR9271_GPIO_OUT_MUX_AS_OUT);
    251         if(rc != EOK) {
     245        int rc = hw_gpio_set_output(ar9271, AR9271_LED_PIN,
     246            AR9271_GPIO_OUT_MUX_AS_OUT);
     247        if (rc != EOK) {
    252248                usb_log_error("Failed to set led GPIO to output.\n");
    253249                return rc;
    … …  
    255251       
    256252        rc = hw_gpio_set_value(ar9271, AR9271_LED_PIN, 0);
    257         if(rc != EOK) {
     253        if (rc != EOK) {
    258254                usb_log_error("Failed to init bring up GPIO led.\n");
    259255                return rc;
    … …  
    271267}
    272268
    273 static int hw_set_operating_mode(ar9271_t *ar9271, 
    274         ieee80211_operating_mode_t op_mode)
     269static int hw_set_operating_mode(ar9271_t *ar9271,
     270    ieee80211_operating_mode_t op_mode)
    275271{
    276272        uint32_t set_bit = 0x10000000;
    277273       
    278274        switch(op_mode) {
    279                 case IEEE80211_OPMODE_ADHOC:
    280                         set_bit |= AR9271_OPMODE_ADHOC_MASK;
    281                         wmi_reg_set_bit(ar9271->htc_device, AR9271_CONFIG,
    282                                 AR9271_CONFIG_ADHOC);
    283                         break;
    284                 case IEEE80211_OPMODE_MESH:
    285                 case IEEE80211_OPMODE_AP:
    286                         set_bit |= AR9271_OPMODE_STATION_AP_MASK;
    287                 case IEEE80211_OPMODE_STATION:
    288                         wmi_reg_clear_bit(ar9271->htc_device, AR9271_CONFIG,
    289                                 AR9271_CONFIG_ADHOC);
     275        case IEEE80211_OPMODE_ADHOC:
     276                set_bit |= AR9271_OPMODE_ADHOC_MASK;
     277                wmi_reg_set_bit(ar9271->htc_device, AR9271_CONFIG,
     278                    AR9271_CONFIG_ADHOC);
     279                break;
     280        case IEEE80211_OPMODE_MESH:
     281        case IEEE80211_OPMODE_AP:
     282                set_bit |= AR9271_OPMODE_STATION_AP_MASK;
     283        case IEEE80211_OPMODE_STATION:
     284                wmi_reg_clear_bit(ar9271->htc_device, AR9271_CONFIG,
     285                    AR9271_CONFIG_ADHOC);
    290286        }
    291287       
    292288        wmi_reg_set_clear_bit(ar9271->htc_device, AR9271_STATION_ID1,
    293                 set_bit,
    294                 AR9271_OPMODE_STATION_AP_MASK | AR9271_OPMODE_ADHOC_MASK);
     289            set_bit, AR9271_OPMODE_STATION_AP_MASK | AR9271_OPMODE_ADHOC_MASK);
    295290       
    296291        ieee80211_report_current_op_mode(ar9271->ieee80211_dev, op_mode);
    … …  
    302297{
    303298        int rc = hw_set_operating_mode(ar9271, IEEE80211_OPMODE_STATION);
    304         if(rc != EOK) {
     299        if (rc != EOK) {
    305300                usb_log_error("Failed to set opmode to station.\n");
    306301                return rc;
    … …  
    314309        uint32_t value;
    315310        wmi_reg_read(ar9271->htc_device, AR9271_PHY_CAL, &value);
    316         value &= 0xFFFFFE00;
    317         value |= (((uint32_t) AR9271_CALIB_NOMINAL_VALUE_2GHZ << 1) & 0x1FF);
     311       
     312        value &= 0xfffffe00;
     313        value |= (((uint32_t) AR9271_CALIB_NOMINAL_VALUE_2GHZ << 1) & 0x1ff);
     314       
    318315        wmi_reg_write(ar9271->htc_device, AR9271_PHY_CAL, value);
    319316       
    320         wmi_reg_clear_bit(ar9271->htc_device, AR9271_AGC_CONTROL, 
    321                 AR9271_AGC_CONTROL_NF_CALIB_EN);
    322        
    323         wmi_reg_clear_bit(ar9271->htc_device, AR9271_AGC_CONTROL, 
    324                 AR9271_AGC_CONTROL_NF_NOT_UPDATE);
    325        
    326         wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL, 
    327                 AR9271_AGC_CONTROL_NF_CALIB);
    328        
    329         int rc = hw_read_wait(ar9271, AR9271_AGC_CONTROL, 
    330                 AR9271_AGC_CONTROL_NF_CALIB, 0);
    331         if(rc != EOK) {
     317        wmi_reg_clear_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
     318            AR9271_AGC_CONTROL_NF_CALIB_EN);
     319       
     320        wmi_reg_clear_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
     321            AR9271_AGC_CONTROL_NF_NOT_UPDATE);
     322       
     323        wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
     324            AR9271_AGC_CONTROL_NF_CALIB);
     325       
     326        int rc = hw_read_wait(ar9271, AR9271_AGC_CONTROL,
     327            AR9271_AGC_CONTROL_NF_CALIB, 0);
     328        if (rc != EOK) {
    332329                usb_log_error("Failed to wait for NF calibration.\n");
    333330                return rc;
    334331        }
    335332       
    336         wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL, 
    337                 AR9271_AGC_CONTROL_NF_CALIB_EN);
    338        
    339         wmi_reg_clear_bit(ar9271->htc_device, AR9271_AGC_CONTROL, 
    340                 AR9271_AGC_CONTROL_NF_NOT_UPDATE);
    341        
    342         wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL, 
    343                 AR9271_AGC_CONTROL_NF_CALIB);
     333        wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
     334            AR9271_AGC_CONTROL_NF_CALIB_EN);
     335       
     336        wmi_reg_clear_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
     337            AR9271_AGC_CONTROL_NF_NOT_UPDATE);
     338       
     339        wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
     340            AR9271_AGC_CONTROL_NF_CALIB);
    344341       
    345342        return EOK;
    … …  
    349346{
    350347        /* Not supported channel frequency. */
    351         if(freq < IEEE80211_FIRST_FREQ || freq > IEEE80211_MAX_FREQ) {
     348        if ((freq < IEEE80211_FIRST_FREQ) || (freq > IEEE80211_MAX_FREQ))
    352349                return EINVAL;
    353         }
    354350       
    355351        /* Not supported channel frequency. */
    356         if((freq - IEEE80211_FIRST_FREQ) % IEEE80211_CHANNEL_GAP != 0) {
     352        if ((freq - IEEE80211_FIRST_FREQ) % IEEE80211_CHANNEL_GAP != 0)
    357353                return EINVAL;
    358         }
    359354       
    360355        uint32_t tx_control;
    361356        wmi_reg_read(ar9271->htc_device, AR9271_PHY_CCK_TX_CTRL, &tx_control);
    362357        wmi_reg_write(ar9271->htc_device, AR9271_PHY_CCK_TX_CTRL,
    363                 tx_control & ~AR9271_PHY_CCK_TX_CTRL_JAPAN);
     358            tx_control & ~AR9271_PHY_CCK_TX_CTRL_JAPAN);
    364359       
    365360        /* Some magic here. */
    366361        uint32_t synth_ctl;
    367362        wmi_reg_read(ar9271->htc_device, AR9271_PHY_SYNTH_CONTROL, &synth_ctl);
    368         synth_ctl &= 0xC0000000;
     363        synth_ctl &= 0xc0000000;
    369364        uint32_t channel_select = (freq * 0x10000) / 15;
    370365        synth_ctl = synth_ctl | (1 << 29) | (1 << 28) | channel_select;
    … …  
    382377       
    383378        int rc = hw_read_wait(ar9271, AR9271_PHY_RFBUS_GRANT, 0x1, 0x1);
    384         if(rc != EOK) {
     379        if (rc != EOK) {
    385380                usb_log_error("Failed to kill RF bus.\n");
    386381                return rc;
    … …  
    388383       
    389384        rc = hw_set_freq(ar9271, freq);
    390         if(rc != EOK) {
     385        if (rc != EOK) {
    391386                usb_log_error("Failed to HW set frequency.\n");
    392387                return rc;
    … …  
    394389       
    395390        rc = hw_activate_phy(ar9271);
    396         if(rc != EOK) {
     391        if (rc != EOK) {
    397392                usb_log_error("Failed to activate physical layer.\n");
    398393                return rc;
    … …  
    403398       
    404399        rc = hw_noise_floor_calibration(ar9271);
    405         if(rc != EOK) {
     400        if (rc != EOK) {
    406401                usb_log_error("Failed to do NF calibration.\n");
    407402                return rc;
    … …  
    413408int hw_set_rx_filter(ar9271_t *ar9271, bool assoc)
    414409{
    415         uint32_t filter_bits;
    416        
    417410        uint32_t additional_bits = 0;
    418411       
    419         if(assoc) {
     412        if (assoc)
    420413                additional_bits |= AR9271_RX_FILTER_MYBEACON;
    421         } else {
     414        else
    422415                additional_bits |= AR9271_RX_FILTER_BEACON;
    423         }
    424        
    425         filter_bits = AR9271_RX_FILTER_UNI | AR9271_RX_FILTER_MULTI |
    426                 AR9271_RX_FILTER_BROAD | additional_bits;
     416       
     417        uint32_t filter_bits = AR9271_RX_FILTER_UNI |
     418            AR9271_RX_FILTER_MULTI | AR9271_RX_FILTER_BROAD |
     419            additional_bits;
    427420       
    428421        wmi_reg_write(ar9271->htc_device, AR9271_RX_FILTER, filter_bits);
    … …  
    441434        uint16_t *last_2bytes = (uint16_t *) &bssid.address[4];
    442435       
    443         wmi_reg_write(ar9271->htc_device, AR9271_BSSID0, 
    444                 uint32_t_le2host(*first_4bytes));
    445        
    446         wmi_reg_write(ar9271->htc_device, AR9271_BSSID1, 
    447                 uint16_t_le2host(*last_2bytes) |
    448                 ((ieee80211_get_aid(ieee80211_dev) & 0x3FFF) << 16));
     436        wmi_reg_write(ar9271->htc_device, AR9271_BSSID0,
     437            uint32_t_le2host(*first_4bytes));
     438       
     439        wmi_reg_write(ar9271->htc_device, AR9271_BSSID1,
     440            uint16_t_le2host(*last_2bytes) |
     441            ((ieee80211_get_aid(ieee80211_dev) & 0x3fff) << 16));
    449442       
    450443        return EOK;
    … …  
    453446int hw_rx_init(ar9271_t *ar9271)
    454447{
    455         wmi_reg_write(ar9271->htc_device, AR9271_COMMAND, 
    456                 AR9271_COMMAND_RX_ENABLE);
     448        wmi_reg_write(ar9271->htc_device, AR9271_COMMAND,
     449            AR9271_COMMAND_RX_ENABLE);
    457450       
    458451        int rc = hw_set_rx_filter(ar9271, false);
    459         if(rc != EOK) {
     452        if (rc != EOK) {
    460453                usb_log_error("Failed to set RX filtering.\n");
    461454                return rc;
    … …  
    473466static int hw_init_pll(ar9271_t *ar9271)
    474467{
    475         uint32_t pll;
    476        
    477468        /* Some magic here (set for 2GHz channels). But VERY important :-) */
    478         pll = (0x5 << 10) | 0x2C;
     469        uint32_t pll = (0x5 << 10) | 0x2c;
    479470       
    480471        wmi_reg_write(ar9271->htc_device, AR9271_RTC_PLL_CONTROL, pll);
    481472       
    482473        wmi_reg_write(ar9271->htc_device, AR9271_RTC_SLEEP_CLOCK,
    483                 AR9271_RTC_SLEEP_CLOCK_FORCE_DERIVED);
     474            AR9271_RTC_SLEEP_CLOCK_FORCE_DERIVED);
    484475        wmi_reg_set_bit(ar9271->htc_device, AR9271_RTC_FORCE_WAKE,
    485                 AR9271_RTC_FORCE_WAKE_ENABLE);
     476            AR9271_RTC_FORCE_WAKE_ENABLE);
    486477       
    487478        return EOK;
    … …  
    490481static void hw_set_init_values(ar9271_t *ar9271)
    491482{
    492         uint32_t reg_offset, reg_value;
    493        
    494         int size = ARRAY_SIZE(ar9271_2g_mode_array);
    495        
    496         for(int i = 0; i < size; i++) {
     483        uint32_t reg_offset;
     484        uint32_t reg_value;
     485       
     486        size_t size = ARRAY_SIZE(ar9271_2g_mode_array);
     487       
     488        for (size_t i = 0; i < size; i++) {
    497489                reg_offset = ar9271_2g_mode_array[i][0];
    498490                reg_value = ar9271_2g_mode_array[i][1];
    … …  
    502494        size = ARRAY_SIZE(ar9271_2g_tx_array);
    503495       
    504         for(int i = 0; i < size; i++) {
     496        for (size_t i = 0; i < size; i++) {
    505497                reg_offset = ar9271_2g_tx_array[i][0];
    506498                reg_value = ar9271_2g_tx_array[i][1];
    … …  
    510502        size = ARRAY_SIZE(ar9271_init_array);
    511503       
    512         for(int i = 0; i < size; i++) {
     504        for (size_t i = 0; i < size; i++) {
    513505                reg_offset = ar9271_init_array[i][0];
    514506                reg_value = ar9271_init_array[i][1];
    … …  
    520512{
    521513        wmi_reg_set_bit(ar9271->htc_device, AR9271_CARRIER_LEAK_CONTROL,
    522                 AR9271_CARRIER_LEAK_CALIB);
     514            AR9271_CARRIER_LEAK_CALIB);
    523515        wmi_reg_clear_bit(ar9271->htc_device, AR9271_ADC_CONTROL,
    524                 AR9271_ADC_CONTROL_OFF_PWDADC);
     516            AR9271_ADC_CONTROL_OFF_PWDADC);
    525517        wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
    526                 AR9271_AGC_CONTROL_TX_CALIB);
     518            AR9271_AGC_CONTROL_TX_CALIB);
    527519        wmi_reg_set_bit(ar9271->htc_device, AR9271_PHY_TPCRG1,
    528                 AR9271_PHY_TPCRG1_PD_CALIB);
     520            AR9271_PHY_TPCRG1_PD_CALIB);
    529521        wmi_reg_set_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
    530                 AR9271_AGC_CONTROL_CALIB);
    531        
    532         int rc = hw_read_wait(ar9271, AR9271_AGC_CONTROL, 
    533                 AR9271_AGC_CONTROL_CALIB, 0);
    534         if(rc != EOK) {
     522            AR9271_AGC_CONTROL_CALIB);
     523       
     524        int rc = hw_read_wait(ar9271, AR9271_AGC_CONTROL,
     525            AR9271_AGC_CONTROL_CALIB, 0);
     526        if (rc != EOK) {
    535527                usb_log_error("Failed to wait on calibrate completion.\n");
    536528                return rc;
    … …  
    538530       
    539531        wmi_reg_set_bit(ar9271->htc_device, AR9271_ADC_CONTROL,
    540                 AR9271_ADC_CONTROL_OFF_PWDADC);
     532            AR9271_ADC_CONTROL_OFF_PWDADC);
    541533        wmi_reg_clear_bit(ar9271->htc_device, AR9271_CARRIER_LEAK_CONTROL,
    542                 AR9271_CARRIER_LEAK_CALIB);
     534            AR9271_CARRIER_LEAK_CALIB);
    543535        wmi_reg_clear_bit(ar9271->htc_device, AR9271_AGC_CONTROL,
    544                 AR9271_AGC_CONTROL_TX_CALIB);
    545        
    546         return EOK;
    547 }
    548 
    549 int hw_reset(ar9271_t *ar9271) 
     536            AR9271_AGC_CONTROL_TX_CALIB);
     537       
     538        return EOK;
     539}
     540
     541int hw_reset(ar9271_t *ar9271)
    550542{
    551543        /* Set physical layer as deactivated. */
    … …  
    553545       
    554546        if(ar9271->starting_up) {
    555                 wmi_reg_write(ar9271->htc_device, 
    556                         AR9271_RESET_POWER_DOWN_CONTROL,
    557                         AR9271_RADIO_RF_RESET);
    558 
     547                wmi_reg_write(ar9271->htc_device,
     548                    AR9271_RESET_POWER_DOWN_CONTROL,
     549                    AR9271_RADIO_RF_RESET);
     550               
    559551                udelay(50);
    560552        }
    … …  
    563555        uint32_t config_reg;
    564556        wmi_reg_read(ar9271->htc_device, AR9271_COMMAND, &config_reg);
    565         if(config_reg & AR9271_COMMAND_RX_ENABLE) {
     557        if (config_reg & AR9271_COMMAND_RX_ENABLE)
    566558                hw_set_reset(ar9271, true);
    567         }
    568559       
    569560        int rc = hw_init_pll(ar9271);
    570         if(rc != EOK) {
     561        if (rc != EOK) {
    571562                usb_log_error("Failed to init PLL.\n");
    572563                return rc;
    … …  
    575566        udelay(500);
    576567       
    577         wmi_reg_write(ar9271->htc_device, AR9271_CLOCK_CONTROL, 
    578                 AR9271_MAX_CPU_CLOCK);
     568        wmi_reg_write(ar9271->htc_device, AR9271_CLOCK_CONTROL,
     569            AR9271_MAX_CPU_CLOCK);
    579570       
    580571        udelay(100);
    581572       
    582         if(ar9271->starting_up) {
    583                 wmi_reg_write(ar9271->htc_device, 
    584                         AR9271_RESET_POWER_DOWN_CONTROL,
    585                         AR9271_GATE_MAC_CONTROL);
    586 
     573        if (ar9271->starting_up) {
     574                wmi_reg_write(ar9271->htc_device,
     575                    AR9271_RESET_POWER_DOWN_CONTROL,
     576                    AR9271_GATE_MAC_CONTROL);
     577               
    587578                udelay(50);
    588579        }
    … …  
    591582       
    592583        /* Set physical layer mode. */
    593         wmi_reg_write(ar9271->htc_device, AR9271_PHY_MODE, 
    594                 AR9271_PHY_MODE_DYNAMIC);
     584        wmi_reg_write(ar9271->htc_device, AR9271_PHY_MODE,
     585            AR9271_PHY_MODE_DYNAMIC);
    595586       
    596587        /* Reset device operating mode. */
    597588        rc = hw_reset_operating_mode(ar9271);
    598         if(rc != EOK) {
     589        if (rc != EOK) {
    599590                usb_log_error("Failed to reset operating mode.\n");
    600591                return rc;
    … …  
    603594        /* Set initial channel frequency. */
    604595        rc = hw_set_freq(ar9271, IEEE80211_FIRST_FREQ);
    605         if(rc != EOK) {
     596        if (rc != EOK) {
    606597                usb_log_error("Failed to set channel.\n");
    607598                return rc;
    … …  
    609600       
    610601        /* Initialize transmission queues. */
    611         for(int i = 0; i < AR9271_QUEUES_COUNT; i++) {
    612                 wmi_reg_write(ar9271->htc_device,
    613                         AR9271_QUEUE_BASE_MASK + (i << 2),
    614                         1 << i);
     602        for (unsigned int i = 0; i < AR9271_QUEUES_COUNT; i++) {
     603                wmi_reg_write(ar9271->htc_device,
     604                    AR9271_QUEUE_BASE_MASK + (i << 2), 1 << i);
    615605        }
    616606       
    617607        /* Activate physical layer. */
    618608        rc = hw_activate_phy(ar9271);
    619         if(rc != EOK) {
     609        if (rc != EOK) {
    620610                usb_log_error("Failed to activate physical layer.\n");
    621611                return rc;
    … …  
    624614        /* Calibration. */
    625615        rc = hw_calibration(ar9271);
    626         if(rc != EOK) {
     616        if (rc != EOK) {
    627617                usb_log_error("Failed to calibrate device.\n");
    628618                return rc;
    … …  
    630620       
    631621        rc = hw_noise_floor_calibration(ar9271);
    632         if(rc != EOK) {
     622        if (rc != EOK) {
    633623                usb_log_error("Failed to calibrate noise floor.\n");
    634624                return rc;
    … …  
    641631}
    642632
    643 /**
    644  * Initialize hardware of AR9271 device.
    645  *
     633/** Initialize hardware of AR9271 device.
     634 *
    646635 * @param ar9271 Device structure.
    647  * 
     636 *
    648637 * @return EOK if succeed, negative error code otherwise.
    649638 */
    … …  
    651640{
    652641        int rc = hw_init_proc(ar9271);
    653         if(rc != EOK) {
     642        if (rc != EOK) {
    654643                usb_log_error("Failed to HW reset device.\n");
    655644                return rc;
    … …  
    657646       
    658647        rc = hw_init_led(ar9271);
    659         if(rc != EOK) {
     648        if (rc != EOK) {
    660649                usb_log_error("Failed to HW init led.\n");
    661650                return rc;
Note: See TracChangeset for help on using the changeset viewer.