Changeset 8a64320e in mainline


Ignore:
Timestamp:
2015-04-23T23:40:14Z (9 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

Files:
35 edited

Legend:

Unmodified
Added
Removed
  • boot/Makefile

    r09044cb r8a64320e  
    115115                cp "$(USPACE_PATH)/$(DRVS_PATH)/$$file_dir/$$file_name/$$file_name.dev" "$(DIST_PATH)/$(DRVS_PATH)/$$file_name/" ; \
    116116        done
    117         for file in $(RD_DRV_FW) ; do \
     117        for file in $(RD_DRVS_FW) ; do \
    118118                file_dir="`dirname "$$file"`" ; \
    119119                file_name="`basename "$$file"`" ; \
  • boot/Makefile.common

    r09044cb r8a64320e  
    139139        nic/rtl8139 \
    140140        nic/rtl8169 \
    141         nic/ar9271 \
     141        nic/ar9271 \
    142142        block/ahci
    143143
    144144RD_DRV_CFG =
    145145
    146 RD_DRV_FW = \
    147         nic/ar9271
     146RD_DRVS_FW_NON_ESSENTIAL = \
     147        nic/ar9271
    148148
    149149RD_LIBS =
     
    228228        $(USPACE_PATH)/app/df/df \
    229229        $(USPACE_PATH)/app/fontviewer/fontviewer \
    230         $(USPACE_PATH)/app/wifi_supplicant/wifi_supplicant
     230        $(USPACE_PATH)/app/wifi_supplicant/wifi_supplicant
    231231
    232232RD_TESTS = \
     
    252252RD_APPS = $(RD_APPS_ESSENTIAL)
    253253RD_DRVS = $(RD_DRVS_ESSENTIAL)
     254RD_DRVS_FW = $(RD_DRVS_FW_ESSENTIAL)
    254255else
    255256RD_SRVS = $(RD_SRVS_ESSENTIAL) $(RD_SRVS_NON_ESSENTIAL)
    256257RD_APPS = $(RD_APPS_ESSENTIAL) $(RD_APPS_NON_ESSENTIAL)
    257258RD_DRVS = $(RD_DRVS_ESSENTIAL) $(RD_DRVS_NON_ESSENTIAL)
     259RD_DRVS_FW = $(RD_DRVS_FW_ESSENTIAL) $(RD_DRVS_FW_NON_ESSENTIAL)
    258260endif
    259261
  • boot/arch/amd64/Makefile.inc

    r09044cb r8a64320e  
    6161RD_DRV_CFG += \
    6262        bus/isa
    63        
     63
    6464RD_APPS_ESSENTIAL += \
    6565        $(USPACE_PATH)/app/edit/edit \
  • uspace/Makefile

    r09044cb r8a64320e  
    252252        lib/mbr \
    253253        lib/gpt \
    254         lib/ieee80211 \
     254        lib/ieee80211
    255255
    256256LIBC_BUILD = $(addsuffix .build,$(LIBC))
  • uspace/app/wifi_supplicant/Makefile

    r09044cb r8a64320e  
    3535        wifi_supplicant.c
    3636
    37 include $(USPACE_PREFIX)/Makefile.common 
     37include $(USPACE_PREFIX)/Makefile.common
  • uspace/app/wifi_supplicant/wifi_supplicant.c

    r09044cb r8a64320e  
    4242#include <loc.h>
    4343
    44 #define NAME "wifi_supplicant"
    45 
    46 #define enum_name(name_arr, i) ((i < 0) ? "NA" : name_arr[i])
     44#define NAME  "wifi_supplicant"
     45
     46#define enum_name(name_arr, i) \
     47        ((i < 0) ? "NA" : name_arr[i])
    4748
    4849static const char* ieee80211_security_type_strs[] = {
     
    6566        printf("\tlist - list wifi devices in <index>: <name> format\n");
    6667        printf("\tscan <index> [-n] - output scan results (force scan "
    67                 "immediately)\n");
     68            "immediately)\n");
    6869        printf("\tconnect <index> <ssid_prefix> [<password>] - connect to "
    69                 "network\n");
     70            "network\n");
    7071        printf("\tdisconnect <index> - disconnect from network\n");
    7172}
    7273
    73 static char *nic_addr_format(nic_address_t *a)
    74 {
    75         int rc;
    76         char *s;
    77 
    78         rc = asprintf(&s, "%02x:%02x:%02x:%02x:%02x:%02x",
    79             a->address[0], a->address[1], a->address[2],
    80             a->address[3], a->address[4], a->address[5]);
    81 
     74static char *nic_addr_format(nic_address_t *addr)
     75{
     76        char *str;
     77        int rc = asprintf(&str, "%02x:%02x:%02x:%02x:%02x:%02x",
     78            addr->address[0], addr->address[1], addr->address[2],
     79            addr->address[3], addr->address[4], addr->address[5]);
     80       
    8281        if (rc < 0)
    8382                return NULL;
    84 
    85         return s;
     83       
     84        return str;
    8685}
    8786
     
    8988{
    9089        category_id_t wifi_cat;
    91 
    9290        int rc = loc_category_get_id("ieee80211", &wifi_cat, 0);
    9391        if (rc != EOK) {
     
    9593                return rc;
    9694        }
    97 
     95       
    9896        rc = loc_category_get_svcs(wifi_cat, wifis, count);
    9997        if (rc != EOK) {
     
    107105static async_sess_t *get_wifi_by_index(size_t i)
    108106{
    109         int rc;
     107        service_id_t *wifis = NULL;
    110108        size_t count;
    111         service_id_t *wifis = NULL;
    112 
    113         rc = get_wifi_list(&wifis, &count);
     109       
     110        int rc = get_wifi_list(&wifis, &count);
    114111        if (rc != EOK) {
    115112                printf("Error fetching wifi list.\n");
     
    117114        }
    118115       
    119         if(i >= count) {
     116        if (i >= count) {
    120117                printf("Invalid wifi index.\n");
    121118                free(wifis);
    122119                return NULL;
    123120        }
    124 
    125         async_sess_t *sess = 
    126                 loc_service_connect(EXCHANGE_SERIALIZE, wifis[i], 0);
     121       
     122        async_sess_t *sess =
     123            loc_service_connect(EXCHANGE_SERIALIZE, wifis[i], 0);
    127124        if (sess == NULL) {
    128125                printf("Error connecting to service.\n");
     
    130127                return NULL;
    131128        }
    132 
     129       
    133130        return sess;
    134131}
     
    138135        service_id_t *wifis = NULL;
    139136        size_t count;
    140         char *svc_name;
    141         int rc;
    142 
    143         rc = get_wifi_list(&wifis, &count);
     137       
     138        int rc = get_wifi_list(&wifis, &count);
    144139        if (rc != EOK) {
    145140                printf("Error fetching wifi list.\n");
    146141                return EINVAL;
    147142        }
    148 
     143       
    149144        printf("[Index]: [Service Name]\n");
    150145        for (size_t i = 0; i < count; i++) {
     146                char *svc_name;
    151147                rc = loc_service_get_name(wifis[i], &svc_name);
    152148                if (rc != EOK) {
     
    157153               
    158154                printf("%zu: %s\n", i, svc_name);
    159 
     155               
    160156                free(svc_name);
    161157        }
    162 
     158       
    163159        return EOK;
    164160}
     
    171167        if (sess == NULL) {
    172168                printf("Specified WIFI doesn't exist or cannot connect to "
    173                         "it.\n");
     169                    "it.\n");
    174170                return EINVAL;
    175171        }
     
    177173        int rc = ieee80211_disconnect(sess);
    178174        if(rc != EOK) {
    179                 if(rc == EREFUSED) {
    180                         printf("Device is not ready yet.\n");                   
    181                 } else {
     175                if (rc == EREFUSED)
     176                        printf("Device is not ready yet.\n");
     177                else
    182178                        printf("Error when disconnecting device. "
    183                                 "Error: %d\n", rc);
    184                 }
     179                            "Error: %d\n", rc);
    185180               
    186181                return rc;
     
    189184        rc = ieee80211_connect(sess, ssid_start, password);
    190185        if(rc != EOK) {
    191                 if(rc == EREFUSED) {
    192                         printf("Device is not ready yet.\n");                   
    193                 } else if(rc == ETIMEOUT) {
     186                if (rc == EREFUSED)
     187                        printf("Device is not ready yet.\n");
     188                else if (rc == ETIMEOUT)
    194189                        printf("Timeout when authenticating to network.\n");
    195                 } else if(rc == ENOENT) {
     190                else if (rc == ENOENT)
    196191                        printf("Given SSID not in scan results.\n");
    197                 } else {
     192                else
    198193                        printf("Error when connecting to network. "
    199                                 "Error: %d\n", rc);
    200                 }
    201                
    202                 return rc;
    203         }
    204        
    205         // TODO: Wait for DHCP address ?
     194                            "Error: %d\n", rc);
     195               
     196                return rc;
     197        }
     198       
     199        // TODO: Wait for DHCP address?
    206200       
    207201        printf("Successfully connected to network!\n");
     
    215209        if (sess == NULL) {
    216210                printf("Specified WIFI doesn't exist or cannot connect to "
    217                         "it.\n");
     211                    "it.\n");
    218212                return EINVAL;
    219213        }
    220214       
    221215        int rc = ieee80211_disconnect(sess);
    222         if(rc != EOK) {
    223                 if(rc == EREFUSED) {
     216        if (rc != EOK) {
     217                if (rc == EREFUSED)
    224218                        printf("Device is not ready yet.\n");
    225                 } else if(rc == EINVAL) {
     219                else if (rc == EINVAL)
    226220                        printf("Not connected to any WiFi network.\n");
    227                 } else {
     221                else
    228222                        printf("Error when disconnecting from network. "
    229                                 "Error: %d\n", rc);
    230                 }
     223                            "Error: %d\n", rc);
     224               
    231225                return rc;
    232226        }
     
    239233static int wifi_scan(uint32_t index, bool now)
    240234{
    241         ieee80211_scan_results_t scan_results;
    242        
    243235        async_sess_t *sess = get_wifi_by_index(index);
    244236        if (sess == NULL) {
    245237                printf("Specified WIFI doesn't exist or cannot connect to "
    246                         "it.\n");
     238                    "it.\n");
    247239                return EINVAL;
    248240        }
    249241       
     242        ieee80211_scan_results_t scan_results;
    250243        int rc = ieee80211_get_scan_results(sess, &scan_results, now);
    251         if(rc != EOK) {
    252                 if(rc == EREFUSED) {
     244        if (rc != EOK) {
     245                if (rc == EREFUSED)
    253246                        printf("Device is not ready yet.\n");
    254                 } else {
     247                else
    255248                        printf("Failed to fetch scan results. Error: %d\n", rc);
    256                 }
    257                
    258                 return rc;
    259         }
    260        
    261         if(scan_results.length == 0)
     249               
     250                return rc;
     251        }
     252       
     253        if (scan_results.length == 0)
    262254                return EOK;
    263255       
    264         printf("%16.16s %17s %4s %5s %5s %7s %7s\n", 
    265                 "SSID", "MAC", "CHAN", "TYPE", "AUTH", "UNI-ALG", "GRP-ALG");
    266        
    267         for(int i = 0; i < scan_results.length; i++) {
     256        printf("%16.16s %17s %4s %5s %5s %7s %7s\n",
     257            "SSID", "MAC", "CHAN", "TYPE", "AUTH", "UNI-ALG", "GRP-ALG");
     258       
     259        for (uint8_t i = 0; i < scan_results.length; i++) {
    268260                ieee80211_scan_result_t result = scan_results.results[i];
    269261               
    270                 printf("%16.16s %17s %4d %5s %5s %7s %7s\n",
    271                         result.ssid,
    272                         nic_addr_format(&result.bssid),
    273                         result.channel,
    274                         enum_name(ieee80211_security_type_strs,
    275                                 result.security.type),
    276                         enum_name(ieee80211_security_auth_strs,
    277                                 result.security.auth),
    278                         enum_name(ieee80211_security_alg_strs,
    279                                 result.security.pair_alg),
    280                         enum_name(ieee80211_security_alg_strs,
    281                                 result.security.group_alg)
    282                 );
     262                printf("%16.16s %17s %4d %5s %5s %7s %7s\n",
     263                    result.ssid, nic_addr_format(&result.bssid),
     264                    result.channel,
     265                    enum_name(ieee80211_security_type_strs, result.security.type),
     266                    enum_name(ieee80211_security_auth_strs, result.security.auth),
     267                    enum_name(ieee80211_security_alg_strs, result.security.pair_alg),
     268                    enum_name(ieee80211_security_alg_strs, result.security.group_alg));
    283269        }
    284270       
     
    288274int main(int argc, char *argv[])
    289275{
    290         int rc;
    291         uint32_t index;
    292        
    293         rc = inetcfg_init();
    294         if (rc != EOK) {
    295                 printf(NAME ": Failed connecting to inetcfg service (%d).\n",
    296                     rc);
     276        int rc = inetcfg_init();
     277        if (rc != EOK) {
     278                printf("%s: Failed connecting to inetcfg service (%d).\n",
     279                    NAME, rc);
    297280                return 1;
    298281        }
     
    300283        rc = dhcp_init();
    301284        if (rc != EOK) {
    302                 printf(NAME ": Failed connecting to dhcp service (%d).\n", rc);
     285                printf("%s: Failed connecting to dhcp service (%d).\n",
     286                    NAME, rc);
    303287                return 1;
    304288        }
    305289       
    306         if(argc == 2) {
    307                 if(!str_cmp(argv[1], "list")) {
     290        if (argc == 2) {
     291                if (!str_cmp(argv[1], "list"))
    308292                        return wifi_list();
    309                 }
    310         } else if(argc > 2) {
     293        } else if (argc > 2) {
     294                uint32_t index;
    311295                rc = str_uint32_t(argv[2], NULL, 10, false, &index);
    312                 if(rc != EOK) {
    313                         printf(NAME ": Invalid argument.\n");
     296                if (rc != EOK) {
     297                        printf("%s: Invalid argument.\n", NAME);
    314298                        print_syntax();
    315299                        return EINVAL;
    316300                }
    317                 if(!str_cmp(argv[1], "scan")) {
     301               
     302                if (!str_cmp(argv[1], "scan")) {
    318303                        bool now = false;
    319                         if(argc > 3)
    320                                 if(!str_cmp(argv[3], "-n"))
     304                        if (argc > 3)
     305                                if (!str_cmp(argv[3], "-n"))
    321306                                        now = true;
     307                       
    322308                        return wifi_scan(index, now);
    323                 } else if(!str_cmp(argv[1], "connect")) {
     309                } else if (!str_cmp(argv[1], "connect")) {
    324310                        char *pass = NULL;
    325                         if(argc > 3) {
    326                                 if(argc > 4)
     311                        if (argc > 3) {
     312                                if (argc > 4)
    327313                                        pass = argv[4];
     314                               
    328315                                return wifi_connect(index, argv[3], pass);
    329                         } 
    330                 } else if(!str_cmp(argv[1], "disconnect")) {
     316                        }
     317                } else if (!str_cmp(argv[1], "disconnect"))
    331318                        return wifi_disconnect(index);
    332                 }
    333319        }
    334320       
  • uspace/drv/nic/ar9271/Makefile

    r09044cb r8a64320e  
    3636        $(LIBIEEE80211_PREFIX)/libieee80211.a \
    3737        $(LIBCRYPTO_PREFIX)/libcrypto.a
    38        
     38
    3939EXTRA_CFLAGS += \
    4040        -I. \
     
    4545        -I$(LIBIEEE80211_PREFIX)/include \
    4646        -I$(LIBCRYPTO_PREFIX)
    47        
     47
    4848BINARY = ar9271
    4949
  • uspace/drv/nic/ar9271/ar9271.c

    r09044cb r8a64320e  
    4242#include <nic.h>
    4343#include <macros.h>
    44 
    4544#include "ath_usb.h"
    4645#include "wmi.h"
     
    4847#include "ar9271.h"
    4948
    50 #define NAME "ar9271"
    51 #define FIRMWARE_FILENAME "/drv/ar9271/ar9271.fw"
     49#define NAME  "ar9271"
     50#define FIRMWARE_FILENAME  "/drv/ar9271/ar9271.fw"
    5251
    5352const usb_endpoint_description_t usb_ar9271_out_bulk_endpoint_description = {
     
    9190        &usb_ar9271_out_bulk_endpoint_description,
    9291        &usb_ar9271_in_bulk_endpoint_description,
    93         &usb_ar9271_in_int_endpoint_description,
    94         &usb_ar9271_out_int_endpoint_description,
     92        &usb_ar9271_in_int_endpoint_description,
     93        &usb_ar9271_out_int_endpoint_description,
    9594        NULL
    9695};
     
    10099
    101100/* IEEE 802.11 callbacks */
    102 static int ar9271_ieee80211_start(ieee80211_dev_t *ieee80211_dev);
    103 static int ar9271_ieee80211_tx_handler(ieee80211_dev_t *ieee80211_dev,
    104         void *buffer, size_t buffer_size);
    105 static int ar9271_ieee80211_set_freq(ieee80211_dev_t *ieee80211_dev,
    106         uint16_t freq);
    107 static int ar9271_ieee80211_bssid_change(ieee80211_dev_t *ieee80211_dev,
    108         bool connected);
    109 static int ar9271_ieee80211_key_config(ieee80211_dev_t *ieee80211_dev,
    110         ieee80211_key_config_t *key_conf, bool insert);
     101static int ar9271_ieee80211_start(ieee80211_dev_t *);
     102static int ar9271_ieee80211_tx_handler(ieee80211_dev_t *, void *, size_t);
     103static int ar9271_ieee80211_set_freq(ieee80211_dev_t *, uint16_t);
     104static int ar9271_ieee80211_bssid_change(ieee80211_dev_t *, bool);
     105static int ar9271_ieee80211_key_config(ieee80211_dev_t *, ieee80211_key_config_t *,
     106    bool);
    111107
    112108static driver_ops_t ar9271_driver_ops = {
     
    129125static ieee80211_iface_t ar9271_ieee80211_iface;
    130126
    131 static int ar9271_get_device_info(ddf_fun_t *dev, nic_device_info_t *info);
     127static int ar9271_get_device_info(ddf_fun_t *, nic_device_info_t *);
    132128static int ar9271_get_cable_state(ddf_fun_t *, nic_cable_state_t *);
    133 static int ar9271_get_operation_mode(ddf_fun_t *, int *,
    134         nic_channel_mode_t *, nic_role_t *);
     129static int ar9271_get_operation_mode(ddf_fun_t *, int *, nic_channel_mode_t *,
     130    nic_role_t *);
    135131
    136132static nic_iface_t ar9271_ieee80211_nic_iface = {
     
    142138static ddf_dev_ops_t ar9271_ieee80211_dev_ops;
    143139
    144 /**
    145  * Get device information.
     140/** Get device information.
    146141 *
    147142 */
     
    153148        memset(info, 0, sizeof(nic_device_info_t));
    154149       
    155         info->vendor_id = 0x0CF3;
     150        info->vendor_id = 0x0cf3;
    156151        info->device_id = 0x9271;
    157152        str_cpy(info->vendor_name, NIC_VENDOR_MAX_LENGTH,
     
    163158}
    164159
    165 /**
    166  * Get cable state.
     160/** Get cable state.
    167161 *
    168162 */
     
    174168}
    175169
    176 /**
    177  * Get operation mode of the device.
     170/** Get operation mode of the device.
    178171 *
    179172 */
     
    188181}
    189182
    190 /**
    191  * Set multicast frames acceptance mode.
    192  *
    193  */
    194 static int ar9271_on_multicast_mode_change(nic_t *nic,
    195         nic_multicast_mode_t mode, const nic_address_t *addr, size_t addr_cnt)
    196 {
    197         /*
    198         ieee80211_dev_t *ieee80211_dev = (ieee80211_dev_t *)
    199                 nic_get_specific(nic);
    200         ar9271_t *ar9271 = (ar9271_t *) ieee80211_get_specific(ieee80211_dev);
    201          */
    202        
     183/** Set multicast frames acceptance mode.
     184 *
     185 */
     186static int ar9271_on_multicast_mode_change(nic_t *nic,
     187    nic_multicast_mode_t mode, const nic_address_t *addr, size_t addr_cnt)
     188{
    203189        switch (mode) {
    204                 case NIC_MULTICAST_BLOCKED:
    205                         /* TODO */
    206                         break;
    207                 case NIC_MULTICAST_LIST:
    208                         /* TODO */
    209                         break;
    210                 case NIC_MULTICAST_PROMISC:
    211                         /* TODO */
    212                         break;
    213                 default:
    214                         return ENOTSUP;
    215         }
    216        
    217         return EOK;
    218 }
    219 
    220 /**
    221  * Set unicast frames acceptance mode.
     190        case NIC_MULTICAST_BLOCKED:
     191                /* TODO */
     192                break;
     193        case NIC_MULTICAST_LIST:
     194                /* TODO */
     195                break;
     196        case NIC_MULTICAST_PROMISC:
     197                /* TODO */
     198                break;
     199        default:
     200                return ENOTSUP;
     201        }
     202       
     203        return EOK;
     204}
     205
     206/** Set unicast frames acceptance mode.
    222207 *
    223208 */
     
    225210    const nic_address_t *addr, size_t addr_cnt)
    226211{
    227         /*
    228         ieee80211_dev_t *ieee80211_dev = (ieee80211_dev_t *)
    229                 nic_get_specific(nic);
    230         ar9271_t *ar9271 = (ar9271_t *) ieee80211_get_specific(ieee80211_dev);
    231          */
    232        
    233212        switch (mode) {
    234                 case NIC_UNICAST_BLOCKED:
    235                         /* TODO */
    236                         break;
    237                 case NIC_UNICAST_DEFAULT:
    238                         /* TODO */
    239                         break;
    240                 case NIC_UNICAST_LIST:
    241                         /* TODO */
    242                         break;
    243                 case NIC_UNICAST_PROMISC:
    244                         /* TODO */
    245                         break;
    246                 default:
    247                         return ENOTSUP;
    248         }
    249        
    250         return EOK;
    251 }
    252 
    253 /**
    254  * Set broadcast frames acceptance mode.
    255  *
    256  */
    257 static int ar9271_on_broadcast_mode_change(nic_t *nic,
    258         nic_broadcast_mode_t mode)
    259 {
    260         /*
    261         ieee80211_dev_t *ieee80211_dev = (ieee80211_dev_t *)
    262                 nic_get_specific(nic);
    263         ar9271_t *ar9271 = (ar9271_t *) ieee80211_get_specific(ieee80211_dev);
    264          */
    265        
     213        case NIC_UNICAST_BLOCKED:
     214                /* TODO */
     215                break;
     216        case NIC_UNICAST_DEFAULT:
     217                /* TODO */
     218                break;
     219        case NIC_UNICAST_LIST:
     220                /* TODO */
     221                break;
     222        case NIC_UNICAST_PROMISC:
     223                /* TODO */
     224                break;
     225        default:
     226                return ENOTSUP;
     227        }
     228       
     229        return EOK;
     230}
     231
     232/** Set broadcast frames acceptance mode.
     233 *
     234 */
     235static int ar9271_on_broadcast_mode_change(nic_t *nic,
     236    nic_broadcast_mode_t mode)
     237{
    266238        switch (mode) {
    267                 case NIC_BROADCAST_BLOCKED:
    268                         /* TODO */
    269                         break;
    270                 case NIC_BROADCAST_ACCEPTED:
    271                         /* TODO */
    272                         break;
    273                 default:
    274                         return ENOTSUP;
     239        case NIC_BROADCAST_BLOCKED:
     240                /* TODO */
     241                break;
     242        case NIC_BROADCAST_ACCEPTED:
     243                /* TODO */
     244                break;
     245        default:
     246                return ENOTSUP;
    275247        }
    276248       
     
    292264        void *buffer = malloc(buffer_size);
    293265       
    294         while(true) {
     266        while (true) {
    295267                size_t transferred_size;
    296                 if(htc_read_data_message(ar9271->htc_device,
    297                         buffer, buffer_size, &transferred_size) == EOK) {
    298                         size_t strip_length = 
    299                                 sizeof(ath_usb_data_header_t) +
    300                                 sizeof(htc_frame_header_t) +
    301                                 sizeof(htc_rx_status_t);
    302                        
    303                         if(transferred_size < strip_length)
     268                if (htc_read_data_message(ar9271->htc_device,
     269                    buffer, buffer_size, &transferred_size) == EOK) {
     270                        size_t strip_length =
     271                            sizeof(ath_usb_data_header_t) +
     272                            sizeof(htc_frame_header_t) +
     273                            sizeof(htc_rx_status_t);
     274                       
     275                        if (transferred_size < strip_length)
    304276                                continue;
    305 
    306                         ath_usb_data_header_t *data_header = 
    307                                 (ath_usb_data_header_t *) buffer;
    308 
     277                       
     278                        ath_usb_data_header_t *data_header =
     279                            (ath_usb_data_header_t *) buffer;
     280                       
    309281                        /* Invalid packet. */
    310                         if(data_header->tag != uint16_t_le2host(RX_TAG))
     282                        if (data_header->tag != uint16_t_le2host(RX_TAG))
    311283                                continue;
    312284                       
    313285                        htc_rx_status_t *rx_status =
    314                                 (htc_rx_status_t *) ((void *) buffer +
    315                                 sizeof(ath_usb_data_header_t) +
    316                                 sizeof(htc_frame_header_t));
     286                            (htc_rx_status_t *) ((void *) buffer +
     287                            sizeof(ath_usb_data_header_t) +
     288                            sizeof(htc_frame_header_t));
    317289                       
    318290                        uint16_t data_length =
    319                                 uint16_t_be2host(rx_status->data_length);
    320                        
    321                         int16_t payload_length = 
    322                                 transferred_size - strip_length;
    323                        
    324                         if(payload_length - data_length < 0)
     291                            uint16_t_be2host(rx_status->data_length);
     292                       
     293                        int16_t payload_length =
     294                            transferred_size - strip_length;
     295                       
     296                        if (payload_length - data_length < 0)
    325297                                continue;
    326298                       
    327                         if(ar9271_rx_status_error(rx_status->status))
     299                        if (ar9271_rx_status_error(rx_status->status))
    328300                                continue;
    329301                       
    330302                        void *strip_buffer = buffer + strip_length;
    331 
     303                       
    332304                        ieee80211_rx_handler(ar9271->ieee80211_dev,
    333                                 strip_buffer,
    334                                 payload_length);
     305                            strip_buffer,
     306                            payload_length);
    335307                }
    336308        }
     
    341313}
    342314
    343 /**
    344  * IEEE 802.11 handlers.
    345  */
    346 
     315/** IEEE 802.11 handlers.
     316 *
     317 */
    347318static int ar9271_ieee80211_set_freq(ieee80211_dev_t *ieee80211_dev,
    348         uint16_t freq)
     319    uint16_t freq)
    349320{
    350321        assert(ieee80211_dev);
     
    357328       
    358329        int rc = hw_freq_switch(ar9271, freq);
    359         if(rc != EOK) {
     330        if (rc != EOK) {
    360331                usb_log_error("Failed to HW switch frequency.\n");
    361332                return rc;
     
    365336       
    366337        rc = hw_rx_init(ar9271);
    367         if(rc != EOK) {
     338        if (rc != EOK) {
    368339                usb_log_error("Failed to initialize RX.\n");
    369340                return rc;
     
    371342       
    372343        uint16_t htc_mode = host2uint16_t_be(1);
    373         wmi_send_command(ar9271->htc_device, WMI_SET_MODE, 
    374                 (uint8_t *) &htc_mode, sizeof(htc_mode), NULL);
     344        wmi_send_command(ar9271->htc_device, WMI_SET_MODE,
     345            (uint8_t *) &htc_mode, sizeof(htc_mode), NULL);
    375346        wmi_send_command(ar9271->htc_device, WMI_ENABLE_INTR, NULL, 0, NULL);
    376347       
     
    379350
    380351static int ar9271_ieee80211_bssid_change(ieee80211_dev_t *ieee80211_dev,
    381         bool connected)
     352    bool connected)
    382353{
    383354        assert(ieee80211_dev);
    384355       
    385356        ar9271_t *ar9271 = (ar9271_t *) ieee80211_get_specific(ieee80211_dev);
    386 
    387         if(connected) {
     357       
     358        if (connected) {
    388359                nic_address_t bssid;
    389360                ieee80211_query_bssid(ieee80211_dev, &bssid);
    390 
     361               
    391362                htc_sta_msg_t sta_msg;
    392363                memset(&sta_msg, 0, sizeof(htc_sta_msg_t));
    393364                sta_msg.is_vif_sta = 0;
    394                 sta_msg.max_ampdu = 
    395                         host2uint16_t_be(1 << IEEE80211_MAX_AMPDU_FACTOR);
     365                sta_msg.max_ampdu =
     366                    host2uint16_t_be(1 << IEEE80211_MAX_AMPDU_FACTOR);
    396367                sta_msg.sta_index = 1;
    397368                sta_msg.vif_index = 0;
    398369                memcpy(&sta_msg.addr, bssid.address, ETH_ADDR);
    399 
    400                 wmi_send_command(ar9271->htc_device, WMI_NODE_CREATE, 
    401                         (uint8_t *) &sta_msg, sizeof(sta_msg), NULL);
    402 
     370               
     371                wmi_send_command(ar9271->htc_device, WMI_NODE_CREATE,
     372                    (uint8_t *) &sta_msg, sizeof(sta_msg), NULL);
     373               
    403374                htc_rate_msg_t rate_msg;
    404375                memset(&rate_msg, 0, sizeof(htc_rate_msg_t));
    405376                rate_msg.sta_index = 1;
    406377                rate_msg.is_new = 1;
    407                 rate_msg.legacy_rates_count =
    408                         ARRAY_SIZE(ieee80211bg_data_rates);
    409                 memcpy(&rate_msg.legacy_rates,
    410                         ieee80211bg_data_rates,
    411                         ARRAY_SIZE(ieee80211bg_data_rates));
    412 
    413                 wmi_send_command(ar9271->htc_device, WMI_RC_RATE_UPDATE,
    414                         (uint8_t *) &rate_msg, sizeof(rate_msg), NULL);
    415 
     378                rate_msg.legacy_rates_count = ARRAY_SIZE(ieee80211bg_data_rates);
     379                memcpy(&rate_msg.legacy_rates,
     380                    ieee80211bg_data_rates,
     381                    ARRAY_SIZE(ieee80211bg_data_rates));
     382               
     383                wmi_send_command(ar9271->htc_device, WMI_RC_RATE_UPDATE,
     384                    (uint8_t *) &rate_msg, sizeof(rate_msg), NULL);
     385               
    416386                hw_set_rx_filter(ar9271, true);
    417387        } else {
    418388                uint8_t station_id = 1;
    419389                wmi_send_command(ar9271->htc_device, WMI_NODE_REMOVE,
    420                         &station_id, sizeof(station_id), NULL);
     390                    &station_id, sizeof(station_id), NULL);
    421391               
    422392                hw_set_rx_filter(ar9271, false);
     
    429399
    430400static int ar9271_ieee80211_key_config(ieee80211_dev_t *ieee80211_dev,
    431         ieee80211_key_config_t *key_conf, bool insert)
     401    ieee80211_key_config_t *key_conf, bool insert)
    432402{
    433403        assert(ieee80211_dev);
     
    446416                ieee80211_query_bssid(ieee80211_dev, &bssid);
    447417               
    448                 switch(key_conf->suite) {
    449                         case IEEE80211_SECURITY_SUITE_WEP40:
    450                                 key_type = AR9271_KEY_TABLE_TYPE_WEP40;
    451                                 break;
    452                         case IEEE80211_SECURITY_SUITE_WEP104:
    453                                 key_type = AR9271_KEY_TABLE_TYPE_WEP104;
    454                                 break;
    455                         case IEEE80211_SECURITY_SUITE_TKIP:
    456                                 key_type = AR9271_KEY_TABLE_TYPE_TKIP;
    457                                 break;
    458                         case IEEE80211_SECURITY_SUITE_CCMP:
    459                                 key_type = AR9271_KEY_TABLE_TYPE_CCMP;
    460                                 break;
    461                         default:
    462                                 key_type = -1;
     418                switch (key_conf->suite) {
     419                case IEEE80211_SECURITY_SUITE_WEP40:
     420                        key_type = AR9271_KEY_TABLE_TYPE_WEP40;
     421                        break;
     422                case IEEE80211_SECURITY_SUITE_WEP104:
     423                        key_type = AR9271_KEY_TABLE_TYPE_WEP104;
     424                        break;
     425                case IEEE80211_SECURITY_SUITE_TKIP:
     426                        key_type = AR9271_KEY_TABLE_TYPE_TKIP;
     427                        break;
     428                case IEEE80211_SECURITY_SUITE_CCMP:
     429                        key_type = AR9271_KEY_TABLE_TYPE_CCMP;
     430                        break;
     431                default:
     432                        key_type = -1;
    463433                }
    464434               
    465                 uint8_t key_id = 
    466                         (key_conf->flags & IEEE80211_KEY_FLAG_TYPE_PAIRWISE) ?
    467                                 AR9271_STA_KEY_INDEX : key_conf->id;
     435                uint8_t key_id =
     436                    (key_conf->flags & IEEE80211_KEY_FLAG_TYPE_PAIRWISE) ?
     437                    AR9271_STA_KEY_INDEX : key_conf->id;
    468438               
    469439                reg_ptr = AR9271_KEY_TABLE(key_id);
     
    471441                data_start = (void *) key_conf->data;
    472442               
    473                 key[0] = uint32_t_le2host(
    474                         *((uint32_t *) data_start));
    475                 key[1] = uint16_t_le2host(
    476                         *((uint16_t *) (data_start + 4)));
    477                 key[2] = uint32_t_le2host(
    478                         *((uint32_t *) (data_start + 6)));
    479                 key[3] = uint16_t_le2host(
    480                         *((uint16_t *) (data_start + 10)));
    481                 key[4] = uint32_t_le2host(
    482                         *((uint32_t *) (data_start + 12)));
    483 
    484                 if(key_conf->suite == IEEE80211_SECURITY_SUITE_WEP40 ||
    485                    key_conf->suite == IEEE80211_SECURITY_SUITE_WEP104) {
     443                key[0] = uint32_t_le2host(*((uint32_t *) data_start));
     444                key[1] = uint16_t_le2host(*((uint16_t *) (data_start + 4)));
     445                key[2] = uint32_t_le2host(*((uint32_t *) (data_start + 6)));
     446                key[3] = uint16_t_le2host(*((uint16_t *) (data_start + 10)));
     447                key[4] = uint32_t_le2host(*((uint32_t *) (data_start + 12)));
     448               
     449                if ((key_conf->suite == IEEE80211_SECURITY_SUITE_WEP40) ||
     450                    (key_conf->suite == IEEE80211_SECURITY_SUITE_WEP104))
    486451                        key[4] &= 0xFF;
    487                 }
    488452               
    489453                wmi_reg_write(ar9271->htc_device, reg_ptr + 0, key[0]);
     
    494458                wmi_reg_write(ar9271->htc_device, reg_ptr + 20, key_type);
    495459               
    496                 uint32_t macL, macH;
    497                 if(key_conf->flags & IEEE80211_KEY_FLAG_TYPE_PAIRWISE) {
     460                uint32_t macl;
     461                uint32_t mach;
     462                if (key_conf->flags & IEEE80211_KEY_FLAG_TYPE_PAIRWISE) {
    498463                        data_start = (void *) bssid.address;
    499                         macL = uint32_t_le2host(*((uint32_t *) data_start));
    500                         macH = uint16_t_le2host(*((uint16_t *)
    501                                 (data_start + 4)));
     464                        macl = uint32_t_le2host(*((uint32_t *) data_start));
     465                        mach = uint16_t_le2host(*((uint16_t *) (data_start + 4)));
    502466                } else {
    503                         macL = macH = 0;
     467                        macl = 0;
     468                        mach = 0;
    504469                }
    505470               
    506                 macL >>= 1;
    507                 macL |= (macH & 1) << 31;
    508                 macH >>= 1;
    509                 macH |= 0x8000;
    510                
    511                 wmi_reg_write(ar9271->htc_device, reg_ptr + 24, macL);
    512                 wmi_reg_write(ar9271->htc_device, reg_ptr + 28, macH);
     471                macl >>= 1;
     472                macl |= (mach & 1) << 31;
     473                mach >>= 1;
     474                mach |= 0x8000;
     475               
     476                wmi_reg_write(ar9271->htc_device, reg_ptr + 24, macl);
     477                wmi_reg_write(ar9271->htc_device, reg_ptr + 28, mach);
    513478               
    514479                /* Setup MIC keys for TKIP. */
    515                 if(key_conf->suite == IEEE80211_SECURITY_SUITE_TKIP) {
     480                if (key_conf->suite == IEEE80211_SECURITY_SUITE_TKIP) {
    516481                        uint32_t mic[5];
    517                         uint8_t *gen_mic =
    518                                 data_start + IEEE80211_TKIP_RX_MIC_OFFSET;
     482                        uint8_t *gen_mic = data_start + IEEE80211_TKIP_RX_MIC_OFFSET;
    519483                        uint8_t *tx_mic;
    520                         if(key_conf->flags & IEEE80211_KEY_FLAG_TYPE_GROUP) {
     484                       
     485                        if (key_conf->flags & IEEE80211_KEY_FLAG_TYPE_GROUP)
    521486                                tx_mic = gen_mic;
    522                         } else {
    523                                 tx_mic = data_start +
    524                                         IEEE80211_TKIP_TX_MIC_OFFSET;
    525                         }
    526                        
    527                         mic[0] = uint32_t_le2host(
    528                                 *((uint32_t *) gen_mic));
    529                         mic[1] = uint16_t_le2host(
    530                                 *((uint16_t *) (tx_mic + 2))) & 0xFFFF;
    531                         mic[2] = uint32_t_le2host(
    532                                 *((uint32_t *) (gen_mic + 4)));
    533                         mic[3] = uint16_t_le2host(
    534                                 *((uint16_t *) tx_mic)) & 0xFFFF;
    535                         mic[4] = uint32_t_le2host(
    536                                 *((uint32_t *) (tx_mic + 4)));
    537                        
    538                         wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 0,
    539                                 mic[0]);
    540                         wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 4,
    541                                 mic[1]);
    542                         wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 8,
    543                                 mic[2]);
    544                         wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 12,
    545                                 mic[3]);
    546                         wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 16,
    547                                 mic[4]);
    548                         wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 20,
    549                                 AR9271_KEY_TABLE_TYPE_CLR);
     487                        else
     488                                tx_mic = data_start + IEEE80211_TKIP_TX_MIC_OFFSET;
     489                       
     490                        mic[0] = uint32_t_le2host(*((uint32_t *) gen_mic));
     491                        mic[1] = uint16_t_le2host(*((uint16_t *) (tx_mic + 2))) & 0xFFFF;
     492                        mic[2] = uint32_t_le2host(*((uint32_t *) (gen_mic + 4)));
     493                        mic[3] = uint16_t_le2host(*((uint16_t *) tx_mic)) & 0xFFFF;
     494                        mic[4] = uint32_t_le2host(*((uint32_t *) (tx_mic + 4)));
     495                       
     496                        wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 0, mic[0]);
     497                        wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 4, mic[1]);
     498                        wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 8, mic[2]);
     499                        wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 12, mic[3]);
     500                        wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 16, mic[4]);
     501                        wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 20,
     502                            AR9271_KEY_TABLE_TYPE_CLR);
    550503                       
    551504                        wmi_reg_write(ar9271->htc_device, mic_reg_ptr + 24, 0);
     
    553506                }
    554507               
    555                 if(key_conf->flags & IEEE80211_KEY_FLAG_TYPE_GROUP)
     508                if (key_conf->flags & IEEE80211_KEY_FLAG_TYPE_GROUP)
    556509                        ieee80211_setup_key_confirm(ieee80211_dev, true);
    557510        } else {
     
    564517
    565518static int ar9271_ieee80211_tx_handler(ieee80211_dev_t *ieee80211_dev,
    566         void *buffer, size_t buffer_size)
     519    void *buffer, size_t buffer_size)
    567520{
    568521        assert(ieee80211_dev);
    569522       
    570         size_t complete_size, offset;
     523        size_t complete_size;
     524        size_t offset;
    571525        void *complete_buffer;
    572526        int endpoint;
     
    575529       
    576530        uint16_t frame_ctrl = *((uint16_t *) buffer);
    577         if(ieee80211_is_data_frame(frame_ctrl)) {
     531        if (ieee80211_is_data_frame(frame_ctrl)) {
    578532                offset = sizeof(htc_tx_data_header_t) +
    579                         sizeof(htc_frame_header_t);
     533                    sizeof(htc_frame_header_t);
    580534                complete_size = buffer_size + offset;
    581535                complete_buffer = malloc(complete_size);
    582536                memset(complete_buffer, 0, complete_size);
    583537               
    584                 /* 
     538                /*
    585539                 * Because we handle just station mode yet, node ID and VIF ID
    586540                 * are fixed.
    587541                 */
    588542                htc_tx_data_header_t *data_header =
    589                         (htc_tx_data_header_t *)
    590                         (complete_buffer + sizeof(htc_frame_header_t));
     543                    (htc_tx_data_header_t *)
     544                    (complete_buffer + sizeof(htc_frame_header_t));
    591545                data_header->data_type = HTC_DATA_NORMAL;
    592546                data_header->node_idx = 1;
     
    594548                data_header->cookie = 0;
    595549               
    596                 if(ieee80211_query_using_key(ieee80211_dev)) {
     550                if (ieee80211_query_using_key(ieee80211_dev)) {
    597551                        data_header->keyix = AR9271_STA_KEY_INDEX;
    598                         int sec_suite =
    599                                 ieee80211_get_pairwise_security(ieee80211_dev);
    600                         switch(sec_suite) {
    601                                 case IEEE80211_SECURITY_SUITE_WEP40:
    602                                 case IEEE80211_SECURITY_SUITE_WEP104:
    603                                         data_header->key_type =
    604                                                 AR9271_KEY_TYPE_WEP;
    605                                         break;
    606                                 case IEEE80211_SECURITY_SUITE_TKIP:
    607                                         data_header->key_type =
    608                                                 AR9271_KEY_TYPE_TKIP;
    609                                         break;
    610                                 case IEEE80211_SECURITY_SUITE_CCMP:
    611                                         data_header->key_type =
    612                                                 AR9271_KEY_TYPE_AES;
    613                                         break;
     552                       
     553                        int sec_suite =
     554                            ieee80211_get_pairwise_security(ieee80211_dev);
     555                       
     556                        switch (sec_suite) {
     557                        case IEEE80211_SECURITY_SUITE_WEP40:
     558                        case IEEE80211_SECURITY_SUITE_WEP104:
     559                                data_header->key_type = AR9271_KEY_TYPE_WEP;
     560                                break;
     561                        case IEEE80211_SECURITY_SUITE_TKIP:
     562                                data_header->key_type = AR9271_KEY_TYPE_TKIP;
     563                                break;
     564                        case IEEE80211_SECURITY_SUITE_CCMP:
     565                                data_header->key_type = AR9271_KEY_TYPE_AES;
     566                                break;
    614567                        }
    615568                } else {
     
    621574        } else {
    622575                offset = sizeof(htc_tx_management_header_t) +
    623                         sizeof(htc_frame_header_t);
     576                    sizeof(htc_frame_header_t);
    624577                complete_size = buffer_size + offset;
    625578                complete_buffer = malloc(complete_size);
    626579                memset(complete_buffer, 0, complete_size);
    627580               
    628                 /* 
     581                /*
    629582                 * Because we handle just station mode yet, node ID and VIF ID
    630583                 * are fixed.
    631584                 */
    632585                htc_tx_management_header_t *mgmt_header =
    633                         (htc_tx_management_header_t *)
    634                         (complete_buffer + sizeof(htc_frame_header_t));
     586                    (htc_tx_management_header_t *)
     587                    (complete_buffer + sizeof(htc_frame_header_t));
    635588                mgmt_header->node_idx = 0;
    636589                mgmt_header->vif_idx = 0;
     
    645598       
    646599        htc_send_data_message(ar9271->htc_device, complete_buffer,
    647                 complete_size, endpoint);
     600            complete_size, endpoint);
    648601       
    649602        free(complete_buffer);
     
    661614       
    662615        int rc = hw_reset(ar9271);
    663         if(rc != EOK) {
     616        if (rc != EOK) {
    664617                usb_log_error("Failed to do HW reset.\n");
    665618                return rc;
     
    667620       
    668621        uint16_t htc_mode = host2uint16_t_be(1);
    669         wmi_send_command(ar9271->htc_device, WMI_SET_MODE, 
    670                 (uint8_t *) &htc_mode, sizeof(htc_mode), NULL);
     622        wmi_send_command(ar9271->htc_device, WMI_SET_MODE,
     623            (uint8_t *) &htc_mode, sizeof(htc_mode), NULL);
    671624        wmi_send_command(ar9271->htc_device, WMI_ATH_INIT, NULL, 0, NULL);
    672625        wmi_send_command(ar9271->htc_device, WMI_START_RECV, NULL, 0, NULL);
     
    674627       
    675628        rc = hw_rx_init(ar9271);
    676         if(rc != EOK) {
     629        if (rc != EOK) {
    677630                usb_log_error("Failed to initialize RX.\n");
    678631                return rc;
     
    681634        /* Send capability message to target. */
    682635        htc_cap_msg_t cap_msg;
    683         cap_msg.ampdu_limit = host2uint32_t_be(0xFFFF);
    684         cap_msg.ampdu_subframes = 0xFF;
     636        cap_msg.ampdu_limit = host2uint32_t_be(0xffff);
     637        cap_msg.ampdu_subframes = 0xff;
    685638        cap_msg.enable_coex = 0;
    686639        cap_msg.tx_chainmask = 0x1;
    687640       
    688641        wmi_send_command(ar9271->htc_device, WMI_TARGET_IC_UPDATE,
    689                 (uint8_t *) &cap_msg, sizeof(cap_msg), NULL);
     642            (uint8_t *) &cap_msg, sizeof(cap_msg), NULL);
    690643       
    691644        rc = htc_init_new_vif(ar9271->htc_device);
    692         if(rc != EOK) {
     645        if (rc != EOK) {
    693646                usb_log_error("Failed to initialize new VIF.\n");
    694647                return rc;
     
    697650        /* Add data polling fibril. */
    698651        fid_t fibril = fibril_create(ar9271_data_polling, ar9271);
    699         if (fibril == 0) {
     652        if (fibril == 0)
    700653                return ENOMEM;
    701         }
     654       
    702655        fibril_add_ready(fibril);
    703656       
     
    725678       
    726679        int rc = ath_usb_init(ar9271->ath_device, usb_device);
    727         if(rc != EOK) {
     680        if (rc != EOK) {
    728681                free(ar9271->ath_device);
    729682                usb_log_error("Failed to initialize ath device.\n");
     
    741694       
    742695        rc = ieee80211_device_init(ar9271->ieee80211_dev, ar9271->ddf_dev);
    743         if(rc != EOK) {
     696        if (rc != EOK) {
    744697                free(ar9271->ieee80211_dev);
    745698                free(ar9271->ath_device);
    746699                usb_log_error("Failed to initialize IEEE80211 device structure."
    747                         "\n");
     700                    "\n");
    748701                return rc;
    749702        }
    750703       
    751704        ieee80211_set_specific(ar9271->ieee80211_dev, ar9271);
    752                
     705       
    753706        /* HTC device structure initialization. */
    754707        ar9271->htc_device = calloc(1, sizeof(htc_device_t));
    755         if(!ar9271->htc_device) {
     708        if (!ar9271->htc_device) {
    756709                free(ar9271->ieee80211_dev);
    757710                free(ar9271->ath_device);
     
    761714        }
    762715       
    763         rc = htc_device_init(ar9271->ath_device, ar9271->ieee80211_dev, 
    764                 ar9271->htc_device);
    765         if(rc != EOK) {
     716        rc = htc_device_init(ar9271->ath_device, ar9271->ieee80211_dev,
     717            ar9271->htc_device);
     718        if (rc != EOK) {
    766719                free(ar9271->htc_device);
    767720                free(ar9271->ieee80211_dev);
     
    774727}
    775728
    776 /**
    777  * Upload firmware to WiFi device.
    778  *
     729/** Upload firmware to WiFi device.
     730 *
    779731 * @param ar9271 AR9271 device structure
    780  * 
     732 *
    781733 * @return EOK if succeed, negative error code otherwise
     734 *
    782735 */
    783736static int ar9271_upload_fw(ar9271_t *ar9271)
    784737{
    785         int rc;
    786        
    787738        usb_device_t *usb_device = ar9271->usb_device;
    788        
    789         /* TODO: Set by maximum packet size in pipe. */
     739       
     740        /* TODO: Set by maximum packet size in pipe. */
    790741        static const size_t MAX_TRANSFER_SIZE = 512;
    791742       
     
    802753       
    803754        void *fw_data = malloc(file_size);
    804         if(fw_data == NULL) {
     755        if (fw_data == NULL) {
    805756                fclose(fw_file);
    806757                usb_log_error("Failed allocating memory for firmware.\n");
    807758                return ENOMEM;
    808759        }
    809 
     760       
    810761        fread(fw_data, file_size, 1, fw_file);
    811762        fclose(fw_file);
     
    816767        uint8_t *current_data = fw_data;
    817768        uint8_t *buffer = malloc(MAX_TRANSFER_SIZE);
    818         while(remain_size > 0) {
     769       
     770        while (remain_size > 0) {
    819771                size_t chunk_size = min(remain_size, MAX_TRANSFER_SIZE);
    820772                memcpy(buffer, current_data, chunk_size);
    821                 rc = usb_control_request_set(&usb_device->ctrl_pipe,
     773                int rc = usb_control_request_set(&usb_device->ctrl_pipe,
    822774                    USB_REQUEST_TYPE_VENDOR,
    823775                    USB_REQUEST_RECIPIENT_DEVICE,
     
    825777                    uint16_host2usb(current_addr >> 8),
    826778                    0, buffer, chunk_size);
    827                 if(rc != EOK) {
     779                if (rc != EOK) {
    828780                        free(fw_data);
    829781                        free(buffer);
     
    841793        free(buffer);
    842794       
    843         /* Send command that firmware is successfully uploaded.
    844          * This should initiate creating confirmation message in
    845          * device side buffer which we will check in htc_check_ready function.
    846          */
    847         rc = usb_control_request_set(&usb_device->ctrl_pipe,
     795        /*
     796         * Send command that firmware is successfully uploaded.
     797         * This should initiate creating confirmation message in
     798         * device side buffer which we will check in htc_check_ready function.
     799        */
     800        int rc = usb_control_request_set(&usb_device->ctrl_pipe,
    848801            USB_REQUEST_TYPE_VENDOR,
    849802            USB_REQUEST_RECIPIENT_DEVICE,
     
    852805            0, NULL, 0);
    853806       
    854         if(rc != EOK) {
     807        if (rc != EOK) {
    855808                usb_log_error("IO error when sending fw upload confirmation "
    856                         "message.\n");
     809                    "message.\n");
    857810                return rc;
    858811        }
     
    867820
    868821/** Create driver data structure.
    869  * 
     822 *
    870823 *  @param dev The device structure
    871  * 
     824 *
    872825 *  @return Intialized device data structure or NULL if error occured
    873826 */
     
    883836        const char *err_msg = NULL;
    884837        int rc = usb_device_init(usb_device, dev, endpoints, &err_msg);
    885         if(rc != EOK) {
     838        if (rc != EOK) {
    886839                free(usb_device);
    887840                usb_log_error("Failed to create USB device: %s, "
     
    902855       
    903856        rc = ar9271_init(ar9271, usb_device);
    904         if(rc != EOK) {
     857        if (rc != EOK) {
    905858                free(ar9271);
    906859                free(usb_device);
    907                 usb_log_error("Failed to initialize AR9271 structure: %d\n", 
    908                         rc);
     860                usb_log_error("Failed to initialize AR9271 structure: %d\n",
     861                    rc);
    909862                return NULL;
    910863        }
     
    948901        /* Initialize AR9271 HTC services. */
    949902        int rc = htc_init(ar9271->htc_device);
    950         if(rc != EOK) {
     903        if (rc != EOK) {
    951904                ar9271_delete_dev_data(ar9271);
    952905                usb_log_error("HTC initialization failed.\n");
     
    956909        /* Initialize AR9271 HW. */
    957910        rc = hw_init(ar9271);
    958         if(rc != EOK) {
     911        if (rc != EOK) {
    959912                ar9271_delete_dev_data(ar9271);
    960913                usb_log_error("HW initialization failed.\n");
     
    964917        /* Initialize AR9271 IEEE 802.11 framework. */
    965918        rc = ieee80211_init(ar9271->ieee80211_dev, &ar9271_ieee80211_ops,
    966                 &ar9271_ieee80211_iface, &ar9271_ieee80211_nic_iface,
    967                 &ar9271_ieee80211_dev_ops);
    968         if(rc != EOK) {
     919            &ar9271_ieee80211_iface, &ar9271_ieee80211_nic_iface,
     920            &ar9271_ieee80211_dev_ops);
     921        if (rc != EOK) {
    969922                ar9271_delete_dev_data(ar9271);
    970923                usb_log_error("Failed to initialize IEEE80211 framework.\n");
     
    973926       
    974927        nic_set_filtering_change_handlers(nic_get_from_ddf_dev(dev),
    975                 ar9271_on_unicast_mode_change, ar9271_on_multicast_mode_change,
    976                 ar9271_on_broadcast_mode_change, NULL, NULL);
     928            ar9271_on_unicast_mode_change, ar9271_on_multicast_mode_change,
     929            ar9271_on_broadcast_mode_change, NULL, NULL);
    977930       
    978931        usb_log_info("HelenOS AR9271 added device.\n");
     
    989942       
    990943        usb_log_info("HelenOS AR9271 driver started.\n");
    991 
     944       
    992945        return ddf_driver_main(&ar9271_driver);
    993946}
  • uspace/drv/nic/ar9271/ar9271.h

    r09044cb r8a64320e  
    3737
    3838#include <usb/dev/driver.h>
    39 
    4039#include "htc.h"
    4140
    4241/** Number of transmission queues */
    43 #define AR9271_QUEUES_COUNT 10
     42#define AR9271_QUEUES_COUNT  10
    4443
    4544/** Number of GPIO pin used for handling led light */
    46 #define AR9271_LED_PIN 15
     45#define AR9271_LED_PIN  15
    4746
    4847/** Nominal value for AR9271 noise floor calibration. */
    49 #define AR9271_CALIB_NOMINAL_VALUE_2GHZ -118
     48#define AR9271_CALIB_NOMINAL_VALUE_2GHZ  -118
    5049
    5150/** RX errors values. */
    52 #define AR9271_RX_ERROR_CRC 0x01
    53 #define AR9271_RX_ERROR_PHY 0x02
     51#define AR9271_RX_ERROR_CRC  0x01
     52#define AR9271_RX_ERROR_PHY  0x02
    5453
    5554/** Key index used for device in station mode. */
    56 #define AR9271_STA_KEY_INDEX 4
     55#define AR9271_STA_KEY_INDEX  4
    5756
    5857/* HW encryption key indicator. */
     
    8382        AR9271_RC = 0x4000,
    8483        AR9271_RC_AHB = 0x00000001,
    85                
     84       
    8685        /* GPIO registers */
    87         AR9271_GPIO_IN_OUT = 0x4048,            /**< GPIO value read/set  */
    88         AR9271_GPIO_OE_OUT = 0x404C,            /**< GPIO set to output  */
    89         AR9271_GPIO_OE_OUT_ALWAYS = 0x3,        /**< GPIO always drive output */
     86        AR9271_GPIO_IN_OUT = 0x4048,       /**< GPIO value read/set  */
     87        AR9271_GPIO_OE_OUT = 0x404C,       /**< GPIO set to output  */
     88        AR9271_GPIO_OE_OUT_ALWAYS = 0x3,   /**< GPIO always drive output */
    9089        AR9271_GPIO_OUT_MUX1 = 0x4060,
    9190        AR9271_GPIO_OUT_MUX2 = 0x4064,
    9291        AR9271_GPIO_OUT_MUX3 = 0x4068,
    93         AR9271_GPIO_OUT_MUX_AS_OUT = 0x0,       /**< GPIO set mux as output */
    94    
     92        AR9271_GPIO_OUT_MUX_AS_OUT = 0x0,  /**< GPIO set mux as output */
     93       
    9594        /* RTC related registers */
    9695        AR9271_RTC_RC = 0x7000,
     
    109108        AR9271_RTC_FORCE_WAKE_ENABLE = 0x00000001,
    110109        AR9271_RTC_FORCE_WAKE_ON_INT = 0x00000002,
    111                
     110       
    112111        /* MAC Registers */
    113         AR9271_STATION_ID0 = 0x8000,    /**< STA Address Lower 32 Bits */
    114         AR9271_STATION_ID1 = 0x8004,    /**< STA Address Upper 16 Bits */
    115         AR9271_BSSID0 = 0x8008,         /**< BSSID Lower 32 Bits */
    116         AR9271_BSSID1 = 0x800C,         /**< BSSID Upper 16 Bits */
    117         AR9271_BSSID_MASK0 = 0x80E0,    /**< BSSID Mask Lower 32 Bits */
    118         AR9271_BSSID_MASK1 = 0x80E4,    /**< BSSID Mask Upper 16 Bits */
     112        AR9271_STATION_ID0 = 0x8000,  /**< STA Address Lower 32 Bits */
     113        AR9271_STATION_ID1 = 0x8004,  /**< STA Address Upper 16 Bits */
     114        AR9271_BSSID0 = 0x8008,       /**< BSSID Lower 32 Bits */
     115        AR9271_BSSID1 = 0x800C,       /**< BSSID Upper 16 Bits */
     116        AR9271_BSSID_MASK0 = 0x80E0,  /**< BSSID Mask Lower 32 Bits */
     117        AR9271_BSSID_MASK1 = 0x80E4,  /**< BSSID Mask Upper 16 Bits */
    119118        AR9271_STATION_ID1_MASK = 0x0000FFFF,
    120119        AR9271_STATION_ID1_POWER_SAVING = 0x00040000,
    121120        AR9271_MULTICAST_FILTER1 = 0x8040,
    122         AR9271_MULTICAST_FILTER2 = 0x8044,     
     121        AR9271_MULTICAST_FILTER2 = 0x8044,
    123122        AR9271_DIAG = 0x8048,
    124                
     123       
    125124        /* RX filtering register */
    126125        AR9271_RX_FILTER = 0x803C,
     
    134133        AR9271_RX_FILTER_MYBEACON = 0x00000200,
    135134        AR9271_RX_FILTER_MCAST_BCAST_ALL = 0x00008000,
    136                
     135       
    137136        /* Key related registers */
    138137        AR9271_KEY_TABLE_BASE = 0x8800,
     
    142141        AR9271_KEY_TABLE_TYPE_CCMP = 0x6,
    143142        AR9271_KEY_TABLE_TYPE_CLR = 0x7,
    144                
     143       
    145144        /* Physical layer registers */
    146145        AR9271_PHY_ACTIVE = 0x981C,
     
    168167        AR9271_PHY_TPCRG1_PD_CALIB = 0x00400000,
    169168        AR9271_CARRIER_LEAK_CALIB = 0x00000002,
    170                
     169       
    171170        AR9271_OPMODE_STATION_AP_MASK = 0x00010000,
    172171        AR9271_OPMODE_ADHOC_MASK = 0x00020000,
    173                
     172       
    174173        AR9271_CLOCK_CONTROL = 0x50040,
    175174        AR9271_MAX_CPU_CLOCK = 0x304,
    176                
     175       
    177176        AR9271_RESET_POWER_DOWN_CONTROL = 0x50044,
    178177        AR9271_RADIO_RF_RESET = 0x20,
    179178        AR9271_GATE_MAC_CONTROL = 0x4000,
    180    
     179       
    181180        /* FW Addresses */
    182181        AR9271_FW_ADDRESS = 0x501000,
     
    185184
    186185/** Compute key table base position for key by its id. */
    187 #define AR9271_KEY_TABLE(id) (AR9271_KEY_TABLE_BASE + (id)*32)
     186#define AR9271_KEY_TABLE(id)  (AR9271_KEY_TABLE_BASE + (id) * 32)
    188187
    189188/** AR9271 Requests */
     
    217216} ar9271_t;
    218217
    219 /**
    220  * AR9271 init values for 2GHz mode operation.
    221  *
     218/** AR9271 init values for 2GHz mode operation.
     219 *
    222220 * Including settings of noise floor limits.
    223  *
    224  * Taken from Linux sources.
     221 *
     222 * Taken from the Linux driver (drivers/net/wireless/ath/ath9k/)
     223 * Copyright (c) 2008-2011 Atheros Communications Inc.
     224 * Licensed under the terms of ISC
     225 *
    225226 */
    226227static const uint32_t ar9271_2g_mode_array[][2] = {
     
    232233        {0x0000801c, 0x12e0002b},
    233234        {0x00008318, 0x00003440},
    234         {0x00009804, 0x000003c0},/*< note: overridden */
     235        {0x00009804, 0x000003c0},  /*< Note: overridden */
    235236        {0x00009820, 0x02020200},
    236237        {0x00009824, 0x01000e0e},
    237         {0x00009828, 0x0a020001},/*< note: overridden */
     238        {0x00009828, 0x0a020001},  /*< Note: overridden */
    238239        {0x00009834, 0x00000e0e},
    239240        {0x00009838, 0x00000007},
     
    530531};
    531532
    532 /**
    533  * AR9271 TX init values for 2GHz mode operation.
    534  *
    535  * Taken from Linux sources.
     533/** AR9271 TX init values for 2GHz mode operation.
     534 *
     535 * Taken from the Linux driver (drivers/net/wireless/ath/ath9k/)
     536 * Copyright (c) 2008-2011 Atheros Communications Inc.
     537 * Licensed under the terms of ISC
     538 *
    536539 */
    537540static const uint32_t ar9271_2g_tx_array[][2] = {
     
    571574};
    572575
    573 /**
    574  * AR9271 hardware init values.
    575  *
    576  * Taken from Linux sources, some values omitted.
     576/** AR9271 hardware init values.
     577 *
     578 * Taken from the Linux driver (drivers/net/wireless/ath/ath9k/)
     579 * Copyright (c) 2008-2011 Atheros Communications Inc.
     580 * Licensed under the terms of ISC
     581 *
    577582 */
    578583static const uint32_t ar9271_init_array[][2] = {
     
    766771        {0x0000833c, 0x00000000},
    767772        {0x00008340, 0x00010380},
    768         {0x00008344, 0x00481083},/*< note: disabled ADHOC_MCAST_KEYID feature */
     773        {0x00008344, 0x00481083},  /**< Note: disabled ADHOC_MCAST_KEYID feature */
    769774        {0x00007010, 0x00000030},
    770775        {0x00007034, 0x00000002},
  • uspace/drv/nic/ar9271/ath.h

    r09044cb r8a64320e  
    3434
    3535#ifndef ATHEROS_ATH_H
    36 #define ATHEROS_ATH_H
     36#define ATHEROS_ATH_H
    3737
    3838struct ath;
     
    6161} ath_t;
    6262
    63 #endif  /* ATHEROS_ATH_H */
     63#endif  /* ATHEROS_ATH_H */
  • uspace/drv/nic/ar9271/ath_usb.c

    r09044cb r8a64320e  
    3636#include <usb/debug.h>
    3737#include <malloc.h>
    38 
    3938#include "ath_usb.h"
    4039
    41 static int ath_usb_send_ctrl_message(ath_t *ath, void *buffer,
    42         size_t buffer_size);
    43 
    44 static int ath_usb_read_ctrl_message(ath_t *ath, void *buffer,
    45         size_t buffer_size, size_t *transferred_size);
    46 
    47 static int ath_usb_send_data_message(ath_t *ath, void *buffer,
    48         size_t buffer_size);
    49 
    50 static int ath_usb_read_data_message(ath_t *ath, void *buffer,
    51         size_t buffer_size, size_t *transferred_size);
     40static int ath_usb_send_ctrl_message(ath_t *, void *, size_t);
     41static int ath_usb_read_ctrl_message(ath_t *, void *, size_t, size_t *);
     42static int ath_usb_send_data_message(ath_t *, void *, size_t);
     43static int ath_usb_read_data_message(ath_t *, void *, size_t, size_t *);
    5244
    5345static ath_ops_t ath_usb_ops = {
     
    5850};
    5951
    60 /**
    61  * Initialize Atheros WiFi USB device.
    62  *
     52/** Initialize Atheros WiFi USB device.
     53 *
    6354 * @param ath Generic Atheros WiFi device structure.
    64  * @param usb_device Connected USB device.
    65  * 
     55 * @param usb_device  Connected USB device.
     56 *
    6657 * @return EOK if succeed, negative error code otherwise.
     58 *
    6759 */
    6860int ath_usb_init(ath_t *ath, usb_device_t *usb_device)
     
    9284}
    9385
    94 /**
    95  * Send control message.
    96  *
    97  * @param ath Generic Atheros WiFi device structure.
    98  * @param buffer Buffer with data to send.
     86/** Send control message.
     87 *
     88 * @param ath         Generic Atheros WiFi device structure.
     89 * @param buffer      Buffer with data to send.
    9990 * @param buffer_size Buffer size.
    100  * 
     91 *
    10192 * @return EOK if succeed, negative error code otherwise.
     93 *
    10294 */
    103 static int ath_usb_send_ctrl_message(ath_t *ath, void *buffer, 
    104         size_t buffer_size)
     95static int ath_usb_send_ctrl_message(ath_t *ath, void *buffer,
     96    size_t buffer_size)
    10597{
    10698        ath_usb_t *ath_usb = (ath_usb_t *) ath->specific_data;
    107         usb_pipe_t *pipe =
    108                 &ath_usb->usb_device->pipes[ath_usb->output_ctrl_pipe_number].
    109                 pipe;
     99        usb_pipe_t *pipe =
     100            &ath_usb->usb_device->pipes[ath_usb->output_ctrl_pipe_number].pipe;
    110101       
    111102        return usb_pipe_write(pipe, buffer, buffer_size);
    112103}
    113104
    114 /**
    115  * Read control message.
    116  *
    117  * @param ath Generic Atheros WiFi device structure.
    118  * @param buffer Buffer with data to send.
    119  * @param buffer_size Buffer size.
     105/** Read control message.
     106 *
     107 * @param ath              Generic Atheros WiFi device structure.
     108 * @param buffer           Buffer with data to send.
     109 * @param buffer_size      Buffer size.
    120110 * @param transferred_size Real size of read data.
    121  * 
     111 *
    122112 * @return EOK if succeed, negative error code otherwise.
     113 *
    123114 */
    124 static int ath_usb_read_ctrl_message(ath_t *ath, void *buffer, 
    125         size_t buffer_size, size_t *transferred_size)
     115static int ath_usb_read_ctrl_message(ath_t *ath, void *buffer,
     116    size_t buffer_size, size_t *transferred_size)
    126117{
    127118        ath_usb_t *ath_usb = (ath_usb_t *) ath->specific_data;
    128         usb_pipe_t *pipe =
    129                 &ath_usb->usb_device->pipes[ath_usb->input_ctrl_pipe_number].
    130                 pipe;
     119        usb_pipe_t *pipe =
     120            &ath_usb->usb_device->pipes[ath_usb->input_ctrl_pipe_number].pipe;
    131121       
    132122        return usb_pipe_read(pipe, buffer, buffer_size, transferred_size);
    133123}
    134124
    135 /**
    136  * Send data message.
    137  *
    138  * @param ath Generic Atheros WiFi device structure.
    139  * @param buffer Buffer with data to send.
     125/** Send data message.
     126 *
     127 * @param ath         Generic Atheros WiFi device structure.
     128 * @param buffer      Buffer with data to send.
    140129 * @param buffer_size Buffer size.
    141  * 
     130 *
    142131 * @return EOK if succeed, negative error code otherwise.
     132 *
    143133 */
    144 static int ath_usb_send_data_message(ath_t *ath, void *buffer, 
    145         size_t buffer_size)
     134static int ath_usb_send_data_message(ath_t *ath, void *buffer,
     135    size_t buffer_size)
    146136{
    147         size_t complete_buffer_size = buffer_size + 
    148                 sizeof(ath_usb_data_header_t);
     137        size_t complete_buffer_size = buffer_size +
     138            sizeof(ath_usb_data_header_t);
    149139        void *complete_buffer = malloc(complete_buffer_size);
    150         memcpy(complete_buffer + sizeof(ath_usb_data_header_t), 
    151                 buffer, buffer_size);
     140        memcpy(complete_buffer + sizeof(ath_usb_data_header_t),
     141            buffer, buffer_size);
    152142       
    153         ath_usb_data_header_t *data_header = 
    154                 (ath_usb_data_header_t *) complete_buffer;
     143        ath_usb_data_header_t *data_header =
     144            (ath_usb_data_header_t *) complete_buffer;
    155145        data_header->length = host2uint16_t_le(buffer_size);
    156146        data_header->tag = host2uint16_t_le(TX_TAG);
    157147       
    158148        ath_usb_t *ath_usb = (ath_usb_t *) ath->specific_data;
    159         usb_pipe_t *pipe =
    160                 &ath_usb->usb_device->pipes[ath_usb->output_data_pipe_number].
    161                 pipe;
     149        usb_pipe_t *pipe =
     150            &ath_usb->usb_device->pipes[ath_usb->output_data_pipe_number].pipe;
    162151       
    163         int ret_val = usb_pipe_write(pipe, complete_buffer, 
    164                 complete_buffer_size);
     152        int ret_val = usb_pipe_write(pipe, complete_buffer,
     153            complete_buffer_size);
    165154       
    166155        free(complete_buffer);
     
    169158}
    170159
    171 /**
    172  * Read data message.
    173  *
    174  * @param ath Generic Atheros WiFi device structure.
    175  * @param buffer Buffer with data to send.
    176  * @param buffer_size Buffer size.
     160/** Read data message.
     161 *
     162 * @param ath              Generic Atheros WiFi device structure.
     163 * @param buffer           Buffer with data to send.
     164 * @param buffer_size      Buffer size.
    177165 * @param transferred_size Real size of read data.
    178  * 
     166 *
    179167 * @return EOK if succeed, negative error code otherwise.
     168 *
    180169 */
    181 static int ath_usb_read_data_message(ath_t *ath, void *buffer, 
    182         size_t buffer_size, size_t *transferred_size)
     170static int ath_usb_read_data_message(ath_t *ath, void *buffer,
     171    size_t buffer_size, size_t *transferred_size)
    183172{
    184173        ath_usb_t *ath_usb = (ath_usb_t *) ath->specific_data;
    185         usb_pipe_t *pipe =
    186                 &ath_usb->usb_device->pipes[ath_usb->input_data_pipe_number].
    187                 pipe;
     174        usb_pipe_t *pipe =
     175            &ath_usb->usb_device->pipes[ath_usb->input_data_pipe_number].pipe;
    188176       
    189         return usb_pipe_read(pipe, buffer, buffer_size, 
    190                 transferred_size);
     177        return usb_pipe_read(pipe, buffer, buffer_size,
     178            transferred_size);
    191179}
  • uspace/drv/nic/ar9271/ath_usb.h

    r09044cb r8a64320e  
    3434
    3535#ifndef ATHEROS_ATH_USB_H
    36 #define ATHEROS_ATH_USB_H
     36#define ATHEROS_ATH_USB_H
    3737
    3838#include <usb/dev/driver.h>
    39 
    4039#include "ath.h"
    4140
    42 #define RX_TAG 0x4e00
    43 #define TX_TAG 0x697e
     41#define RX_TAG  0x4e00
     42#define TX_TAG  0x697e
    4443
    4544/** Atheros USB wifi device structure */
     
    5655
    5756typedef struct {
    58         uint16_t length;                /**< Little Endian value! */
    59         uint16_t tag;                   /**< Little Endian value! */
     57        uint16_t length;  /**< Little Endian value! */
     58        uint16_t tag;     /**< Little Endian value! */
    6059} ath_usb_data_header_t;
    6160
    62 extern int ath_usb_init(ath_t *ath, usb_device_t *usb_device);
     61extern int ath_usb_init(ath_t *, usb_device_t *);
    6362
    64 #endif  /* ATHEROS_ATH_USB_H */
     63#endif  /* ATHEROS_ATH_USB_H */
  • uspace/drv/nic/ar9271/htc.c

    r09044cb r8a64320e  
    3636#include <byteorder.h>
    3737#include <errno.h>
    38 
    3938#include "wmi.h"
    4039#include "htc.h"
     
    4241#include "ar9271.h"
    4342
    44 /**
    45  * HTC download pipes mapping.
    46  *
     43/** HTC download pipes mapping.
     44 *
    4745 * @param service_id Identification of WMI service.
    48  * 
     46 *
    4947 * @return Number of pipe used for this service.
     48 *
    5049 */
    5150static inline uint8_t wmi_service_to_download_pipe(wmi_services_t service_id)
     
    5453}
    5554
    56 /**
    57  * HTC upload pipes mapping.
    58  *
     55/** HTC upload pipes mapping.
     56 *
    5957 * @param service_id Identification of WMI service.
    60  * 
     58 *
    6159 * @return Number of pipe used for this service.
     60 *
    6261 */
    6362static inline uint8_t wmi_service_to_upload_pipe(wmi_services_t service_id)
     
    7574       
    7675        nic_address_t addr;
    77         nic_t *nic =
    78                 nic_get_from_ddf_dev(
    79                         ieee80211_get_ddf_dev(htc_device->ieee80211_dev)
    80                 );
     76        nic_t *nic =
     77            nic_get_from_ddf_dev(ieee80211_get_ddf_dev(htc_device->ieee80211_dev));
    8178        nic_query_address(nic, &addr);
    8279       
     
    8481        memcpy(&sta_msg.addr, &addr.address, ETH_ADDR);
    8582       
    86         ieee80211_operating_mode_t op_mode = 
    87                 ieee80211_query_current_op_mode(htc_device->ieee80211_dev);
    88        
    89         switch(op_mode) {
    90                 case IEEE80211_OPMODE_ADHOC:
    91                         vif_msg.op_mode = HTC_OPMODE_ADHOC;
    92                         break;
    93                 case IEEE80211_OPMODE_AP:
    94                         vif_msg.op_mode = HTC_OPMODE_AP;
    95                         break;
    96                 case IEEE80211_OPMODE_MESH:
    97                         vif_msg.op_mode = HTC_OPMODE_MESH;
    98                         break;
    99                 case IEEE80211_OPMODE_STATION:
    100                         vif_msg.op_mode = HTC_OPMODE_STATION;
    101                         break;
     83        ieee80211_operating_mode_t op_mode =
     84            ieee80211_query_current_op_mode(htc_device->ieee80211_dev);
     85       
     86        switch (op_mode) {
     87        case IEEE80211_OPMODE_ADHOC:
     88                vif_msg.op_mode = HTC_OPMODE_ADHOC;
     89                break;
     90        case IEEE80211_OPMODE_AP:
     91                vif_msg.op_mode = HTC_OPMODE_AP;
     92                break;
     93        case IEEE80211_OPMODE_MESH:
     94                vif_msg.op_mode = HTC_OPMODE_MESH;
     95                break;
     96        case IEEE80211_OPMODE_STATION:
     97                vif_msg.op_mode = HTC_OPMODE_STATION;
     98                break;
    10299        }
    103100       
     
    105102        vif_msg.rts_thres = host2uint16_t_be(HTC_RTS_THRESHOLD);
    106103       
    107         wmi_send_command(htc_device, WMI_VAP_CREATE, (uint8_t *) &vif_msg, 
    108                 sizeof(vif_msg), NULL);
     104        wmi_send_command(htc_device, WMI_VAP_CREATE, (uint8_t *) &vif_msg,
     105            sizeof(vif_msg), NULL);
    109106       
    110107        sta_msg.is_vif_sta = 1;
     
    113110        sta_msg.vif_index = 0;
    114111       
    115         wmi_send_command(htc_device, WMI_NODE_CREATE, (uint8_t *) &sta_msg, 
    116                 sizeof(sta_msg), NULL);
     112        wmi_send_command(htc_device, WMI_NODE_CREATE, (uint8_t *) &sta_msg,
     113            sizeof(sta_msg), NULL);
    117114       
    118115        /* Write first 4 bytes of MAC address. */
     
    121118        id0 = host2uint32_t_le(id0);
    122119        wmi_reg_write(htc_device, AR9271_STATION_ID0, id0);
    123 
     120       
    124121        /* Write last 2 bytes of MAC address (and preserve existing data). */
    125122        uint32_t id1;
    126123        wmi_reg_read(htc_device, AR9271_STATION_ID1, &id1);
    127 
     124       
    128125        uint16_t id1_addr;
    129126        memcpy(&id1_addr, &addr.address[4], 2);
     
    134131}
    135132
    136 static void htc_config_frame_header(htc_frame_header_t *header, 
    137         size_t buffer_size, uint8_t endpoint_id)
     133static void htc_config_frame_header(htc_frame_header_t *header,
     134    size_t buffer_size, uint8_t endpoint_id)
    138135{
    139136        memset(header, 0, sizeof(htc_frame_header_t));
    140137       
    141138        header->endpoint_id = endpoint_id;
    142         header->payload_length =
    143                 host2uint16_t_be(buffer_size - sizeof(htc_frame_header_t));
    144 }
    145 
    146 /**
    147  * Send control HTC message to USB device.
    148  *
    149  * @param htc_device HTC device structure.
    150  * @param buffer Buffer with data to be sent to USB device (without HTC frame
    151  *              header).
     139        header->payload_length =
     140            host2uint16_t_be(buffer_size - sizeof(htc_frame_header_t));
     141}
     142
     143/** Send control HTC message to USB device.
     144 *
     145 * @param htc_device  HTC device structure.
     146 * @param buffer      Buffer with data to be sent to USB device
     147 *                    (without HTC frame header).
    152148 * @param buffer_size Size of buffer (including HTC frame header).
    153149 * @param endpoint_id Destination endpoint.
    154  *
    155  * @return EOK if succeed, negative error code otherwise.
    156  */
    157 int htc_send_control_message(htc_device_t *htc_device, void *buffer,
    158         size_t buffer_size, uint8_t endpoint_id)
     150 *
     151 * @return EOK if succeed, negative error code otherwise.
     152 *
     153 */
     154int htc_send_control_message(htc_device_t *htc_device, void *buffer,
     155    size_t buffer_size, uint8_t endpoint_id)
    159156{
    160157        htc_config_frame_header((htc_frame_header_t *) buffer, buffer_size,
    161                 endpoint_id);
     158            endpoint_id);
    162159       
    163160        ath_t *ath_device = htc_device->ath_device;
    164161       
    165         return ath_device->ops->send_ctrl_message(ath_device, buffer,
    166                 buffer_size);
    167 }
    168 
    169 /**
    170  * Send data HTC message to USB device.
    171  *
    172  * @param htc_device HTC device structure.
    173  * @param buffer Buffer with data to be sent to USB device (without HTC frame
    174  *              header).
     162        return ath_device->ops->send_ctrl_message(ath_device, buffer,
     163            buffer_size);
     164}
     165
     166/** Send data HTC message to USB device.
     167 *
     168 * @param htc_device  HTC device structure.
     169 * @param buffer      Buffer with data to be sent to USB device
     170 *                    (without HTC frame header).
    175171 * @param buffer_size Size of buffer (including HTC frame header).
    176172 * @param endpoint_id Destination endpoint.
    177  *
    178  * @return EOK if succeed, negative error code otherwise.
    179  */
    180 int htc_send_data_message(htc_device_t *htc_device, void *buffer,
    181         size_t buffer_size, uint8_t endpoint_id)
     173 *
     174 * @return EOK if succeed, negative error code otherwise.
     175 *
     176 */
     177int htc_send_data_message(htc_device_t *htc_device, void *buffer,
     178    size_t buffer_size, uint8_t endpoint_id)
    182179{
    183180        htc_config_frame_header((htc_frame_header_t *) buffer, buffer_size,
    184                 endpoint_id);
     181            endpoint_id);
    185182       
    186183        ath_t *ath_device = htc_device->ath_device;
    187184       
    188         return ath_device->ops->send_data_message(ath_device, buffer, 
    189                 buffer_size);
    190 }
    191 
    192 /**
    193  * Read HTC data message from USB device.
    194  *
    195  * @param htc_device HTC device structure.
    196  * @param buffer Buffer where data from USB device will be stored.
    197  * @param buffer_size Size of buffer.
     185        return ath_device->ops->send_data_message(ath_device, buffer,
     186            buffer_size);
     187}
     188
     189/** Read HTC data message from USB device.
     190 *
     191 * @param htc_device       HTC device structure.
     192 * @param buffer           Buffer where data from USB device
     193 *                         will be stored.
     194 * @param buffer_size      Size of buffer.
    198195 * @param transferred_size Real size of read data.
    199  *
    200  * @return EOK if succeed, negative error code otherwise.
    201  */
    202 int htc_read_data_message(htc_device_t *htc_device, void *buffer,
    203         size_t buffer_size, size_t *transferred_size)
     196 *
     197 * @return EOK if succeed, negative error code otherwise.
     198 *
     199 */
     200int htc_read_data_message(htc_device_t *htc_device, void *buffer,
     201    size_t buffer_size, size_t *transferred_size)
    204202{
    205203        ath_t *ath_device = htc_device->ath_device;
    206204       
    207         return ath_device->ops->read_data_message(ath_device, buffer, 
    208                 buffer_size, transferred_size);
    209 }
    210 
    211 /**
    212  * Read HTC control message from USB device.
    213  *
    214  * @param htc_device HTC device structure.
    215  * @param buffer Buffer where data from USB device will be stored.
    216  * @param buffer_size Size of buffer.
     205        return ath_device->ops->read_data_message(ath_device, buffer,
     206            buffer_size, transferred_size);
     207}
     208
     209/** Read HTC control message from USB device.
     210 *
     211 * @param htc_device       HTC device structure.
     212 * @param buffer           Buffer where data from USB device
     213 *                         will be stored.
     214 * @param buffer_size      Size of buffer.
    217215 * @param transferred_size Real size of read data.
    218  *
    219  * @return EOK if succeed, negative error code otherwise.
    220  */
    221 int htc_read_control_message(htc_device_t *htc_device, void *buffer,
    222         size_t buffer_size, size_t *transferred_size)
     216 *
     217 * @return EOK if succeed, negative error code otherwise.
     218 *
     219 */
     220int htc_read_control_message(htc_device_t *htc_device, void *buffer,
     221    size_t buffer_size, size_t *transferred_size)
    223222{
    224223        ath_t *ath_device = htc_device->ath_device;
    225224       
    226         return ath_device->ops->read_ctrl_message(ath_device, buffer,
    227                 buffer_size, transferred_size);
    228 }
    229 
    230 /**
    231  * Initialize HTC service.
    232  *
    233  * @param htc_device HTC device structure.
    234  * @param service_id Identification of WMI service.
    235  * @param response_endpoint_no HTC endpoint to be used for this service.
    236  *
    237  * @return EOK if succeed, EINVAL when failed to connect service,
    238  * negative error code otherwise.
    239  */
    240 static int htc_connect_service(htc_device_t *htc_device,
     225        return ath_device->ops->read_ctrl_message(ath_device, buffer,
     226            buffer_size, transferred_size);
     227}
     228
     229/** Initialize HTC service.
     230 *
     231 * @param htc_device           HTC device structure.
     232 * @param service_id           Identification of WMI service.
     233 * @param response_endpoint_no HTC endpoint to be used for
     234 *                             this service.
     235 *
     236 * @return EOK if succeed, EINVAL when failed to connect service,
     237 *         negative error code otherwise.
     238 *
     239 */
     240static int htc_connect_service(htc_device_t *htc_device,
    241241    wmi_services_t service_id, int *response_endpoint_no)
    242242{
    243         size_t buffer_size = sizeof(htc_frame_header_t) + 
    244                 sizeof(htc_service_msg_t);
     243        size_t buffer_size = sizeof(htc_frame_header_t) +
     244            sizeof(htc_service_msg_t);
    245245        void *buffer = malloc(buffer_size);
    246246        memset(buffer, 0, buffer_size);
     
    248248        /* Fill service message structure. */
    249249        htc_service_msg_t *service_message = (htc_service_msg_t *)
    250                 ((void *) buffer + sizeof(htc_frame_header_t));
    251         service_message->service_id = 
    252                 host2uint16_t_be(service_id);
    253         service_message->message_id = 
    254                 host2uint16_t_be(HTC_MESSAGE_CONNECT_SERVICE);
    255         service_message->download_pipe_id = 
    256                 wmi_service_to_download_pipe(service_id);
    257         service_message->upload_pipe_id = 
    258                 wmi_service_to_upload_pipe(service_id);
     250            ((void *) buffer + sizeof(htc_frame_header_t));
     251        service_message->service_id =
     252            host2uint16_t_be(service_id);
     253        service_message->message_id =
     254            host2uint16_t_be(HTC_MESSAGE_CONNECT_SERVICE);
     255        service_message->download_pipe_id =
     256            wmi_service_to_download_pipe(service_id);
     257        service_message->upload_pipe_id =
     258            wmi_service_to_upload_pipe(service_id);
    259259        service_message->connection_flags = 0;
    260260       
    261261        /* Send HTC message. */
    262262        int rc = htc_send_control_message(htc_device, buffer, buffer_size,
    263                 htc_device->endpoints.ctrl_endpoint);
    264         if(rc != EOK) {
     263            htc_device->endpoints.ctrl_endpoint);
     264        if (rc != EOK) {
    265265                free(buffer);
    266266                usb_log_error("Failed to send HTC message. Error: %d\n", rc);
     
    275275        /* Read response from device. */
    276276        rc = htc_read_control_message(htc_device, buffer, buffer_size, NULL);
    277         if(rc != EOK) {
     277        if (rc != EOK) {
    278278                free(buffer);
    279279                usb_log_error("Failed to receive HTC service connect response. "
    280                         "Error: %d\n", rc);
     280                    "Error: %d\n", rc);
    281281                return rc;
    282282        }
    283283       
    284284        htc_service_resp_msg_t *response_message = (htc_service_resp_msg_t *)
    285                 ((void *) buffer + sizeof(htc_frame_header_t));
    286 
    287         /* If service was successfully connected, write down HTC endpoint number
    288          * that will be used for communication. */
    289         if(response_message->status == HTC_SERVICE_SUCCESS) {
     285            ((void *) buffer + sizeof(htc_frame_header_t));
     286       
     287        /*
     288         * If service was successfully connected,
     289         * write down HTC endpoint number that will
     290         * be used for communication.
     291         */
     292        if (response_message->status == HTC_SERVICE_SUCCESS) {
    290293                *response_endpoint_no = response_message->endpoint_id;
    291294                rc = EOK;
    292295        } else {
    293296                usb_log_error("Failed to connect HTC service. "
    294                         "Message status: %d\n", response_message->status);
     297                    "Message status: %d\n", response_message->status);
    295298                rc = EINVAL;
    296         }
     299        }
    297300       
    298301        free(buffer);
     
    301304}
    302305
    303 /**
    304  * HTC credits initialization message.
    305  *
     306/** HTC credits initialization message.
     307 *
    306308 * @param htc_device HTC device structure.
    307  *
    308  * @return EOK if succeed, negative error code otherwise.
     309 *
     310 * @return EOK if succeed, negative error code otherwise.
     311 *
    309312 */
    310313static int htc_config_credits(htc_device_t *htc_device)
    311314{
    312         size_t buffer_size = sizeof(htc_frame_header_t) + 
    313                 sizeof(htc_config_msg_t);
     315        size_t buffer_size = sizeof(htc_frame_header_t) +
     316            sizeof(htc_config_msg_t);
    314317        void *buffer = malloc(buffer_size);
    315318        htc_config_msg_t *config_message = (htc_config_msg_t *)
    316                 ((void *) buffer + sizeof(htc_frame_header_t));
     319            ((void *) buffer + sizeof(htc_frame_header_t));
    317320       
    318321        config_message->message_id =
    319                 host2uint16_t_be(HTC_MESSAGE_CONFIG);
     322            host2uint16_t_be(HTC_MESSAGE_CONFIG);
    320323        /* Magic number to initialize device. */
    321324        config_message->credits = 33;
    322325        config_message->pipe_id = 1;
    323 
     326       
    324327        /* Send HTC message. */
    325328        int rc = htc_send_control_message(htc_device, buffer, buffer_size,
    326                 htc_device->endpoints.ctrl_endpoint);
    327         if(rc != EOK) {
     329            htc_device->endpoints.ctrl_endpoint);
     330        if (rc != EOK) {
    328331                free(buffer);
    329332                usb_log_error("Failed to send HTC config message. "
    330                         "Error: %d\n", rc);
     333                    "Error: %d\n", rc);
    331334                return rc;
    332335        }
     
    336339        buffer_size = htc_device->ath_device->ctrl_response_length;
    337340        buffer = malloc(buffer_size);
    338 
     341       
    339342        /* Check response from device. */
    340343        rc = htc_read_control_message(htc_device, buffer, buffer_size, NULL);
    341         if(rc != EOK) {
     344        if (rc != EOK) {
    342345                usb_log_error("Failed to receive HTC config response message. "
    343                         "Error: %d\n", rc);
     346                    "Error: %d\n", rc);
    344347        }
    345348       
    346349        free(buffer);
    347 
     350       
    348351        return rc;
    349352}
    350353
    351 /**
    352  * HTC setup complete confirmation message.
    353  *
     354/** HTC setup complete confirmation message.
     355 *
    354356 * @param htc_device HTC device structure.
    355  *
    356  * @return EOK if succeed, negative error code otherwise.
     357 *
     358 * @return EOK if succeed, negative error code otherwise.
     359 *
    357360 */
    358361static int htc_complete_setup(htc_device_t *htc_device)
    359362{
    360         size_t buffer_size = sizeof(htc_frame_header_t) + 
    361                 sizeof(htc_setup_complete_msg_t);
     363        size_t buffer_size = sizeof(htc_frame_header_t) +
     364            sizeof(htc_setup_complete_msg_t);
    362365        void *buffer = malloc(buffer_size);
    363         htc_setup_complete_msg_t *complete_message = 
    364                 (htc_setup_complete_msg_t *)
    365                 ((void *) buffer + sizeof(htc_frame_header_t));
    366        
    367         complete_message->message_id = 
    368                 host2uint16_t_be(HTC_MESSAGE_SETUP_COMPLETE);
    369 
     366        htc_setup_complete_msg_t *complete_message =
     367            (htc_setup_complete_msg_t *)
     368            ((void *) buffer + sizeof(htc_frame_header_t));
     369       
     370        complete_message->message_id =
     371            host2uint16_t_be(HTC_MESSAGE_SETUP_COMPLETE);
     372       
    370373        /* Send HTC message. */
    371         int rc = htc_send_control_message(htc_device, buffer, buffer_size, 
    372                 htc_device->endpoints.ctrl_endpoint);
    373         if(rc != EOK) {
     374        int rc = htc_send_control_message(htc_device, buffer, buffer_size,
     375            htc_device->endpoints.ctrl_endpoint);
     376        if (rc != EOK)
    374377                usb_log_error("Failed to send HTC setup complete message. "
    375                         "Error: %d\n", rc);
    376         }
     378                    "Error: %d\n", rc);
    377379       
    378380        free(buffer);
    379 
     381       
    380382        return rc;
    381383}
    382384
    383 /**
    384  * Try to fetch ready message from device.
     385/** Try to fetch ready message from device.
     386 *
    385387 * Checks that firmware was successfully loaded on device side.
    386  * 
     388 *
    387389 * @param htc_device HTC device structure.
    388  *
    389  * @return EOK if succeed, EINVAL if response error, negative error code
    390  * otherwise.
     390 *
     391 * @return EOK if succeed, EINVAL if response error,
     392 *         negative error code otherwise.
     393 *
    391394 */
    392395static int htc_check_ready(htc_device_t *htc_device)
     
    394397        size_t buffer_size = htc_device->ath_device->ctrl_response_length;
    395398        void *buffer = malloc(buffer_size);
    396 
     399       
    397400        /* Read response from device. */
    398         int rc = htc_read_control_message(htc_device, buffer, buffer_size, 
    399                 NULL);
    400         if(rc != EOK) {
     401        int rc = htc_read_control_message(htc_device, buffer, buffer_size,
     402            NULL);
     403        if (rc != EOK) {
    401404                free(buffer);
    402405                usb_log_error("Failed to receive HTC check ready message. "
    403                         "Error: %d\n", rc);
    404                 return rc;
    405         }
    406 
    407         uint16_t *message_id = (uint16_t *) ((void *) buffer + 
    408                 sizeof(htc_frame_header_t));
    409         if(uint16_t_be2host(*message_id) == HTC_MESSAGE_READY) {
     406                    "Error: %d\n", rc);
     407                return rc;
     408        }
     409       
     410        uint16_t *message_id = (uint16_t *) ((void *) buffer +
     411            sizeof(htc_frame_header_t));
     412        if (uint16_t_be2host(*message_id) == HTC_MESSAGE_READY)
    410413                rc = EOK;
    411         } else {
     414        else
    412415                rc = EINVAL;
    413         }
    414416       
    415417        free(buffer);
     
    418420}
    419421
    420 /**
    421  * Initialize HTC device structure.
    422  *
    423  * @param ath_device Atheros WiFi device connected with this HTC device.
     422/** Initialize HTC device structure.
     423 *
     424 * @param ath_device Atheros WiFi device connected
     425 *                   with this HTC device.
    424426 * @param htc_device HTC device structure to be initialized.
    425  *
    426  * @return EOK if succeed, negative error code otherwise.
    427  */
    428 int htc_device_init(ath_t *ath_device, ieee80211_dev_t *ieee80211_dev,
    429         htc_device_t *htc_device)
     427 *
     428 * @return EOK if succeed, negative error code otherwise.
     429 *
     430 */
     431int htc_device_init(ath_t *ath_device, ieee80211_dev_t *ieee80211_dev,
     432    htc_device_t *htc_device)
    430433{
    431434        fibril_mutex_initialize(&htc_device->rx_lock);
     
    440443}
    441444
    442 /**
    443  * HTC communication initalization.
    444  *
     445/** HTC communication initalization.
     446 *
    445447 * @param htc_device HTC device structure.
    446  *
    447  * @return EOK if succeed, negative error code otherwise.
     448 *
     449 * @return EOK if succeed, negative error code otherwise.
     450 *
    448451 */
    449452int htc_init(htc_device_t *htc_device)
     
    451454        /* First check ready message in device. */
    452455        int rc = htc_check_ready(htc_device);
    453         if(rc != EOK) {
     456        if (rc != EOK) {
    454457                usb_log_error("Device is not in ready state after loading "
    455                         "firmware.\n");
    456                 return rc;
    457         }
    458 
    459         /* 
     458                    "firmware.\n");
     459                return rc;
     460        }
     461       
     462        /*
    460463         * HTC services initialization start.
    461          *
    462464         */
    463        
    464465        rc = htc_connect_service(htc_device, WMI_CONTROL_SERVICE,
    465466            &htc_device->endpoints.wmi_endpoint);
    466         if(rc != EOK) {
     467        if (rc != EOK) {
    467468                usb_log_error("Error while initalizing WMI service.\n");
    468469                return rc;
    469470        }
    470 
     471       
    471472        rc = htc_connect_service(htc_device, WMI_BEACON_SERVICE,
    472473            &htc_device->endpoints.beacon_endpoint);
    473         if(rc != EOK) {
     474        if (rc != EOK) {
    474475                usb_log_error("Error while initalizing beacon service.\n");
    475476                return rc;
    476477        }
    477 
     478       
    478479        rc = htc_connect_service(htc_device, WMI_CAB_SERVICE,
    479480            &htc_device->endpoints.cab_endpoint);
    480         if(rc != EOK) {
     481        if (rc != EOK) {
    481482                usb_log_error("Error while initalizing CAB service.\n");
    482483                return rc;
    483484        }
    484 
     485       
    485486        rc = htc_connect_service(htc_device, WMI_UAPSD_SERVICE,
    486487            &htc_device->endpoints.uapsd_endpoint);
    487         if(rc != EOK) {
     488        if (rc != EOK) {
    488489                usb_log_error("Error while initalizing UAPSD service.\n");
    489490                return rc;
    490491        }
    491 
     492       
    492493        rc = htc_connect_service(htc_device, WMI_MGMT_SERVICE,
    493494            &htc_device->endpoints.mgmt_endpoint);
    494         if(rc != EOK) {
     495        if (rc != EOK) {
    495496                usb_log_error("Error while initalizing MGMT service.\n");
    496497                return rc;
     
    499500        rc = htc_connect_service(htc_device, WMI_DATA_BE_SERVICE,
    500501            &htc_device->endpoints.data_be_endpoint);
    501         if(rc != EOK) {
     502        if (rc != EOK) {
    502503                usb_log_error("Error while initalizing data best effort "
    503504                    "service.\n");
    504505                return rc;
    505506        }
    506 
     507       
    507508        rc = htc_connect_service(htc_device, WMI_DATA_BK_SERVICE,
    508509            &htc_device->endpoints.data_bk_endpoint);
    509         if(rc != EOK) {
     510        if (rc != EOK) {
    510511                usb_log_error("Error while initalizing data background "
    511512                    "service.\n");
    512513                return rc;
    513514        }
    514 
     515       
    515516        rc = htc_connect_service(htc_device, WMI_DATA_VIDEO_SERVICE,
    516517            &htc_device->endpoints.data_video_endpoint);
    517         if(rc != EOK) {
     518        if (rc != EOK) {
    518519                usb_log_error("Error while initalizing data video service.\n");
    519520                return rc;
     
    522523        rc = htc_connect_service(htc_device, WMI_DATA_VOICE_SERVICE,
    523524            &htc_device->endpoints.data_voice_endpoint);
    524         if(rc != EOK) {
     525        if (rc != EOK) {
    525526                usb_log_error("Error while initalizing data voice service.\n");
    526527                return rc;
    527528        }
    528 
    529         /* 
     529       
     530        /*
    530531         * HTC services initialization end.
    531          *
    532532         */
    533 
     533       
    534534        /* Credits initialization message. */
    535535        rc = htc_config_credits(htc_device);
    536         if(rc != EOK) {
     536        if (rc != EOK) {
    537537                usb_log_error("Failed to send HTC config message.\n");
    538538                return rc;
    539539        }
    540 
     540       
    541541        /* HTC setup complete confirmation message. */
    542542        rc = htc_complete_setup(htc_device);
    543         if(rc != EOK) {
     543        if (rc != EOK) {
    544544                usb_log_error("Failed to send HTC complete setup message.\n");
    545545                return rc;
    546546        }
    547 
     547       
    548548        usb_log_info("HTC services initialization finished successfully.\n");
    549549       
  • uspace/drv/nic/ar9271/htc.h

    r09044cb r8a64320e  
    2929/** @file htc.h
    3030 *
    31  * Definitions of the Atheros HTC (Host Target Communication) technology 
     31 * Definitions of the Atheros HTC (Host Target Communication) technology
    3232 * for communication between host (PC) and target (device firmware).
    3333 *
     
    3535
    3636#ifndef ATHEROS_HTC_H
    37 #define ATHEROS_HTC_H
     37#define ATHEROS_HTC_H
    3838
    3939#include <ieee80211.h>
     
    4141#include <sys/types.h>
    4242#include <nic.h>
    43 
    4443#include "ath.h"
    4544
    46 #define HTC_RTS_THRESHOLD 2304
    47 #define HTC_RATES_MAX_LENGTH 30
    48 
    49 /**
    50  * HTC message IDs.
     45#define HTC_RTS_THRESHOLD     2304
     46#define HTC_RATES_MAX_LENGTH  30
     47
     48/** HTC message IDs.
     49 *
    5150 */
    5251typedef enum {
    5352        HTC_MESSAGE_READY = 1,
    5453        HTC_MESSAGE_CONNECT_SERVICE,
    55         HTC_MESSAGE_CONNECT_SERVICE_RESPONSE,
    56         HTC_MESSAGE_SETUP_COMPLETE,
    57         HTC_MESSAGE_CONFIG
     54        HTC_MESSAGE_CONNECT_SERVICE_RESPONSE,
     55        HTC_MESSAGE_SETUP_COMPLETE,
     56        HTC_MESSAGE_CONFIG
    5857} htc_message_id_t;
    5958
    60 /**
    61  * HTC response message status codes.
     59/** HTC response message status codes.
     60 *
    6261 */
    6362typedef enum {
    64         HTC_SERVICE_SUCCESS = 0,
    65         HTC_SERVICE_NOT_FOUND,
    66         HTC_SERVICE_FAILED,
    67         HTC_SERVICE_NO_RESOURCES,
    68         HTC_SERVICE_NO_MORE_EP
     63        HTC_SERVICE_SUCCESS = 0,
     64        HTC_SERVICE_NOT_FOUND,
     65        HTC_SERVICE_FAILED,
     66        HTC_SERVICE_NO_RESOURCES,
     67        HTC_SERVICE_NO_MORE_EP
    6968} htc_response_status_code_t;
    7069
    71 /**
    72  * HTC operating mode definition.
     70/** HTC operating mode definition.
     71 *
    7372 */
    7473typedef enum {
     
    7978} htc_operating_mode_t;
    8079
    81 /**
    82  * HTC data type indicator.
     80/** HTC data type indicator.
     81 *
    8382 */
    8483typedef enum {
     
    8988} htc_data_type_t;
    9089
    91 /**
    92  * HTC endpoint numbers.
    93  */
    94 typedef struct {
    95         int ctrl_endpoint;
     90/** HTC endpoint numbers.
     91 *
     92 */
     93typedef struct {
     94        int ctrl_endpoint;
    9695        int wmi_endpoint;
    9796        int beacon_endpoint;
     
    105104} htc_pipes_t;
    106105
    107 /**
    108  * HTC device data.
    109  */
    110 typedef struct {
    111         /** WMI message sequence number */
    112         uint16_t sequence_number;
    113    
     106/** HTC device data.
     107 *
     108 */
     109typedef struct {
     110        /** WMI message sequence number */
     111        uint16_t sequence_number;
     112       
    114113        /** HTC endpoints numbers */
    115114        htc_pipes_t endpoints;
     
    128127} htc_device_t;
    129128
    130 /**
    131  * HTC frame header structure.
    132  */
    133 typedef struct {
    134         uint8_t   endpoint_id;
    135         uint8_t   flags;
    136         uint16_t  payload_length;       /**< Big Endian value! */
    137         uint8_t   control_bytes[4];
     129/** HTC frame header structure.
     130 *
     131 */
     132typedef struct {
     133        uint8_t endpoint_id;
     134        uint8_t flags;
     135        uint16_t payload_length;   /**< Big Endian value! */
     136        uint8_t control_bytes[4];
    138137} __attribute__((packed)) htc_frame_header_t;
    139138
    140 /**
    141  * HTC management TX frame header structure.
     139/** HTC management TX frame header structure.
     140 *
    142141 */
    143142typedef struct {
     
    152151} __attribute__((packed)) htc_tx_management_header_t;
    153152
    154 /**
    155  * HTC data TX frame header structure.
     153/** HTC data TX frame header structure.
     154 *
    156155 */
    157156typedef struct {
     
    160159        uint8_t vif_idx;
    161160        uint8_t tidno;
    162         uint32_t flags;                 /**< Big Endian value! */
     161        uint32_t flags;    /**< Big Endian value! */
    163162        uint8_t key_type;
    164163        uint8_t keyix;
     
    167166} __attribute__((packed)) htc_tx_data_header_t;
    168167
    169 /**
    170  * HTC ready message structure.
    171  */
    172 typedef struct {
    173         uint16_t message_id;            /**< Big Endian value! */
    174         uint16_t credits;               /**< Big Endian value! */
    175         uint16_t credit_size;           /**< Big Endian value! */
    176        
    177         uint8_t max_endpoints;
     168/** HTC ready message structure.
     169 *
     170 */
     171typedef struct {
     172        uint16_t message_id;   /**< Big Endian value! */
     173        uint16_t credits;      /**< Big Endian value! */
     174        uint16_t credit_size;  /**< Big Endian value! */
     175       
     176        uint8_t max_endpoints;
    178177        uint8_t pad;
    179178} __attribute__((packed)) htc_ready_msg_t;
    180179
    181 /**
    182  * HTC service message structure.
    183  */
    184 typedef struct {
    185         uint16_t message_id;            /**< Big Endian value! */
    186         uint16_t service_id;            /**< Big Endian value! */
    187         uint16_t connection_flags;      /**< Big Endian value! */
     180/** HTC service message structure.
     181 *
     182 */
     183typedef struct {
     184        uint16_t message_id;        /**< Big Endian value! */
     185        uint16_t service_id;        /**< Big Endian value! */
     186        uint16_t connection_flags;  /**< Big Endian value! */
    188187       
    189188        uint8_t download_pipe_id;
     
    193192} __attribute__((packed)) htc_service_msg_t;
    194193
    195 /**
    196  * HTC service response message structure.
    197  */
    198 typedef struct {
    199         uint16_t message_id;            /**< Big Endian value! */
    200         uint16_t service_id;            /**< Big Endian value! */
    201         uint8_t status;
    202         uint8_t endpoint_id;
    203         uint16_t max_message_length;    /**< Big Endian value! */
    204         uint8_t service_meta_length;
    205         uint8_t pad;
     194/** HTC service response message structure.
     195 *
     196 */
     197typedef struct {
     198        uint16_t message_id;          /**< Big Endian value! */
     199        uint16_t service_id;          /**< Big Endian value! */
     200        uint8_t status;
     201        uint8_t endpoint_id;
     202        uint16_t max_message_length;  /**< Big Endian value! */
     203        uint8_t service_meta_length;
     204        uint8_t pad;
    206205} __attribute__((packed)) htc_service_resp_msg_t;
    207206
    208 /**
    209  * HTC credits config message structure.
    210  */
    211 typedef struct {
    212         uint16_t message_id;            /**< Big Endian value! */
    213         uint8_t pipe_id;
    214         uint8_t credits;
     207/** HTC credits config message structure.
     208 *
     209 */
     210typedef struct {
     211        uint16_t message_id;  /**< Big Endian value! */
     212        uint8_t pipe_id;
     213        uint8_t credits;
    215214} __attribute__((packed)) htc_config_msg_t;
    216215
    217 /**
    218  * HTC new virtual interface message.
    219  */
    220 typedef struct {
    221         uint8_t index;
     216/** HTC new virtual interface message.
     217 *
     218 */
     219typedef struct {
     220        uint8_t index;
    222221        uint8_t op_mode;
    223222        uint8_t addr[ETH_ADDR];
    224223        uint8_t ath_cap;
    225         uint16_t rts_thres;             /**< Big Endian value! */
     224        uint16_t rts_thres;      /**< Big Endian value! */
    226225        uint8_t pad;
    227226} __attribute__((packed)) htc_vif_msg_t;
    228227
    229 /**
    230  * HTC new station message.
     228/** HTC new station message.
     229 *
    231230 */
    232231typedef struct {
    233232        uint8_t addr[ETH_ADDR];
    234233        uint8_t bssid[ETH_ADDR];
    235         uint8_t sta_index;
     234        uint8_t sta_index;
    236235        uint8_t vif_index;
    237236        uint8_t is_vif_sta;
    238                
    239         uint16_t flags;         /**< Big Endian value! */
    240         uint16_t ht_cap;        /**< Big Endian value! */
    241         uint16_t max_ampdu;     /**< Big Endian value! */
     237       
     238        uint16_t flags;      /**< Big Endian value! */
     239        uint16_t ht_cap;     /**< Big Endian value! */
     240        uint16_t max_ampdu;  /**< Big Endian value! */
    242241       
    243242        uint8_t pad;
    244243} __attribute__((packed)) htc_sta_msg_t;
    245244
    246 /**
    247  * HTC message to inform target about available capabilities.
    248  */
    249 typedef struct {
    250         uint32_t ampdu_limit;   /**< Big Endian value! */
     245/** HTC message to inform target about available capabilities.
     246 *
     247 */
     248typedef struct {
     249        uint32_t ampdu_limit;     /**< Big Endian value! */
    251250        uint8_t ampdu_subframes;
    252251        uint8_t enable_coex;
     
    258257        uint8_t sta_index;
    259258        uint8_t is_new;
    260         uint32_t cap_flags;     /**< Big Endian value! */
     259        uint32_t cap_flags;  /**< Big Endian value! */
    261260        uint8_t legacy_rates_count;
    262261        uint8_t legacy_rates[HTC_RATES_MAX_LENGTH];
     
    264263} htc_rate_msg_t;
    265264
    266 /**
    267  * HTC RX status structure used in incoming HTC data messages.
    268  */
    269 typedef struct {
    270         uint64_t timestamp;     /**< Big Endian value! */
    271         uint16_t data_length;   /**< Big Endian value! */
     265/** HTC RX status structure used in incoming HTC data messages.
     266 *
     267 */
     268typedef struct {
     269        uint64_t timestamp;    /**< Big Endian value! */
     270        uint16_t data_length;  /**< Big Endian value! */
    272271        uint8_t status;
    273272        uint8_t phy_err;
     
    284283        uint8_t flags;
    285284        uint8_t dummy;
    286         uint32_t evm0;          /**< Big Endian value! */
    287         uint32_t evm1;          /**< Big Endian value! */
    288         uint32_t evm2;          /**< Big Endian value! */
     285        uint32_t evm0;         /**< Big Endian value! */
     286        uint32_t evm1;         /**< Big Endian value! */
     287        uint32_t evm2;         /**< Big Endian value! */
    289288} htc_rx_status_t;
    290289
    291 /**
    292  * HTC setup complete message structure
    293  */
    294 typedef struct {
    295         uint16_t message_id;            /**< Big Endian value! */
     290/** HTC setup complete message structure
     291 *
     292 */
     293typedef struct {
     294        uint16_t message_id;  /**< Big Endian value! */
    296295} __attribute__((packed)) htc_setup_complete_msg_t;
    297296
    298 extern int htc_device_init(ath_t *ath_device, ieee80211_dev_t *ieee80211_dev,
    299         htc_device_t *htc_device);
    300 extern int htc_init(htc_device_t *htc_device);
    301 extern int htc_init_new_vif(htc_device_t *htc_device);
    302 extern int htc_read_control_message(htc_device_t *htc_device, void *buffer,
    303         size_t buffer_size, size_t *transferred_size);
    304 extern int htc_read_data_message(htc_device_t *htc_device, void *buffer,
    305         size_t buffer_size, size_t *transferred_size);
    306 extern int htc_send_control_message(htc_device_t *htc_device, void *buffer,
    307         size_t buffer_size, uint8_t endpoint_id);
    308 extern int htc_send_data_message(htc_device_t *htc_device, void *buffer,
    309         size_t buffer_size, uint8_t endpoint_id);
    310 
    311 #endif  /* ATHEROS_HTC_H */
    312 
     297extern int htc_device_init(ath_t *, ieee80211_dev_t *, htc_device_t *);
     298extern int htc_init(htc_device_t *);
     299extern int htc_init_new_vif(htc_device_t *);
     300extern int htc_read_control_message(htc_device_t *, void *, size_t, size_t *);
     301extern int htc_read_data_message(htc_device_t *, void *, size_t, size_t *);
     302extern int htc_send_control_message(htc_device_t *, void *, size_t, uint8_t);
     303extern int htc_send_data_message(htc_device_t *, void *, size_t, uint8_t);
     304
     305#endif  /* ATHEROS_HTC_H */
  • 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;
  • uspace/drv/nic/ar9271/hw.h

    r09044cb r8a64320e  
    3434
    3535#ifndef ATHEROS_HW_H
    36 #define ATHEROS_HW_H
     36#define ATHEROS_HW_H
    3737
    3838#include "ar9271.h"
    3939
    40 #define HW_WAIT_LOOPS 1000
    41 #define HW_WAIT_TIME_US 10
     40#define HW_WAIT_LOOPS    1000
     41#define HW_WAIT_TIME_US  10
    4242
    43 extern int hw_init(ar9271_t *ar9271);
    44 extern int hw_freq_switch(ar9271_t *, uint16_t freq);
    45 extern int hw_rx_init(ar9271_t *ar9271);
    46 extern int hw_reset(ar9271_t *ar9271);
    47 extern int hw_set_bssid(ar9271_t *ar9271);
    48 extern int hw_set_rx_filter(ar9271_t *ar9271, bool assoc);
     43extern int hw_init(ar9271_t *);
     44extern int hw_freq_switch(ar9271_t *, uint16_t);
     45extern int hw_rx_init(ar9271_t *);
     46extern int hw_reset(ar9271_t *);
     47extern int hw_set_bssid(ar9271_t *);
     48extern int hw_set_rx_filter(ar9271_t *, bool);
    4949
    50 #endif  /* ATHEROS_HW_H */
     50#endif  /* ATHEROS_HW_H */
  • uspace/drv/nic/ar9271/wmi.c

    r09044cb r8a64320e  
    3434
    3535#include <usb/debug.h>
    36 
    3736#include <malloc.h>
    3837#include <mem.h>
    3938#include <byteorder.h>
    40 
    4139#include "wmi.h"
    4240
    43 /**
    44  * WMI registry read.
    45  *
     41/** WMI registry read.
     42 *
    4643 * @param htc_device HTC device structure.
    4744 * @param reg_offset Registry offset (address) to be read.
    48  * @param res Stored result.
    49  *
    50  * @return EOK if succeed, negative error code otherwise.
     45 * @param res        Stored result.
     46 *
     47 * @return EOK if succeed, negative error code otherwise.
     48 *
    5149 */
    5250int wmi_reg_read(htc_device_t *htc_device, uint32_t reg_offset, uint32_t *res)
     
    5452        uint32_t cmd_value = host2uint32_t_be(reg_offset);
    5553       
    56         void *resp_buffer = 
    57                 malloc(htc_device->ath_device->ctrl_response_length);
    58        
    59         int rc = wmi_send_command(htc_device, WMI_REG_READ, 
    60                 (uint8_t *) &cmd_value, sizeof(cmd_value), resp_buffer);
    61        
    62         if(rc != EOK) {
     54        void *resp_buffer =
     55            malloc(htc_device->ath_device->ctrl_response_length);
     56       
     57        int rc = wmi_send_command(htc_device, WMI_REG_READ,
     58            (uint8_t *) &cmd_value, sizeof(cmd_value), resp_buffer);
     59       
     60        if (rc != EOK) {
    6361                usb_log_error("Failed to read registry value.\n");
    6462                return rc;
    6563        }
    6664       
    67         uint32_t *resp_value = (uint32_t *) ((void*) resp_buffer +
    68                 sizeof(htc_frame_header_t) +
    69                 sizeof(wmi_command_header_t));
     65        uint32_t *resp_value = (uint32_t *) ((void *) resp_buffer +
     66            sizeof(htc_frame_header_t) + sizeof(wmi_command_header_t));
    7067       
    7168        *res = uint32_t_be2host(*resp_value);
     
    7471}
    7572
    76 /**
    77  * WMI registry write.
    78  *
    79  * @param htc_device HTC device structure.
    80  * @param reg_offset Registry offset (address) to be written.
    81  * @param val Value to be written
    82  *
    83  * @return EOK if succeed, negative error code otherwise.
     73/** WMI registry write.
     74 *
     75 * @param htc_device HTC device structure.
     76 * @param reg_offset Registry offset (address) to be written.
     77 * @param val        Value to be written
     78 *
     79 * @return EOK if succeed, negative error code otherwise.
     80 *
    8481 */
    8582int wmi_reg_write(htc_device_t *htc_device, uint32_t reg_offset, uint32_t val)
    8683{
    8784        uint32_t cmd_buffer[] = {
    88             host2uint32_t_be(reg_offset),
    89             host2uint32_t_be(val)
     85                host2uint32_t_be(reg_offset),
     86                host2uint32_t_be(val)
    9087        };
    9188       
    92         void *resp_buffer = 
    93                 malloc(htc_device->ath_device->ctrl_response_length);
    94        
    95         int rc = wmi_send_command(htc_device, WMI_REG_WRITE, 
    96                 (uint8_t *) &cmd_buffer, sizeof(cmd_buffer), resp_buffer);
     89        void *resp_buffer =
     90            malloc(htc_device->ath_device->ctrl_response_length);
     91       
     92        int rc = wmi_send_command(htc_device, WMI_REG_WRITE,
     93            (uint8_t *) &cmd_buffer, sizeof(cmd_buffer), resp_buffer);
    9794       
    9895        free(resp_buffer);
    9996       
    100         if(rc != EOK) {
     97        if (rc != EOK) {
    10198                usb_log_error("Failed to write registry value.\n");
    10299                return rc;
     
    106103}
    107104
    108 /**
    109  * WMI registry set or clear specified bits.
    110  *
    111  * @param htc_device HTC device structure.
    112  * @param reg_offset Registry offset (address) to be written.
    113  * @param set_bit Bit to be set.
    114  * @param clear_bit Bit to be cleared.
    115  *
    116  * @return EOK if succeed, negative error code otherwise.
    117  */
    118 int wmi_reg_set_clear_bit(htc_device_t *htc_device, uint32_t reg_offset, 
    119         uint32_t set_bit, uint32_t clear_bit)
     105/** WMI registry set or clear specified bits.
     106 *
     107 * @param htc_device HTC device structure.
     108 * @param reg_offset Registry offset (address) to be written.
     109 * @param set_bit    Bit to be set.
     110 * @param clear_bit  Bit to be cleared.
     111 *
     112 * @return EOK if succeed, negative error code otherwise.
     113 *
     114 */
     115int wmi_reg_set_clear_bit(htc_device_t *htc_device, uint32_t reg_offset,
     116    uint32_t set_bit, uint32_t clear_bit)
    120117{
    121118        uint32_t value;
    122119       
    123120        int rc = wmi_reg_read(htc_device, reg_offset, &value);
    124         if(rc != EOK) {
     121        if (rc != EOK) {
    125122                usb_log_error("Failed to read registry value in RMW "
    126                         "function.\n");
     123                    "function.\n");
    127124                return rc;
    128125        }
     
    132129       
    133130        rc = wmi_reg_write(htc_device, reg_offset, value);
    134         if(rc != EOK) {
     131        if (rc != EOK) {
    135132                usb_log_error("Failed to write registry value in RMW "
    136                         "function.\n");
    137                 return rc;
    138         }
    139        
    140         return rc;
    141 }
    142 
    143 /**
    144  * WMI registry set specified bit.
    145  *
    146  * @param htc_device HTC device structure.
    147  * @param reg_offset Registry offset (address) to be written.
    148  * @param set_bit Bit to be set.
    149  *
    150  * @return EOK if succeed, negative error code otherwise.
    151  */
    152 int wmi_reg_set_bit(htc_device_t *htc_device, uint32_t reg_offset, 
    153         uint32_t set_bit)
     133                    "function.\n");
     134                return rc;
     135        }
     136       
     137        return rc;
     138}
     139
     140/** WMI registry set specified bit.
     141 *
     142 * @param htc_device HTC device structure.
     143 * @param reg_offset Registry offset (address) to be written.
     144 * @param set_bit    Bit to be set.
     145 *
     146 * @return EOK if succeed, negative error code otherwise.
     147 *
     148 */
     149int wmi_reg_set_bit(htc_device_t *htc_device, uint32_t reg_offset,
     150    uint32_t set_bit)
    154151{
    155152        return wmi_reg_set_clear_bit(htc_device, reg_offset, set_bit, 0);
    156153}
    157154
    158 /**
    159  * WMI registry clear specified bit.
    160  *
    161  * @param htc_device HTC device structure.
    162  * @param reg_offset Registry offset (address) to be written.
    163  * @param clear_bit Bit to be cleared.
    164  *
    165  * @return EOK if succeed, negative error code otherwise.
    166  */
    167 int wmi_reg_clear_bit(htc_device_t *htc_device, uint32_t reg_offset, 
    168         uint32_t clear_bit)
     155/** WMI registry clear specified bit.
     156 *
     157 * @param htc_device HTC device structure.
     158 * @param reg_offset Registry offset (address) to be written.
     159 * @param clear_bit  Bit to be cleared.
     160 *
     161 * @return EOK if succeed, negative error code otherwise.
     162 *
     163 */
     164int wmi_reg_clear_bit(htc_device_t *htc_device, uint32_t reg_offset,
     165    uint32_t clear_bit)
    169166{
    170167        return wmi_reg_set_clear_bit(htc_device, reg_offset, 0, clear_bit);
    171168}
    172169
    173 /**
    174  * WMI multi registry write.
    175  *
     170/** WMI multi registry write.
     171 *
    176172 * @param htc_device HTC device structure.
    177173 * @param reg_buffer Array of registry values to be written.
    178  * @param elements Number of elements in array.
    179  *
    180  * @return EOK if succeed, negative error code otherwise.
     174 * @param elements   Number of elements in array.
     175 *
     176 * @return EOK if succeed, negative error code otherwise.
     177 *
    181178 */
    182179int wmi_reg_buffer_write(htc_device_t *htc_device, wmi_reg_t *reg_buffer,
    183         size_t elements)
     180    size_t elements)
    184181{
    185182        size_t buffer_size = sizeof(wmi_reg_t) * elements;
    186183        void *buffer = malloc(buffer_size);
    187         void *resp_buffer = 
    188                 malloc(htc_device->ath_device->ctrl_response_length);
     184        void *resp_buffer =
     185            malloc(htc_device->ath_device->ctrl_response_length);
    189186       
    190187        /* Convert values to correct endianness. */
    191         for(size_t i = 0; i < elements; i++) {
     188        for (size_t i = 0; i < elements; i++) {
    192189                wmi_reg_t *buffer_element = &reg_buffer[i];
    193190                wmi_reg_t *buffer_it = (wmi_reg_t *)
    194                         ((void *) buffer + i*sizeof(wmi_reg_t));
    195                 buffer_it->offset = 
    196                         host2uint32_t_be(buffer_element->offset);
     191                    ((void *) buffer + i * sizeof(wmi_reg_t));
     192                buffer_it->offset =
     193                    host2uint32_t_be(buffer_element->offset);
    197194                buffer_it->value =
    198                         host2uint32_t_be(buffer_element->value);
    199         }
    200        
    201         int rc = wmi_send_command(htc_device, WMI_REG_WRITE, 
    202                 (uint8_t *) buffer, buffer_size, resp_buffer);
     195                    host2uint32_t_be(buffer_element->value);
     196        }
     197       
     198        int rc = wmi_send_command(htc_device, WMI_REG_WRITE,
     199            (uint8_t *) buffer, buffer_size, resp_buffer);
    203200       
    204201        free(buffer);
    205202        free(resp_buffer);
    206203       
    207         if(rc != EOK) {
     204        if (rc != EOK) {
    208205                usb_log_error("Failed to write multi registry value.\n");
    209206                return rc;
     
    213210}
    214211
    215 /**
    216  * Send WMI message to HTC device.
    217  *
    218  * @param htc_device HTC device structure.
    219  * @param command_id Command identification.
    220  * @param command_buffer Buffer with command data.
    221  * @param command_length Length of command data.
     212/** Send WMI message to HTC device.
     213 *
     214 * @param htc_device      HTC device structure.
     215 * @param command_id      Command identification.
     216 * @param command_buffer  Buffer with command data.
     217 * @param command_length  Length of command data.
    222218 * @param response_buffer Buffer with response data.
    223  *
    224  * @return EOK if succeed, negative error code otherwise.
    225  */
    226 int wmi_send_command(htc_device_t *htc_device, wmi_command_t command_id,
    227     uint8_t *command_buffer, uint32_t command_length, void *response_buffer)
    228 {
    229         size_t header_size = sizeof(wmi_command_header_t) +
    230                 sizeof(htc_frame_header_t);
     219 *
     220 * @return EOK if succeed, negative error code otherwise.
     221 *
     222 */
     223int wmi_send_command(htc_device_t *htc_device, wmi_command_t command_id,
     224    uint8_t *command_buffer, uint32_t command_length, void *response_buffer)
     225{
     226        size_t header_size = sizeof(wmi_command_header_t) +
     227            sizeof(htc_frame_header_t);
    231228        size_t buffer_size = header_size + command_length;
    232229        void *buffer = malloc(buffer_size);
    233230       
    234         if(command_buffer != NULL) {
     231        if (command_buffer != NULL)
    235232                memcpy(buffer+header_size, command_buffer, command_length);
    236         }
    237233       
    238234        /* Set up WMI header */
    239235        wmi_command_header_t *wmi_header = (wmi_command_header_t *)
    240                 ((void *) buffer + sizeof(htc_frame_header_t));
    241         wmi_header->command_id =
    242                 host2uint16_t_be(command_id);
    243         wmi_header->sequence_number =
    244                 host2uint16_t_be(++htc_device->sequence_number);
     236            ((void *) buffer + sizeof(htc_frame_header_t));
     237        wmi_header->command_id = host2uint16_t_be(command_id);
     238        wmi_header->sequence_number =
     239            host2uint16_t_be(++htc_device->sequence_number);
    245240       
    246241        /* Send message. */
    247242        int rc = htc_send_control_message(htc_device, buffer, buffer_size,
    248                 htc_device->endpoints.wmi_endpoint);
    249         if(rc != EOK) {
     243            htc_device->endpoints.wmi_endpoint);
     244        if (rc != EOK) {
    250245                free(buffer);
    251246                usb_log_error("Failed to send WMI message. Error: %d\n", rc);
     
    256251       
    257252        bool clean_resp_buffer = false;
    258         size_t response_buffer_size = 
    259                 htc_device->ath_device->ctrl_response_length;
    260         if(response_buffer == NULL) {
     253        size_t response_buffer_size =
     254            htc_device->ath_device->ctrl_response_length;
     255        if (response_buffer == NULL) {
    261256                response_buffer = malloc(response_buffer_size);
    262257                clean_resp_buffer = true;
     
    267262        uint16_t cmd_id;
    268263        do {
    269                 rc = htc_read_control_message(htc_device, response_buffer, 
    270                         response_buffer_size, NULL);
    271                 if(rc != EOK) {
     264                rc = htc_read_control_message(htc_device, response_buffer,
     265                    response_buffer_size, NULL);
     266                if (rc != EOK) {
    272267                        free(buffer);
    273268                        usb_log_error("Failed to receive WMI message response. "
     
    276271                }
    277272               
    278                 if(response_buffer_size < sizeof(htc_frame_header_t) +
    279                         sizeof(wmi_command_header_t)) {
     273                if (response_buffer_size < sizeof(htc_frame_header_t) +
     274                    sizeof(wmi_command_header_t)) {
    280275                        free(buffer);
    281276                        usb_log_error("Corrupted response received.\n");
     
    283278                }
    284279               
    285                 wmi_command_header_t *wmi_hdr = (wmi_command_header_t *) 
    286                         ((void*) response_buffer + sizeof(htc_frame_header_t));
     280                wmi_command_header_t *wmi_hdr = (wmi_command_header_t *)
     281                    ((void *) response_buffer + sizeof(htc_frame_header_t));
    287282                cmd_id = uint16_t_be2host(wmi_hdr->command_id);
    288283        } while(cmd_id & WMI_MGMT_CMD_MASK);
    289284       
    290         if(clean_resp_buffer) {
     285        if (clean_resp_buffer)
    291286                free(response_buffer);
    292         }
    293        
    294         return rc;
    295 }
     287       
     288        return rc;
     289}
  • uspace/drv/nic/ar9271/wmi.h

    r09044cb r8a64320e  
    3535
    3636#ifndef ATHEROS_WMI_H
    37 #define ATHEROS_WMI_H
     37#define ATHEROS_WMI_H
    3838
    3939#include "htc.h"
    4040
    4141/* Macros for creating service identificators. */
    42 #define WMI_SERVICE_GROUP 1
    43 #define CREATE_SERVICE_ID(group, i) (int) (((int) group << 8) | (int) (i))
     42#define WMI_SERVICE_GROUP  1
    4443
    45 #define WMI_MGMT_CMD_MASK 0x1000
     44#define CREATE_SERVICE_ID(group, i) \
     45        (unsigned int) (((unsigned int) group << 8) | (unsigned int) (i))
    4646
    47 /**
    48  * WMI header structure.
     47#define WMI_MGMT_CMD_MASK  0x1000
     48
     49/** WMI header structure.
     50 *
    4951 */
    5052typedef struct {
    51     uint16_t command_id;                /**< Big Endian value! */
    52     uint16_t sequence_number;           /**< Big Endian value! */
     53        uint16_t command_id;       /**< Big Endian value! */
     54        uint16_t sequence_number;  /**< Big Endian value! */
    5355} __attribute__((packed)) wmi_command_header_t;
    5456
    55 /**
    56  * WMI services IDs
     57/** WMI services IDs
     58 *
    5759 */
    5860typedef enum {
     
    6870} wmi_services_t;
    6971
    70 /**
    71  * List of WMI commands
     72/** List of WMI commands
     73 *
    7274 */
    7375typedef enum {
    7476        WMI_ECHO = 0x0001,
    7577        WMI_ACCESS_MEMORY,
    76 
     78       
    7779        /* Commands used for HOST -> DEVICE communication */
    7880        WMI_GET_FW_VERSION,
     
    107109} wmi_command_t;
    108110
    109 /**
    110  * Structure used when sending registry buffer
     111/**Structure used when sending registry buffer
     112 *
    111113 */
    112114typedef struct {
    113         uint32_t offset;                /**< Big Endian value! */
    114         uint32_t value;                 /**< Big Endian value! */
     115        uint32_t offset;  /**< Big Endian value! */
     116        uint32_t value;   /**< Big Endian value! */
    115117} wmi_reg_t;
    116118
    117 extern int wmi_reg_read(htc_device_t *htc_device, uint32_t reg_offset,
    118         uint32_t *res);
    119 extern int wmi_reg_write(htc_device_t *htc_device, uint32_t reg_offset,
    120         uint32_t val);
    121 extern int wmi_reg_set_clear_bit(htc_device_t *htc_device,
    122         uint32_t reg_offset, uint32_t set_bit, uint32_t clear_bit);
    123 extern int wmi_reg_set_bit(htc_device_t *htc_device, uint32_t reg_offset,
    124         uint32_t set_bit);
    125 extern int wmi_reg_clear_bit(htc_device_t *htc_device, uint32_t reg_offset,
    126         uint32_t clear_bit);
    127 extern int wmi_reg_buffer_write(htc_device_t *htc_device,
    128         wmi_reg_t *reg_buffer, size_t elements);
    129 extern int wmi_send_command(htc_device_t *htc_device,
    130         wmi_command_t command_id,
    131         uint8_t *command_buffer, uint32_t command_length,
    132         void *response_buffer);
     119extern int wmi_reg_read(htc_device_t *, uint32_t, uint32_t *);
     120extern int wmi_reg_write(htc_device_t *, uint32_t, uint32_t);
     121extern int wmi_reg_set_clear_bit(htc_device_t *, uint32_t, uint32_t, uint32_t);
     122extern int wmi_reg_set_bit(htc_device_t *, uint32_t, uint32_t);
     123extern int wmi_reg_clear_bit(htc_device_t *, uint32_t, uint32_t);
     124extern int wmi_reg_buffer_write(htc_device_t *, wmi_reg_t *, size_t);
     125extern int wmi_send_command(htc_device_t *, wmi_command_t, uint8_t *, uint32_t,
     126    void *);
    133127
    134 #endif  /* ATHEROS_WMI_H */
    135 
     128#endif  /* ATHEROS_WMI_H */
  • uspace/lib/c/include/ieee80211/ieee80211.h

    r09044cb r8a64320e  
    4444
    4545/** Max length of scan results array. */
    46 #define IEEE80211_MAX_RESULTS_LENGTH 32
     46#define IEEE80211_MAX_RESULTS_LENGTH  32
    4747
    4848/** Max SSID length including null character. */
    49 #define IEEE80211_MAX_SSID_LENGTH 35
     49#define IEEE80211_MAX_SSID_LENGTH  35
    5050
    5151/** WiFi security authentication method indicator. */
     
    9797/** @}
    9898 */
    99 
  • uspace/lib/crypto/aes.c

    r09044cb r8a64320e  
    2828
    2929/** @file aes.c
    30  * 
     30 *
    3131 * Implementation of AES-128 symmetric cipher cryptographic algorithm.
    32  * 
     32 *
    3333 * Based on FIPS 197.
    3434 */
     
    3737#include <errno.h>
    3838#include <mem.h>
    39 
    4039#include "crypto.h"
    4140
    4241/* Number of elements in rows/columns in AES arrays. */
    43 #define ELEMS 4
     42#define ELEMS  4
    4443
    4544/* Number of elements (words) in cipher. */
    46 #define CIPHER_ELEMS 4
     45#define CIPHER_ELEMS  4
    4746
    4847/* Length of AES block. */
    49 #define BLOCK_LEN 16
     48#define BLOCK_LEN  16
    5049
    5150/* Number of iterations in AES algorithm. */
    52 #define ROUNDS 10
    53 
    54 /*
    55  * Irreducible polynomial used in AES algorithm.
    56  *
     51#define ROUNDS  10
     52
     53/** Irreducible polynomial used in AES algorithm.
     54 *
    5755 * NOTE: x^8 + x^4 + x^3 + x + 1.
    58  */
    59 #define AES_IP 0x1B
    60 
    61 /* Precomputed values for AES sub_byte transformation. */
     56 *
     57 */
     58#define AES_IP  0x1b
     59
     60/** Precomputed values for AES sub_byte transformation. */
    6261static const uint8_t sbox[BLOCK_LEN][BLOCK_LEN] = {
    6362        {
    64                 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 
     63                0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
    6564                0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76
    6665        },
    6766        {
    68                 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 
     67                0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
    6968                0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0
    7069        },
     
    7473        },
    7574        {
    76                 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 
     75                0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
    7776                0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75
    7877        },
    7978        {
    80                 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 
     79                0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
    8180                0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84
    8281        },
    8382        {
    84                 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 
     83                0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
    8584                0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf
    8685        },
    8786        {
    88                 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 
     87                0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
    8988                0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8
    9089        },
    9190        {
    92                 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 
     91                0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
    9392                0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2
    9493        },
    9594        {
    96                 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 
     95                0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
    9796                0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73
    9897        },
    9998        {
    100                 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 
     99                0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
    101100                0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb
    102101        },
    103102        {
    104                 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 
     103                0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
    105104                0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79
    106105        },
    107106        {
    108                 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 
     107                0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
    109108                0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08
    110109        },
    111110        {
    112                 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 
     111                0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
    113112                0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a
    114113        },
    115114        {
    116                 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 
     115                0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
    117116                0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e
    118117        },
    119118        {
    120                 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 
     119                0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
    121120                0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf
    122121        },
    123122        {
    124                 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 
     123                0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
    125124                0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
    126125        }
    127126};
    128127
    129 /* Precomputed values for AES inv_sub_byte transformation. */
     128/** Precomputed values for AES inv_sub_byte transformation. */
    130129static uint8_t inv_sbox[BLOCK_LEN][BLOCK_LEN] = {
    131130        {
    132                 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 
     131                0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38,
    133132                0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb
    134133        },
    135134        {
    136                 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 
     135                0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
    137136                0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb
    138137        },
    139138        {
    140                 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 
     139                0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d,
    141140                0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e
    142141        },
    143142        {
    144                 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 
     143                0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2,
    145144                0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25
    146145        },
    147146        {
    148                 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 
     147                0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
    149148                0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92
    150149        },
    151150        {
    152                 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 
     151                0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda,
    153152                0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84
    154153        },
    155154        {
    156                 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 
     155                0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a,
    157156                0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06
    158157        },
    159158        {
    160                 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 
     159                0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
    161160                0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b
    162161        },
    163162        {
    164                 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 
     163                0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea,
    165164                0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73
    166165        },
    167166        {
    168                 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 
     167                0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85,
    169168                0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e
    170169        },
    171170        {
    172                 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 
     171                0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
    173172                0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b
    174173        },
    175174        {
    176                 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 
     175                0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20,
    177176                0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4
    178177        },
    179178        {
    180                 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 
     179                0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31,
    181180                0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f
    182181        },
    183182        {
    184                 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 
     183                0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
    185184                0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef
    186185        },
    187186        {
    188                 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 
     187                0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0,
    189188                0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61
    190189        },
    191190        {
    192                 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 
     191                0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26,
    193192                0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
    194193        }
    195194};
    196195
    197 /* Precomputed values of powers of 2 in GF(2^8) left shifted by 24b. */
     196/** Precomputed values of powers of 2 in GF(2^8) left shifted by 24b. */
    198197static const uint32_t r_con_array[] = {
    199         0x01000000, 0x02000000, 0x04000000, 0x08000000,
     198        0x01000000, 0x02000000, 0x04000000, 0x08000000,
    200199        0x10000000, 0x20000000, 0x40000000, 0x80000000,
    201         0x1B000000, 0x36000000
     200        0x1b000000, 0x36000000
    202201};
    203202
    204 /**
    205  * Perform substitution transformation on given byte.
    206  *
     203/** Perform substitution transformation on given byte.
     204 *
    207205 * @param byte Input byte.
    208  * @param inv Flag indicating whether to use inverse table.
    209  * 
     206 * @param inv  Flag indicating whether to use inverse table.
     207 *
    210208 * @return Substituted value.
     209 *
    211210 */
    212211static uint8_t sub_byte(uint8_t byte, bool inv)
     
    215214        uint8_t j = byte & 0xF;
    216215       
    217         if(!inv) {
     216        if (!inv)
    218217                return sbox[i][j];
    219         } else {
    220                 return inv_sbox[i][j];
    221         }
    222 }
    223 
    224 /**
    225  * Perform substitution transformation on state table.
    226  *
     218       
     219        return inv_sbox[i][j];
     220}
     221
     222/** Perform substitution transformation on state table.
     223 *
    227224 * @param state State table to be modified.
    228  * @param inv Flag indicating whether to use inverse table.
     225 * @param inv   Flag indicating whether to use inverse table.
     226 *
    229227 */
    230228static void sub_bytes(uint8_t state[ELEMS][ELEMS], bool inv)
     
    232230        uint8_t val;
    233231       
    234         for(size_t i = 0; i < ELEMS; i++) {
    235                 for(size_t j = 0; j < ELEMS; j++) {
     232        for (size_t i = 0; i < ELEMS; i++) {
     233                for (size_t j = 0; j < ELEMS; j++) {
    236234                        val = state[i][j];
    237235                        state[i][j] = sub_byte(val, inv);
     
    240238}
    241239
    242 /**
    243  * Perform shift rows transformation on state table.
    244  *
     240/** Perform shift rows transformation on state table.
     241 *
    245242 * @param state State table to be modified.
     243 *
    246244 */
    247245static void shift_rows(uint8_t state[ELEMS][ELEMS])
     
    249247        uint8_t temp[ELEMS];
    250248       
    251         for(size_t i = 1; i < ELEMS; i++) {
     249        for (size_t i = 1; i < ELEMS; i++) {
    252250                memcpy(temp, state[i], i);
    253251                memcpy(state[i], state[i] + i, ELEMS - i);
     
    256254}
    257255
    258 /**
    259  * Perform inverted shift rows transformation on state table.
    260  *
     256/** Perform inverted shift rows transformation on state table.
     257 *
    261258 * @param state State table to be modified.
     259 *
    262260 */
    263261static void inv_shift_rows(uint8_t state[ELEMS][ELEMS])
     
    265263        uint8_t temp[ELEMS];
    266264       
    267         for(size_t i = 1; i < ELEMS; i++) {
     265        for (size_t i = 1; i < ELEMS; i++) {
    268266                memcpy(temp, state[i], ELEMS - i);
    269267                memcpy(state[i], state[i] + ELEMS - i, i);
     
    272270}
    273271
    274 /**
    275  * Multiplication in GF(2^8).
    276  *
     272/** Multiplication in GF(2^8).
     273 *
    277274 * @param x First factor.
    278275 * @param y Second factor.
    279  * 
     276 *
    280277 * @return Multiplication of given factors in GF(2^8).
    281  */
    282 static uint8_t galois_mult(uint8_t x, uint8_t y) {
    283         uint8_t result = 0;
    284         uint8_t F_bitH;
    285        
    286         for(size_t i = 0; i < 8; i++) {
    287                 if (y & 1)
     278 *
     279 */
     280static uint8_t galois_mult(uint8_t x, uint8_t y)
     281{
     282        uint8_t result = 0;
     283        uint8_t f_bith;
     284       
     285        for (size_t i = 0; i < 8; i++) {
     286                if (y & 1)
    288287                        result ^= x;
    289                 F_bitH = (x & 0x80);
    290                 x <<= 1;
    291                 if (F_bitH)
    292                         x ^= AES_IP;
    293                 y >>= 1;
    294         }
    295        
    296         return result;
    297 }
    298 
    299 /**
    300  * Perform mix columns transformation on state table.
    301  *
     288               
     289                f_bith = (x & 0x80);
     290                x <<= 1;
     291               
     292                if (f_bith)
     293                        x ^= AES_IP;
     294               
     295                y >>= 1;
     296        }
     297       
     298        return result;
     299}
     300
     301/** Perform mix columns transformation on state table.
     302 *
    302303 * @param state State table to be modified.
     304 *
    303305 */
    304306static void mix_columns(uint8_t state[ELEMS][ELEMS])
     
    307309        memcpy(orig_state, state, BLOCK_LEN);
    308310       
    309         for(size_t j = 0; j < ELEMS; j++) {
    310                 state[0][j] =
    311                         galois_mult(0x2, orig_state[0][j]) ^
    312                         galois_mult(0x3, orig_state[1][j]) ^
    313                         orig_state[2][j] ^
    314                         orig_state[3][j];
    315                 state[1][j] =
    316                         orig_state[0][j] ^
    317                         galois_mult(0x2, orig_state[1][j]) ^
    318                         galois_mult(0x3, orig_state[2][j]) ^
    319                         orig_state[3][j];
    320                 state[2][j] =
    321                         orig_state[0][j] ^
    322                         orig_state[1][j] ^
    323                         galois_mult(0x2, orig_state[2][j]) ^
    324                         galois_mult(0x3, orig_state[3][j]);
    325                 state[3][j] =
    326                         galois_mult(0x3, orig_state[0][j]) ^
    327                         orig_state[1][j] ^
    328                         orig_state[2][j] ^
    329                         galois_mult(0x2, orig_state[3][j]);
    330         }
    331 }
    332 
    333 /**
    334  * Perform inverted mix columns transformation on state table.
    335  *
     311        for (size_t j = 0; j < ELEMS; j++) {
     312                state[0][j] =
     313                    galois_mult(0x2, orig_state[0][j]) ^
     314                    galois_mult(0x3, orig_state[1][j]) ^
     315                    orig_state[2][j] ^
     316                    orig_state[3][j];
     317                state[1][j] =
     318                    orig_state[0][j] ^
     319                    galois_mult(0x2, orig_state[1][j]) ^
     320                    galois_mult(0x3, orig_state[2][j]) ^
     321                    orig_state[3][j];
     322                state[2][j] =
     323                    orig_state[0][j] ^
     324                    orig_state[1][j] ^
     325                    galois_mult(0x2, orig_state[2][j]) ^
     326                    galois_mult(0x3, orig_state[3][j]);
     327                state[3][j] =
     328                    galois_mult(0x3, orig_state[0][j]) ^
     329                    orig_state[1][j] ^
     330                    orig_state[2][j] ^
     331                    galois_mult(0x2, orig_state[3][j]);
     332        }
     333}
     334
     335/** Perform inverted mix columns transformation on state table.
     336 *
    336337 * @param state State table to be modified.
     338 *
    337339 */
    338340static void inv_mix_columns(uint8_t state[ELEMS][ELEMS])
     
    341343        memcpy(orig_state, state, BLOCK_LEN);
    342344       
    343         for(size_t j = 0; j < ELEMS; j++) {
    344                 state[0][j] =
    345                         galois_mult(0x0E, orig_state[0][j]) ^
    346                         galois_mult(0x0B, orig_state[1][j]) ^
    347                         galois_mult(0x0D, orig_state[2][j]) ^
    348                         galois_mult(0x09, orig_state[3][j]);
    349                 state[1][j] =
    350                         galois_mult(0x09, orig_state[0][j]) ^
    351                         galois_mult(0x0E, orig_state[1][j]) ^
    352                         galois_mult(0x0B, orig_state[2][j]) ^
    353                         galois_mult(0x0D, orig_state[3][j]);
    354                 state[2][j] =
    355                         galois_mult(0x0D, orig_state[0][j]) ^
    356                         galois_mult(0x09, orig_state[1][j]) ^
    357                         galois_mult(0x0E, orig_state[2][j]) ^
    358                         galois_mult(0x0B, orig_state[3][j]);
    359                 state[3][j] =
    360                         galois_mult(0x0B, orig_state[0][j]) ^
    361                         galois_mult(0x0D, orig_state[1][j]) ^
    362                         galois_mult(0x09, orig_state[2][j]) ^
    363                         galois_mult(0x0E, orig_state[3][j]);
    364         }
    365 }
    366 
    367 /**
    368  * Perform round key transformation on state table.
    369  *
    370  * @param state State table to be modified.
     345        for (size_t j = 0; j < ELEMS; j++) {
     346                state[0][j] =
     347                    galois_mult(0x0e, orig_state[0][j]) ^
     348                    galois_mult(0x0b, orig_state[1][j]) ^
     349                    galois_mult(0x0d, orig_state[2][j]) ^
     350                    galois_mult(0x09, orig_state[3][j]);
     351                state[1][j] =
     352                    galois_mult(0x09, orig_state[0][j]) ^
     353                    galois_mult(0x0e, orig_state[1][j]) ^
     354                    galois_mult(0x0b, orig_state[2][j]) ^
     355                    galois_mult(0x0d, orig_state[3][j]);
     356                state[2][j] =
     357                    galois_mult(0x0d, orig_state[0][j]) ^
     358                    galois_mult(0x09, orig_state[1][j]) ^
     359                    galois_mult(0x0e, orig_state[2][j]) ^
     360                    galois_mult(0x0b, orig_state[3][j]);
     361                state[3][j] =
     362                    galois_mult(0x0b, orig_state[0][j]) ^
     363                    galois_mult(0x0d, orig_state[1][j]) ^
     364                    galois_mult(0x09, orig_state[2][j]) ^
     365                    galois_mult(0x0e, orig_state[3][j]);
     366        }
     367}
     368
     369/** Perform round key transformation on state table.
     370 *
     371 * @param state     State table to be modified.
    371372 * @param round_key Round key to be applied on state table.
     373 *
    372374 */
    373375static void add_round_key(uint8_t state[ELEMS][ELEMS], uint32_t *round_key)
     
    375377        uint8_t byte_round;
    376378        uint8_t shift;
    377         uint32_t mask = 0xFF;
    378        
    379         for(size_t j = 0; j < ELEMS; j++) {
    380                 for(size_t i = 0; i < ELEMS; i++) {
    381                         shift = 24 - 8*i;
     379        uint32_t mask = 0xff;
     380       
     381        for (size_t j = 0; j < ELEMS; j++) {
     382                for (size_t i = 0; i < ELEMS; i++) {
     383                        shift = 24 - 8 * i;
    382384                        byte_round = (round_key[j] & (mask << shift)) >> shift;
    383385                        state[i][j] = state[i][j] ^ byte_round;
     
    386388}
    387389
    388 /**
    389  * Perform substitution transformation on given word.
    390  *
     390/** Perform substitution transformation on given word.
     391 *
    391392 * @param byte Input word.
    392  * 
     393 *
    393394 * @return Substituted word.
     395 *
    394396 */
    395397static uint32_t sub_word(uint32_t word)
     
    398400        uint8_t *start = (uint8_t *) &temp;
    399401       
    400         for(size_t i = 0; i < 4; i++) {
    401                 *(start+i) = sub_byte(*(start+i), false);
    402         }
     402        for (size_t i = 0; i < 4; i++)
     403                *(start + i) = sub_byte(*(start + i), false);
    403404       
    404405        return temp;
    405406}
    406407
    407 /**
    408  * Perform left rotation by one byte on given word.
    409  *
     408/** Perform left rotation by one byte on given word.
     409 *
    410410 * @param byte Input word.
    411  * 
     411 *
    412412 * @return Rotated word.
     413 *
    413414 */
    414415static uint32_t rot_word(uint32_t word)
     
    417418}
    418419
    419 /**
    420  * Key expansion procedure for AES algorithm.
    421  *
    422  * @param key Input key.
     420/** Key expansion procedure for AES algorithm.
     421 *
     422 * @param key     Input key.
    423423 * @param key_exp Result key expansion.
     424 *
    424425 */
    425426static void key_expansion(uint8_t *key, uint32_t *key_exp)
     
    427428        uint32_t temp;
    428429       
    429         for(size_t i = 0; i < CIPHER_ELEMS; i++) {
    430                 key_exp[i] = 
    431                         (key[4*i] << 24) +
    432                         (key[4*i+1] << 16) +
    433                         (key[4*i+2] << 8) +
    434                         (key[4*i+3]);
    435         }
    436        
    437         for(size_t i = CIPHER_ELEMS; i < ELEMS * (ROUNDS + 1); i++) {
    438                 temp = key_exp[i-1];
    439                
    440                 if((i % CIPHER_ELEMS) == 0) {
    441                         temp = sub_word(rot_word(temp)) ^ 
    442                                 r_con_array[i/CIPHER_ELEMS - 1];
     430        for (size_t i = 0; i < CIPHER_ELEMS; i++) {
     431                key_exp[i] =
     432                    (key[4 * i] << 24) +
     433                    (key[4 * i + 1] << 16) +
     434                    (key[4 * i + 2] << 8) +
     435                    (key[4 * i + 3]);
     436        }
     437       
     438        for (size_t i = CIPHER_ELEMS; i < ELEMS * (ROUNDS + 1); i++) {
     439                temp = key_exp[i - 1];
     440               
     441                if ((i % CIPHER_ELEMS) == 0) {
     442                        temp = sub_word(rot_word(temp)) ^
     443                            r_con_array[i / CIPHER_ELEMS - 1];
    443444                }
    444445               
     
    447448}
    448449
    449 /**
    450  * AES-128 encryption algorithm.
    451  *
    452  * @param key Input key.
    453  * @param input Input data sequence to be encrypted.
     450/** AES-128 encryption algorithm.
     451 *
     452 * @param key    Input key.
     453 * @param input  Input data sequence to be encrypted.
    454454 * @param output Encrypted data sequence.
    455  *
    456  * @return EINVAL when input or key not specified, ENOMEM when pointer for
    457  * output is not allocated, otherwise EOK. 
     455 *
     456 * @return EINVAL when input or key not specified,
     457 *         ENOMEM when pointer for output is not allocated,
     458 *         otherwise EOK.
     459 *
    458460 */
    459461int aes_encrypt(uint8_t *key, uint8_t *input, uint8_t *output)
    460462{
    461         if(!key || !input)
     463        if ((!key) || (!input))
    462464                return EINVAL;
    463465       
    464         if(!output)
     466        if (!output)
    465467                return ENOMEM;
    466468       
    467469        /* Create key expansion. */
    468         uint32_t key_exp[ELEMS * (ROUNDS+1)];
     470        uint32_t key_exp[ELEMS * (ROUNDS + 1)];
    469471        key_expansion(key, key_exp);
    470472       
    471473        /* Copy input into state array. */
    472474        uint8_t state[ELEMS][ELEMS];
    473         for(size_t i = 0; i < ELEMS; i++) {
    474                 for(size_t j = 0; j < ELEMS; j++) {
    475                         state[i][j] = input[i + ELEMS*j];
    476                 }
     475        for (size_t i = 0; i < ELEMS; i++) {
     476                for (size_t j = 0; j < ELEMS; j++)
     477                        state[i][j] = input[i + ELEMS * j];
    477478        }
    478479       
     
    480481        add_round_key(state, key_exp);
    481482       
    482         for(size_t k = 1; k <= ROUNDS; k++) {
     483        for (size_t k = 1; k <= ROUNDS; k++) {
    483484                sub_bytes(state, false);
    484485                shift_rows(state);
    485                 if(k < ROUNDS)
     486               
     487                if (k < ROUNDS)
    486488                        mix_columns(state);
    487                 add_round_key(state, key_exp + k*ELEMS);
     489               
     490                add_round_key(state, key_exp + k * ELEMS);
    488491        }
    489492       
    490493        /* Copy state array into output. */
    491         for(size_t i = 0; i < ELEMS; i++) {
    492                 for(size_t j = 0; j < ELEMS; j++) {
    493                         output[i + j*ELEMS] = state[i][j];
    494                 }
     494        for (size_t i = 0; i < ELEMS; i++) {
     495                for (size_t j = 0; j < ELEMS; j++)
     496                        output[i + j * ELEMS] = state[i][j];
    495497        }
    496498       
     
    498500}
    499501
    500 /**
    501  * AES-128 decryption algorithm.
    502  *
    503  * @param key Input key.
    504  * @param input Input data sequence to be decrypted.
     502/** AES-128 decryption algorithm.
     503 *
     504 * @param key    Input key.
     505 * @param input  Input data sequence to be decrypted.
    505506 * @param output Decrypted data sequence.
    506  *
    507  * @return EINVAL when input or key not specified, ENOMEM when pointer for
    508  * output is not allocated, otherwise EOK. 
     507 *
     508 * @return EINVAL when input or key not specified,
     509 *         ENOMEM when pointer for output is not allocated,
     510 *         otherwise EOK.
     511 *
    509512 */
    510513int aes_decrypt(uint8_t *key, uint8_t *input, uint8_t *output)
    511514{
    512         if(!key || !input)
     515        if ((!key) || (!input))
    513516                return EINVAL;
    514517       
    515         if(!output)
     518        if (!output)
    516519                return ENOMEM;
    517520       
    518521        /* Create key expansion. */
    519         uint32_t key_exp[ELEMS * (ROUNDS+1)];
     522        uint32_t key_exp[ELEMS * (ROUNDS + 1)];
    520523        key_expansion(key, key_exp);
    521524       
    522525        /* Copy input into state array. */
    523526        uint8_t state[ELEMS][ELEMS];
    524         for(size_t i = 0; i < ELEMS; i++) {
    525                 for(size_t j = 0; j < ELEMS; j++) {
    526                         state[i][j] = input[i + ELEMS*j];
    527                 }
     527        for (size_t i = 0; i < ELEMS; i++) {
     528                for (size_t j = 0; j < ELEMS; j++)
     529                        state[i][j] = input[i + ELEMS * j];
    528530        }
    529531       
    530532        /* Processing loop. */
    531         add_round_key(state, key_exp + ROUNDS*ELEMS);
    532        
    533         for(int k = ROUNDS - 1; k >= 0; k--) {
     533        add_round_key(state, key_exp + ROUNDS * ELEMS);
     534       
     535        for (int k = ROUNDS - 1; k >= 0; k--) {
    534536                inv_shift_rows(state);
    535537                sub_bytes(state, true);
    536                 add_round_key(state, key_exp + k*ELEMS);
    537                 if(k > 0)
     538                add_round_key(state, key_exp + k * ELEMS);
     539               
     540                if (k > 0)
    538541                        inv_mix_columns(state);
    539542        }
    540543       
    541544        /* Copy state array into output. */
    542         for(size_t i = 0; i < ELEMS; i++) {
    543                 for(size_t j = 0; j < ELEMS; j++) {
    544                         output[i + j*ELEMS] = state[i][j];
    545                 }
     545        for (size_t i = 0; i < ELEMS; i++) {
     546                for (size_t j = 0; j < ELEMS; j++)
     547                        output[i + j * ELEMS] = state[i][j];
    546548        }
    547549       
  • uspace/lib/crypto/crypto.c

    r09044cb r8a64320e  
    2828
    2929/** @file crypto.c
    30  * 
     30 *
    3131 * Cryptographic functions library.
    3232 */
     
    3737#include <errno.h>
    3838#include <byteorder.h>
    39 
    4039#include "crypto.h"
    4140
    42 /* Hash function procedure definition. */
    43 typedef void (*HASH_FUNC)(uint32_t*, uint32_t*);
    44 
    45 /* Length of HMAC block. */
    46 #define HMAC_BLOCK_LENGTH 64
    47 
    48 /* Ceiling for UINT32. */
    49 #define ceil_uint32(val) (((val) - (uint32_t)(val)) > 0 ? \
    50         (uint32_t)((val) + 1) : (uint32_t)(val))
    51 
    52 /* Floor for UINT32. */
    53 #define floor_uint32(val) (((val) - (uint32_t)(val)) < 0 ? \
    54         (uint32_t)((val) - 1) : (uint32_t)(val))
    55 
    56 /* Pick value at specified index from array or zero if out of bounds. */
    57 #define get_at(input, size, i) (i < size ? input[i] : 0)
    58 
    59 /* Init values used in SHA1 and MD5 functions. */
     41/** Hash function procedure definition. */
     42typedef void (*hash_fnc_t)(uint32_t *, uint32_t *);
     43
     44/** Length of HMAC block. */
     45#define HMAC_BLOCK_LENGTH  64
     46
     47/** Ceiling for uint32_t. */
     48#define ceil_uint32(val) \
     49        (((val) - (uint32_t) (val)) > 0 ? \
     50        (uint32_t) ((val) + 1) : (uint32_t) (val))
     51
     52/** Floor for uint32_t. */
     53#define floor_uint32(val) \
     54        (((val) - (uint32_t) (val)) < 0 ? \
     55        (uint32_t) ((val) - 1) : (uint32_t) (val))
     56
     57/** Pick value at specified index from array or zero if out of bounds. */
     58#define get_at(input, size, i) \
     59        ((i) < (size) ? (input[i]) : 0)
     60
     61/** Init values used in SHA1 and MD5 functions. */
    6062static const uint32_t hash_init[] = {
    61         0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0
     63        0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
    6264};
    6365
    64 /* Shift amount array for MD5 algorithm. */
     66/** Shift amount array for MD5 algorithm. */
    6567static const uint32_t md5_shift[] = {
    6668        7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,
     
    7072};
    7173
    72 /* Substitution box for MD5 algorithm. */
     74/** Substitution box for MD5 algorithm. */
    7375static const uint32_t md5_sbox[] = {
    7476        0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
     
    9092};
    9193
    92 /**
    93  * Working procedure of MD5 cryptographic hash function.
    94  *
    95  * @param h Working array with interim hash parts values.
     94/** Working procedure of MD5 cryptographic hash function.
     95 *
     96 * @param h         Working array with interim hash parts values.
    9697 * @param sched_arr Input array with scheduled values from input string.
     98 *
    9799 */
    98100static void md5_proc(uint32_t *h, uint32_t *sched_arr)
    99101{
    100102        uint32_t f, g, temp;
    101         uint32_t w[HASH_MD5/4];
    102        
    103         memcpy(w, h, (HASH_MD5/4) * sizeof(uint32_t));
    104        
    105         for(size_t k = 0; k < 64; k++) {
    106                 if(k < 16) {
     103        uint32_t w[HASH_MD5 / 4];
     104       
     105        memcpy(w, h, (HASH_MD5 / 4) * sizeof(uint32_t));
     106       
     107        for (size_t k = 0; k < 64; k++) {
     108                if (k < 16) {
    107109                        f = (w[1] & w[2]) | (~w[1] & w[3]);
    108110                        g = k;
    109                 } else if(k >= 16 && k < 32) {
     111                } else if ((k >= 16) && (k < 32)) {
    110112                        f = (w[1] & w[3]) | (w[2] & ~w[3]);
    111                         g = (5*k + 1) % 16;
    112                 } else if(k >= 32 && k < 48) {
     113                        g = (5 * k + 1) % 16;
     114                } else if ((k >= 32) && (k < 48)) {
    113115                        f = w[1] ^ w[2] ^ w[3];
    114                         g = (3*k + 5) % 16;
     116                        g = (3 * k + 5) % 16;
    115117                } else {
    116118                        f = w[2] ^ (w[1] | ~w[3]);
    117                         g = 7*k % 16;
     119                        g = 7 * k % 16;
    118120                }
     121               
    119122                temp = w[3];
    120123                w[3] = w[2];
    121124                w[2] = w[1];
    122                 w[1] += rotl_uint32(w[0] + f + md5_sbox[k] + 
    123                         uint32_t_byteorder_swap(sched_arr[g]), 
    124                         md5_shift[k]);
     125                w[1] += rotl_uint32(w[0] + f + md5_sbox[k] +
     126                    uint32_t_byteorder_swap(sched_arr[g]),
     127                    md5_shift[k]);
    125128                w[0] = temp;
    126129        }
    127130       
    128         for(uint8_t k = 0; k < HASH_MD5/4; k++)
     131        for (uint8_t k = 0; k < HASH_MD5 / 4; k++)
    129132                h[k] += w[k];
    130133}
    131134
    132 /**
    133  * Working procedure of SHA-1 cryptographic hash function.
    134  *
    135  * @param h Working array with interim hash parts values.
     135/** Working procedure of SHA-1 cryptographic hash function.
     136 *
     137 * @param h         Working array with interim hash parts values.
    136138 * @param sched_arr Input array with scheduled values from input string.
     139 *
    137140 */
    138141static void sha1_proc(uint32_t *h, uint32_t *sched_arr)
    139142{
    140143        uint32_t f, cf, temp;
    141         uint32_t w[HASH_SHA1/4];
    142        
    143         for(size_t k = 16; k < 80; k++) {
     144        uint32_t w[HASH_SHA1 / 4];
     145       
     146        for (size_t k = 16; k < 80; k++) {
    144147                sched_arr[k] = rotl_uint32(
    145                         sched_arr[k-3] ^
    146                         sched_arr[k-8] ^
    147                         sched_arr[k-14] ^
    148                         sched_arr[k-16],
    149                         1);
    150         }
    151 
    152         memcpy(w, h, (HASH_SHA1/4) * sizeof(uint32_t));
    153        
    154         for(size_t k = 0; k < 80; k++) {
    155                 if(k < 20) {
     148                    sched_arr[k-3] ^
     149                    sched_arr[k-8] ^
     150                    sched_arr[k-14] ^
     151                    sched_arr[k-16],
     152                    1);
     153        }
     154       
     155        memcpy(w, h, (HASH_SHA1 / 4) * sizeof(uint32_t));
     156       
     157        for (size_t k = 0; k < 80; k++) {
     158                if (k < 20) {
    156159                        f = (w[1] & w[2]) | (~w[1] & w[3]);
    157160                        cf = 0x5A827999;
    158                 } else if(k >= 20 && k < 40) {
     161                } else if ((k >= 20) && (k < 40)) {
    159162                        f = w[1] ^ w[2] ^ w[3];
    160                         cf = 0x6ED9EBA1;
    161                 } else if(k >= 40 && k < 60) {
     163                        cf = 0x6ed9eba1;
     164                } else if ((k >= 40) && (k < 60)) {
    162165                        f = (w[1] & w[2]) | (w[1] & w[3]) | (w[2] & w[3]);
    163                         cf = 0x8F1BBCDC;
     166                        cf = 0x8f1bbcdc;
    164167                } else {
    165168                        f = w[1] ^ w[2] ^ w[3];
    166                         cf = 0xCA62C1D6;
     169                        cf = 0xca62c1d6;
    167170                }
    168 
     171               
    169172                temp = rotl_uint32(w[0], 5) + f + w[4] + cf + sched_arr[k];
    170 
     173               
    171174                w[4] = w[3];
    172175                w[3] = w[2];
     
    175178                w[0] = temp;
    176179        }
    177 
    178         for(uint8_t k = 0; k < HASH_SHA1/4; k++)
     180       
     181        for (uint8_t k = 0; k < HASH_SHA1 / 4; k++)
    179182                h[k] += w[k];
    180183}
    181184
    182 /**
    183  * Create hash based on selected algorithm.
    184  *
    185  * @param input Input message byte sequence.
     185/** Create hash based on selected algorithm.
     186 *
     187 * @param input      Input message byte sequence.
    186188 * @param input_size Size of message sequence.
    187  * @param output Result hash byte sequence.
    188  * @param hash_sel Hash function selector.
    189  *
    190  * @return EINVAL when input not specified, ENOMEM when pointer for
    191  * output hash result is not allocated, otherwise EOK.
     189 * @param output     Result hash byte sequence.
     190 * @param hash_sel   Hash function selector.
     191 *
     192 * @return EINVAL when input not specified,
     193 *         ENOMEM when pointer for output hash result
     194 *         is not allocated, otherwise EOK.
     195 *
    192196 */
    193197int create_hash(uint8_t *input, size_t input_size, uint8_t *output,
    194         hash_func_t hash_sel)
    195 {
    196         if(!input)
     198    hash_func_t hash_sel)
     199{
     200        if (!input)
    197201                return EINVAL;
    198202       
    199         if(!output)
     203        if (!output)
    200204                return ENOMEM;
    201205       
    202         HASH_FUNC hash_func = (hash_sel == HASH_MD5) ? md5_proc : sha1_proc;
     206        hash_fnc_t hash_func = (hash_sel == HASH_MD5) ? md5_proc : sha1_proc;
    203207       
    204208        /* Prepare scheduled input. */
     
    207211        work_input[input_size] = 0x80;
    208212       
    209         size_t blocks = ceil_uint32((((double)input_size + 1) / 4 + 2) / 16);
     213        // FIXME: double?
     214        size_t blocks = ceil_uint32((((double) input_size + 1) / 4 + 2) / 16);
    210215        uint32_t work_arr[blocks * 16];
    211         for(size_t i = 0; i < blocks; i++) {
    212                 for(size_t j = 0; j < 16; j++) {
    213                         work_arr[i*16 + j] = 
    214                         (get_at(work_input, input_size+1, i*64+j*4) << 24) |
    215                         (get_at(work_input, input_size+1, i*64+j*4+1) << 16) |
    216                         (get_at(work_input, input_size+1, i*64+j*4+2) << 8) |
    217                         get_at(work_input, input_size+1, i*64+j*4+3);
     216        for (size_t i = 0; i < blocks; i++) {
     217                for (size_t j = 0; j < 16; j++) {
     218                        work_arr[i*16 + j] =
     219                            (get_at(work_input, input_size + 1, i * 64 + j * 4) << 24) |
     220                            (get_at(work_input, input_size + 1, i * 64 + j * 4 + 1) << 16) |
     221                            (get_at(work_input, input_size + 1, i * 64 + j * 4 + 2) << 8) |
     222                            get_at(work_input, input_size + 1, i * 64 + j * 4 + 3);
    218223                }
    219224        }
    220225       
    221         uint64_t bits_size = (uint64_t)(input_size * 8);
    222         if(hash_sel == HASH_MD5)
     226        uint64_t bits_size = (uint64_t) (input_size * 8);
     227        if (hash_sel == HASH_MD5)
    223228                bits_size = uint64_t_byteorder_swap(bits_size);
    224229       
    225230        work_arr[(blocks - 1) * 16 + 14] = bits_size >> 32;
    226         work_arr[(blocks - 1) * 16 + 15] = bits_size & 0xFFFFFFFF;
     231        work_arr[(blocks - 1) * 16 + 15] = bits_size & 0xffffffff;
    227232       
    228233        /* Hash computation. */
    229         uint32_t h[hash_sel/4];
    230         memcpy(h, hash_init, (hash_sel/4) * sizeof(uint32_t));
     234        uint32_t h[hash_sel / 4];
     235        memcpy(h, hash_init, (hash_sel / 4) * sizeof(uint32_t));
    231236        uint32_t sched_arr[80];
    232         for(size_t i = 0; i < blocks; i++) {
    233                 for(size_t k = 0; k < 16; k++) {
    234                         sched_arr[k] = work_arr[i*16 + k];
    235                 }
     237        for (size_t i = 0; i < blocks; i++) {
     238                for (size_t k = 0; k < 16; k++)
     239                        sched_arr[k] = work_arr[i * 16 + k];
    236240               
    237241                hash_func(h, sched_arr);
     
    239243       
    240244        /* Copy hash parts into final result. */
    241         for(size_t i = 0; i < hash_sel/4; i++) {
    242                 if(hash_sel == HASH_SHA1)
     245        for (size_t i = 0; i < hash_sel / 4; i++) {
     246                if (hash_sel == HASH_SHA1)
    243247                        h[i] = uint32_t_byteorder_swap(h[i]);
    244                 memcpy(output + i*sizeof(uint32_t), &h[i], sizeof(uint32_t));
     248               
     249                memcpy(output + i * sizeof(uint32_t), &h[i], sizeof(uint32_t));
    245250        }
    246251       
     
    248253}
    249254
    250 /**
    251  * Hash-based message authentication code.
    252  *
    253  * @param key Cryptographic key sequence.
     255/** Hash-based message authentication code.
     256 *
     257 * @param key      Cryptographic key sequence.
    254258 * @param key_size Size of key sequence.
    255  * @param msg Message sequence.
     259 * @param msg      Message sequence.
    256260 * @param msg_size Size of message sequence.
    257  * @param hash Output parameter for result hash.
     261 * @param hash     Output parameter for result hash.
    258262 * @param hash_sel Hash function selector.
    259  *
    260  * @return EINVAL when key or message not specified, ENOMEM when pointer for
    261  * output hash result is not allocated, otherwise EOK.
     263 *
     264 * @return EINVAL when key or message not specified,
     265 *         ENOMEM when pointer for output hash result
     266 *         is not allocated, otherwise EOK.
     267 *
    262268 */
    263269int hmac(uint8_t *key, size_t key_size, uint8_t *msg, size_t msg_size,
    264         uint8_t *hash, hash_func_t hash_sel)
    265 {
    266         if(!key || !msg)
     270    uint8_t *hash, hash_func_t hash_sel)
     271{
     272        if ((!key) || (!msg))
    267273                return EINVAL;
    268274       
    269         if(!hash)
     275        if (!hash)
    270276                return ENOMEM;
    271277       
     
    276282        memset(work_key, 0, HMAC_BLOCK_LENGTH);
    277283       
    278         if(key_size > HMAC_BLOCK_LENGTH) {
     284        if(key_size > HMAC_BLOCK_LENGTH)
    279285                create_hash(key, key_size, work_key, hash_sel);
    280         } else {
     286        else
    281287                memcpy(work_key, key, key_size);
    282         }
    283        
    284         for(size_t i = 0; i < HMAC_BLOCK_LENGTH; i++) {
    285                 o_key_pad[i] = work_key[i] ^ 0x5C;
     288       
     289        for (size_t i = 0; i < HMAC_BLOCK_LENGTH; i++) {
     290                o_key_pad[i] = work_key[i] ^ 0x5c;
    286291                i_key_pad[i] = work_key[i] ^ 0x36;
    287292        }
     
    291296        memcpy(temp_work + HMAC_BLOCK_LENGTH, msg, msg_size);
    292297       
    293         create_hash(temp_work, HMAC_BLOCK_LENGTH + msg_size, temp_hash, 
    294                 hash_sel);
     298        create_hash(temp_work, HMAC_BLOCK_LENGTH + msg_size, temp_hash,
     299            hash_sel);
    295300       
    296301        memcpy(temp_work, o_key_pad, HMAC_BLOCK_LENGTH);
     
    302307}
    303308
    304 /**
    305  * Password-Based Key Derivation Function 2 as defined in RFC 2898,
    306  * using HMAC-SHA1 with 4096 iterations and 32 bytes key result used
    307  * for WPA/WPA2.
    308  * 
    309  * @param pass Password sequence.
     309/** Password-Based Key Derivation Function 2.
     310 *
     311 * As defined in RFC 2898, using HMAC-SHA1 with 4096 iterations
     312 * and 32 bytes key result used for WPA/WPA2.
     313 *
     314 * @param pass      Password sequence.
    310315 * @param pass_size Password sequence length.
    311  * @param salt Salt sequence to be used with password.
     316 * @param salt      Salt sequence to be used with password.
    312317 * @param salt_size Salt sequence length.
    313  * @param hash Output parameter for result hash (32 byte value).
    314  *
    315  * @return EINVAL when pass or salt not specified, ENOMEM when pointer for
    316  * output hash result is not allocated, otherwise EOK.
    317  */
    318 int pbkdf2(uint8_t *pass, size_t pass_size, uint8_t *salt, size_t salt_size,
    319         uint8_t *hash)
    320 {
    321         if(!pass || !salt)
     318 * @param hash      Output parameter for result hash (32 byte value).
     319 *
     320 * @return EINVAL when pass or salt not specified,
     321 *         ENOMEM when pointer for output hash result
     322 *         is not allocated, otherwise EOK.
     323 *
     324 */
     325int pbkdf2(uint8_t *pass, size_t pass_size, uint8_t *salt, size_t salt_size,
     326    uint8_t *hash)
     327{
     328        if ((!pass) || (!salt))
    322329                return EINVAL;
    323330       
    324         if(!hash)
     331        if (!hash)
    325332                return ENOMEM;
    326333       
     
    330337        uint8_t temp_hmac[HASH_SHA1];
    331338        uint8_t xor_hmac[HASH_SHA1];
    332         uint8_t temp_hash[HASH_SHA1*2];
    333        
    334         for(size_t i = 0; i < 2; i++) {
    335                 uint32_t be_i = host2uint32_t_be(i+1);
     339        uint8_t temp_hash[HASH_SHA1 * 2];
     340       
     341        for (size_t i = 0; i < 2; i++) {
     342                uint32_t be_i = host2uint32_t_be(i + 1);
     343               
    336344                memcpy(work_salt + salt_size, &be_i, 4);
    337345                hmac(pass, pass_size, work_salt, salt_size + 4,
    338                         work_hmac, HASH_SHA1);
     346                    work_hmac, HASH_SHA1);
    339347                memcpy(xor_hmac, work_hmac, HASH_SHA1);
    340348               
    341                 for(size_t k = 1; k < 4096; k++) {
     349                for (size_t k = 1; k < 4096; k++) {
    342350                        memcpy(temp_hmac, work_hmac, HASH_SHA1);
    343                         hmac(pass, pass_size, temp_hmac, HASH_SHA1,
    344                                 work_hmac, HASH_SHA1);
    345                         for(size_t t = 0; t < HASH_SHA1; t++) {
     351                        hmac(pass, pass_size, temp_hmac, HASH_SHA1,
     352                            work_hmac, HASH_SHA1);
     353                       
     354                        for (size_t t = 0; t < HASH_SHA1; t++)
    346355                                xor_hmac[t] ^= work_hmac[t];
    347                         }
    348356                }
    349                 memcpy(temp_hash + i*HASH_SHA1, xor_hmac, HASH_SHA1);
     357               
     358                memcpy(temp_hash + i * HASH_SHA1, xor_hmac, HASH_SHA1);
    350359        }
    351360       
  • uspace/lib/crypto/crypto.h

    r09044cb r8a64320e  
    3232#include <sys/types.h>
    3333
    34 #define AES_CIPHER_LENGTH 16
    35 #define PBKDF2_KEY_LENGTH 32
     34#define AES_CIPHER_LENGTH  16
     35#define PBKDF2_KEY_LENGTH  32
    3636
    37 /* Left rotation for UINT32. */
    38 #define rotl_uint32(val, shift) (((val) << shift) | ((val) >> (32 - shift)))
     37/* Left rotation for uint32_t. */
     38#define rotl_uint32(val, shift) \
     39        (((val) << shift) | ((val) >> (32 - shift)))
    3940
    40 /* Right rotation for UINT32. */
    41 #define rotr_uint32(val, shift) (((val) >> shift) | ((val) << (32 - shift)))
     41/* Right rotation for uint32_t. */
     42#define rotr_uint32(val, shift) \
     43        (((val) >> shift) | ((val) << (32 - shift)))
    4244
    4345/** Hash function selector and also result hash length indicator. */
    4446typedef enum {
    45         HASH_MD5 =      16,
    46         HASH_SHA1 =     20
     47        HASH_MD5 =  16,
     48        HASH_SHA1 = 20
    4749} hash_func_t;
    4850
    49 extern int rc4(uint8_t *key, size_t key_size, uint8_t *input, size_t input_size,
    50         size_t skip, uint8_t *output);
    51 extern int aes_encrypt(uint8_t *key, uint8_t *input, uint8_t *output);
    52 extern int aes_decrypt(uint8_t *key, uint8_t *input, uint8_t *output);
    53 extern int create_hash(uint8_t *input, size_t input_size, uint8_t *output,
    54         hash_func_t hash_sel);
    55 extern int hmac(uint8_t *key, size_t key_size, uint8_t *msg, size_t msg_size,
    56         uint8_t *hash, hash_func_t hash_sel);
    57 extern int pbkdf2(uint8_t *pass, size_t pass_size, uint8_t *salt,
    58         size_t salt_size, uint8_t *hash);
     51extern int rc4(uint8_t *, size_t, uint8_t *, size_t, size_t, uint8_t *);
     52extern int aes_encrypt(uint8_t *, uint8_t *, uint8_t *);
     53extern int aes_decrypt(uint8_t *, uint8_t *, uint8_t *);
     54extern int create_hash(uint8_t *, size_t, uint8_t *, hash_func_t);
     55extern int hmac(uint8_t *, size_t, uint8_t *, size_t, uint8_t *, hash_func_t);
     56extern int pbkdf2(uint8_t *, size_t, uint8_t *, size_t, uint8_t *);
    5957
    6058#endif
  • uspace/lib/crypto/rc4.c

    r09044cb r8a64320e  
    2828
    2929/** @file rc4.c
    30  * 
     30 *
    3131 * Implementation of ARC4 symmetric cipher cryptographic algorithm.