tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

ath6kl: alignment should match open parenthesis

Fix the issues which checkpatch found and were easy to fix. Especially
callers of ath6kl_bmi_write() are tricky and that needs to be fixed
separately.

Signed-off-by: Kalle Valo <kvalo@qca.qualcomm.com>

Kalle Valo 96f1fadc c650538f

+115 -115
+3 -3
drivers/net/wireless/ath/ath6kl/bmi.c
··· 106 106 } 107 107 108 108 ath6kl_dbg(ATH6KL_DBG_BMI, "target info (ver: 0x%x type: 0x%x)\n", 109 - targ_info->version, targ_info->type); 109 + targ_info->version, targ_info->type); 110 110 111 111 return 0; 112 112 } ··· 193 193 memset(ar->bmi.cmd_buf, 0, ar->bmi.max_data_size + header); 194 194 195 195 ath6kl_dbg(ATH6KL_DBG_BMI, 196 - "bmi write memory: addr: 0x%x, len: %d\n", addr, len); 196 + "bmi write memory: addr: 0x%x, len: %d\n", addr, len); 197 197 198 198 len_remain = len; 199 199 while (len_remain) { ··· 435 435 memcpy(&(ar->bmi.cmd_buf[offset]), &tx_len, sizeof(tx_len)); 436 436 offset += sizeof(tx_len); 437 437 memcpy(&(ar->bmi.cmd_buf[offset]), &buf[len - len_remain], 438 - tx_len); 438 + tx_len); 439 439 offset += tx_len; 440 440 441 441 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
+9 -9
drivers/net/wireless/ath/ath6kl/cfg80211.c
··· 390 390 return false; 391 391 392 392 if (ar->ibss_if_active || ((type == NL80211_IFTYPE_ADHOC) && 393 - ar->num_vif)) 393 + ar->num_vif)) 394 394 return false; 395 395 396 396 if (type == NL80211_IFTYPE_STATION || ··· 556 556 if (!ar->usr_bss_filter) { 557 557 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags); 558 558 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx, 559 - ALL_BSS_FILTER, 0) != 0) { 559 + ALL_BSS_FILTER, 0) != 0) { 560 560 ath6kl_err("couldn't set bss filtering\n"); 561 561 up(&ar->sem); 562 562 return -EIO; ··· 848 848 849 849 if (vif->sme_state == SME_CONNECTING) { 850 850 cfg80211_connect_result(vif->ndev, 851 - bssid, NULL, 0, 852 - NULL, 0, 853 - WLAN_STATUS_UNSPECIFIED_FAILURE, 854 - GFP_KERNEL); 851 + bssid, NULL, 0, 852 + NULL, 0, 853 + WLAN_STATUS_UNSPECIFIED_FAILURE, 854 + GFP_KERNEL); 855 855 } else if (vif->sme_state == SME_CONNECTED) { 856 856 cfg80211_disconnected(vif->ndev, reason, 857 - NULL, 0, GFP_KERNEL); 857 + NULL, 0, GFP_KERNEL); 858 858 } 859 859 860 860 vif->sme_state = SME_DISCONNECTED; ··· 936 936 force_fg_scan = 1; 937 937 938 938 if (test_bit(ATH6KL_FW_CAPABILITY_STA_P2PDEV_DUPLEX, 939 - ar->fw_capabilities)) { 939 + ar->fw_capabilities)) { 940 940 /* 941 941 * If capable of doing P2P mgmt operations using 942 942 * station interface, send additional information like ··· 1371 1371 } 1372 1372 1373 1373 if (ath6kl_wmi_powermode_cmd(ar->wmi, vif->fw_vif_idx, 1374 - mode.pwr_mode) != 0) { 1374 + mode.pwr_mode) != 0) { 1375 1375 ath6kl_err("wmi_powermode_cmd failed\n"); 1376 1376 return -EIO; 1377 1377 }
+3 -3
drivers/net/wireless/ath/ath6kl/core.c
··· 115 115 ATH6KL_CONF_ENABLE_11N | ATH6KL_CONF_ENABLE_TX_BURST; 116 116 117 117 if (suspend_mode && 118 - suspend_mode >= WLAN_POWER_STATE_CUT_PWR && 119 - suspend_mode <= WLAN_POWER_STATE_WOW) 118 + suspend_mode >= WLAN_POWER_STATE_CUT_PWR && 119 + suspend_mode <= WLAN_POWER_STATE_WOW) 120 120 ar->suspend_mode = suspend_mode; 121 121 else 122 122 ar->suspend_mode = 0; ··· 174 174 } 175 175 176 176 ath6kl_dbg(ATH6KL_DBG_TRC, "%s: name=%s dev=0x%p, ar=0x%p\n", 177 - __func__, ndev->name, ndev, ar); 177 + __func__, ndev->name, ndev, ar); 178 178 179 179 return ret; 180 180
+24 -24
drivers/net/wireless/ath/ath6kl/debug.c
··· 119 119 120 120 if (irq_proc_reg != NULL) { 121 121 ath6kl_dbg(ATH6KL_DBG_IRQ, 122 - "Host Int status: 0x%x\n", 123 - irq_proc_reg->host_int_status); 122 + "Host Int status: 0x%x\n", 123 + irq_proc_reg->host_int_status); 124 124 ath6kl_dbg(ATH6KL_DBG_IRQ, 125 125 "CPU Int status: 0x%x\n", 126 - irq_proc_reg->cpu_int_status); 126 + irq_proc_reg->cpu_int_status); 127 127 ath6kl_dbg(ATH6KL_DBG_IRQ, 128 128 "Error Int status: 0x%x\n", 129 - irq_proc_reg->error_int_status); 129 + irq_proc_reg->error_int_status); 130 130 ath6kl_dbg(ATH6KL_DBG_IRQ, 131 131 "Counter Int status: 0x%x\n", 132 - irq_proc_reg->counter_int_status); 132 + irq_proc_reg->counter_int_status); 133 133 ath6kl_dbg(ATH6KL_DBG_IRQ, 134 134 "Mbox Frame: 0x%x\n", 135 - irq_proc_reg->mbox_frame); 135 + irq_proc_reg->mbox_frame); 136 136 ath6kl_dbg(ATH6KL_DBG_IRQ, 137 137 "Rx Lookahead Valid: 0x%x\n", 138 - irq_proc_reg->rx_lkahd_valid); 138 + irq_proc_reg->rx_lkahd_valid); 139 139 ath6kl_dbg(ATH6KL_DBG_IRQ, 140 140 "Rx Lookahead 0: 0x%x\n", 141 - irq_proc_reg->rx_lkahd[0]); 141 + irq_proc_reg->rx_lkahd[0]); 142 142 ath6kl_dbg(ATH6KL_DBG_IRQ, 143 143 "Rx Lookahead 1: 0x%x\n", 144 - irq_proc_reg->rx_lkahd[1]); 144 + irq_proc_reg->rx_lkahd[1]); 145 145 146 146 if (dev->ar->mbox_info.gmbox_addr != 0) { 147 147 /* ··· 149 149 * additional state. 150 150 */ 151 151 ath6kl_dbg(ATH6KL_DBG_IRQ, 152 - "GMBOX Host Int status 2: 0x%x\n", 153 - irq_proc_reg->host_int_status2); 152 + "GMBOX Host Int status 2: 0x%x\n", 153 + irq_proc_reg->host_int_status2); 154 154 ath6kl_dbg(ATH6KL_DBG_IRQ, 155 - "GMBOX RX Avail: 0x%x\n", 156 - irq_proc_reg->gmbox_rx_avail); 155 + "GMBOX RX Avail: 0x%x\n", 156 + irq_proc_reg->gmbox_rx_avail); 157 157 ath6kl_dbg(ATH6KL_DBG_IRQ, 158 - "GMBOX lookahead alias 0: 0x%x\n", 159 - irq_proc_reg->rx_gmbox_lkahd_alias[0]); 158 + "GMBOX lookahead alias 0: 0x%x\n", 159 + irq_proc_reg->rx_gmbox_lkahd_alias[0]); 160 160 ath6kl_dbg(ATH6KL_DBG_IRQ, 161 - "GMBOX lookahead alias 1: 0x%x\n", 162 - irq_proc_reg->rx_gmbox_lkahd_alias[1]); 161 + "GMBOX lookahead alias 1: 0x%x\n", 162 + irq_proc_reg->rx_gmbox_lkahd_alias[1]); 163 163 } 164 164 165 165 } 166 166 167 167 if (irq_enable_reg != NULL) { 168 168 ath6kl_dbg(ATH6KL_DBG_IRQ, 169 - "Int status Enable: 0x%x\n", 170 - irq_enable_reg->int_status_en); 169 + "Int status Enable: 0x%x\n", 170 + irq_enable_reg->int_status_en); 171 171 ath6kl_dbg(ATH6KL_DBG_IRQ, "Counter Int status Enable: 0x%x\n", 172 - irq_enable_reg->cntr_int_status_en); 172 + irq_enable_reg->cntr_int_status_en); 173 173 } 174 174 ath6kl_dbg(ATH6KL_DBG_IRQ, "<------------------------------->\n"); 175 175 } ··· 1804 1804 ar->debugfs_phy, ar, &fops_disconnect_timeout); 1805 1805 1806 1806 debugfs_create_file("create_qos", S_IWUSR, ar->debugfs_phy, ar, 1807 - &fops_create_qos); 1807 + &fops_create_qos); 1808 1808 1809 1809 debugfs_create_file("delete_qos", S_IWUSR, ar->debugfs_phy, ar, 1810 - &fops_delete_qos); 1810 + &fops_delete_qos); 1811 1811 1812 1812 debugfs_create_file("bgscan_interval", S_IWUSR, 1813 - ar->debugfs_phy, ar, &fops_bgscan_int); 1813 + ar->debugfs_phy, ar, &fops_bgscan_int); 1814 1814 1815 1815 debugfs_create_file("listen_interval", S_IRUSR | S_IWUSR, 1816 1816 ar->debugfs_phy, ar, &fops_listen_int); 1817 1817 1818 1818 debugfs_create_file("power_params", S_IWUSR, ar->debugfs_phy, ar, 1819 - &fops_power_params); 1819 + &fops_power_params); 1820 1820 1821 1821 return 0; 1822 1822 }
+3 -3
drivers/net/wireless/ath/ath6kl/hif.c
··· 90 90 } 91 91 92 92 ath6kl_dbg(ATH6KL_DBG_IRQ, "register dump data address 0x%x\n", 93 - regdump_addr); 93 + regdump_addr); 94 94 regdump_addr = TARG_VTOP(ar->target_type, regdump_addr); 95 95 96 96 /* fetch register dump data */ ··· 285 285 dev->irq_en_reg.cntr_int_status_en; 286 286 287 287 ath6kl_dbg(ATH6KL_DBG_IRQ, 288 - "valid interrupt source(s) in COUNTER_INT_STATUS: 0x%x\n", 288 + "valid interrupt source(s) in COUNTER_INT_STATUS: 0x%x\n", 289 289 counter_int_status); 290 290 291 291 /* ··· 360 360 } 361 361 362 362 ath6kl_dbg(ATH6KL_DBG_IRQ, 363 - "valid interrupt source(s) in CPU_INT_STATUS: 0x%x\n", 363 + "valid interrupt source(s) in CPU_INT_STATUS: 0x%x\n", 364 364 cpu_int_status); 365 365 366 366 /* Clear the interrupt */
+31 -31
drivers/net/wireless/ath/ath6kl/htc.c
··· 185 185 if (cur_dist_list->credits > 186 186 cur_dist_list->cred_assngd) 187 187 ath6kl_credit_reduce(cred_info, 188 - cur_dist_list, 189 - cur_dist_list->cred_assngd); 188 + cur_dist_list, 189 + cur_dist_list->cred_assngd); 190 190 191 191 if (cur_dist_list->credits > 192 192 cur_dist_list->cred_norm) ··· 464 464 INIT_LIST_HEAD(&tx_compq); 465 465 466 466 ath6kl_dbg(ATH6KL_DBG_HTC, 467 - "htc tx scat complete len %d entries %d\n", 468 - scat_req->len, scat_req->scat_entries); 467 + "htc tx scat complete len %d entries %d\n", 468 + scat_req->len, scat_req->scat_entries); 469 469 470 470 if (scat_req->status) 471 471 ath6kl_err("send scatter req failed: %d\n", scat_req->status); ··· 603 603 list); 604 604 605 605 ath6kl_dbg(ATH6KL_DBG_HTC, 606 - "htc tx got packet 0x%p queue depth %d\n", 607 - packet, get_queue_depth(&endpoint->txq)); 606 + "htc tx got packet 0x%p queue depth %d\n", 607 + packet, get_queue_depth(&endpoint->txq)); 608 608 609 609 len = CALC_TXRX_PADDED_LEN(target, 610 610 packet->act_len + HTC_HDR_LENGTH); ··· 701 701 scat_req->scat_list[i].packet = packet; 702 702 /* prepare packet and flag message as part of a send bundle */ 703 703 ath6kl_htc_tx_prep_pkt(packet, 704 - packet->info.tx.flags | HTC_FLAGS_SEND_BUNDLE, 705 - cred_pad, packet->info.tx.seqno); 704 + packet->info.tx.flags | HTC_FLAGS_SEND_BUNDLE, 705 + cred_pad, packet->info.tx.seqno); 706 706 /* Make sure the buffer is 4-byte aligned */ 707 707 ath6kl_htc_tx_buf_align(&packet->buf, 708 708 packet->act_len + HTC_HDR_LENGTH); ··· 752 752 u8 ac = WMM_NUM_AC; 753 753 754 754 if ((HTC_CTRL_RSVD_SVC != endpoint->svc_id) || 755 - (WMI_CONTROL_SVC != endpoint->svc_id)) 755 + (WMI_CONTROL_SVC != endpoint->svc_id)) 756 756 ac = target->dev->ar->ep2ac_map[endpoint->eid]; 757 757 758 758 while (true) { ··· 769 769 if (!scat_req) { 770 770 /* no scatter resources */ 771 771 ath6kl_dbg(ATH6KL_DBG_HTC, 772 - "htc tx no more scatter resources\n"); 772 + "htc tx no more scatter resources\n"); 773 773 break; 774 774 } 775 775 ··· 860 860 INIT_LIST_HEAD(&txq); 861 861 862 862 if ((HTC_CTRL_RSVD_SVC != endpoint->svc_id) || 863 - (WMI_CONTROL_SVC != endpoint->svc_id)) 863 + (WMI_CONTROL_SVC != endpoint->svc_id)) 864 864 ac = target->dev->ar->ep2ac_map[endpoint->eid]; 865 865 866 866 while (true) { ··· 918 918 */ 919 919 if (!bundle_sent) { 920 920 if (!(target->tx_bndl_mask & (1 << ac)) && 921 - (ac < WMM_NUM_AC)) { 921 + (ac < WMM_NUM_AC)) { 922 922 if (++target->ac_tx_count[ac] >= 923 923 TX_RESUME_BUNDLE_THRESHOLD) { 924 924 target->ac_tx_count[ac] = 0; ··· 1042 1042 memcpy(&setup_comp_ext->flags, &flags, 1043 1043 sizeof(setup_comp_ext->flags)); 1044 1044 set_htc_pkt_info(send_pkt, NULL, (u8 *) setup_comp_ext, 1045 - sizeof(struct htc_setup_comp_ext_msg), 1046 - ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); 1045 + sizeof(struct htc_setup_comp_ext_msg), 1046 + ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); 1047 1047 1048 1048 } else { 1049 1049 struct htc_setup_comp_msg *setup_comp; ··· 1051 1051 memset(setup_comp, 0, sizeof(struct htc_setup_comp_msg)); 1052 1052 setup_comp->msg_id = cpu_to_le16(HTC_MSG_SETUP_COMPLETE_ID); 1053 1053 set_htc_pkt_info(send_pkt, NULL, (u8 *) setup_comp, 1054 - sizeof(struct htc_setup_comp_msg), 1055 - ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); 1054 + sizeof(struct htc_setup_comp_msg), 1055 + ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); 1056 1056 } 1057 1057 1058 1058 /* we want synchronous operation */ ··· 1151 1151 packet->status = -ECANCELED; 1152 1152 list_del(&packet->list); 1153 1153 ath6kl_dbg(ATH6KL_DBG_HTC, 1154 - "htc tx flushing pkt 0x%p len %d ep %d tag 0x%x\n", 1155 - packet, packet->act_len, 1156 - packet->endpoint, packet->info.tx.tag); 1154 + "htc tx flushing pkt 0x%p len %d ep %d tag 0x%x\n", 1155 + packet, packet->act_len, 1156 + packet->endpoint, packet->info.tx.tag); 1157 1157 1158 1158 INIT_LIST_HEAD(&container); 1159 1159 list_add_tail(&packet->list, &container); ··· 1553 1553 1554 1554 if (packets->act_len > 0) { 1555 1555 ath6kl_err("htc_ctrl_rx, got message with len:%zu\n", 1556 - packets->act_len + HTC_HDR_LENGTH); 1556 + packets->act_len + HTC_HDR_LENGTH); 1557 1557 1558 1558 ath6kl_dbg_dump(ATH6KL_DBG_HTC, 1559 1559 "htc rx unexpected endpoint 0 message", "", ··· 2101 2101 list_for_each_entry_safe(packet, tmp_pkt, rx_pktq, list) { 2102 2102 list_del(&packet->list); 2103 2103 htc_reclaim_rxbuf(target, packet, 2104 - &target->endpoint[packet->endpoint]); 2104 + &target->endpoint[packet->endpoint]); 2105 2105 } 2106 2106 2107 2107 list_for_each_entry_safe(packet, tmp_pkt, &tmp_rxq, list) { 2108 2108 list_del(&packet->list); 2109 2109 htc_reclaim_rxbuf(target, packet, 2110 - &target->endpoint[packet->endpoint]); 2110 + &target->endpoint[packet->endpoint]); 2111 2111 } 2112 2112 2113 2113 return status; ··· 2239 2239 u32 look_ahead; 2240 2240 2241 2241 if (ath6kl_hif_poll_mboxmsg_rx(target->dev, &look_ahead, 2242 - HTC_TARGET_RESPONSE_TIMEOUT)) 2242 + HTC_TARGET_RESPONSE_TIMEOUT)) 2243 2243 return NULL; 2244 2244 2245 2245 ath6kl_dbg(ATH6KL_DBG_HTC, 2246 - "htc rx wait ctrl look_ahead 0x%X\n", look_ahead); 2246 + "htc rx wait ctrl look_ahead 0x%X\n", look_ahead); 2247 2247 2248 2248 htc_hdr = (struct htc_frame_hdr *)&look_ahead; 2249 2249 ··· 2308 2308 depth = get_queue_depth(pkt_queue); 2309 2309 2310 2310 ath6kl_dbg(ATH6KL_DBG_HTC, 2311 - "htc rx add multiple ep id %d cnt %d len %d\n", 2311 + "htc rx add multiple ep id %d cnt %d len %d\n", 2312 2312 first_pkt->endpoint, depth, first_pkt->buf_len); 2313 2313 2314 2314 endpoint = &target->endpoint[first_pkt->endpoint]; ··· 2334 2334 if (target->rx_st_flags & HTC_RECV_WAIT_BUFFERS) { 2335 2335 if (target->ep_waiting == first_pkt->endpoint) { 2336 2336 ath6kl_dbg(ATH6KL_DBG_HTC, 2337 - "htc rx blocked on ep %d, unblocking\n", 2338 - target->ep_waiting); 2337 + "htc rx blocked on ep %d, unblocking\n", 2338 + target->ep_waiting); 2339 2339 target->rx_st_flags &= ~HTC_RECV_WAIT_BUFFERS; 2340 2340 target->ep_waiting = ENDPOINT_MAX; 2341 2341 rx_unblock = true; ··· 2676 2676 } 2677 2677 2678 2678 ath6kl_dbg(ATH6KL_DBG_BOOT, "htc using protocol %s (%d)\n", 2679 - (target->htc_tgt_ver == HTC_VERSION_2P0) ? "2.0" : ">= 2.1", 2680 - target->htc_tgt_ver); 2679 + (target->htc_tgt_ver == HTC_VERSION_2P0) ? "2.0" : ">= 2.1", 2680 + target->htc_tgt_ver); 2681 2681 2682 2682 if (target->msg_per_bndl_max > 0) 2683 2683 htc_setup_msg_bndl(target); ··· 2871 2871 ath6kl_hif_cleanup_scatter(target->dev->ar); 2872 2872 2873 2873 list_for_each_entry_safe(packet, tmp_packet, 2874 - &target->free_ctrl_txbuf, list) { 2874 + &target->free_ctrl_txbuf, list) { 2875 2875 list_del(&packet->list); 2876 2876 kfree(packet->buf_start); 2877 2877 kfree(packet); 2878 2878 } 2879 2879 2880 2880 list_for_each_entry_safe(packet, tmp_packet, 2881 - &target->free_ctrl_rxbuf, list) { 2881 + &target->free_ctrl_rxbuf, list) { 2882 2882 list_del(&packet->list); 2883 2883 kfree(packet->buf_start); 2884 2884 kfree(packet);
+10 -10
drivers/net/wireless/ath/ath6kl/init.c
··· 414 414 } 415 415 416 416 if (ath6kl_wmi_set_keepalive_cmd(ar->wmi, idx, 417 - WLAN_CONFIG_KEEP_ALIVE_INTERVAL)) { 417 + WLAN_CONFIG_KEEP_ALIVE_INTERVAL)) { 418 418 ath6kl_err("unable to set keep alive interval\n"); 419 419 status = -EIO; 420 420 } 421 421 422 422 if (ath6kl_wmi_disctimeout_cmd(ar->wmi, idx, 423 - WLAN_CONFIG_DISCONNECT_TIMEOUT)) { 423 + WLAN_CONFIG_DISCONNECT_TIMEOUT)) { 424 424 ath6kl_err("unable to set disconnect timeout\n"); 425 425 status = -EIO; 426 426 } ··· 833 833 return 0; 834 834 835 835 snprintf(filename, sizeof(filename), "%s/%s", 836 - ar->hw.fw.dir, ar->hw.fw.testscript); 836 + ar->hw.fw.dir, ar->hw.fw.testscript); 837 837 838 838 ret = ath6kl_get_fw(ar, filename, &ar->fw_testscript, 839 839 &ar->fw_testscript_len); 840 840 if (ret) { 841 841 ath6kl_err("Failed to get testscript file %s: %d\n", 842 - filename, ret); 842 + filename, ret); 843 843 return ret; 844 844 } 845 845 ··· 923 923 switch (ie_id) { 924 924 case ATH6KL_FW_IE_OTP_IMAGE: 925 925 ath6kl_dbg(ATH6KL_DBG_BOOT, "found otp image ie (%zd B)\n", 926 - ie_len); 926 + ie_len); 927 927 928 928 ar->fw_otp = kmemdup(data, ie_len, GFP_KERNEL); 929 929 ··· 936 936 break; 937 937 case ATH6KL_FW_IE_FW_IMAGE: 938 938 ath6kl_dbg(ATH6KL_DBG_BOOT, "found fw image ie (%zd B)\n", 939 - ie_len); 939 + ie_len); 940 940 941 941 /* in testmode we already might have a fw file */ 942 942 if (ar->fw != NULL) ··· 953 953 break; 954 954 case ATH6KL_FW_IE_PATCH_IMAGE: 955 955 ath6kl_dbg(ATH6KL_DBG_BOOT, "found patch image ie (%zd B)\n", 956 - ie_len); 956 + ie_len); 957 957 958 958 ar->fw_patch = kmemdup(data, ie_len, GFP_KERNEL); 959 959 ··· 1313 1313 address = ar->hw.testscript_addr; 1314 1314 1315 1315 ath6kl_dbg(ATH6KL_DBG_BOOT, "writing testscript to 0x%x (%zd B)\n", 1316 - address, ar->fw_testscript_len); 1316 + address, ar->fw_testscript_len); 1317 1317 1318 1318 ret = ath6kl_bmi_write(ar, address, ar->fw_testscript, 1319 1319 ar->fw_testscript_len); ··· 1349 1349 int status = 0; 1350 1350 1351 1351 if (ar->target_type != TARGET_TYPE_AR6003 && 1352 - ar->target_type != TARGET_TYPE_AR6004) 1352 + ar->target_type != TARGET_TYPE_AR6004) 1353 1353 return -EINVAL; 1354 1354 1355 1355 /* temporarily disable system sleep */ ··· 1730 1730 * configure NOT to reset the target during a debug session. 1731 1731 */ 1732 1732 ath6kl_dbg(ATH6KL_DBG_TRC, 1733 - "attempting to reset target on instance destroy\n"); 1733 + "attempting to reset target on instance destroy\n"); 1734 1734 ath6kl_reset_device(ar, ar->target_type, true, true); 1735 1735 1736 1736 clear_bit(WLAN_ENABLED, &ar->flag);
+9 -9
drivers/net/wireless/ath/ath6kl/main.c
··· 350 350 __le32 data; 351 351 352 352 if (target_type != TARGET_TYPE_AR6003 && 353 - target_type != TARGET_TYPE_AR6004) 353 + target_type != TARGET_TYPE_AR6004) 354 354 return; 355 355 356 356 data = cold_reset ? cpu_to_le32(RESET_CONTROL_COLD_RST) : ··· 948 948 } 949 949 950 950 ath6kl_cfg80211_disconnect_event(vif, reason, bssid, 951 - assoc_resp_len, assoc_info, 952 - prot_reason_status); 951 + assoc_resp_len, assoc_info, 952 + prot_reason_status); 953 953 954 954 aggr_reset_state(vif->aggr_cntxt->aggr_conn); 955 955 ··· 969 969 } else { 970 970 set_bit(CONNECT_PEND, &vif->flags); 971 971 if (((reason == ASSOC_FAILED) && 972 - (prot_reason_status == 0x11)) || 972 + (prot_reason_status == 0x11)) || 973 973 ((reason == ASSOC_FAILED) && (prot_reason_status == 0x0) 974 974 && (vif->reconnect_flag == 1))) { 975 975 set_bit(CONNECTED, &vif->flags); ··· 1105 1105 if (mc_all_on || mc_all_off) { 1106 1106 /* Enable/disable all multicast */ 1107 1107 ath6kl_dbg(ATH6KL_DBG_TRC, "%s multicast filter\n", 1108 - mc_all_on ? "enabling" : "disabling"); 1108 + mc_all_on ? "enabling" : "disabling"); 1109 1109 ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi, vif->fw_vif_idx, 1110 1110 mc_all_on); 1111 1111 if (ret) ··· 1118 1118 found = false; 1119 1119 netdev_for_each_mc_addr(ha, ndev) { 1120 1120 if (memcmp(ha->addr, mc_filter->hw_addr, 1121 - ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE) == 0) { 1121 + ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE) == 0) { 1122 1122 found = true; 1123 1123 break; 1124 1124 } ··· 1137 1137 false); 1138 1138 if (ret) { 1139 1139 ath6kl_warn("Failed to remove multicast filter:%pM\n", 1140 - mc_filter->hw_addr); 1140 + mc_filter->hw_addr); 1141 1141 return; 1142 1142 } 1143 1143 ··· 1152 1152 found = false; 1153 1153 list_for_each_entry(mc_filter, &vif->mc_filter, list) { 1154 1154 if (memcmp(ha->addr, mc_filter->hw_addr, 1155 - ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE) == 0) { 1155 + ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE) == 0) { 1156 1156 found = true; 1157 1157 break; 1158 1158 } ··· 1177 1177 true); 1178 1178 if (ret) { 1179 1179 ath6kl_warn("Failed to add multicast filter :%pM\n", 1180 - mc_filter->hw_addr); 1180 + mc_filter->hw_addr); 1181 1181 kfree(mc_filter); 1182 1182 goto out; 1183 1183 }
+3 -3
drivers/net/wireless/ath/ath6kl/sdio.c
··· 656 656 return -EINVAL; 657 657 658 658 ath6kl_dbg(ATH6KL_DBG_SCATTER, 659 - "hif-scatter: total len: %d scatter entries: %d\n", 660 - scat_req->len, scat_req->scat_entries); 659 + "hif-scatter: total len: %d scatter entries: %d\n", 660 + scat_req->len, scat_req->scat_entries); 661 661 662 662 if (request & HIF_SYNCHRONOUS) 663 663 status = ath6kl_sdio_scat_rw(ar_sdio, scat_req->busrequest); ··· 1019 1019 (u8 *)data, sizeof(u32), HIF_RD_SYNC_BYTE_INC); 1020 1020 if (status) { 1021 1021 ath6kl_err("%s: failed to read from window data addr\n", 1022 - __func__); 1022 + __func__); 1023 1023 return status; 1024 1024 } 1025 1025
+9 -9
drivers/net/wireless/ath/ath6kl/txrx.c
··· 159 159 */ 160 160 if (is_apsdq_empty) { 161 161 ath6kl_wmi_set_apsd_bfrd_traf(ar->wmi, 162 - vif->fw_vif_idx, 163 - conn->aid, 1, 0); 162 + vif->fw_vif_idx, 163 + conn->aid, 1, 0); 164 164 } 165 165 *flags |= WMI_DATA_HDR_FLAGS_UAPSD; 166 166 ··· 379 379 380 380 if (test_bit(WMI_ENABLED, &ar->flag)) { 381 381 if ((dev->features & NETIF_F_IP_CSUM) && 382 - (csum == CHECKSUM_PARTIAL)) { 382 + (csum == CHECKSUM_PARTIAL)) { 383 383 csum_start = skb->csum_start - 384 384 (skb_network_header(skb) - skb->head) + 385 385 sizeof(struct ath6kl_llc_snap_hdr); ··· 403 403 } 404 404 405 405 if ((dev->features & NETIF_F_IP_CSUM) && 406 - (csum == CHECKSUM_PARTIAL)) { 406 + (csum == CHECKSUM_PARTIAL)) { 407 407 meta_v2.csum_start = csum_start; 408 408 meta_v2.csum_dest = csum_dest; 409 409 ··· 428 428 } 429 429 430 430 if ((vif->nw_type == ADHOC_NETWORK) && 431 - ar->ibss_ps_enable && test_bit(CONNECTED, &vif->flags)) 431 + ar->ibss_ps_enable && test_bit(CONNECTED, &vif->flags)) 432 432 chk_adhoc_ps_mapping = true; 433 433 else { 434 434 /* get the stream mapping */ ··· 886 886 if (!IS_ALIGNED((unsigned long) skb->data, 4)) 887 887 skb->data = PTR_ALIGN(skb->data - 4, 4); 888 888 set_htc_rxpkt_info(packet, skb, skb->data, 889 - ATH6KL_BUFFER_SIZE, endpoint); 889 + ATH6KL_BUFFER_SIZE, endpoint); 890 890 list_add_tail(&packet->list, &queue); 891 891 } 892 892 ··· 1266 1266 flags = 0; 1267 1267 1268 1268 ath6kl_wmi_set_apsd_bfrd_traf(ar->wmi, 1269 - vif->fw_vif_idx, 1270 - conn->aid, 0, flags); 1269 + vif->fw_vif_idx, 1270 + conn->aid, 0, flags); 1271 1271 } 1272 1272 1273 1273 return; ··· 1575 1575 aggr_conn = vif->aggr_cntxt->aggr_conn; 1576 1576 1577 1577 if (aggr_process_recv_frm(aggr_conn, tid, seq_no, 1578 - is_amsdu, skb)) { 1578 + is_amsdu, skb)) { 1579 1579 /* aggregation code will handle the skb */ 1580 1580 return; 1581 1581 }
+11 -11
drivers/net/wireless/ath/ath6kl/wmi.c
··· 127 127 128 128 if (!is_ethertype(be16_to_cpu(type))) { 129 129 ath6kl_dbg(ATH6KL_DBG_WMI, 130 - "%s: pkt is already in 802.3 format\n", __func__); 130 + "%s: pkt is already in 802.3 format\n", __func__); 131 131 return 0; 132 132 } 133 133 ··· 911 911 regpair = ath6kl_get_regpair((u16) reg_code); 912 912 country = ath6kl_regd_find_country_by_rd((u16) reg_code); 913 913 ath6kl_dbg(ATH6KL_DBG_WMI, "Regpair used: 0x%0x\n", 914 - regpair->regDmnEnum); 914 + regpair->regDmnEnum); 915 915 } 916 916 917 917 if (country && wmi->parent_dev->wiphy_registered) { ··· 921 921 regulatory_hint(wmi->parent_dev->wiphy, alpha2); 922 922 923 923 ath6kl_dbg(ATH6KL_DBG_WMI, "Country alpha2 being used: %c%c\n", 924 - alpha2[0], alpha2[1]); 924 + alpha2[0], alpha2[1]); 925 925 } 926 926 } 927 927 ··· 1365 1365 /* Upper threshold breached */ 1366 1366 if (rssi < sq_thresh->upper_threshold[0]) { 1367 1367 ath6kl_dbg(ATH6KL_DBG_WMI, 1368 - "spurious upper rssi threshold event: %d\n", 1369 - rssi); 1368 + "spurious upper rssi threshold event: %d\n", 1369 + rssi); 1370 1370 } else if ((rssi < sq_thresh->upper_threshold[1]) && 1371 1371 (rssi >= sq_thresh->upper_threshold[0])) { 1372 1372 new_threshold = WMI_RSSI_THRESHOLD1_ABOVE; ··· 1389 1389 /* Lower threshold breached */ 1390 1390 if (rssi > sq_thresh->lower_threshold[0]) { 1391 1391 ath6kl_dbg(ATH6KL_DBG_WMI, 1392 - "spurious lower rssi threshold event: %d %d\n", 1392 + "spurious lower rssi threshold event: %d %d\n", 1393 1393 rssi, sq_thresh->lower_threshold[0]); 1394 1394 } else if ((rssi > sq_thresh->lower_threshold[1]) && 1395 1395 (rssi <= sq_thresh->lower_threshold[0])) { ··· 1550 1550 /* Upper threshold breached */ 1551 1551 if (snr < sq_thresh->upper_threshold[0]) { 1552 1552 ath6kl_dbg(ATH6KL_DBG_WMI, 1553 - "spurious upper snr threshold event: %d\n", 1554 - snr); 1553 + "spurious upper snr threshold event: %d\n", 1554 + snr); 1555 1555 } else if ((snr < sq_thresh->upper_threshold[1]) && 1556 1556 (snr >= sq_thresh->upper_threshold[0])) { 1557 1557 new_threshold = WMI_SNR_THRESHOLD1_ABOVE; ··· 1568 1568 /* Lower threshold breached */ 1569 1569 if (snr > sq_thresh->lower_threshold[0]) { 1570 1570 ath6kl_dbg(ATH6KL_DBG_WMI, 1571 - "spurious lower snr threshold event: %d\n", 1572 - sq_thresh->lower_threshold[0]); 1571 + "spurious lower snr threshold event: %d\n", 1572 + sq_thresh->lower_threshold[0]); 1573 1573 } else if ((snr > sq_thresh->lower_threshold[1]) && 1574 1574 (snr <= sq_thresh->lower_threshold[0])) { 1575 1575 new_threshold = WMI_SNR_THRESHOLD4_BELOW; ··· 2632 2632 int ret; 2633 2633 2634 2634 if ((wow_mode != ATH6KL_WOW_MODE_ENABLE) && 2635 - wow_mode != ATH6KL_WOW_MODE_DISABLE) { 2635 + wow_mode != ATH6KL_WOW_MODE_DISABLE) { 2636 2636 ath6kl_err("invalid wow mode: %d\n", wow_mode); 2637 2637 return -EINVAL; 2638 2638 }