1 /* 2 * This file is part of wl1271 3 * 4 * Copyright (C) 2009-2010 Nokia Corporation 5 * 6 * Contact: Luciano Coelho <luciano.coelho@nokia.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * version 2 as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 * 22 */ 23 24 #include <linux/module.h> 25 #include <linux/platform_device.h> 26 #include <linux/spi/spi.h> 27 #include <linux/etherdevice.h> 28 #include <linux/ieee80211.h> 29 #include <linux/slab.h> 30 31 #include "wlcore.h" 32 #include "debug.h" 33 #include "reg.h" 34 #include "io.h" 35 #include "acx.h" 36 #include "wl12xx_80211.h" 37 #include "cmd.h" 38 #include "event.h" 39 #include "tx.h" 40 41 #define WL1271_CMD_FAST_POLL_COUNT 50 42 43 /* 44 * send command to firmware 45 * 46 * @wl: wl struct 47 * @id: command id 48 * @buf: buffer containing the command, must work with dma 49 * @len: length of the buffer 50 */ 51 int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len, 52 size_t res_len) 53 { 54 struct wl1271_cmd_header *cmd; 55 unsigned long timeout; 56 u32 intr; 57 int ret = 0; 58 u16 status; 59 u16 poll_count = 0; 60 61 cmd = buf; 62 cmd->id = cpu_to_le16(id); 63 cmd->status = 0; 64 65 WARN_ON(len % 4 != 0); 66 WARN_ON(test_bit(WL1271_FLAG_IN_ELP, &wl->flags)); 67 68 wl1271_write(wl, wl->cmd_box_addr, buf, len, false); 69 70 wl1271_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD); 71 72 timeout = jiffies + msecs_to_jiffies(WL1271_COMMAND_TIMEOUT); 73 74 intr = wl1271_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR); 75 while (!(intr & WL1271_ACX_INTR_CMD_COMPLETE)) { 76 if (time_after(jiffies, timeout)) { 77 wl1271_error("command complete timeout"); 78 ret = -ETIMEDOUT; 79 goto fail; 80 } 81 82 poll_count++; 83 if (poll_count < WL1271_CMD_FAST_POLL_COUNT) 84 udelay(10); 85 else 86 msleep(1); 87 88 intr = wl1271_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR); 89 } 90 91 /* read back the status code of the command */ 92 if (res_len == 0) 93 res_len = sizeof(struct wl1271_cmd_header); 94 wl1271_read(wl, wl->cmd_box_addr, cmd, res_len, false); 95 96 status = le16_to_cpu(cmd->status); 97 if (status != CMD_STATUS_SUCCESS) { 98 wl1271_error("command execute failure %d", status); 99 ret = -EIO; 100 goto fail; 101 } 102 103 wl1271_write32(wl, ACX_REG_INTERRUPT_ACK, 104 WL1271_ACX_INTR_CMD_COMPLETE); 105 return 0; 106 107 fail: 108 WARN_ON(1); 109 wl12xx_queue_recovery_work(wl); 110 return ret; 111 } 112 113 int wl1271_cmd_general_parms(struct wl1271 *wl) 114 { 115 struct wl1271_general_parms_cmd *gen_parms; 116 struct wl1271_ini_general_params *gp = 117 &((struct wl1271_nvs_file *)wl->nvs)->general_params; 118 bool answer = false; 119 int ret; 120 121 if (!wl->nvs) 122 return -ENODEV; 123 124 if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) { 125 wl1271_warning("FEM index from INI out of bounds"); 126 return -EINVAL; 127 } 128 129 gen_parms = kzalloc(sizeof(*gen_parms), GFP_KERNEL); 130 if (!gen_parms) 131 return -ENOMEM; 132 133 gen_parms->test.id = TEST_CMD_INI_FILE_GENERAL_PARAM; 134 135 memcpy(&gen_parms->general_params, gp, sizeof(*gp)); 136 137 if (gp->tx_bip_fem_auto_detect) 138 answer = true; 139 140 /* Override the REF CLK from the NVS with the one from platform data */ 141 gen_parms->general_params.ref_clock = wl->ref_clock; 142 143 ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer); 144 if (ret < 0) { 145 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed"); 146 goto out; 147 } 148 149 gp->tx_bip_fem_manufacturer = 150 gen_parms->general_params.tx_bip_fem_manufacturer; 151 152 if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) { 153 wl1271_warning("FEM index from FW out of bounds"); 154 ret = -EINVAL; 155 goto out; 156 } 157 158 wl1271_debug(DEBUG_CMD, "FEM autodetect: %s, manufacturer: %d\n", 159 answer ? "auto" : "manual", gp->tx_bip_fem_manufacturer); 160 161 out: 162 kfree(gen_parms); 163 return ret; 164 } 165 166 int wl128x_cmd_general_parms(struct wl1271 *wl) 167 { 168 struct wl128x_general_parms_cmd *gen_parms; 169 struct wl128x_ini_general_params *gp = 170 &((struct wl128x_nvs_file *)wl->nvs)->general_params; 171 bool answer = false; 172 int ret; 173 174 if (!wl->nvs) 175 return -ENODEV; 176 177 if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) { 178 wl1271_warning("FEM index from ini out of bounds"); 179 return -EINVAL; 180 } 181 182 gen_parms = kzalloc(sizeof(*gen_parms), GFP_KERNEL); 183 if (!gen_parms) 184 return -ENOMEM; 185 186 gen_parms->test.id = TEST_CMD_INI_FILE_GENERAL_PARAM; 187 188 memcpy(&gen_parms->general_params, gp, sizeof(*gp)); 189 190 if (gp->tx_bip_fem_auto_detect) 191 answer = true; 192 193 /* Replace REF and TCXO CLKs with the ones from platform data */ 194 gen_parms->general_params.ref_clock = wl->ref_clock; 195 gen_parms->general_params.tcxo_ref_clock = wl->tcxo_clock; 196 197 ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer); 198 if (ret < 0) { 199 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed"); 200 goto out; 201 } 202 203 gp->tx_bip_fem_manufacturer = 204 gen_parms->general_params.tx_bip_fem_manufacturer; 205 206 if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) { 207 wl1271_warning("FEM index from FW out of bounds"); 208 ret = -EINVAL; 209 goto out; 210 } 211 212 wl1271_debug(DEBUG_CMD, "FEM autodetect: %s, manufacturer: %d\n", 213 answer ? "auto" : "manual", gp->tx_bip_fem_manufacturer); 214 215 out: 216 kfree(gen_parms); 217 return ret; 218 } 219 220 int wl1271_cmd_radio_parms(struct wl1271 *wl) 221 { 222 struct wl1271_nvs_file *nvs = (struct wl1271_nvs_file *)wl->nvs; 223 struct wl1271_radio_parms_cmd *radio_parms; 224 struct wl1271_ini_general_params *gp = &nvs->general_params; 225 int ret; 226 227 if (!wl->nvs) 228 return -ENODEV; 229 230 radio_parms = kzalloc(sizeof(*radio_parms), GFP_KERNEL); 231 if (!radio_parms) 232 return -ENOMEM; 233 234 radio_parms->test.id = TEST_CMD_INI_FILE_RADIO_PARAM; 235 236 /* 2.4GHz parameters */ 237 memcpy(&radio_parms->static_params_2, &nvs->stat_radio_params_2, 238 sizeof(struct wl1271_ini_band_params_2)); 239 memcpy(&radio_parms->dyn_params_2, 240 &nvs->dyn_radio_params_2[gp->tx_bip_fem_manufacturer].params, 241 sizeof(struct wl1271_ini_fem_params_2)); 242 243 /* 5GHz parameters */ 244 memcpy(&radio_parms->static_params_5, 245 &nvs->stat_radio_params_5, 246 sizeof(struct wl1271_ini_band_params_5)); 247 memcpy(&radio_parms->dyn_params_5, 248 &nvs->dyn_radio_params_5[gp->tx_bip_fem_manufacturer].params, 249 sizeof(struct wl1271_ini_fem_params_5)); 250 251 wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_RADIO_PARAM: ", 252 radio_parms, sizeof(*radio_parms)); 253 254 ret = wl1271_cmd_test(wl, radio_parms, sizeof(*radio_parms), 0); 255 if (ret < 0) 256 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed"); 257 258 kfree(radio_parms); 259 return ret; 260 } 261 262 int wl128x_cmd_radio_parms(struct wl1271 *wl) 263 { 264 struct wl128x_nvs_file *nvs = (struct wl128x_nvs_file *)wl->nvs; 265 struct wl128x_radio_parms_cmd *radio_parms; 266 struct wl128x_ini_general_params *gp = &nvs->general_params; 267 int ret; 268 269 if (!wl->nvs) 270 return -ENODEV; 271 272 radio_parms = kzalloc(sizeof(*radio_parms), GFP_KERNEL); 273 if (!radio_parms) 274 return -ENOMEM; 275 276 radio_parms->test.id = TEST_CMD_INI_FILE_RADIO_PARAM; 277 278 /* 2.4GHz parameters */ 279 memcpy(&radio_parms->static_params_2, &nvs->stat_radio_params_2, 280 sizeof(struct wl128x_ini_band_params_2)); 281 memcpy(&radio_parms->dyn_params_2, 282 &nvs->dyn_radio_params_2[gp->tx_bip_fem_manufacturer].params, 283 sizeof(struct wl128x_ini_fem_params_2)); 284 285 /* 5GHz parameters */ 286 memcpy(&radio_parms->static_params_5, 287 &nvs->stat_radio_params_5, 288 sizeof(struct wl128x_ini_band_params_5)); 289 memcpy(&radio_parms->dyn_params_5, 290 &nvs->dyn_radio_params_5[gp->tx_bip_fem_manufacturer].params, 291 sizeof(struct wl128x_ini_fem_params_5)); 292 293 radio_parms->fem_vendor_and_options = nvs->fem_vendor_and_options; 294 295 wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_RADIO_PARAM: ", 296 radio_parms, sizeof(*radio_parms)); 297 298 ret = wl1271_cmd_test(wl, radio_parms, sizeof(*radio_parms), 0); 299 if (ret < 0) 300 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed"); 301 302 kfree(radio_parms); 303 return ret; 304 } 305 306 int wl1271_cmd_ext_radio_parms(struct wl1271 *wl) 307 { 308 struct wl1271_ext_radio_parms_cmd *ext_radio_parms; 309 struct conf_rf_settings *rf = &wl->conf.rf; 310 int ret; 311 312 if (!wl->nvs) 313 return -ENODEV; 314 315 ext_radio_parms = kzalloc(sizeof(*ext_radio_parms), GFP_KERNEL); 316 if (!ext_radio_parms) 317 return -ENOMEM; 318 319 ext_radio_parms->test.id = TEST_CMD_INI_FILE_RF_EXTENDED_PARAM; 320 321 memcpy(ext_radio_parms->tx_per_channel_power_compensation_2, 322 rf->tx_per_channel_power_compensation_2, 323 CONF_TX_PWR_COMPENSATION_LEN_2); 324 memcpy(ext_radio_parms->tx_per_channel_power_compensation_5, 325 rf->tx_per_channel_power_compensation_5, 326 CONF_TX_PWR_COMPENSATION_LEN_5); 327 328 wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_EXT_RADIO_PARAM: ", 329 ext_radio_parms, sizeof(*ext_radio_parms)); 330 331 ret = wl1271_cmd_test(wl, ext_radio_parms, sizeof(*ext_radio_parms), 0); 332 if (ret < 0) 333 wl1271_warning("TEST_CMD_INI_FILE_RF_EXTENDED_PARAM failed"); 334 335 kfree(ext_radio_parms); 336 return ret; 337 } 338 339 /* 340 * Poll the mailbox event field until any of the bits in the mask is set or a 341 * timeout occurs (WL1271_EVENT_TIMEOUT in msecs) 342 */ 343 static int wl1271_cmd_wait_for_event_or_timeout(struct wl1271 *wl, u32 mask) 344 { 345 u32 *events_vector; 346 u32 event; 347 unsigned long timeout; 348 int ret = 0; 349 350 events_vector = kmalloc(sizeof(*events_vector), GFP_DMA); 351 352 timeout = jiffies + msecs_to_jiffies(WL1271_EVENT_TIMEOUT); 353 354 do { 355 if (time_after(jiffies, timeout)) { 356 wl1271_debug(DEBUG_CMD, "timeout waiting for event %d", 357 (int)mask); 358 ret = -ETIMEDOUT; 359 goto out; 360 } 361 362 msleep(1); 363 364 /* read from both event fields */ 365 wl1271_read(wl, wl->mbox_ptr[0], events_vector, 366 sizeof(*events_vector), false); 367 event = *events_vector & mask; 368 wl1271_read(wl, wl->mbox_ptr[1], events_vector, 369 sizeof(*events_vector), false); 370 event |= *events_vector & mask; 371 } while (!event); 372 373 out: 374 kfree(events_vector); 375 return ret; 376 } 377 378 static int wl1271_cmd_wait_for_event(struct wl1271 *wl, u32 mask) 379 { 380 int ret; 381 382 ret = wl1271_cmd_wait_for_event_or_timeout(wl, mask); 383 if (ret != 0) { 384 wl12xx_queue_recovery_work(wl); 385 return ret; 386 } 387 388 return 0; 389 } 390 391 int wl12xx_cmd_role_enable(struct wl1271 *wl, u8 *addr, u8 role_type, 392 u8 *role_id) 393 { 394 struct wl12xx_cmd_role_enable *cmd; 395 int ret; 396 397 wl1271_debug(DEBUG_CMD, "cmd role enable"); 398 399 if (WARN_ON(*role_id != WL12XX_INVALID_ROLE_ID)) 400 return -EBUSY; 401 402 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 403 if (!cmd) { 404 ret = -ENOMEM; 405 goto out; 406 } 407 408 /* get role id */ 409 cmd->role_id = find_first_zero_bit(wl->roles_map, WL12XX_MAX_ROLES); 410 if (cmd->role_id >= WL12XX_MAX_ROLES) { 411 ret = -EBUSY; 412 goto out_free; 413 } 414 415 memcpy(cmd->mac_address, addr, ETH_ALEN); 416 cmd->role_type = role_type; 417 418 ret = wl1271_cmd_send(wl, CMD_ROLE_ENABLE, cmd, sizeof(*cmd), 0); 419 if (ret < 0) { 420 wl1271_error("failed to initiate cmd role enable"); 421 goto out_free; 422 } 423 424 __set_bit(cmd->role_id, wl->roles_map); 425 *role_id = cmd->role_id; 426 427 out_free: 428 kfree(cmd); 429 430 out: 431 return ret; 432 } 433 434 int wl12xx_cmd_role_disable(struct wl1271 *wl, u8 *role_id) 435 { 436 struct wl12xx_cmd_role_disable *cmd; 437 int ret; 438 439 wl1271_debug(DEBUG_CMD, "cmd role disable"); 440 441 if (WARN_ON(*role_id == WL12XX_INVALID_ROLE_ID)) 442 return -ENOENT; 443 444 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 445 if (!cmd) { 446 ret = -ENOMEM; 447 goto out; 448 } 449 cmd->role_id = *role_id; 450 451 ret = wl1271_cmd_send(wl, CMD_ROLE_DISABLE, cmd, sizeof(*cmd), 0); 452 if (ret < 0) { 453 wl1271_error("failed to initiate cmd role disable"); 454 goto out_free; 455 } 456 457 __clear_bit(*role_id, wl->roles_map); 458 *role_id = WL12XX_INVALID_ROLE_ID; 459 460 out_free: 461 kfree(cmd); 462 463 out: 464 return ret; 465 } 466 467 int wl12xx_allocate_link(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 *hlid) 468 { 469 unsigned long flags; 470 u8 link = find_first_zero_bit(wl->links_map, WL12XX_MAX_LINKS); 471 if (link >= WL12XX_MAX_LINKS) 472 return -EBUSY; 473 474 /* these bits are used by op_tx */ 475 spin_lock_irqsave(&wl->wl_lock, flags); 476 __set_bit(link, wl->links_map); 477 __set_bit(link, wlvif->links_map); 478 spin_unlock_irqrestore(&wl->wl_lock, flags); 479 *hlid = link; 480 return 0; 481 } 482 483 void wl12xx_free_link(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 *hlid) 484 { 485 unsigned long flags; 486 487 if (*hlid == WL12XX_INVALID_LINK_ID) 488 return; 489 490 /* these bits are used by op_tx */ 491 spin_lock_irqsave(&wl->wl_lock, flags); 492 __clear_bit(*hlid, wl->links_map); 493 __clear_bit(*hlid, wlvif->links_map); 494 spin_unlock_irqrestore(&wl->wl_lock, flags); 495 496 /* 497 * At this point op_tx() will not add more packets to the queues. We 498 * can purge them. 499 */ 500 wl1271_tx_reset_link_queues(wl, *hlid); 501 502 *hlid = WL12XX_INVALID_LINK_ID; 503 } 504 505 static int wl12xx_get_new_session_id(struct wl1271 *wl, 506 struct wl12xx_vif *wlvif) 507 { 508 if (wlvif->session_counter >= SESSION_COUNTER_MAX) 509 wlvif->session_counter = 0; 510 511 wlvif->session_counter++; 512 513 return wlvif->session_counter; 514 } 515 516 static int wl12xx_cmd_role_start_dev(struct wl1271 *wl, 517 struct wl12xx_vif *wlvif) 518 { 519 struct wl12xx_cmd_role_start *cmd; 520 int ret; 521 522 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 523 if (!cmd) { 524 ret = -ENOMEM; 525 goto out; 526 } 527 528 wl1271_debug(DEBUG_CMD, "cmd role start dev %d", wlvif->dev_role_id); 529 530 cmd->role_id = wlvif->dev_role_id; 531 if (wlvif->band == IEEE80211_BAND_5GHZ) 532 cmd->band = WL12XX_BAND_5GHZ; 533 cmd->channel = wlvif->channel; 534 535 if (wlvif->dev_hlid == WL12XX_INVALID_LINK_ID) { 536 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->dev_hlid); 537 if (ret) 538 goto out_free; 539 } 540 cmd->device.hlid = wlvif->dev_hlid; 541 cmd->device.session = wl12xx_get_new_session_id(wl, wlvif); 542 543 wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d", 544 cmd->role_id, cmd->device.hlid, cmd->device.session); 545 546 ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0); 547 if (ret < 0) { 548 wl1271_error("failed to initiate cmd role enable"); 549 goto err_hlid; 550 } 551 552 goto out_free; 553 554 err_hlid: 555 /* clear links on error */ 556 wl12xx_free_link(wl, wlvif, &wlvif->dev_hlid); 557 558 out_free: 559 kfree(cmd); 560 561 out: 562 return ret; 563 } 564 565 static int wl12xx_cmd_role_stop_dev(struct wl1271 *wl, 566 struct wl12xx_vif *wlvif) 567 { 568 struct wl12xx_cmd_role_stop *cmd; 569 int ret; 570 571 if (WARN_ON(wlvif->dev_hlid == WL12XX_INVALID_LINK_ID)) 572 return -EINVAL; 573 574 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 575 if (!cmd) { 576 ret = -ENOMEM; 577 goto out; 578 } 579 580 wl1271_debug(DEBUG_CMD, "cmd role stop dev"); 581 582 cmd->role_id = wlvif->dev_role_id; 583 cmd->disc_type = DISCONNECT_IMMEDIATE; 584 cmd->reason = cpu_to_le16(WLAN_REASON_UNSPECIFIED); 585 586 ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0); 587 if (ret < 0) { 588 wl1271_error("failed to initiate cmd role stop"); 589 goto out_free; 590 } 591 592 ret = wl1271_cmd_wait_for_event(wl, ROLE_STOP_COMPLETE_EVENT_ID); 593 if (ret < 0) { 594 wl1271_error("cmd role stop dev event completion error"); 595 goto out_free; 596 } 597 598 wl12xx_free_link(wl, wlvif, &wlvif->dev_hlid); 599 600 out_free: 601 kfree(cmd); 602 603 out: 604 return ret; 605 } 606 607 int wl12xx_cmd_role_start_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif) 608 { 609 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 610 struct wl12xx_cmd_role_start *cmd; 611 int ret; 612 613 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 614 if (!cmd) { 615 ret = -ENOMEM; 616 goto out; 617 } 618 619 wl1271_debug(DEBUG_CMD, "cmd role start sta %d", wlvif->role_id); 620 621 cmd->role_id = wlvif->role_id; 622 if (wlvif->band == IEEE80211_BAND_5GHZ) 623 cmd->band = WL12XX_BAND_5GHZ; 624 cmd->channel = wlvif->channel; 625 cmd->sta.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set); 626 cmd->sta.beacon_interval = cpu_to_le16(wlvif->beacon_int); 627 cmd->sta.ssid_type = WL12XX_SSID_TYPE_ANY; 628 cmd->sta.ssid_len = wlvif->ssid_len; 629 memcpy(cmd->sta.ssid, wlvif->ssid, wlvif->ssid_len); 630 memcpy(cmd->sta.bssid, vif->bss_conf.bssid, ETH_ALEN); 631 cmd->sta.local_rates = cpu_to_le32(wlvif->rate_set); 632 633 if (wlvif->sta.hlid == WL12XX_INVALID_LINK_ID) { 634 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->sta.hlid); 635 if (ret) 636 goto out_free; 637 } 638 cmd->sta.hlid = wlvif->sta.hlid; 639 cmd->sta.session = wl12xx_get_new_session_id(wl, wlvif); 640 cmd->sta.remote_rates = cpu_to_le32(wlvif->rate_set); 641 642 wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d " 643 "basic_rate_set: 0x%x, remote_rates: 0x%x", 644 wlvif->role_id, cmd->sta.hlid, cmd->sta.session, 645 wlvif->basic_rate_set, wlvif->rate_set); 646 647 ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0); 648 if (ret < 0) { 649 wl1271_error("failed to initiate cmd role start sta"); 650 goto err_hlid; 651 } 652 653 goto out_free; 654 655 err_hlid: 656 /* clear links on error. */ 657 wl12xx_free_link(wl, wlvif, &wlvif->sta.hlid); 658 659 out_free: 660 kfree(cmd); 661 662 out: 663 return ret; 664 } 665 666 /* use this function to stop ibss as well */ 667 int wl12xx_cmd_role_stop_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif) 668 { 669 struct wl12xx_cmd_role_stop *cmd; 670 int ret; 671 672 if (WARN_ON(wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)) 673 return -EINVAL; 674 675 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 676 if (!cmd) { 677 ret = -ENOMEM; 678 goto out; 679 } 680 681 wl1271_debug(DEBUG_CMD, "cmd role stop sta %d", wlvif->role_id); 682 683 cmd->role_id = wlvif->role_id; 684 cmd->disc_type = DISCONNECT_IMMEDIATE; 685 cmd->reason = cpu_to_le16(WLAN_REASON_UNSPECIFIED); 686 687 ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0); 688 if (ret < 0) { 689 wl1271_error("failed to initiate cmd role stop sta"); 690 goto out_free; 691 } 692 693 wl12xx_free_link(wl, wlvif, &wlvif->sta.hlid); 694 695 out_free: 696 kfree(cmd); 697 698 out: 699 return ret; 700 } 701 702 int wl12xx_cmd_role_start_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif) 703 { 704 struct wl12xx_cmd_role_start *cmd; 705 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 706 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 707 int ret; 708 709 wl1271_debug(DEBUG_CMD, "cmd role start ap %d", wlvif->role_id); 710 711 /* trying to use hidden SSID with an old hostapd version */ 712 if (wlvif->ssid_len == 0 && !bss_conf->hidden_ssid) { 713 wl1271_error("got a null SSID from beacon/bss"); 714 ret = -EINVAL; 715 goto out; 716 } 717 718 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 719 if (!cmd) { 720 ret = -ENOMEM; 721 goto out; 722 } 723 724 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->ap.global_hlid); 725 if (ret < 0) 726 goto out_free; 727 728 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->ap.bcast_hlid); 729 if (ret < 0) 730 goto out_free_global; 731 732 cmd->role_id = wlvif->role_id; 733 cmd->ap.aging_period = cpu_to_le16(wl->conf.tx.ap_aging_period); 734 cmd->ap.bss_index = WL1271_AP_BSS_INDEX; 735 cmd->ap.global_hlid = wlvif->ap.global_hlid; 736 cmd->ap.broadcast_hlid = wlvif->ap.bcast_hlid; 737 cmd->ap.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set); 738 cmd->ap.beacon_interval = cpu_to_le16(wlvif->beacon_int); 739 cmd->ap.dtim_interval = bss_conf->dtim_period; 740 cmd->ap.beacon_expiry = WL1271_AP_DEF_BEACON_EXP; 741 /* FIXME: Change when adding DFS */ 742 cmd->ap.reset_tsf = 1; /* By default reset AP TSF */ 743 cmd->channel = wlvif->channel; 744 745 if (!bss_conf->hidden_ssid) { 746 /* take the SSID from the beacon for backward compatibility */ 747 cmd->ap.ssid_type = WL12XX_SSID_TYPE_PUBLIC; 748 cmd->ap.ssid_len = wlvif->ssid_len; 749 memcpy(cmd->ap.ssid, wlvif->ssid, wlvif->ssid_len); 750 } else { 751 cmd->ap.ssid_type = WL12XX_SSID_TYPE_HIDDEN; 752 cmd->ap.ssid_len = bss_conf->ssid_len; 753 memcpy(cmd->ap.ssid, bss_conf->ssid, bss_conf->ssid_len); 754 } 755 756 cmd->ap.local_rates = cpu_to_le32(0xffffffff); 757 758 switch (wlvif->band) { 759 case IEEE80211_BAND_2GHZ: 760 cmd->band = RADIO_BAND_2_4GHZ; 761 break; 762 case IEEE80211_BAND_5GHZ: 763 cmd->band = RADIO_BAND_5GHZ; 764 break; 765 default: 766 wl1271_warning("ap start - unknown band: %d", (int)wlvif->band); 767 cmd->band = RADIO_BAND_2_4GHZ; 768 break; 769 } 770 771 ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0); 772 if (ret < 0) { 773 wl1271_error("failed to initiate cmd role start ap"); 774 goto out_free_bcast; 775 } 776 777 goto out_free; 778 779 out_free_bcast: 780 wl12xx_free_link(wl, wlvif, &wlvif->ap.bcast_hlid); 781 782 out_free_global: 783 wl12xx_free_link(wl, wlvif, &wlvif->ap.global_hlid); 784 785 out_free: 786 kfree(cmd); 787 788 out: 789 return ret; 790 } 791 792 int wl12xx_cmd_role_stop_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif) 793 { 794 struct wl12xx_cmd_role_stop *cmd; 795 int ret; 796 797 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 798 if (!cmd) { 799 ret = -ENOMEM; 800 goto out; 801 } 802 803 wl1271_debug(DEBUG_CMD, "cmd role stop ap %d", wlvif->role_id); 804 805 cmd->role_id = wlvif->role_id; 806 807 ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0); 808 if (ret < 0) { 809 wl1271_error("failed to initiate cmd role stop ap"); 810 goto out_free; 811 } 812 813 wl12xx_free_link(wl, wlvif, &wlvif->ap.bcast_hlid); 814 wl12xx_free_link(wl, wlvif, &wlvif->ap.global_hlid); 815 816 out_free: 817 kfree(cmd); 818 819 out: 820 return ret; 821 } 822 823 int wl12xx_cmd_role_start_ibss(struct wl1271 *wl, struct wl12xx_vif *wlvif) 824 { 825 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 826 struct wl12xx_cmd_role_start *cmd; 827 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 828 int ret; 829 830 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 831 if (!cmd) { 832 ret = -ENOMEM; 833 goto out; 834 } 835 836 wl1271_debug(DEBUG_CMD, "cmd role start ibss %d", wlvif->role_id); 837 838 cmd->role_id = wlvif->role_id; 839 if (wlvif->band == IEEE80211_BAND_5GHZ) 840 cmd->band = WL12XX_BAND_5GHZ; 841 cmd->channel = wlvif->channel; 842 cmd->ibss.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set); 843 cmd->ibss.beacon_interval = cpu_to_le16(wlvif->beacon_int); 844 cmd->ibss.dtim_interval = bss_conf->dtim_period; 845 cmd->ibss.ssid_type = WL12XX_SSID_TYPE_ANY; 846 cmd->ibss.ssid_len = wlvif->ssid_len; 847 memcpy(cmd->ibss.ssid, wlvif->ssid, wlvif->ssid_len); 848 memcpy(cmd->ibss.bssid, vif->bss_conf.bssid, ETH_ALEN); 849 cmd->sta.local_rates = cpu_to_le32(wlvif->rate_set); 850 851 if (wlvif->sta.hlid == WL12XX_INVALID_LINK_ID) { 852 ret = wl12xx_allocate_link(wl, wlvif, &wlvif->sta.hlid); 853 if (ret) 854 goto out_free; 855 } 856 cmd->ibss.hlid = wlvif->sta.hlid; 857 cmd->ibss.remote_rates = cpu_to_le32(wlvif->rate_set); 858 859 wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d " 860 "basic_rate_set: 0x%x, remote_rates: 0x%x", 861 wlvif->role_id, cmd->sta.hlid, cmd->sta.session, 862 wlvif->basic_rate_set, wlvif->rate_set); 863 864 wl1271_debug(DEBUG_CMD, "vif->bss_conf.bssid = %pM", 865 vif->bss_conf.bssid); 866 867 ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0); 868 if (ret < 0) { 869 wl1271_error("failed to initiate cmd role enable"); 870 goto err_hlid; 871 } 872 873 goto out_free; 874 875 err_hlid: 876 /* clear links on error. */ 877 wl12xx_free_link(wl, wlvif, &wlvif->sta.hlid); 878 879 out_free: 880 kfree(cmd); 881 882 out: 883 return ret; 884 } 885 886 887 /** 888 * send test command to firmware 889 * 890 * @wl: wl struct 891 * @buf: buffer containing the command, with all headers, must work with dma 892 * @len: length of the buffer 893 * @answer: is answer needed 894 */ 895 int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer) 896 { 897 int ret; 898 size_t res_len = 0; 899 900 wl1271_debug(DEBUG_CMD, "cmd test"); 901 902 if (answer) 903 res_len = buf_len; 904 905 ret = wl1271_cmd_send(wl, CMD_TEST, buf, buf_len, res_len); 906 907 if (ret < 0) { 908 wl1271_warning("TEST command failed"); 909 return ret; 910 } 911 912 return ret; 913 } 914 915 /** 916 * read acx from firmware 917 * 918 * @wl: wl struct 919 * @id: acx id 920 * @buf: buffer for the response, including all headers, must work with dma 921 * @len: length of buf 922 */ 923 int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf, size_t len) 924 { 925 struct acx_header *acx = buf; 926 int ret; 927 928 wl1271_debug(DEBUG_CMD, "cmd interrogate"); 929 930 acx->id = cpu_to_le16(id); 931 932 /* payload length, does not include any headers */ 933 acx->len = cpu_to_le16(len - sizeof(*acx)); 934 935 ret = wl1271_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx), len); 936 if (ret < 0) 937 wl1271_error("INTERROGATE command failed"); 938 939 return ret; 940 } 941 942 /** 943 * write acx value to firmware 944 * 945 * @wl: wl struct 946 * @id: acx id 947 * @buf: buffer containing acx, including all headers, must work with dma 948 * @len: length of buf 949 */ 950 int wl1271_cmd_configure(struct wl1271 *wl, u16 id, void *buf, size_t len) 951 { 952 struct acx_header *acx = buf; 953 int ret; 954 955 wl1271_debug(DEBUG_CMD, "cmd configure (%d)", id); 956 957 acx->id = cpu_to_le16(id); 958 959 /* payload length, does not include any headers */ 960 acx->len = cpu_to_le16(len - sizeof(*acx)); 961 962 ret = wl1271_cmd_send(wl, CMD_CONFIGURE, acx, len, 0); 963 if (ret < 0) { 964 wl1271_warning("CONFIGURE command NOK"); 965 return ret; 966 } 967 968 return 0; 969 } 970 971 int wl1271_cmd_data_path(struct wl1271 *wl, bool enable) 972 { 973 struct cmd_enabledisable_path *cmd; 974 int ret; 975 u16 cmd_rx, cmd_tx; 976 977 wl1271_debug(DEBUG_CMD, "cmd data path"); 978 979 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 980 if (!cmd) { 981 ret = -ENOMEM; 982 goto out; 983 } 984 985 /* the channel here is only used for calibration, so hardcoded to 1 */ 986 cmd->channel = 1; 987 988 if (enable) { 989 cmd_rx = CMD_ENABLE_RX; 990 cmd_tx = CMD_ENABLE_TX; 991 } else { 992 cmd_rx = CMD_DISABLE_RX; 993 cmd_tx = CMD_DISABLE_TX; 994 } 995 996 ret = wl1271_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd), 0); 997 if (ret < 0) { 998 wl1271_error("rx %s cmd for channel %d failed", 999 enable ? "start" : "stop", cmd->channel); 1000 goto out; 1001 } 1002 1003 wl1271_debug(DEBUG_BOOT, "rx %s cmd channel %d", 1004 enable ? "start" : "stop", cmd->channel); 1005 1006 ret = wl1271_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd), 0); 1007 if (ret < 0) { 1008 wl1271_error("tx %s cmd for channel %d failed", 1009 enable ? "start" : "stop", cmd->channel); 1010 goto out; 1011 } 1012 1013 wl1271_debug(DEBUG_BOOT, "tx %s cmd channel %d", 1014 enable ? "start" : "stop", cmd->channel); 1015 1016 out: 1017 kfree(cmd); 1018 return ret; 1019 } 1020 1021 int wl1271_cmd_ps_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1022 u8 ps_mode, u16 auto_ps_timeout) 1023 { 1024 struct wl1271_cmd_ps_params *ps_params = NULL; 1025 int ret = 0; 1026 1027 wl1271_debug(DEBUG_CMD, "cmd set ps mode"); 1028 1029 ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL); 1030 if (!ps_params) { 1031 ret = -ENOMEM; 1032 goto out; 1033 } 1034 1035 ps_params->role_id = wlvif->role_id; 1036 ps_params->ps_mode = ps_mode; 1037 ps_params->auto_ps_timeout = auto_ps_timeout; 1038 1039 ret = wl1271_cmd_send(wl, CMD_SET_PS_MODE, ps_params, 1040 sizeof(*ps_params), 0); 1041 if (ret < 0) { 1042 wl1271_error("cmd set_ps_mode failed"); 1043 goto out; 1044 } 1045 1046 out: 1047 kfree(ps_params); 1048 return ret; 1049 } 1050 1051 int wl1271_cmd_template_set(struct wl1271 *wl, u8 role_id, 1052 u16 template_id, void *buf, size_t buf_len, 1053 int index, u32 rates) 1054 { 1055 struct wl1271_cmd_template_set *cmd; 1056 int ret = 0; 1057 1058 wl1271_debug(DEBUG_CMD, "cmd template_set %d (role %d)", 1059 template_id, role_id); 1060 1061 WARN_ON(buf_len > WL1271_CMD_TEMPL_MAX_SIZE); 1062 buf_len = min_t(size_t, buf_len, WL1271_CMD_TEMPL_MAX_SIZE); 1063 1064 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1065 if (!cmd) { 1066 ret = -ENOMEM; 1067 goto out; 1068 } 1069 1070 /* during initialization wlvif is NULL */ 1071 cmd->role_id = role_id; 1072 cmd->len = cpu_to_le16(buf_len); 1073 cmd->template_type = template_id; 1074 cmd->enabled_rates = cpu_to_le32(rates); 1075 cmd->short_retry_limit = wl->conf.tx.tmpl_short_retry_limit; 1076 cmd->long_retry_limit = wl->conf.tx.tmpl_long_retry_limit; 1077 cmd->index = index; 1078 1079 if (buf) 1080 memcpy(cmd->template_data, buf, buf_len); 1081 1082 ret = wl1271_cmd_send(wl, CMD_SET_TEMPLATE, cmd, sizeof(*cmd), 0); 1083 if (ret < 0) { 1084 wl1271_warning("cmd set_template failed: %d", ret); 1085 goto out_free; 1086 } 1087 1088 out_free: 1089 kfree(cmd); 1090 1091 out: 1092 return ret; 1093 } 1094 1095 int wl12xx_cmd_build_null_data(struct wl1271 *wl, struct wl12xx_vif *wlvif) 1096 { 1097 struct sk_buff *skb = NULL; 1098 int size; 1099 void *ptr; 1100 int ret = -ENOMEM; 1101 1102 1103 if (wlvif->bss_type == BSS_TYPE_IBSS) { 1104 size = sizeof(struct wl12xx_null_data_template); 1105 ptr = NULL; 1106 } else { 1107 skb = ieee80211_nullfunc_get(wl->hw, 1108 wl12xx_wlvif_to_vif(wlvif)); 1109 if (!skb) 1110 goto out; 1111 size = skb->len; 1112 ptr = skb->data; 1113 } 1114 1115 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 1116 CMD_TEMPL_NULL_DATA, ptr, size, 0, 1117 wlvif->basic_rate); 1118 1119 out: 1120 dev_kfree_skb(skb); 1121 if (ret) 1122 wl1271_warning("cmd buld null data failed %d", ret); 1123 1124 return ret; 1125 1126 } 1127 1128 int wl12xx_cmd_build_klv_null_data(struct wl1271 *wl, 1129 struct wl12xx_vif *wlvif) 1130 { 1131 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 1132 struct sk_buff *skb = NULL; 1133 int ret = -ENOMEM; 1134 1135 skb = ieee80211_nullfunc_get(wl->hw, vif); 1136 if (!skb) 1137 goto out; 1138 1139 ret = wl1271_cmd_template_set(wl, wlvif->role_id, CMD_TEMPL_KLV, 1140 skb->data, skb->len, 1141 CMD_TEMPL_KLV_IDX_NULL_DATA, 1142 wlvif->basic_rate); 1143 1144 out: 1145 dev_kfree_skb(skb); 1146 if (ret) 1147 wl1271_warning("cmd build klv null data failed %d", ret); 1148 1149 return ret; 1150 1151 } 1152 1153 int wl1271_cmd_build_ps_poll(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1154 u16 aid) 1155 { 1156 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 1157 struct sk_buff *skb; 1158 int ret = 0; 1159 1160 skb = ieee80211_pspoll_get(wl->hw, vif); 1161 if (!skb) 1162 goto out; 1163 1164 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 1165 CMD_TEMPL_PS_POLL, skb->data, 1166 skb->len, 0, wlvif->basic_rate_set); 1167 1168 out: 1169 dev_kfree_skb(skb); 1170 return ret; 1171 } 1172 1173 int wl12xx_cmd_build_probe_req(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1174 u8 role_id, u8 band, 1175 const u8 *ssid, size_t ssid_len, 1176 const u8 *ie, size_t ie_len) 1177 { 1178 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 1179 struct sk_buff *skb; 1180 int ret; 1181 u32 rate; 1182 1183 skb = ieee80211_probereq_get(wl->hw, vif, ssid, ssid_len, 1184 ie, ie_len); 1185 if (!skb) { 1186 ret = -ENOMEM; 1187 goto out; 1188 } 1189 1190 wl1271_dump(DEBUG_SCAN, "PROBE REQ: ", skb->data, skb->len); 1191 1192 rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[band]); 1193 if (band == IEEE80211_BAND_2GHZ) 1194 ret = wl1271_cmd_template_set(wl, role_id, 1195 CMD_TEMPL_CFG_PROBE_REQ_2_4, 1196 skb->data, skb->len, 0, rate); 1197 else 1198 ret = wl1271_cmd_template_set(wl, role_id, 1199 CMD_TEMPL_CFG_PROBE_REQ_5, 1200 skb->data, skb->len, 0, rate); 1201 1202 out: 1203 dev_kfree_skb(skb); 1204 return ret; 1205 } 1206 1207 struct sk_buff *wl1271_cmd_build_ap_probe_req(struct wl1271 *wl, 1208 struct wl12xx_vif *wlvif, 1209 struct sk_buff *skb) 1210 { 1211 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 1212 int ret; 1213 u32 rate; 1214 1215 if (!skb) 1216 skb = ieee80211_ap_probereq_get(wl->hw, vif); 1217 if (!skb) 1218 goto out; 1219 1220 wl1271_dump(DEBUG_SCAN, "AP PROBE REQ: ", skb->data, skb->len); 1221 1222 rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[wlvif->band]); 1223 if (wlvif->band == IEEE80211_BAND_2GHZ) 1224 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 1225 CMD_TEMPL_CFG_PROBE_REQ_2_4, 1226 skb->data, skb->len, 0, rate); 1227 else 1228 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 1229 CMD_TEMPL_CFG_PROBE_REQ_5, 1230 skb->data, skb->len, 0, rate); 1231 1232 if (ret < 0) 1233 wl1271_error("Unable to set ap probe request template."); 1234 1235 out: 1236 return skb; 1237 } 1238 1239 int wl1271_cmd_build_arp_rsp(struct wl1271 *wl, struct wl12xx_vif *wlvif) 1240 { 1241 int ret, extra; 1242 u16 fc; 1243 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 1244 struct sk_buff *skb; 1245 struct wl12xx_arp_rsp_template *tmpl; 1246 struct ieee80211_hdr_3addr *hdr; 1247 struct arphdr *arp_hdr; 1248 1249 skb = dev_alloc_skb(sizeof(*hdr) + sizeof(__le16) + sizeof(*tmpl) + 1250 WL1271_EXTRA_SPACE_MAX); 1251 if (!skb) { 1252 wl1271_error("failed to allocate buffer for arp rsp template"); 1253 return -ENOMEM; 1254 } 1255 1256 skb_reserve(skb, sizeof(*hdr) + WL1271_EXTRA_SPACE_MAX); 1257 1258 tmpl = (struct wl12xx_arp_rsp_template *)skb_put(skb, sizeof(*tmpl)); 1259 memset(tmpl, 0, sizeof(tmpl)); 1260 1261 /* llc layer */ 1262 memcpy(tmpl->llc_hdr, rfc1042_header, sizeof(rfc1042_header)); 1263 tmpl->llc_type = cpu_to_be16(ETH_P_ARP); 1264 1265 /* arp header */ 1266 arp_hdr = &tmpl->arp_hdr; 1267 arp_hdr->ar_hrd = cpu_to_be16(ARPHRD_ETHER); 1268 arp_hdr->ar_pro = cpu_to_be16(ETH_P_IP); 1269 arp_hdr->ar_hln = ETH_ALEN; 1270 arp_hdr->ar_pln = 4; 1271 arp_hdr->ar_op = cpu_to_be16(ARPOP_REPLY); 1272 1273 /* arp payload */ 1274 memcpy(tmpl->sender_hw, vif->addr, ETH_ALEN); 1275 tmpl->sender_ip = wlvif->ip_addr; 1276 1277 /* encryption space */ 1278 switch (wlvif->encryption_type) { 1279 case KEY_TKIP: 1280 extra = WL1271_EXTRA_SPACE_TKIP; 1281 break; 1282 case KEY_AES: 1283 extra = WL1271_EXTRA_SPACE_AES; 1284 break; 1285 case KEY_NONE: 1286 case KEY_WEP: 1287 case KEY_GEM: 1288 extra = 0; 1289 break; 1290 default: 1291 wl1271_warning("Unknown encryption type: %d", 1292 wlvif->encryption_type); 1293 ret = -EINVAL; 1294 goto out; 1295 } 1296 1297 if (extra) { 1298 u8 *space = skb_push(skb, extra); 1299 memset(space, 0, extra); 1300 } 1301 1302 /* QoS header - BE */ 1303 if (wlvif->sta.qos) 1304 memset(skb_push(skb, sizeof(__le16)), 0, sizeof(__le16)); 1305 1306 /* mac80211 header */ 1307 hdr = (struct ieee80211_hdr_3addr *)skb_push(skb, sizeof(*hdr)); 1308 memset(hdr, 0, sizeof(hdr)); 1309 fc = IEEE80211_FTYPE_DATA | IEEE80211_FCTL_TODS; 1310 if (wlvif->sta.qos) 1311 fc |= IEEE80211_STYPE_QOS_DATA; 1312 else 1313 fc |= IEEE80211_STYPE_DATA; 1314 if (wlvif->encryption_type != KEY_NONE) 1315 fc |= IEEE80211_FCTL_PROTECTED; 1316 1317 hdr->frame_control = cpu_to_le16(fc); 1318 memcpy(hdr->addr1, vif->bss_conf.bssid, ETH_ALEN); 1319 memcpy(hdr->addr2, vif->addr, ETH_ALEN); 1320 memset(hdr->addr3, 0xff, ETH_ALEN); 1321 1322 ret = wl1271_cmd_template_set(wl, wlvif->role_id, CMD_TEMPL_ARP_RSP, 1323 skb->data, skb->len, 0, 1324 wlvif->basic_rate); 1325 out: 1326 dev_kfree_skb(skb); 1327 return ret; 1328 } 1329 1330 int wl1271_build_qos_null_data(struct wl1271 *wl, struct ieee80211_vif *vif) 1331 { 1332 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 1333 struct ieee80211_qos_hdr template; 1334 1335 memset(&template, 0, sizeof(template)); 1336 1337 memcpy(template.addr1, vif->bss_conf.bssid, ETH_ALEN); 1338 memcpy(template.addr2, vif->addr, ETH_ALEN); 1339 memcpy(template.addr3, vif->bss_conf.bssid, ETH_ALEN); 1340 1341 template.frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 1342 IEEE80211_STYPE_QOS_NULLFUNC | 1343 IEEE80211_FCTL_TODS); 1344 1345 /* FIXME: not sure what priority to use here */ 1346 template.qos_ctrl = cpu_to_le16(0); 1347 1348 return wl1271_cmd_template_set(wl, wlvif->role_id, 1349 CMD_TEMPL_QOS_NULL_DATA, &template, 1350 sizeof(template), 0, 1351 wlvif->basic_rate); 1352 } 1353 1354 int wl12xx_cmd_set_default_wep_key(struct wl1271 *wl, u8 id, u8 hlid) 1355 { 1356 struct wl1271_cmd_set_keys *cmd; 1357 int ret = 0; 1358 1359 wl1271_debug(DEBUG_CMD, "cmd set_default_wep_key %d", id); 1360 1361 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1362 if (!cmd) { 1363 ret = -ENOMEM; 1364 goto out; 1365 } 1366 1367 cmd->hlid = hlid; 1368 cmd->key_id = id; 1369 cmd->lid_key_type = WEP_DEFAULT_LID_TYPE; 1370 cmd->key_action = cpu_to_le16(KEY_SET_ID); 1371 cmd->key_type = KEY_WEP; 1372 1373 ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0); 1374 if (ret < 0) { 1375 wl1271_warning("cmd set_default_wep_key failed: %d", ret); 1376 goto out; 1377 } 1378 1379 out: 1380 kfree(cmd); 1381 1382 return ret; 1383 } 1384 1385 int wl1271_cmd_set_sta_key(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1386 u16 action, u8 id, u8 key_type, 1387 u8 key_size, const u8 *key, const u8 *addr, 1388 u32 tx_seq_32, u16 tx_seq_16) 1389 { 1390 struct wl1271_cmd_set_keys *cmd; 1391 int ret = 0; 1392 1393 /* hlid might have already been deleted */ 1394 if (wlvif->sta.hlid == WL12XX_INVALID_LINK_ID) 1395 return 0; 1396 1397 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1398 if (!cmd) { 1399 ret = -ENOMEM; 1400 goto out; 1401 } 1402 1403 cmd->hlid = wlvif->sta.hlid; 1404 1405 if (key_type == KEY_WEP) 1406 cmd->lid_key_type = WEP_DEFAULT_LID_TYPE; 1407 else if (is_broadcast_ether_addr(addr)) 1408 cmd->lid_key_type = BROADCAST_LID_TYPE; 1409 else 1410 cmd->lid_key_type = UNICAST_LID_TYPE; 1411 1412 cmd->key_action = cpu_to_le16(action); 1413 cmd->key_size = key_size; 1414 cmd->key_type = key_type; 1415 1416 cmd->ac_seq_num16[0] = cpu_to_le16(tx_seq_16); 1417 cmd->ac_seq_num32[0] = cpu_to_le32(tx_seq_32); 1418 1419 cmd->key_id = id; 1420 1421 if (key_type == KEY_TKIP) { 1422 /* 1423 * We get the key in the following form: 1424 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes) 1425 * but the target is expecting: 1426 * TKIP - RX MIC - TX MIC 1427 */ 1428 memcpy(cmd->key, key, 16); 1429 memcpy(cmd->key + 16, key + 24, 8); 1430 memcpy(cmd->key + 24, key + 16, 8); 1431 1432 } else { 1433 memcpy(cmd->key, key, key_size); 1434 } 1435 1436 wl1271_dump(DEBUG_CRYPT, "TARGET KEY: ", cmd, sizeof(*cmd)); 1437 1438 ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0); 1439 if (ret < 0) { 1440 wl1271_warning("could not set keys"); 1441 goto out; 1442 } 1443 1444 out: 1445 kfree(cmd); 1446 1447 return ret; 1448 } 1449 1450 /* 1451 * TODO: merge with sta/ibss into 1 set_key function. 1452 * note there are slight diffs 1453 */ 1454 int wl1271_cmd_set_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1455 u16 action, u8 id, u8 key_type, 1456 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32, 1457 u16 tx_seq_16) 1458 { 1459 struct wl1271_cmd_set_keys *cmd; 1460 int ret = 0; 1461 u8 lid_type; 1462 1463 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1464 if (!cmd) 1465 return -ENOMEM; 1466 1467 if (hlid == wlvif->ap.bcast_hlid) { 1468 if (key_type == KEY_WEP) 1469 lid_type = WEP_DEFAULT_LID_TYPE; 1470 else 1471 lid_type = BROADCAST_LID_TYPE; 1472 } else { 1473 lid_type = UNICAST_LID_TYPE; 1474 } 1475 1476 wl1271_debug(DEBUG_CRYPT, "ap key action: %d id: %d lid: %d type: %d" 1477 " hlid: %d", (int)action, (int)id, (int)lid_type, 1478 (int)key_type, (int)hlid); 1479 1480 cmd->lid_key_type = lid_type; 1481 cmd->hlid = hlid; 1482 cmd->key_action = cpu_to_le16(action); 1483 cmd->key_size = key_size; 1484 cmd->key_type = key_type; 1485 cmd->key_id = id; 1486 cmd->ac_seq_num16[0] = cpu_to_le16(tx_seq_16); 1487 cmd->ac_seq_num32[0] = cpu_to_le32(tx_seq_32); 1488 1489 if (key_type == KEY_TKIP) { 1490 /* 1491 * We get the key in the following form: 1492 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes) 1493 * but the target is expecting: 1494 * TKIP - RX MIC - TX MIC 1495 */ 1496 memcpy(cmd->key, key, 16); 1497 memcpy(cmd->key + 16, key + 24, 8); 1498 memcpy(cmd->key + 24, key + 16, 8); 1499 } else { 1500 memcpy(cmd->key, key, key_size); 1501 } 1502 1503 wl1271_dump(DEBUG_CRYPT, "TARGET AP KEY: ", cmd, sizeof(*cmd)); 1504 1505 ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0); 1506 if (ret < 0) { 1507 wl1271_warning("could not set ap keys"); 1508 goto out; 1509 } 1510 1511 out: 1512 kfree(cmd); 1513 return ret; 1514 } 1515 1516 int wl12xx_cmd_set_peer_state(struct wl1271 *wl, u8 hlid) 1517 { 1518 struct wl12xx_cmd_set_peer_state *cmd; 1519 int ret = 0; 1520 1521 wl1271_debug(DEBUG_CMD, "cmd set peer state (hlid=%d)", hlid); 1522 1523 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1524 if (!cmd) { 1525 ret = -ENOMEM; 1526 goto out; 1527 } 1528 1529 cmd->hlid = hlid; 1530 cmd->state = WL1271_CMD_STA_STATE_CONNECTED; 1531 1532 ret = wl1271_cmd_send(wl, CMD_SET_PEER_STATE, cmd, sizeof(*cmd), 0); 1533 if (ret < 0) { 1534 wl1271_error("failed to send set peer state command"); 1535 goto out_free; 1536 } 1537 1538 out_free: 1539 kfree(cmd); 1540 1541 out: 1542 return ret; 1543 } 1544 1545 int wl12xx_cmd_add_peer(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1546 struct ieee80211_sta *sta, u8 hlid) 1547 { 1548 struct wl12xx_cmd_add_peer *cmd; 1549 int i, ret; 1550 u32 sta_rates; 1551 1552 wl1271_debug(DEBUG_CMD, "cmd add peer %d", (int)hlid); 1553 1554 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1555 if (!cmd) { 1556 ret = -ENOMEM; 1557 goto out; 1558 } 1559 1560 memcpy(cmd->addr, sta->addr, ETH_ALEN); 1561 cmd->bss_index = WL1271_AP_BSS_INDEX; 1562 cmd->aid = sta->aid; 1563 cmd->hlid = hlid; 1564 cmd->sp_len = sta->max_sp; 1565 cmd->wmm = sta->wme ? 1 : 0; 1566 1567 for (i = 0; i < NUM_ACCESS_CATEGORIES_COPY; i++) 1568 if (sta->wme && (sta->uapsd_queues & BIT(i))) 1569 cmd->psd_type[i] = WL1271_PSD_UPSD_TRIGGER; 1570 else 1571 cmd->psd_type[i] = WL1271_PSD_LEGACY; 1572 1573 sta_rates = sta->supp_rates[wlvif->band]; 1574 if (sta->ht_cap.ht_supported) 1575 sta_rates |= sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET; 1576 1577 cmd->supported_rates = 1578 cpu_to_le32(wl1271_tx_enabled_rates_get(wl, sta_rates, 1579 wlvif->band)); 1580 1581 wl1271_debug(DEBUG_CMD, "new peer rates=0x%x queues=0x%x", 1582 cmd->supported_rates, sta->uapsd_queues); 1583 1584 ret = wl1271_cmd_send(wl, CMD_ADD_PEER, cmd, sizeof(*cmd), 0); 1585 if (ret < 0) { 1586 wl1271_error("failed to initiate cmd add peer"); 1587 goto out_free; 1588 } 1589 1590 out_free: 1591 kfree(cmd); 1592 1593 out: 1594 return ret; 1595 } 1596 1597 int wl12xx_cmd_remove_peer(struct wl1271 *wl, u8 hlid) 1598 { 1599 struct wl12xx_cmd_remove_peer *cmd; 1600 int ret; 1601 1602 wl1271_debug(DEBUG_CMD, "cmd remove peer %d", (int)hlid); 1603 1604 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1605 if (!cmd) { 1606 ret = -ENOMEM; 1607 goto out; 1608 } 1609 1610 cmd->hlid = hlid; 1611 /* We never send a deauth, mac80211 is in charge of this */ 1612 cmd->reason_opcode = 0; 1613 cmd->send_deauth_flag = 0; 1614 1615 ret = wl1271_cmd_send(wl, CMD_REMOVE_PEER, cmd, sizeof(*cmd), 0); 1616 if (ret < 0) { 1617 wl1271_error("failed to initiate cmd remove peer"); 1618 goto out_free; 1619 } 1620 1621 /* 1622 * We are ok with a timeout here. The event is sometimes not sent 1623 * due to a firmware bug. 1624 */ 1625 wl1271_cmd_wait_for_event_or_timeout(wl, 1626 PEER_REMOVE_COMPLETE_EVENT_ID); 1627 1628 out_free: 1629 kfree(cmd); 1630 1631 out: 1632 return ret; 1633 } 1634 1635 int wl12xx_cmd_config_fwlog(struct wl1271 *wl) 1636 { 1637 struct wl12xx_cmd_config_fwlog *cmd; 1638 int ret = 0; 1639 1640 wl1271_debug(DEBUG_CMD, "cmd config firmware logger"); 1641 1642 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1643 if (!cmd) { 1644 ret = -ENOMEM; 1645 goto out; 1646 } 1647 1648 cmd->logger_mode = wl->conf.fwlog.mode; 1649 cmd->log_severity = wl->conf.fwlog.severity; 1650 cmd->timestamp = wl->conf.fwlog.timestamp; 1651 cmd->output = wl->conf.fwlog.output; 1652 cmd->threshold = wl->conf.fwlog.threshold; 1653 1654 ret = wl1271_cmd_send(wl, CMD_CONFIG_FWLOGGER, cmd, sizeof(*cmd), 0); 1655 if (ret < 0) { 1656 wl1271_error("failed to send config firmware logger command"); 1657 goto out_free; 1658 } 1659 1660 out_free: 1661 kfree(cmd); 1662 1663 out: 1664 return ret; 1665 } 1666 1667 int wl12xx_cmd_start_fwlog(struct wl1271 *wl) 1668 { 1669 struct wl12xx_cmd_start_fwlog *cmd; 1670 int ret = 0; 1671 1672 wl1271_debug(DEBUG_CMD, "cmd start firmware logger"); 1673 1674 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1675 if (!cmd) { 1676 ret = -ENOMEM; 1677 goto out; 1678 } 1679 1680 ret = wl1271_cmd_send(wl, CMD_START_FWLOGGER, cmd, sizeof(*cmd), 0); 1681 if (ret < 0) { 1682 wl1271_error("failed to send start firmware logger command"); 1683 goto out_free; 1684 } 1685 1686 out_free: 1687 kfree(cmd); 1688 1689 out: 1690 return ret; 1691 } 1692 1693 int wl12xx_cmd_stop_fwlog(struct wl1271 *wl) 1694 { 1695 struct wl12xx_cmd_stop_fwlog *cmd; 1696 int ret = 0; 1697 1698 wl1271_debug(DEBUG_CMD, "cmd stop firmware logger"); 1699 1700 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1701 if (!cmd) { 1702 ret = -ENOMEM; 1703 goto out; 1704 } 1705 1706 ret = wl1271_cmd_send(wl, CMD_STOP_FWLOGGER, cmd, sizeof(*cmd), 0); 1707 if (ret < 0) { 1708 wl1271_error("failed to send stop firmware logger command"); 1709 goto out_free; 1710 } 1711 1712 out_free: 1713 kfree(cmd); 1714 1715 out: 1716 return ret; 1717 } 1718 1719 static int wl12xx_cmd_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif, 1720 u8 role_id) 1721 { 1722 struct wl12xx_cmd_roc *cmd; 1723 int ret = 0; 1724 1725 wl1271_debug(DEBUG_CMD, "cmd roc %d (%d)", wlvif->channel, role_id); 1726 1727 if (WARN_ON(role_id == WL12XX_INVALID_ROLE_ID)) 1728 return -EINVAL; 1729 1730 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1731 if (!cmd) { 1732 ret = -ENOMEM; 1733 goto out; 1734 } 1735 1736 cmd->role_id = role_id; 1737 cmd->channel = wlvif->channel; 1738 switch (wlvif->band) { 1739 case IEEE80211_BAND_2GHZ: 1740 cmd->band = RADIO_BAND_2_4GHZ; 1741 break; 1742 case IEEE80211_BAND_5GHZ: 1743 cmd->band = RADIO_BAND_5GHZ; 1744 break; 1745 default: 1746 wl1271_error("roc - unknown band: %d", (int)wlvif->band); 1747 ret = -EINVAL; 1748 goto out_free; 1749 } 1750 1751 1752 ret = wl1271_cmd_send(wl, CMD_REMAIN_ON_CHANNEL, cmd, sizeof(*cmd), 0); 1753 if (ret < 0) { 1754 wl1271_error("failed to send ROC command"); 1755 goto out_free; 1756 } 1757 1758 out_free: 1759 kfree(cmd); 1760 1761 out: 1762 return ret; 1763 } 1764 1765 static int wl12xx_cmd_croc(struct wl1271 *wl, u8 role_id) 1766 { 1767 struct wl12xx_cmd_croc *cmd; 1768 int ret = 0; 1769 1770 wl1271_debug(DEBUG_CMD, "cmd croc (%d)", role_id); 1771 1772 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1773 if (!cmd) { 1774 ret = -ENOMEM; 1775 goto out; 1776 } 1777 cmd->role_id = role_id; 1778 1779 ret = wl1271_cmd_send(wl, CMD_CANCEL_REMAIN_ON_CHANNEL, cmd, 1780 sizeof(*cmd), 0); 1781 if (ret < 0) { 1782 wl1271_error("failed to send ROC command"); 1783 goto out_free; 1784 } 1785 1786 out_free: 1787 kfree(cmd); 1788 1789 out: 1790 return ret; 1791 } 1792 1793 int wl12xx_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 role_id) 1794 { 1795 int ret = 0; 1796 1797 if (WARN_ON(test_bit(role_id, wl->roc_map))) 1798 return 0; 1799 1800 ret = wl12xx_cmd_roc(wl, wlvif, role_id); 1801 if (ret < 0) 1802 goto out; 1803 1804 ret = wl1271_cmd_wait_for_event(wl, 1805 REMAIN_ON_CHANNEL_COMPLETE_EVENT_ID); 1806 if (ret < 0) { 1807 wl1271_error("cmd roc event completion error"); 1808 goto out; 1809 } 1810 1811 __set_bit(role_id, wl->roc_map); 1812 out: 1813 return ret; 1814 } 1815 1816 int wl12xx_croc(struct wl1271 *wl, u8 role_id) 1817 { 1818 int ret = 0; 1819 1820 if (WARN_ON(!test_bit(role_id, wl->roc_map))) 1821 return 0; 1822 1823 ret = wl12xx_cmd_croc(wl, role_id); 1824 if (ret < 0) 1825 goto out; 1826 1827 __clear_bit(role_id, wl->roc_map); 1828 1829 /* 1830 * Rearm the tx watchdog when removing the last ROC. This prevents 1831 * recoveries due to just finished ROCs - when Tx hasn't yet had 1832 * a chance to get out. 1833 */ 1834 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) >= WL12XX_MAX_ROLES) 1835 wl12xx_rearm_tx_watchdog_locked(wl); 1836 out: 1837 return ret; 1838 } 1839 1840 int wl12xx_cmd_channel_switch(struct wl1271 *wl, 1841 struct wl12xx_vif *wlvif, 1842 struct ieee80211_channel_switch *ch_switch) 1843 { 1844 struct wl12xx_cmd_channel_switch *cmd; 1845 int ret; 1846 1847 wl1271_debug(DEBUG_ACX, "cmd channel switch"); 1848 1849 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1850 if (!cmd) { 1851 ret = -ENOMEM; 1852 goto out; 1853 } 1854 1855 cmd->role_id = wlvif->role_id; 1856 cmd->channel = ch_switch->channel->hw_value; 1857 cmd->switch_time = ch_switch->count; 1858 cmd->stop_tx = ch_switch->block_tx; 1859 1860 /* FIXME: control from mac80211 in the future */ 1861 cmd->post_switch_tx_disable = 0; /* Enable TX on the target channel */ 1862 1863 ret = wl1271_cmd_send(wl, CMD_CHANNEL_SWITCH, cmd, sizeof(*cmd), 0); 1864 if (ret < 0) { 1865 wl1271_error("failed to send channel switch command"); 1866 goto out_free; 1867 } 1868 1869 out_free: 1870 kfree(cmd); 1871 1872 out: 1873 return ret; 1874 } 1875 1876 int wl12xx_cmd_stop_channel_switch(struct wl1271 *wl) 1877 { 1878 struct wl12xx_cmd_stop_channel_switch *cmd; 1879 int ret; 1880 1881 wl1271_debug(DEBUG_ACX, "cmd stop channel switch"); 1882 1883 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1884 if (!cmd) { 1885 ret = -ENOMEM; 1886 goto out; 1887 } 1888 1889 ret = wl1271_cmd_send(wl, CMD_STOP_CHANNEL_SWICTH, cmd, sizeof(*cmd), 0); 1890 if (ret < 0) { 1891 wl1271_error("failed to stop channel switch command"); 1892 goto out_free; 1893 } 1894 1895 out_free: 1896 kfree(cmd); 1897 1898 out: 1899 return ret; 1900 } 1901 1902 /* start dev role and roc on its channel */ 1903 int wl12xx_start_dev(struct wl1271 *wl, struct wl12xx_vif *wlvif) 1904 { 1905 int ret; 1906 1907 if (WARN_ON(!(wlvif->bss_type == BSS_TYPE_STA_BSS || 1908 wlvif->bss_type == BSS_TYPE_IBSS))) 1909 return -EINVAL; 1910 1911 ret = wl12xx_cmd_role_start_dev(wl, wlvif); 1912 if (ret < 0) 1913 goto out; 1914 1915 ret = wl12xx_roc(wl, wlvif, wlvif->dev_role_id); 1916 if (ret < 0) 1917 goto out_stop; 1918 1919 return 0; 1920 1921 out_stop: 1922 wl12xx_cmd_role_stop_dev(wl, wlvif); 1923 out: 1924 return ret; 1925 } 1926 1927 /* croc dev hlid, and stop the role */ 1928 int wl12xx_stop_dev(struct wl1271 *wl, struct wl12xx_vif *wlvif) 1929 { 1930 int ret; 1931 1932 if (WARN_ON(!(wlvif->bss_type == BSS_TYPE_STA_BSS || 1933 wlvif->bss_type == BSS_TYPE_IBSS))) 1934 return -EINVAL; 1935 1936 /* flush all pending packets */ 1937 wl1271_tx_work_locked(wl); 1938 1939 if (test_bit(wlvif->dev_role_id, wl->roc_map)) { 1940 ret = wl12xx_croc(wl, wlvif->dev_role_id); 1941 if (ret < 0) 1942 goto out; 1943 } 1944 1945 ret = wl12xx_cmd_role_stop_dev(wl, wlvif); 1946 if (ret < 0) 1947 goto out; 1948 out: 1949 return ret; 1950 } 1951