2 * Driver for KeyStream, KS7010 based SDIO cards.
4 * Copyright (C) 2006-2008 KeyStream Corp.
5 * Copyright (C) 2009 Renesas Technology Corp.
6 * Copyright (C) 2016 Sang Engineering, Wolfram Sang
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/firmware.h>
14 #include <linux/mmc/card.h>
15 #include <linux/mmc/sdio_func.h>
16 #include <linux/workqueue.h>
17 #include <linux/atomic.h>
20 #include "ks_wlan_ioctl.h"
21 #include "ks_hostif.h"
22 #include "ks7010_sdio.h"
24 #define KS7010_FUNC_NUM 1
25 #define KS7010_IO_BLOCK_SIZE 512
26 #define KS7010_MAX_CLOCK 25000000
28 static const struct sdio_device_id ks7010_sdio_ids[] = {
29 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
30 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
33 MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids);
35 #define inc_txqhead(priv) \
36 (priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE)
37 #define inc_txqtail(priv) \
38 (priv->tx_dev.qtail = (priv->tx_dev.qtail + 1) % TX_DEVICE_BUFF_SIZE)
39 #define cnt_txqbody(priv) \
40 (((priv->tx_dev.qtail + TX_DEVICE_BUFF_SIZE) - (priv->tx_dev.qhead)) % TX_DEVICE_BUFF_SIZE)
42 #define inc_rxqhead(priv) \
43 (priv->rx_dev.qhead = (priv->rx_dev.qhead + 1) % RX_DEVICE_BUFF_SIZE)
44 #define inc_rxqtail(priv) \
45 (priv->rx_dev.qtail = (priv->rx_dev.qtail + 1) % RX_DEVICE_BUFF_SIZE)
46 #define cnt_rxqbody(priv) \
47 (((priv->rx_dev.qtail + RX_DEVICE_BUFF_SIZE) - (priv->rx_dev.qhead)) % RX_DEVICE_BUFF_SIZE)
49 /* Read single byte from device address into byte (CMD52) */
50 static int ks7010_sdio_readb(struct ks_wlan_private *priv, unsigned int address,
53 struct sdio_func *func = priv->ks_sdio_card->func;
56 *byte = sdio_readb(func, address, &ret);
61 /* Read length bytes from device address into buffer (CMD53) */
62 static int ks7010_sdio_read(struct ks_wlan_private *priv, unsigned int address,
63 unsigned char *buffer, int length)
65 struct sdio_func *func = priv->ks_sdio_card->func;
67 return sdio_memcpy_fromio(func, buffer, address, length);
70 /* Write single byte to device address (CMD52) */
71 static int ks7010_sdio_writeb(struct ks_wlan_private *priv,
72 unsigned int address, unsigned char byte)
74 struct sdio_func *func = priv->ks_sdio_card->func;
77 sdio_writeb(func, byte, address, &ret);
82 /* Write length bytes to device address from buffer (CMD53) */
83 static int ks7010_sdio_write(struct ks_wlan_private *priv, unsigned int address,
84 unsigned char *buffer, int length)
86 struct sdio_func *func = priv->ks_sdio_card->func;
88 return sdio_memcpy_toio(func, address, buffer, length);
91 static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
98 atomic_set(&priv->sleepstatus.doze_request, 0);
100 if (atomic_read(&priv->sleepstatus.status) == 0) {
101 ret = ks7010_sdio_writeb(priv, GCR_B, GCR_B_DOZE);
103 DPRINTK(1, " error : GCR_B\n");
106 DPRINTK(3, "sleep_mode=SLP_SLEEP\n");
107 atomic_set(&priv->sleepstatus.status, 1);
108 priv->last_doze = jiffies;
110 DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
114 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
117 static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
124 atomic_set(&priv->sleepstatus.wakeup_request, 0);
126 if (atomic_read(&priv->sleepstatus.status) == 1) {
127 ret = ks7010_sdio_writeb(priv, WAKEUP, WAKEUP_REQ);
129 DPRINTK(1, " error : WAKEUP\n");
132 DPRINTK(4, "wake up : WAKEUP\n");
133 atomic_set(&priv->sleepstatus.status, 0);
134 priv->last_wakeup = jiffies;
135 ++priv->wakeup_count;
137 DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
141 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
144 void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
149 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
150 ret = ks7010_sdio_writeb(priv, WAKEUP, WAKEUP_REQ);
152 DPRINTK(1, " error : WAKEUP\n");
154 DPRINTK(4, "wake up : WAKEUP\n");
156 priv->last_wakeup = jiffies;
157 ++priv->wakeup_count;
159 DPRINTK(1, "psstatus=%d\n",
160 atomic_read(&priv->psstatus.status));
164 static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
169 if (priv->reg.power_mgmt == POWER_MGMT_ACTIVE)
172 if (priv->reg.operation_mode != MODE_INFRASTRUCTURE)
175 if (!is_connect_status(priv->connect_status))
178 if (priv->dev_state != DEVICE_STATE_SLEEP)
181 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE)
184 DPRINTK(5, "\npsstatus.status=%d\npsstatus.confirm_wait=%d\npsstatus.snooze_guard=%d\ncnt_txqbody=%d\n",
185 atomic_read(&priv->psstatus.status),
186 atomic_read(&priv->psstatus.confirm_wait),
187 atomic_read(&priv->psstatus.snooze_guard),
190 if (atomic_read(&priv->psstatus.confirm_wait) ||
191 atomic_read(&priv->psstatus.snooze_guard) ||
193 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
197 ret = ks7010_sdio_readb(priv, INT_PENDING, &byte);
199 DPRINTK(1, " error : INT_PENDING\n");
200 goto queue_delayed_work;
203 goto queue_delayed_work;
205 ret = ks7010_sdio_writeb(priv, GCR_B, GCR_B_DOZE);
207 DPRINTK(1, " error : GCR_B\n");
208 goto queue_delayed_work;
210 atomic_set(&priv->psstatus.status, PS_SNOOZE);
211 DPRINTK(3, "psstatus.status=PS_SNOOZE\n");
216 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
219 int ks_wlan_hw_power_save(struct ks_wlan_private *priv)
221 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
225 static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
227 void (*complete_handler)(struct ks_wlan_private *priv,
228 struct sk_buff *skb),
231 struct tx_device_buffer *sp;
234 if (priv->dev_state < DEVICE_STATE_BOOT) {
239 if ((TX_DEVICE_BUFF_SIZE - 1) <= cnt_txqbody(priv)) {
240 DPRINTK(1, "tx buffer overflow\n");
245 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
248 sp->complete_handler = complete_handler;
256 if (complete_handler)
257 (*complete_handler)(priv, skb);
263 static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer,
266 struct hostif_hdr *hdr;
269 hdr = (struct hostif_hdr *)buffer;
271 DPRINTK(4, "size=%d\n", hdr->size);
272 if (le16_to_cpu(hdr->event) < HIF_DATA_REQ ||
273 le16_to_cpu(hdr->event) > HIF_REQ_MAX) {
274 DPRINTK(1, "unknown event=%04X\n", hdr->event);
278 ret = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
280 DPRINTK(1, " write error : retval=%d\n", ret);
284 ret = ks7010_sdio_writeb(priv, WRITE_STATUS, REG_STATUS_BUSY);
286 DPRINTK(1, " error : WRITE_STATUS\n");
293 static void tx_device_task(struct ks_wlan_private *priv)
295 struct tx_device_buffer *sp;
299 if (cnt_txqbody(priv) <= 0 ||
300 atomic_read(&priv->psstatus.status) == PS_SNOOZE)
303 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
304 if (priv->dev_state >= DEVICE_STATE_BOOT) {
305 ret = write_to_device(priv, sp->sendp, sp->size);
307 DPRINTK(1, "write_to_device error !!(%d)\n", ret);
308 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
313 if (sp->complete_handler) /* TX Complete */
314 (*sp->complete_handler)(priv, sp->skb);
317 if (cnt_txqbody(priv) > 0)
318 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
321 int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size,
322 void (*complete_handler)(struct ks_wlan_private *priv,
323 struct sk_buff *skb),
327 struct hostif_hdr *hdr;
329 hdr = (struct hostif_hdr *)p;
331 if (le16_to_cpu(hdr->event) < HIF_DATA_REQ ||
332 le16_to_cpu(hdr->event) > HIF_REQ_MAX) {
333 DPRINTK(1, "unknown event=%04X\n", hdr->event);
337 /* add event to hostt buffer */
338 priv->hostt.buff[priv->hostt.qtail] = le16_to_cpu(hdr->event);
339 priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
341 DPRINTK(4, "event=%04X\n", hdr->event);
342 spin_lock(&priv->tx_dev.tx_dev_lock);
343 result = enqueue_txdev(priv, p, size, complete_handler, skb);
344 spin_unlock(&priv->tx_dev.tx_dev_lock);
346 if (cnt_txqbody(priv) > 0)
347 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
352 static void rx_event_task(unsigned long dev)
354 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
355 struct rx_device_buffer *rp;
359 if (cnt_rxqbody(priv) > 0 && priv->dev_state >= DEVICE_STATE_BOOT) {
360 rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
361 hostif_receive(priv, rp->data, rp->size);
364 if (cnt_rxqbody(priv) > 0)
365 tasklet_schedule(&priv->rx_bh_task);
369 static void ks_wlan_hw_rx(struct ks_wlan_private *priv, uint16_t size)
372 struct rx_device_buffer *rx_buffer;
373 struct hostif_hdr *hdr;
374 unsigned short event = 0;
379 if (cnt_rxqbody(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
380 DPRINTK(1, "rx buffer overflow\n");
383 rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];
385 ret = ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0],
386 hif_align_size(size));
391 if (size > 2046 || size == 0) {
393 if (KS_WLAN_DEBUG > 5)
394 print_hex_dump_bytes("INVALID DATA dump: ",
396 rx_buffer->data, 32);
398 ret = ks7010_sdio_writeb(priv, READ_STATUS, REG_STATUS_IDLE);
400 DPRINTK(1, " error : READ_STATUS\n");
402 /* length check fail */
406 hdr = (struct hostif_hdr *)&rx_buffer->data[0];
407 rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
408 event = le16_to_cpu(hdr->event);
411 ret = ks7010_sdio_writeb(priv, READ_STATUS, REG_STATUS_IDLE);
413 DPRINTK(1, " error : READ_STATUS\n");
415 if (atomic_read(&priv->psstatus.confirm_wait)) {
416 if (IS_HIF_CONF(event)) {
417 DPRINTK(4, "IS_HIF_CONF true !!\n");
418 atomic_dec(&priv->psstatus.confirm_wait);
422 tasklet_schedule(&priv->rx_bh_task);
425 static void ks7010_rw_function(struct work_struct *work)
427 struct ks_wlan_private *priv;
431 priv = container_of(work, struct ks_wlan_private, rw_dwork.work);
435 /* wait after DOZE */
436 if (time_after(priv->last_doze + ((30 * HZ) / 1000), jiffies)) {
437 DPRINTK(4, "wait after DOZE\n");
438 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
442 /* wait after WAKEUP */
443 while (time_after(priv->last_wakeup + ((30 * HZ) / 1000), jiffies)) {
444 DPRINTK(4, "wait after WAKEUP\n");
445 dev_info(&priv->ks_sdio_card->func->dev,
447 priv->last_wakeup + (30 * HZ) / 1000,
452 sdio_claim_host(priv->ks_sdio_card->func);
454 /* power save wakeup */
455 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
456 if (cnt_txqbody(priv) > 0) {
457 ks_wlan_hw_wakeup_request(priv);
458 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
463 /* sleep mode doze */
464 if (atomic_read(&priv->sleepstatus.doze_request) == 1) {
465 ks_wlan_hw_sleep_doze_request(priv);
468 /* sleep mode wakeup */
469 if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) {
470 ks_wlan_hw_sleep_wakeup_request(priv);
474 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
475 ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE, &byte);
477 DPRINTK(1, " error : WSTATUS_RSIZE psstatus=%d\n",
478 atomic_read(&priv->psstatus.status));
481 DPRINTK(4, "WSTATUS_RSIZE=%02X\n", byte);
483 if (byte & RSIZE_MASK) { /* Read schedule */
484 ks_wlan_hw_rx(priv, (uint16_t)((byte & RSIZE_MASK) << 4));
486 if ((byte & WSTATUS_MASK))
487 tx_device_task(priv);
489 _ks_wlan_hw_power_save(priv);
492 sdio_release_host(priv->ks_sdio_card->func);
495 static void ks_sdio_interrupt(struct sdio_func *func)
498 struct ks_sdio_card *card;
499 struct ks_wlan_private *priv;
500 unsigned char status, rsize, byte;
502 card = sdio_get_drvdata(func);
506 if (priv->dev_state < DEVICE_STATE_BOOT)
507 goto queue_delayed_work;
509 ret = ks7010_sdio_readb(priv, INT_PENDING, &status);
511 DPRINTK(1, "error : INT_PENDING\n");
512 goto queue_delayed_work;
514 DPRINTK(4, "INT_PENDING=%02X\n", status);
516 /* schedule task for interrupt status */
517 /* bit7 -> Write General Communication B register */
518 /* read (General Communication B register) */
519 /* bit5 -> Write Status Idle */
520 /* bit2 -> Read Status Busy */
521 if (status & INT_GCR_B ||
522 atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
523 ret = ks7010_sdio_readb(priv, GCR_B, &byte);
525 DPRINTK(1, " error : GCR_B\n");
526 goto queue_delayed_work;
528 if (byte == GCR_B_ACTIVE) {
529 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
530 atomic_set(&priv->psstatus.status, PS_WAKEUP);
531 priv->wakeup_count = 0;
533 complete(&priv->psstatus.wakeup_wait);
538 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
539 ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE, &byte);
541 DPRINTK(1, " error : WSTATUS_RSIZE\n");
542 goto queue_delayed_work;
544 DPRINTK(4, "WSTATUS_RSIZE=%02X\n", byte);
545 rsize = byte & RSIZE_MASK;
546 if (rsize != 0) /* Read schedule */
547 ks_wlan_hw_rx(priv, (uint16_t)(rsize << 4));
549 if (byte & WSTATUS_MASK) {
550 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
551 if (cnt_txqbody(priv)) {
552 ks_wlan_hw_wakeup_request(priv);
553 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
557 tx_device_task(priv);
563 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
566 static int trx_device_init(struct ks_wlan_private *priv)
568 priv->tx_dev.qhead = 0;
569 priv->tx_dev.qtail = 0;
571 priv->rx_dev.qhead = 0;
572 priv->rx_dev.qtail = 0;
574 spin_lock_init(&priv->tx_dev.tx_dev_lock);
575 spin_lock_init(&priv->rx_dev.rx_dev_lock);
577 tasklet_init(&priv->rx_bh_task, rx_event_task, (unsigned long)priv);
582 static void trx_device_exit(struct ks_wlan_private *priv)
584 struct tx_device_buffer *sp;
586 /* tx buffer clear */
587 while (cnt_txqbody(priv) > 0) {
588 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
590 if (sp->complete_handler) /* TX Complete */
591 (*sp->complete_handler)(priv, sp->skb);
595 tasklet_kill(&priv->rx_bh_task);
598 static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
601 unsigned char *data_buf;
603 data_buf = kmalloc(sizeof(u32), GFP_KERNEL);
607 memcpy(data_buf, &index, sizeof(index));
608 ret = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index));
610 goto err_free_data_buf;
612 ret = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index));
614 goto err_free_data_buf;
624 #define ROM_BUFF_SIZE (64 * 1024)
625 static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
626 unsigned char *data, unsigned int size)
629 unsigned char *read_buf;
631 read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
635 ret = ks7010_sdio_read(priv, address, read_buf, size);
637 goto err_free_read_buf;
639 if (memcmp(data, read_buf, size) != 0) {
641 DPRINTK(0, "data compare error (%d)\n", ret);
642 goto err_free_read_buf;
653 static int ks7010_upload_firmware(struct ks_sdio_card *card)
655 struct ks_wlan_private *priv = card->priv;
656 unsigned int size, offset, n = 0;
657 unsigned char *rom_buf;
658 unsigned char byte = 0;
661 const struct firmware *fw_entry = NULL;
663 rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
667 sdio_claim_host(card->func);
669 /* Firmware running ? */
670 ret = ks7010_sdio_readb(priv, GCR_A, &byte);
671 if (byte == GCR_A_RUN) {
672 DPRINTK(0, "MAC firmware running ...\n");
673 goto release_host_and_free;
676 ret = reject_firmware(&fw_entry, ROM_FILE,
677 &priv->ks_sdio_card->func->dev);
679 goto release_host_and_free;
681 length = fw_entry->size;
685 if (length >= ROM_BUFF_SIZE) {
686 size = ROM_BUFF_SIZE;
687 length = length - ROM_BUFF_SIZE;
692 DPRINTK(4, "size = %d\n", size);
695 memcpy(rom_buf, fw_entry->data + n, size);
698 ret = ks7010_sdio_update_index(priv, KS7010_IRAM_ADDRESS + offset);
700 goto release_firmware;
702 ret = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
704 goto release_firmware;
706 ret = ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size);
708 goto release_firmware;
714 ret = ks7010_sdio_writeb(priv, GCR_A, GCR_A_REMAP);
716 goto release_firmware;
718 DPRINTK(4, " REMAP Request : GCR_A\n");
720 /* Firmware running check */
721 for (n = 0; n < 50; ++n) {
722 mdelay(10); /* wait_ms(10); */
723 ret = ks7010_sdio_readb(priv, GCR_A, &byte);
725 goto release_firmware;
727 if (byte == GCR_A_RUN)
730 DPRINTK(4, "firmware wakeup (%d)!!!!\n", n);
732 DPRINTK(1, "firmware can't start\n");
734 goto release_firmware;
740 release_firmware(fw_entry);
741 release_host_and_free:
742 sdio_release_host(card->func);
748 static void ks7010_card_init(struct ks_wlan_private *priv)
750 DPRINTK(5, "\ncard_init_task()\n");
752 init_completion(&priv->confirm_wait);
754 DPRINTK(5, "init_completion()\n");
756 /* get mac address & firmware version */
757 hostif_sme_enqueue(priv, SME_START);
759 DPRINTK(5, "hostif_sme_enqueu()\n");
761 if (!wait_for_completion_interruptible_timeout
762 (&priv->confirm_wait, 5 * HZ)) {
763 DPRINTK(1, "wait time out!! SME_START\n");
766 if (priv->mac_address_valid && priv->version_size != 0)
767 priv->dev_state = DEVICE_STATE_PREINIT;
769 hostif_sme_enqueue(priv, SME_GET_EEPROM_CKSUM);
771 /* load initial wireless parameter */
772 hostif_sme_enqueue(priv, SME_STOP_REQUEST);
774 hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_REQUEST);
775 hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_REQUEST);
777 hostif_sme_enqueue(priv, SME_WEP_INDEX_REQUEST);
778 hostif_sme_enqueue(priv, SME_WEP_KEY1_REQUEST);
779 hostif_sme_enqueue(priv, SME_WEP_KEY2_REQUEST);
780 hostif_sme_enqueue(priv, SME_WEP_KEY3_REQUEST);
781 hostif_sme_enqueue(priv, SME_WEP_KEY4_REQUEST);
783 hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
784 hostif_sme_enqueue(priv, SME_RSN_ENABLED_REQUEST);
785 hostif_sme_enqueue(priv, SME_MODE_SET_REQUEST);
786 hostif_sme_enqueue(priv, SME_START_REQUEST);
788 if (!wait_for_completion_interruptible_timeout
789 (&priv->confirm_wait, 5 * HZ)) {
790 DPRINTK(1, "wait time out!! wireless parameter set\n");
793 if (priv->dev_state >= DEVICE_STATE_PREINIT) {
794 DPRINTK(1, "DEVICE READY!!\n");
795 priv->dev_state = DEVICE_STATE_READY;
797 DPRINTK(1, "dev_state=%d\n", priv->dev_state);
801 static void ks7010_init_defaults(struct ks_wlan_private *priv)
803 priv->reg.tx_rate = TX_RATE_AUTO;
804 priv->reg.preamble = LONG_PREAMBLE;
805 priv->reg.power_mgmt = POWER_MGMT_ACTIVE;
806 priv->reg.scan_type = ACTIVE_SCAN;
807 priv->reg.beacon_lost_count = 20;
808 priv->reg.rts = 2347UL;
809 priv->reg.fragment = 2346UL;
810 priv->reg.phy_type = D_11BG_COMPATIBLE_MODE;
811 priv->reg.cts_mode = CTS_MODE_FALSE;
812 priv->reg.rate_set.body[11] = TX_RATE_54M;
813 priv->reg.rate_set.body[10] = TX_RATE_48M;
814 priv->reg.rate_set.body[9] = TX_RATE_36M;
815 priv->reg.rate_set.body[8] = TX_RATE_18M;
816 priv->reg.rate_set.body[7] = TX_RATE_9M;
817 priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
818 priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
819 priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
820 priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
821 priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
822 priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
823 priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
824 priv->reg.tx_rate = TX_RATE_FULL_AUTO;
825 priv->reg.rate_set.size = 12;
828 static int ks7010_sdio_probe(struct sdio_func *func,
829 const struct sdio_device_id *device)
831 struct ks_wlan_private *priv;
832 struct ks_sdio_card *card;
833 struct net_device *netdev;
840 card = kzalloc(sizeof(*card), GFP_KERNEL);
846 sdio_claim_host(func);
848 ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
849 DPRINTK(5, "multi_block=%d sdio_set_block_size()=%d %d\n",
850 func->card->cccr.multi_block, func->cur_blksize, ret);
852 ret = sdio_enable_func(func);
853 DPRINTK(5, "sdio_enable_func() %d\n", ret);
857 /* interrupt disable */
858 sdio_writeb(func, 0, INT_ENABLE, &ret);
861 sdio_writeb(func, 0xff, INT_PENDING, &ret);
863 goto err_disable_func;
865 /* setup interrupt handler */
866 ret = sdio_claim_irq(func, ks_sdio_interrupt);
868 goto err_disable_func;
870 sdio_release_host(func);
872 sdio_set_drvdata(func, card);
874 DPRINTK(5, "class = 0x%X, vendor = 0x%X, device = 0x%X\n",
875 func->class, func->vendor, func->device);
877 /* private memory allocate */
878 netdev = alloc_etherdev(sizeof(*priv));
880 dev_err(&card->func->dev, "ks7010 : Unable to alloc new net device\n");
881 goto err_release_irq;
883 if (dev_alloc_name(netdev, "wlan%d") < 0) {
884 dev_err(&card->func->dev,
885 "ks7010 : Couldn't get name!\n");
886 goto err_free_netdev;
889 priv = netdev_priv(netdev);
892 SET_NETDEV_DEV(netdev, &card->func->dev); /* for create sysfs symlinks */
894 /* private memory initialize */
895 priv->ks_sdio_card = card;
897 priv->dev_state = DEVICE_STATE_PREBOOT;
898 priv->net_dev = netdev;
899 priv->firmware_version[0] = '\0';
900 priv->version_size = 0;
901 priv->last_doze = jiffies;
902 priv->last_wakeup = jiffies;
903 memset(&priv->nstats, 0, sizeof(priv->nstats));
904 memset(&priv->wstats, 0, sizeof(priv->wstats));
907 atomic_set(&priv->sleepstatus.status, 0);
908 atomic_set(&priv->sleepstatus.doze_request, 0);
909 atomic_set(&priv->sleepstatus.wakeup_request, 0);
911 trx_device_init(priv);
913 ks_wlan_net_start(netdev);
915 ks7010_init_defaults(priv);
917 ret = ks7010_upload_firmware(card);
919 dev_err(&card->func->dev,
920 "ks7010: firmware load failed !! return code = %d\n",
922 goto err_free_netdev;
925 /* interrupt setting */
926 /* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */
927 sdio_claim_host(func);
928 ret = ks7010_sdio_writeb(priv, INT_PENDING, 0xff);
929 sdio_release_host(func);
931 DPRINTK(1, " error : INT_PENDING\n");
933 /* enable ks7010sdio interrupt */
934 byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
935 sdio_claim_host(func);
936 ret = ks7010_sdio_writeb(priv, INT_ENABLE, byte);
937 sdio_release_host(func);
939 DPRINTK(1, " err : INT_ENABLE\n");
941 DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", byte);
942 priv->dev_state = DEVICE_STATE_BOOT;
944 priv->wq = create_workqueue("wq");
946 DPRINTK(1, "create_workqueue failed !!\n");
947 goto err_free_netdev;
950 INIT_DELAYED_WORK(&priv->rw_dwork, ks7010_rw_function);
951 ks7010_card_init(priv);
953 ret = register_netdev(priv->net_dev);
955 goto err_free_netdev;
960 free_netdev(priv->net_dev);
963 sdio_claim_host(func);
964 sdio_release_irq(func);
966 sdio_disable_func(func);
968 sdio_release_host(func);
969 sdio_set_drvdata(func, NULL);
975 /* send stop request to MAC */
976 static int send_stop_request(struct sdio_func *func)
978 struct hostif_stop_request_t *pp;
979 struct ks_sdio_card *card;
982 card = sdio_get_drvdata(func);
984 pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
986 DPRINTK(3, "allocate memory failed..\n");
990 size = sizeof(*pp) - sizeof(pp->header.size);
991 pp->header.size = cpu_to_le16((uint16_t)size);
992 pp->header.event = cpu_to_le16((uint16_t)HIF_STOP_REQ);
994 sdio_claim_host(func);
995 write_to_device(card->priv, (unsigned char *)pp,
996 hif_align_size(sizeof(*pp)));
997 sdio_release_host(func);
1003 static void ks7010_sdio_remove(struct sdio_func *func)
1006 struct ks_sdio_card *card;
1007 struct ks_wlan_private *priv;
1009 card = sdio_get_drvdata(func);
1014 DPRINTK(1, "priv = card->priv\n");
1017 struct net_device *netdev = priv->net_dev;
1019 ks_wlan_net_stop(netdev);
1020 DPRINTK(1, "ks_wlan_net_stop\n");
1022 /* interrupt disable */
1023 sdio_claim_host(func);
1024 sdio_writeb(func, 0, INT_ENABLE, &ret);
1025 sdio_writeb(func, 0xff, INT_PENDING, &ret);
1026 sdio_release_host(func);
1027 DPRINTK(1, "interrupt disable\n");
1029 ret = send_stop_request(func);
1030 if (ret) /* memory allocation failure */
1033 DPRINTK(1, "STOP Req\n");
1036 flush_workqueue(priv->wq);
1037 destroy_workqueue(priv->wq);
1039 DPRINTK(1, "destroy_workqueue(priv->wq);\n");
1042 DPRINTK(1, "hostif_exit\n");
1044 unregister_netdev(netdev);
1046 trx_device_exit(priv);
1047 free_netdev(priv->net_dev);
1051 sdio_claim_host(func);
1052 sdio_release_irq(func);
1053 DPRINTK(1, "sdio_release_irq()\n");
1054 sdio_disable_func(func);
1055 DPRINTK(1, "sdio_disable_func()\n");
1056 sdio_release_host(func);
1058 sdio_set_drvdata(func, NULL);
1061 DPRINTK(1, "kfree()\n");
1063 DPRINTK(5, " Bye !!\n");
1066 static struct sdio_driver ks7010_sdio_driver = {
1067 .name = "ks7010_sdio",
1068 .id_table = ks7010_sdio_ids,
1069 .probe = ks7010_sdio_probe,
1070 .remove = ks7010_sdio_remove,
1073 module_driver(ks7010_sdio_driver, sdio_register_driver, sdio_unregister_driver);
1074 MODULE_AUTHOR("Sang Engineering, Qi-Hardware, KeyStream");
1075 MODULE_DESCRIPTION("Driver for KeyStream KS7010 based SDIO cards");
1076 MODULE_LICENSE("GPL v2");