1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Driver for KeyStream, KS7010 based SDIO cards. 4 * 5 * Copyright (C) 2006-2008 KeyStream Corp. 6 * Copyright (C) 2009 Renesas Technology Corp. 7 * Copyright (C) 2016 Sang Engineering, Wolfram Sang 8 */ 9 10 #include <linux/atomic.h> 11 #include <linux/firmware.h> 12 #include <linux/jiffies.h> 13 #include <linux/mmc/card.h> 14 #include <linux/mmc/sdio_func.h> 15 #include <linux/module.h> 16 #include <linux/workqueue.h> 17 #include "ks_wlan.h" 18 #include "ks_hostif.h" 19 20 #define ROM_FILE "ks7010sd.rom" 21 22 /* SDIO KeyStream vendor and device */ 23 #define SDIO_VENDOR_ID_KS_CODE_A 0x005b 24 #define SDIO_VENDOR_ID_KS_CODE_B 0x0023 25 26 /* Older sources suggest earlier versions were named 7910 or 79xx */ 27 #define SDIO_DEVICE_ID_KS_7010 0x7910 28 29 /* Read/Write Status Register */ 30 #define READ_STATUS_REG 0x000000 31 #define WRITE_STATUS_REG 0x00000C 32 enum reg_status_type { 33 REG_STATUS_BUSY, 34 REG_STATUS_IDLE 35 }; 36 37 /* Read Index Register */ 38 #define READ_INDEX_REG 0x000004 39 40 /* Read Data Size Register */ 41 #define READ_DATA_SIZE_REG 0x000008 42 43 /* Write Index Register */ 44 #define WRITE_INDEX_REG 0x000010 45 46 /* 47 * Write Status/Read Data Size Register 48 * for network packet (less than 2048 bytes data) 49 */ 50 #define WSTATUS_RSIZE_REG 0x000014 51 52 /* Write Status Register value */ 53 #define WSTATUS_MASK 0x80 54 55 /* Read Data Size Register value [10:4] */ 56 #define RSIZE_MASK 0x7F 57 58 /* ARM to SD interrupt Enable */ 59 #define INT_ENABLE_REG 0x000020 60 /* ARM to SD interrupt Pending */ 61 #define INT_PENDING_REG 0x000024 62 63 #define INT_GCR_B BIT(7) 64 #define INT_GCR_A BIT(6) 65 #define INT_WRITE_STATUS BIT(5) 66 #define INT_WRITE_INDEX BIT(4) 67 #define INT_WRITE_SIZE BIT(3) 68 #define INT_READ_STATUS BIT(2) 69 #define INT_READ_INDEX BIT(1) 70 #define INT_READ_SIZE BIT(0) 71 72 /* General Communication Register A */ 73 #define GCR_A_REG 0x000028 74 enum gen_com_reg_a { 75 GCR_A_INIT, 76 GCR_A_REMAP, 77 GCR_A_RUN 78 }; 79 80 /* General Communication Register B */ 81 #define GCR_B_REG 0x00002C 82 enum gen_com_reg_b { 83 GCR_B_ACTIVE, 84 GCR_B_DOZE 85 }; 86 87 /* Wakeup Register */ 88 #define WAKEUP_REG 0x008018 89 #define WAKEUP_REQ 0x5a 90 91 /* AHB Data Window 0x010000-0x01FFFF */ 92 #define DATA_WINDOW 0x010000 93 #define WINDOW_SIZE (64 * 1024) 94 95 #define KS7010_IRAM_ADDRESS 0x06000000 96 97 #define KS7010_IO_BLOCK_SIZE 512 98 99 /** 100 * struct ks_sdio_card - SDIO device data. 101 * 102 * Structure is used as the &struct sdio_func private data. 103 * 104 * @func: Pointer to the SDIO function device. 105 * @priv: Pointer to the &struct net_device private data. 106 */ 107 struct ks_sdio_card { 108 struct sdio_func *func; 109 struct ks_wlan_private *priv; 110 }; 111 112 static struct sdio_func *ks7010_to_func(struct ks_wlan_private *priv) 113 { 114 struct ks_sdio_card *ks_sdio = priv->if_hw; 115 116 return ks_sdio->func; 117 } 118 119 /* Read single byte from device address into byte (CMD52) */ 120 static int ks7010_sdio_readb(struct ks_wlan_private *priv, 121 u32 address, u8 *byte) 122 { 123 struct sdio_func *func = ks7010_to_func(priv); 124 int ret; 125 126 *byte = sdio_readb(func, address, &ret); 127 128 return ret; 129 } 130 131 /* Read length bytes from device address into buffer (CMD53) */ 132 static int ks7010_sdio_read(struct ks_wlan_private *priv, u32 address, 133 u8 *buffer, unsigned int length) 134 { 135 struct sdio_func *func = ks7010_to_func(priv); 136 137 return sdio_memcpy_fromio(func, buffer, address, length); 138 } 139 140 /* Write single byte to device address (CMD52) */ 141 static int ks7010_sdio_writeb(struct ks_wlan_private *priv, 142 u32 address, u8 byte) 143 { 144 struct sdio_func *func = ks7010_to_func(priv); 145 int ret; 146 147 sdio_writeb(func, byte, address, &ret); 148 149 return ret; 150 } 151 152 /* Write length bytes to device address from buffer (CMD53) */ 153 static int ks7010_sdio_write(struct ks_wlan_private *priv, u32 address, 154 u8 *buffer, unsigned int length) 155 { 156 struct sdio_func *func = ks7010_to_func(priv); 157 158 return sdio_memcpy_toio(func, address, buffer, length); 159 } 160 161 static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv) 162 { 163 int ret; 164 165 /* clear request */ 166 atomic_set(&priv->sleepstatus.doze_request, 0); 167 168 if (atomic_read(&priv->sleepstatus.status) == 0) { 169 ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE); 170 if (ret) { 171 netdev_err(priv->net_dev, "write GCR_B_REG\n"); 172 goto set_sleep_mode; 173 } 174 atomic_set(&priv->sleepstatus.status, 1); 175 priv->last_doze = jiffies; 176 } 177 178 set_sleep_mode: 179 priv->sleep_mode = atomic_read(&priv->sleepstatus.status); 180 } 181 182 static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv) 183 { 184 int ret; 185 186 /* clear request */ 187 atomic_set(&priv->sleepstatus.wakeup_request, 0); 188 189 if (atomic_read(&priv->sleepstatus.status) == 1) { 190 ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ); 191 if (ret) { 192 netdev_err(priv->net_dev, "write WAKEUP_REG\n"); 193 goto set_sleep_mode; 194 } 195 atomic_set(&priv->sleepstatus.status, 0); 196 priv->last_wakeup = jiffies; 197 ++priv->wakeup_count; 198 } 199 200 set_sleep_mode: 201 priv->sleep_mode = atomic_read(&priv->sleepstatus.status); 202 } 203 204 void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv) 205 { 206 int ret; 207 208 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { 209 ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ); 210 if (ret) 211 netdev_err(priv->net_dev, "write WAKEUP_REG\n"); 212 213 priv->last_wakeup = jiffies; 214 ++priv->wakeup_count; 215 } 216 } 217 218 static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv) 219 { 220 u8 byte; 221 int ret; 222 223 if (priv->reg.power_mgmt == POWER_MGMT_ACTIVE) 224 return; 225 226 if (priv->reg.operation_mode != MODE_INFRASTRUCTURE) 227 return; 228 229 if (!is_connect_status(priv->connect_status)) 230 return; 231 232 if (priv->dev_state != DEVICE_STATE_SLEEP) 233 return; 234 235 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) 236 return; 237 238 netdev_dbg(priv->net_dev, 239 "STATUS:\n" 240 "- psstatus.status = %d\n" 241 "- psstatus.confirm_wait = %d\n" 242 "- psstatus.snooze_guard = %d\n" 243 "- txq_count = %d\n", 244 atomic_read(&priv->psstatus.status), 245 atomic_read(&priv->psstatus.confirm_wait), 246 atomic_read(&priv->psstatus.snooze_guard), 247 txq_count(priv)); 248 249 if (atomic_read(&priv->psstatus.confirm_wait) || 250 atomic_read(&priv->psstatus.snooze_guard) || 251 txq_has_space(priv)) { 252 queue_delayed_work(priv->wq, &priv->rw_dwork, 0); 253 return; 254 } 255 256 ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &byte); 257 if (ret) { 258 netdev_err(priv->net_dev, "read INT_PENDING_REG\n"); 259 goto queue_delayed_work; 260 } 261 if (byte) 262 goto queue_delayed_work; 263 264 ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE); 265 if (ret) { 266 netdev_err(priv->net_dev, "write GCR_B_REG\n"); 267 goto queue_delayed_work; 268 } 269 atomic_set(&priv->psstatus.status, PS_SNOOZE); 270 271 return; 272 273 queue_delayed_work: 274 queue_delayed_work(priv->wq, &priv->rw_dwork, 1); 275 } 276 277 int ks_wlan_hw_power_save(struct ks_wlan_private *priv) 278 { 279 queue_delayed_work(priv->wq, &priv->rw_dwork, 1); 280 return 0; 281 } 282 283 static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p, 284 unsigned long size, 285 void (*complete_handler)(struct ks_wlan_private *priv, 286 struct sk_buff *skb), 287 struct sk_buff *skb) 288 { 289 struct tx_device_buffer *sp; 290 int ret; 291 292 if (priv->dev_state < DEVICE_STATE_BOOT) { 293 ret = -EPERM; 294 goto err_complete; 295 } 296 297 if ((TX_DEVICE_BUFF_SIZE - 1) <= txq_count(priv)) { 298 netdev_err(priv->net_dev, "tx buffer overflow\n"); 299 ret = -EOVERFLOW; 300 goto err_complete; 301 } 302 303 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail]; 304 sp->sendp = p; 305 sp->size = size; 306 sp->complete_handler = complete_handler; 307 sp->skb = skb; 308 inc_txqtail(priv); 309 310 return 0; 311 312 err_complete: 313 kfree(p); 314 if (complete_handler) 315 (*complete_handler)(priv, skb); 316 317 return ret; 318 } 319 320 /* write data */ 321 static int write_to_device(struct ks_wlan_private *priv, u8 *buffer, 322 unsigned long size) 323 { 324 struct hostif_hdr *hdr; 325 int ret; 326 327 hdr = (struct hostif_hdr *)buffer; 328 329 if (le16_to_cpu(hdr->event) < HIF_DATA_REQ || 330 le16_to_cpu(hdr->event) > HIF_REQ_MAX) { 331 netdev_err(priv->net_dev, "unknown event=%04X\n", hdr->event); 332 return 0; 333 } 334 335 ret = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size); 336 if (ret) { 337 netdev_err(priv->net_dev, "write DATA_WINDOW\n"); 338 return ret; 339 } 340 341 ret = ks7010_sdio_writeb(priv, WRITE_STATUS_REG, REG_STATUS_BUSY); 342 if (ret) { 343 netdev_err(priv->net_dev, "write WRITE_STATUS_REG\n"); 344 return ret; 345 } 346 347 return 0; 348 } 349 350 static void tx_device_task(struct ks_wlan_private *priv) 351 { 352 struct tx_device_buffer *sp; 353 int ret; 354 355 if (!txq_has_space(priv) || 356 atomic_read(&priv->psstatus.status) == PS_SNOOZE) 357 return; 358 359 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead]; 360 if (priv->dev_state >= DEVICE_STATE_BOOT) { 361 ret = write_to_device(priv, sp->sendp, sp->size); 362 if (ret) { 363 netdev_err(priv->net_dev, 364 "write_to_device error !!(%d)\n", ret); 365 queue_delayed_work(priv->wq, &priv->rw_dwork, 1); 366 return; 367 } 368 } 369 kfree(sp->sendp); 370 if (sp->complete_handler) /* TX Complete */ 371 (*sp->complete_handler)(priv, sp->skb); 372 inc_txqhead(priv); 373 374 if (txq_has_space(priv)) 375 queue_delayed_work(priv->wq, &priv->rw_dwork, 0); 376 } 377 378 int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size, 379 void (*complete_handler)(struct ks_wlan_private *priv, 380 struct sk_buff *skb), 381 struct sk_buff *skb) 382 { 383 int result = 0; 384 struct hostif_hdr *hdr; 385 386 hdr = (struct hostif_hdr *)p; 387 388 if (le16_to_cpu(hdr->event) < HIF_DATA_REQ || 389 le16_to_cpu(hdr->event) > HIF_REQ_MAX) { 390 netdev_err(priv->net_dev, "unknown event=%04X\n", hdr->event); 391 return 0; 392 } 393 394 /* add event to hostt buffer */ 395 priv->hostt.buff[priv->hostt.qtail] = le16_to_cpu(hdr->event); 396 priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE; 397 398 spin_lock(&priv->tx_dev.tx_dev_lock); 399 result = enqueue_txdev(priv, p, size, complete_handler, skb); 400 spin_unlock(&priv->tx_dev.tx_dev_lock); 401 402 if (txq_has_space(priv)) 403 queue_delayed_work(priv->wq, &priv->rw_dwork, 0); 404 405 return result; 406 } 407 408 static void rx_event_task(unsigned long dev) 409 { 410 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev; 411 struct rx_device_buffer *rp; 412 413 if (rxq_has_space(priv) && priv->dev_state >= DEVICE_STATE_BOOT) { 414 rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead]; 415 hostif_receive(priv, rp->data, rp->size); 416 inc_rxqhead(priv); 417 418 if (rxq_has_space(priv)) 419 tasklet_schedule(&priv->rx_bh_task); 420 } 421 } 422 423 static void ks_wlan_hw_rx(struct ks_wlan_private *priv, size_t size) 424 { 425 int ret; 426 struct rx_device_buffer *rx_buffer; 427 struct hostif_hdr *hdr; 428 u16 event = 0; 429 430 /* receive data */ 431 if (rxq_count(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) { 432 netdev_err(priv->net_dev, "rx buffer overflow\n"); 433 return; 434 } 435 rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail]; 436 437 ret = ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0], 438 hif_align_size(size)); 439 if (ret) 440 return; 441 442 /* length check */ 443 if (size > 2046 || size == 0) { 444 #ifdef DEBUG 445 print_hex_dump_bytes("INVALID DATA dump: ", 446 DUMP_PREFIX_OFFSET, 447 rx_buffer->data, 32); 448 #endif 449 ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE); 450 if (ret) 451 netdev_err(priv->net_dev, "write READ_STATUS_REG\n"); 452 453 /* length check fail */ 454 return; 455 } 456 457 hdr = (struct hostif_hdr *)&rx_buffer->data[0]; 458 rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size); 459 event = le16_to_cpu(hdr->event); 460 inc_rxqtail(priv); 461 462 ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE); 463 if (ret) 464 netdev_err(priv->net_dev, "write READ_STATUS_REG\n"); 465 466 if (atomic_read(&priv->psstatus.confirm_wait) && is_hif_conf(event)) { 467 netdev_dbg(priv->net_dev, "IS_HIF_CONF true !!\n"); 468 atomic_dec(&priv->psstatus.confirm_wait); 469 } 470 471 tasklet_schedule(&priv->rx_bh_task); 472 } 473 474 static void ks7010_rw_function(struct work_struct *work) 475 { 476 struct ks_wlan_private *priv = container_of(work, 477 struct ks_wlan_private, 478 rw_dwork.work); 479 struct sdio_func *func = ks7010_to_func(priv); 480 u8 byte; 481 int ret; 482 483 /* wait after DOZE */ 484 if (time_after(priv->last_doze + msecs_to_jiffies(30), jiffies)) { 485 netdev_dbg(priv->net_dev, "wait after DOZE\n"); 486 queue_delayed_work(priv->wq, &priv->rw_dwork, 1); 487 return; 488 } 489 490 /* wait after WAKEUP */ 491 while (time_after(priv->last_wakeup + msecs_to_jiffies(30), jiffies)) { 492 netdev_dbg(priv->net_dev, "wait after WAKEUP\n"); 493 dev_info(&func->dev, "wake: %lu %lu\n", 494 priv->last_wakeup + msecs_to_jiffies(30), jiffies); 495 msleep(30); 496 } 497 498 sdio_claim_host(func); 499 500 /* power save wakeup */ 501 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { 502 if (txq_has_space(priv)) { 503 ks_wlan_hw_wakeup_request(priv); 504 queue_delayed_work(priv->wq, &priv->rw_dwork, 1); 505 } 506 goto release_host; 507 } 508 509 /* sleep mode doze */ 510 if (atomic_read(&priv->sleepstatus.doze_request) == 1) { 511 ks_wlan_hw_sleep_doze_request(priv); 512 goto release_host; 513 } 514 /* sleep mode wakeup */ 515 if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) { 516 ks_wlan_hw_sleep_wakeup_request(priv); 517 goto release_host; 518 } 519 520 /* read (WriteStatus/ReadDataSize FN1:00_0014) */ 521 ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte); 522 if (ret) { 523 netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG psstatus=%d\n", 524 atomic_read(&priv->psstatus.status)); 525 goto release_host; 526 } 527 528 if (byte & RSIZE_MASK) { /* Read schedule */ 529 ks_wlan_hw_rx(priv, (size_t)((byte & RSIZE_MASK) << 4)); 530 } 531 if ((byte & WSTATUS_MASK)) 532 tx_device_task(priv); 533 534 _ks_wlan_hw_power_save(priv); 535 536 release_host: 537 sdio_release_host(func); 538 } 539 540 static void ks_sdio_interrupt(struct sdio_func *func) 541 { 542 int ret; 543 struct ks_sdio_card *card; 544 struct ks_wlan_private *priv; 545 u8 status, rsize, byte; 546 547 card = sdio_get_drvdata(func); 548 priv = card->priv; 549 550 if (priv->dev_state < DEVICE_STATE_BOOT) 551 goto queue_delayed_work; 552 553 ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &status); 554 if (ret) { 555 netdev_err(priv->net_dev, "read INT_PENDING_REG\n"); 556 goto queue_delayed_work; 557 } 558 559 /* schedule task for interrupt status */ 560 /* bit7 -> Write General Communication B register */ 561 /* read (General Communication B register) */ 562 /* bit5 -> Write Status Idle */ 563 /* bit2 -> Read Status Busy */ 564 if (status & INT_GCR_B || 565 atomic_read(&priv->psstatus.status) == PS_SNOOZE) { 566 ret = ks7010_sdio_readb(priv, GCR_B_REG, &byte); 567 if (ret) { 568 netdev_err(priv->net_dev, "read GCR_B_REG\n"); 569 goto queue_delayed_work; 570 } 571 if (byte == GCR_B_ACTIVE) { 572 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { 573 atomic_set(&priv->psstatus.status, PS_WAKEUP); 574 priv->wakeup_count = 0; 575 } 576 complete(&priv->psstatus.wakeup_wait); 577 } 578 } 579 580 do { 581 /* read (WriteStatus/ReadDataSize FN1:00_0014) */ 582 ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte); 583 if (ret) { 584 netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG\n"); 585 goto queue_delayed_work; 586 } 587 rsize = byte & RSIZE_MASK; 588 if (rsize != 0) /* Read schedule */ 589 ks_wlan_hw_rx(priv, (size_t)(rsize << 4)); 590 591 if (byte & WSTATUS_MASK) { 592 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { 593 if (txq_has_space(priv)) { 594 ks_wlan_hw_wakeup_request(priv); 595 queue_delayed_work(priv->wq, 596 &priv->rw_dwork, 1); 597 return; 598 } 599 } else { 600 tx_device_task(priv); 601 } 602 } 603 } while (rsize); 604 605 queue_delayed_work: 606 queue_delayed_work(priv->wq, &priv->rw_dwork, 0); 607 } 608 609 static int trx_device_init(struct ks_wlan_private *priv) 610 { 611 priv->tx_dev.qhead = 0; 612 priv->tx_dev.qtail = 0; 613 614 priv->rx_dev.qhead = 0; 615 priv->rx_dev.qtail = 0; 616 617 spin_lock_init(&priv->tx_dev.tx_dev_lock); 618 spin_lock_init(&priv->rx_dev.rx_dev_lock); 619 620 tasklet_init(&priv->rx_bh_task, rx_event_task, (unsigned long)priv); 621 622 return 0; 623 } 624 625 static void trx_device_exit(struct ks_wlan_private *priv) 626 { 627 struct tx_device_buffer *sp; 628 629 /* tx buffer clear */ 630 while (txq_has_space(priv)) { 631 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead]; 632 kfree(sp->sendp); 633 if (sp->complete_handler) /* TX Complete */ 634 (*sp->complete_handler)(priv, sp->skb); 635 inc_txqhead(priv); 636 } 637 638 tasklet_kill(&priv->rx_bh_task); 639 } 640 641 static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index) 642 { 643 int ret; 644 unsigned char *data_buf; 645 646 data_buf = kmemdup(&index, sizeof(u32), GFP_KERNEL); 647 if (!data_buf) 648 return -ENOMEM; 649 650 ret = ks7010_sdio_write(priv, WRITE_INDEX_REG, data_buf, sizeof(index)); 651 if (ret) 652 goto err_free_data_buf; 653 654 ret = ks7010_sdio_write(priv, READ_INDEX_REG, data_buf, sizeof(index)); 655 if (ret) 656 goto err_free_data_buf; 657 658 return 0; 659 660 err_free_data_buf: 661 kfree(data_buf); 662 663 return ret; 664 } 665 666 #define ROM_BUFF_SIZE (64 * 1024) 667 static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address, 668 u8 *data, unsigned int size) 669 { 670 int ret; 671 u8 *read_buf; 672 673 read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL); 674 if (!read_buf) 675 return -ENOMEM; 676 677 ret = ks7010_sdio_read(priv, address, read_buf, size); 678 if (ret) 679 goto err_free_read_buf; 680 681 if (memcmp(data, read_buf, size) != 0) { 682 ret = -EIO; 683 netdev_err(priv->net_dev, "data compare error (%d)\n", ret); 684 goto err_free_read_buf; 685 } 686 687 return 0; 688 689 err_free_read_buf: 690 kfree(read_buf); 691 692 return ret; 693 } 694 695 static int ks7010_copy_firmware(struct ks_wlan_private *priv, 696 const struct firmware *fw_entry) 697 { 698 unsigned int length; 699 unsigned int size; 700 unsigned int offset; 701 unsigned int n = 0; 702 u8 *rom_buf; 703 int ret; 704 705 rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL); 706 if (!rom_buf) 707 return -ENOMEM; 708 709 length = fw_entry->size; 710 711 do { 712 if (length >= ROM_BUFF_SIZE) { 713 size = ROM_BUFF_SIZE; 714 length = length - ROM_BUFF_SIZE; 715 } else { 716 size = length; 717 length = 0; 718 } 719 if (size == 0) 720 break; 721 722 memcpy(rom_buf, fw_entry->data + n, size); 723 724 offset = n; 725 ret = ks7010_sdio_update_index(priv, 726 KS7010_IRAM_ADDRESS + offset); 727 if (ret) 728 goto free_rom_buf; 729 730 ret = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size); 731 if (ret) 732 goto free_rom_buf; 733 734 ret = ks7010_sdio_data_compare(priv, 735 DATA_WINDOW, rom_buf, size); 736 if (ret) 737 goto free_rom_buf; 738 739 n += size; 740 741 } while (size); 742 743 ret = ks7010_sdio_writeb(priv, GCR_A_REG, GCR_A_REMAP); 744 745 free_rom_buf: 746 kfree(rom_buf); 747 return ret; 748 } 749 750 static int ks7010_upload_firmware(struct ks_sdio_card *card) 751 { 752 struct ks_wlan_private *priv = card->priv; 753 struct sdio_func *func = ks7010_to_func(priv); 754 unsigned int n; 755 u8 byte = 0; 756 int ret; 757 const struct firmware *fw_entry = NULL; 758 759 sdio_claim_host(func); 760 761 /* Firmware running ? */ 762 ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte); 763 if (ret) 764 goto release_host; 765 if (byte == GCR_A_RUN) { 766 netdev_dbg(priv->net_dev, "MAC firmware running ...\n"); 767 ret = -EBUSY; 768 goto release_host; 769 } 770 771 ret = request_firmware(&fw_entry, ROM_FILE, 772 &func->dev); 773 if (ret) 774 goto release_host; 775 776 ret = ks7010_copy_firmware(priv, fw_entry); 777 if (ret) 778 goto release_firmware; 779 780 /* Firmware running check */ 781 for (n = 0; n < 50; ++n) { 782 usleep_range(10000, 11000); /* wait_ms(10); */ 783 ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte); 784 if (ret) 785 goto release_firmware; 786 787 if (byte == GCR_A_RUN) 788 break; 789 } 790 if ((50) <= n) { 791 netdev_err(priv->net_dev, "firmware can't start\n"); 792 ret = -EIO; 793 goto release_firmware; 794 } 795 796 ret = 0; 797 798 release_firmware: 799 release_firmware(fw_entry); 800 release_host: 801 sdio_release_host(func); 802 803 return ret; 804 } 805 806 static void ks7010_sme_enqueue_events(struct ks_wlan_private *priv) 807 { 808 static const u16 init_events[] = { 809 SME_GET_EEPROM_CKSUM, SME_STOP_REQUEST, 810 SME_RTS_THRESHOLD_REQUEST, SME_FRAGMENTATION_THRESHOLD_REQUEST, 811 SME_WEP_INDEX_REQUEST, SME_WEP_KEY1_REQUEST, 812 SME_WEP_KEY2_REQUEST, SME_WEP_KEY3_REQUEST, 813 SME_WEP_KEY4_REQUEST, SME_WEP_FLAG_REQUEST, 814 SME_RSN_ENABLED_REQUEST, SME_MODE_SET_REQUEST, 815 SME_START_REQUEST 816 }; 817 int ev; 818 819 for (ev = 0; ev < ARRAY_SIZE(init_events); ev++) 820 hostif_sme_enqueue(priv, init_events[ev]); 821 } 822 823 static void ks7010_card_init(struct ks_wlan_private *priv) 824 { 825 init_completion(&priv->confirm_wait); 826 827 /* get mac address & firmware version */ 828 hostif_sme_enqueue(priv, SME_START); 829 830 if (!wait_for_completion_interruptible_timeout 831 (&priv->confirm_wait, 5 * HZ)) { 832 netdev_dbg(priv->net_dev, "wait time out!! SME_START\n"); 833 } 834 835 if (priv->mac_address_valid && priv->version_size != 0) 836 priv->dev_state = DEVICE_STATE_PREINIT; 837 838 ks7010_sme_enqueue_events(priv); 839 840 if (!wait_for_completion_interruptible_timeout 841 (&priv->confirm_wait, 5 * HZ)) { 842 netdev_dbg(priv->net_dev, "wait time out!! wireless parameter set\n"); 843 } 844 845 if (priv->dev_state >= DEVICE_STATE_PREINIT) { 846 netdev_dbg(priv->net_dev, "DEVICE READY!!\n"); 847 priv->dev_state = DEVICE_STATE_READY; 848 } 849 } 850 851 static void ks7010_init_defaults(struct ks_wlan_private *priv) 852 { 853 priv->reg.tx_rate = TX_RATE_AUTO; 854 priv->reg.preamble = LONG_PREAMBLE; 855 priv->reg.power_mgmt = POWER_MGMT_ACTIVE; 856 priv->reg.scan_type = ACTIVE_SCAN; 857 priv->reg.beacon_lost_count = 20; 858 priv->reg.rts = 2347UL; 859 priv->reg.fragment = 2346UL; 860 priv->reg.phy_type = D_11BG_COMPATIBLE_MODE; 861 priv->reg.cts_mode = CTS_MODE_FALSE; 862 priv->reg.rate_set.body[11] = TX_RATE_54M; 863 priv->reg.rate_set.body[10] = TX_RATE_48M; 864 priv->reg.rate_set.body[9] = TX_RATE_36M; 865 priv->reg.rate_set.body[8] = TX_RATE_18M; 866 priv->reg.rate_set.body[7] = TX_RATE_9M; 867 priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE; 868 priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE; 869 priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE; 870 priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE; 871 priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE; 872 priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE; 873 priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE; 874 priv->reg.tx_rate = TX_RATE_FULL_AUTO; 875 priv->reg.rate_set.size = 12; 876 } 877 878 static int ks7010_sdio_setup_irqs(struct sdio_func *func) 879 { 880 int ret; 881 882 /* interrupt disable */ 883 sdio_writeb(func, 0, INT_ENABLE_REG, &ret); 884 if (ret) 885 goto irq_error; 886 887 sdio_writeb(func, 0xff, INT_PENDING_REG, &ret); 888 if (ret) 889 goto irq_error; 890 891 /* setup interrupt handler */ 892 ret = sdio_claim_irq(func, ks_sdio_interrupt); 893 894 irq_error: 895 return ret; 896 } 897 898 static void ks7010_sdio_init_irqs(struct sdio_func *func, 899 struct ks_wlan_private *priv) 900 { 901 u8 byte; 902 int ret; 903 904 /* 905 * interrupt setting 906 * clear Interrupt status write 907 * (ARMtoSD_InterruptPending FN1:00_0024) 908 */ 909 sdio_claim_host(func); 910 ret = ks7010_sdio_writeb(priv, INT_PENDING_REG, 0xff); 911 sdio_release_host(func); 912 if (ret) 913 netdev_err(priv->net_dev, "write INT_PENDING_REG\n"); 914 915 /* enable ks7010sdio interrupt */ 916 byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS); 917 sdio_claim_host(func); 918 ret = ks7010_sdio_writeb(priv, INT_ENABLE_REG, byte); 919 sdio_release_host(func); 920 if (ret) 921 netdev_err(priv->net_dev, "write INT_ENABLE_REG\n"); 922 } 923 924 static void ks7010_private_init(struct ks_wlan_private *priv, 925 struct ks_sdio_card *card, 926 struct net_device *netdev) 927 { 928 /* private memory initialize */ 929 priv->if_hw = card; 930 931 priv->dev_state = DEVICE_STATE_PREBOOT; 932 priv->net_dev = netdev; 933 priv->firmware_version[0] = '\0'; 934 priv->version_size = 0; 935 priv->last_doze = jiffies; 936 priv->last_wakeup = jiffies; 937 memset(&priv->nstats, 0, sizeof(priv->nstats)); 938 memset(&priv->wstats, 0, sizeof(priv->wstats)); 939 940 /* sleep mode */ 941 atomic_set(&priv->sleepstatus.doze_request, 0); 942 atomic_set(&priv->sleepstatus.wakeup_request, 0); 943 atomic_set(&priv->sleepstatus.wakeup_request, 0); 944 945 trx_device_init(priv); 946 hostif_init(priv); 947 ks_wlan_net_start(netdev); 948 ks7010_init_defaults(priv); 949 } 950 951 static int ks7010_sdio_probe(struct sdio_func *func, 952 const struct sdio_device_id *device) 953 { 954 struct ks_wlan_private *priv = NULL; 955 struct net_device *netdev = NULL; 956 struct ks_sdio_card *card; 957 int ret; 958 959 card = kzalloc(sizeof(*card), GFP_KERNEL); 960 if (!card) 961 return -ENOMEM; 962 963 card->func = func; 964 965 sdio_claim_host(func); 966 967 ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE); 968 if (ret) 969 goto err_free_card; 970 971 dev_dbg(&card->func->dev, "multi_block=%d sdio_set_block_size()=%d %d\n", 972 func->card->cccr.multi_block, func->cur_blksize, ret); 973 974 ret = sdio_enable_func(func); 975 if (ret) 976 goto err_free_card; 977 978 ret = ks7010_sdio_setup_irqs(func); 979 if (ret) 980 goto err_disable_func; 981 982 sdio_release_host(func); 983 984 sdio_set_drvdata(func, card); 985 986 dev_dbg(&card->func->dev, "class = 0x%X, vendor = 0x%X, device = 0x%X\n", 987 func->class, func->vendor, func->device); 988 989 /* private memory allocate */ 990 netdev = alloc_etherdev(sizeof(*priv)); 991 if (!netdev) { 992 dev_err(&card->func->dev, "Unable to alloc new net device\n"); 993 goto err_release_irq; 994 } 995 996 ret = dev_alloc_name(netdev, "wlan%d"); 997 if (ret < 0) { 998 dev_err(&card->func->dev, "Couldn't get name!\n"); 999 goto err_free_netdev; 1000 } 1001 1002 priv = netdev_priv(netdev); 1003 1004 card->priv = priv; 1005 SET_NETDEV_DEV(netdev, &card->func->dev); 1006 1007 ks7010_private_init(priv, card, netdev); 1008 1009 ret = ks7010_upload_firmware(card); 1010 if (ret) { 1011 netdev_err(priv->net_dev, 1012 "firmware load failed !! ret = %d\n", ret); 1013 goto err_free_netdev; 1014 } 1015 1016 ks7010_sdio_init_irqs(func, priv); 1017 1018 priv->dev_state = DEVICE_STATE_BOOT; 1019 1020 priv->wq = alloc_workqueue("wq", WQ_MEM_RECLAIM, 1); 1021 if (!priv->wq) { 1022 netdev_err(priv->net_dev, "create_workqueue failed !!\n"); 1023 goto err_free_netdev; 1024 } 1025 1026 INIT_DELAYED_WORK(&priv->rw_dwork, ks7010_rw_function); 1027 ks7010_card_init(priv); 1028 1029 ret = register_netdev(priv->net_dev); 1030 if (ret) 1031 goto err_free_netdev; 1032 1033 return 0; 1034 1035 err_free_netdev: 1036 free_netdev(netdev); 1037 err_release_irq: 1038 sdio_claim_host(func); 1039 sdio_release_irq(func); 1040 err_disable_func: 1041 sdio_disable_func(func); 1042 err_free_card: 1043 sdio_release_host(func); 1044 sdio_set_drvdata(func, NULL); 1045 kfree(card); 1046 1047 return -ENODEV; 1048 } 1049 1050 /* send stop request to MAC */ 1051 static int send_stop_request(struct sdio_func *func) 1052 { 1053 struct hostif_stop_request *pp; 1054 struct ks_sdio_card *card; 1055 size_t size; 1056 1057 card = sdio_get_drvdata(func); 1058 1059 pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL); 1060 if (!pp) 1061 return -ENOMEM; 1062 1063 size = sizeof(*pp) - sizeof(pp->header.size); 1064 pp->header.size = cpu_to_le16(size); 1065 pp->header.event = cpu_to_le16(HIF_STOP_REQ); 1066 1067 sdio_claim_host(func); 1068 write_to_device(card->priv, (u8 *)pp, hif_align_size(sizeof(*pp))); 1069 sdio_release_host(func); 1070 1071 kfree(pp); 1072 return 0; 1073 } 1074 1075 static void ks7010_sdio_remove(struct sdio_func *func) 1076 { 1077 int ret; 1078 struct ks_sdio_card *card; 1079 struct ks_wlan_private *priv; 1080 1081 card = sdio_get_drvdata(func); 1082 1083 if (!card) 1084 return; 1085 1086 priv = card->priv; 1087 if (!priv) 1088 goto err_free_card; 1089 1090 ks_wlan_net_stop(priv->net_dev); 1091 1092 /* interrupt disable */ 1093 sdio_claim_host(func); 1094 sdio_writeb(func, 0, INT_ENABLE_REG, &ret); 1095 sdio_writeb(func, 0xff, INT_PENDING_REG, &ret); 1096 sdio_release_host(func); 1097 1098 ret = send_stop_request(func); 1099 if (ret) /* memory allocation failure */ 1100 goto err_free_card; 1101 1102 if (priv->wq) { 1103 flush_workqueue(priv->wq); 1104 destroy_workqueue(priv->wq); 1105 } 1106 1107 hostif_exit(priv); 1108 1109 unregister_netdev(priv->net_dev); 1110 1111 trx_device_exit(priv); 1112 free_netdev(priv->net_dev); 1113 card->priv = NULL; 1114 1115 sdio_claim_host(func); 1116 sdio_release_irq(func); 1117 sdio_disable_func(func); 1118 sdio_release_host(func); 1119 err_free_card: 1120 sdio_set_drvdata(func, NULL); 1121 kfree(card); 1122 } 1123 1124 static const struct sdio_device_id ks7010_sdio_ids[] = { 1125 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)}, 1126 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)}, 1127 { /* all zero */ } 1128 }; 1129 MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids); 1130 1131 static struct sdio_driver ks7010_sdio_driver = { 1132 .name = "ks7010_sdio", 1133 .id_table = ks7010_sdio_ids, 1134 .probe = ks7010_sdio_probe, 1135 .remove = ks7010_sdio_remove, 1136 }; 1137 1138 module_driver(ks7010_sdio_driver, sdio_register_driver, sdio_unregister_driver); 1139 MODULE_AUTHOR("Sang Engineering, Qi-Hardware, KeyStream"); 1140 MODULE_DESCRIPTION("Driver for KeyStream KS7010 based SDIO cards"); 1141 MODULE_LICENSE("GPL v2"); 1142 MODULE_FIRMWARE(ROM_FILE); 1143