1 // SPDX-License-Identifier: GPL-2.0
3 * Driver for KeyStream, KS7010 based SDIO cards.
5 * Copyright (C) 2006-2008 KeyStream Corp.
6 * Copyright (C) 2009 Renesas Technology Corp.
7 * Copyright (C) 2016 Sang Engineering, Wolfram Sang
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>
18 #include "ks_hostif.h"
20 #define ROM_FILE "ks7010sd.rom"
22 /* SDIO KeyStream vendor and device */
23 #define SDIO_VENDOR_ID_KS_CODE_A 0x005b
24 #define SDIO_VENDOR_ID_KS_CODE_B 0x0023
26 /* Older sources suggest earlier versions were named 7910 or 79xx */
27 #define SDIO_DEVICE_ID_KS_7010 0x7910
29 /* Read/Write Status Register */
30 #define READ_STATUS_REG 0x000000
31 #define WRITE_STATUS_REG 0x00000C
32 enum reg_status_type {
37 /* Read Index Register */
38 #define READ_INDEX_REG 0x000004
40 /* Read Data Size Register */
41 #define READ_DATA_SIZE_REG 0x000008
43 /* Write Index Register */
44 #define WRITE_INDEX_REG 0x000010
47 * Write Status/Read Data Size Register
48 * for network packet (less than 2048 bytes data)
50 #define WSTATUS_RSIZE_REG 0x000014
52 /* Write Status Register value */
53 #define WSTATUS_MASK 0x80
55 /* Read Data Size Register value [10:4] */
56 #define RSIZE_MASK 0x7F
58 /* ARM to SD interrupt Enable */
59 #define INT_ENABLE_REG 0x000020
60 /* ARM to SD interrupt Pending */
61 #define INT_PENDING_REG 0x000024
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)
72 /* General Communication Register A */
73 #define GCR_A_REG 0x000028
80 /* General Communication Register B */
81 #define GCR_B_REG 0x00002C
88 #define WAKEUP_REG 0x008018
89 #define WAKEUP_REQ 0x5a
91 /* AHB Data Window 0x010000-0x01FFFF */
92 #define DATA_WINDOW 0x010000
93 #define WINDOW_SIZE (64 * 1024)
95 #define KS7010_IRAM_ADDRESS 0x06000000
97 #define KS7010_IO_BLOCK_SIZE 512
100 * struct ks_sdio_card - SDIO device data.
102 * Structure is used as the &struct sdio_func private data.
104 * @func: Pointer to the SDIO function device.
105 * @priv: Pointer to the &struct net_device private data.
107 struct ks_sdio_card {
108 struct sdio_func *func;
109 struct ks_wlan_private *priv;
112 static struct sdio_func *ks7010_to_func(struct ks_wlan_private *priv)
114 struct ks_sdio_card *ks_sdio = priv->if_hw;
116 return ks_sdio->func;
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)
123 struct sdio_func *func = ks7010_to_func(priv);
126 *byte = sdio_readb(func, address, &ret);
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)
135 struct sdio_func *func = ks7010_to_func(priv);
137 return sdio_memcpy_fromio(func, buffer, address, length);
140 /* Write single byte to device address (CMD52) */
141 static int ks7010_sdio_writeb(struct ks_wlan_private *priv,
142 u32 address, u8 byte)
144 struct sdio_func *func = ks7010_to_func(priv);
147 sdio_writeb(func, byte, address, &ret);
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)
156 struct sdio_func *func = ks7010_to_func(priv);
158 return sdio_memcpy_toio(func, address, buffer, length);
161 static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
166 atomic_set(&priv->sleepstatus.doze_request, 0);
168 if (atomic_read(&priv->sleepstatus.status) == 0) {
169 ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
171 netdev_err(priv->net_dev, "write GCR_B_REG\n");
174 atomic_set(&priv->sleepstatus.status, 1);
175 priv->last_doze = jiffies;
179 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
182 static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
187 atomic_set(&priv->sleepstatus.wakeup_request, 0);
189 if (atomic_read(&priv->sleepstatus.status) == 1) {
190 ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
192 netdev_err(priv->net_dev, "write WAKEUP_REG\n");
195 atomic_set(&priv->sleepstatus.status, 0);
196 priv->last_wakeup = jiffies;
197 ++priv->wakeup_count;
201 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
204 void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
208 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
209 ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
211 netdev_err(priv->net_dev, "write WAKEUP_REG\n");
213 priv->last_wakeup = jiffies;
214 ++priv->wakeup_count;
218 static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
223 if (priv->reg.power_mgmt == POWER_MGMT_ACTIVE)
226 if (priv->reg.operation_mode != MODE_INFRASTRUCTURE)
229 if (!is_connect_status(priv->connect_status))
232 if (priv->dev_state != DEVICE_STATE_SLEEP)
235 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE)
238 netdev_dbg(priv->net_dev,
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),
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);
256 ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &byte);
258 netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
259 goto queue_delayed_work;
262 goto queue_delayed_work;
264 ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
266 netdev_err(priv->net_dev, "write GCR_B_REG\n");
267 goto queue_delayed_work;
269 atomic_set(&priv->psstatus.status, PS_SNOOZE);
274 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
277 int ks_wlan_hw_power_save(struct ks_wlan_private *priv)
279 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
283 static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
285 void (*complete_handler)(struct ks_wlan_private *priv,
286 struct sk_buff *skb),
289 struct tx_device_buffer *sp;
292 if (priv->dev_state < DEVICE_STATE_BOOT) {
297 if ((TX_DEVICE_BUFF_SIZE - 1) <= txq_count(priv)) {
298 netdev_err(priv->net_dev, "tx buffer overflow\n");
303 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
306 sp->complete_handler = complete_handler;
314 if (complete_handler)
315 (*complete_handler)(priv, skb);
321 static int write_to_device(struct ks_wlan_private *priv, u8 *buffer,
324 struct hostif_hdr *hdr;
327 hdr = (struct hostif_hdr *)buffer;
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);
335 ret = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
337 netdev_err(priv->net_dev, "write DATA_WINDOW\n");
341 ret = ks7010_sdio_writeb(priv, WRITE_STATUS_REG, REG_STATUS_BUSY);
343 netdev_err(priv->net_dev, "write WRITE_STATUS_REG\n");
350 static void tx_device_task(struct ks_wlan_private *priv)
352 struct tx_device_buffer *sp;
355 if (!txq_has_space(priv) ||
356 atomic_read(&priv->psstatus.status) == PS_SNOOZE)
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);
363 netdev_err(priv->net_dev,
364 "write_to_device error !!(%d)\n", ret);
365 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
370 if (sp->complete_handler) /* TX Complete */
371 (*sp->complete_handler)(priv, sp->skb);
374 if (txq_has_space(priv))
375 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
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),
384 struct hostif_hdr *hdr;
386 hdr = (struct hostif_hdr *)p;
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);
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;
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);
402 if (txq_has_space(priv))
403 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
408 static void rx_event_task(unsigned long dev)
410 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
411 struct rx_device_buffer *rp;
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);
418 if (rxq_has_space(priv))
419 tasklet_schedule(&priv->rx_bh_task);
423 static void ks_wlan_hw_rx(struct ks_wlan_private *priv, size_t size)
426 struct rx_device_buffer *rx_buffer;
427 struct hostif_hdr *hdr;
431 if (rxq_count(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
432 netdev_err(priv->net_dev, "rx buffer overflow\n");
435 rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];
437 ret = ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0],
438 hif_align_size(size));
443 if (size > 2046 || size == 0) {
445 print_hex_dump_bytes("INVALID DATA dump: ",
447 rx_buffer->data, 32);
449 ret = ks7010_sdio_writeb(priv, READ_STATUS_REG,
452 netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
454 /* length check fail */
458 hdr = (struct hostif_hdr *)&rx_buffer->data[0];
459 rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
460 event = le16_to_cpu(hdr->event);
463 ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE);
465 netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
467 if (atomic_read(&priv->psstatus.confirm_wait) && is_hif_conf(event)) {
468 netdev_dbg(priv->net_dev, "IS_HIF_CONF true !!\n");
469 atomic_dec(&priv->psstatus.confirm_wait);
472 tasklet_schedule(&priv->rx_bh_task);
475 static void ks7010_rw_function(struct work_struct *work)
477 struct ks_wlan_private *priv = container_of(work,
478 struct ks_wlan_private,
480 struct sdio_func *func = ks7010_to_func(priv);
484 /* wait after DOZE */
485 if (time_after(priv->last_doze + msecs_to_jiffies(30), jiffies)) {
486 netdev_dbg(priv->net_dev, "wait after DOZE\n");
487 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
491 /* wait after WAKEUP */
492 while (time_after(priv->last_wakeup + msecs_to_jiffies(30), jiffies)) {
493 netdev_dbg(priv->net_dev, "wait after WAKEUP\n");
494 dev_info(&func->dev, "wake: %lu %lu\n",
495 priv->last_wakeup + msecs_to_jiffies(30), jiffies);
499 sdio_claim_host(func);
501 /* power save wakeup */
502 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
503 if (txq_has_space(priv)) {
504 ks_wlan_hw_wakeup_request(priv);
505 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
510 /* sleep mode doze */
511 if (atomic_read(&priv->sleepstatus.doze_request) == 1) {
512 ks_wlan_hw_sleep_doze_request(priv);
515 /* sleep mode wakeup */
516 if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) {
517 ks_wlan_hw_sleep_wakeup_request(priv);
521 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
522 ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
524 netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG psstatus=%d\n",
525 atomic_read(&priv->psstatus.status));
529 if (byte & RSIZE_MASK) { /* Read schedule */
530 ks_wlan_hw_rx(priv, (size_t)((byte & RSIZE_MASK) << 4));
532 if ((byte & WSTATUS_MASK))
533 tx_device_task(priv);
535 _ks_wlan_hw_power_save(priv);
538 sdio_release_host(func);
541 static void ks_sdio_interrupt(struct sdio_func *func)
544 struct ks_sdio_card *card;
545 struct ks_wlan_private *priv;
546 u8 status, rsize, byte;
548 card = sdio_get_drvdata(func);
551 if (priv->dev_state < DEVICE_STATE_BOOT)
552 goto queue_delayed_work;
554 ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &status);
556 netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
557 goto queue_delayed_work;
560 /* schedule task for interrupt status */
561 /* bit7 -> Write General Communication B register */
562 /* read (General Communication B register) */
563 /* bit5 -> Write Status Idle */
564 /* bit2 -> Read Status Busy */
565 if (status & INT_GCR_B ||
566 atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
567 ret = ks7010_sdio_readb(priv, GCR_B_REG, &byte);
569 netdev_err(priv->net_dev, "read GCR_B_REG\n");
570 goto queue_delayed_work;
572 if (byte == GCR_B_ACTIVE) {
573 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
574 atomic_set(&priv->psstatus.status, PS_WAKEUP);
575 priv->wakeup_count = 0;
577 complete(&priv->psstatus.wakeup_wait);
582 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
583 ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
585 netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG\n");
586 goto queue_delayed_work;
588 rsize = byte & RSIZE_MASK;
589 if (rsize != 0) /* Read schedule */
590 ks_wlan_hw_rx(priv, (size_t)(rsize << 4));
592 if (byte & WSTATUS_MASK) {
593 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
594 if (txq_has_space(priv)) {
595 ks_wlan_hw_wakeup_request(priv);
596 queue_delayed_work(priv->wq,
601 tx_device_task(priv);
607 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
610 static int trx_device_init(struct ks_wlan_private *priv)
612 priv->tx_dev.qhead = 0;
613 priv->tx_dev.qtail = 0;
615 priv->rx_dev.qhead = 0;
616 priv->rx_dev.qtail = 0;
618 spin_lock_init(&priv->tx_dev.tx_dev_lock);
619 spin_lock_init(&priv->rx_dev.rx_dev_lock);
621 tasklet_init(&priv->rx_bh_task, rx_event_task, (unsigned long)priv);
626 static void trx_device_exit(struct ks_wlan_private *priv)
628 struct tx_device_buffer *sp;
630 /* tx buffer clear */
631 while (txq_has_space(priv)) {
632 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
634 if (sp->complete_handler) /* TX Complete */
635 (*sp->complete_handler)(priv, sp->skb);
639 tasklet_kill(&priv->rx_bh_task);
642 static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
645 unsigned char *data_buf;
647 data_buf = kmemdup(&index, sizeof(u32), GFP_KERNEL);
651 ret = ks7010_sdio_write(priv, WRITE_INDEX_REG, data_buf, sizeof(index));
653 goto err_free_data_buf;
655 ret = ks7010_sdio_write(priv, READ_INDEX_REG, data_buf, sizeof(index));
657 goto err_free_data_buf;
667 #define ROM_BUFF_SIZE (64 * 1024)
668 static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
669 u8 *data, unsigned int size)
674 read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
678 ret = ks7010_sdio_read(priv, address, read_buf, size);
680 goto err_free_read_buf;
682 if (memcmp(data, read_buf, size) != 0) {
684 netdev_err(priv->net_dev, "data compare error (%d)\n", ret);
685 goto err_free_read_buf;
696 static int ks7010_copy_firmware(struct ks_wlan_private *priv,
697 const struct firmware *fw_entry)
706 rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
710 length = fw_entry->size;
713 if (length >= ROM_BUFF_SIZE) {
714 size = ROM_BUFF_SIZE;
715 length = length - ROM_BUFF_SIZE;
723 memcpy(rom_buf, fw_entry->data + n, size);
726 ret = ks7010_sdio_update_index(priv,
727 KS7010_IRAM_ADDRESS + offset);
731 ret = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
735 ret = ks7010_sdio_data_compare(priv,
736 DATA_WINDOW, rom_buf, size);
744 ret = ks7010_sdio_writeb(priv, GCR_A_REG, GCR_A_REMAP);
751 static int ks7010_upload_firmware(struct ks_sdio_card *card)
753 struct ks_wlan_private *priv = card->priv;
754 struct sdio_func *func = ks7010_to_func(priv);
758 const struct firmware *fw_entry = NULL;
760 sdio_claim_host(func);
762 /* Firmware running ? */
763 ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
766 if (byte == GCR_A_RUN) {
767 netdev_dbg(priv->net_dev, "MAC firmware running ...\n");
772 ret = request_firmware(&fw_entry, ROM_FILE,
777 ret = ks7010_copy_firmware(priv, fw_entry);
779 goto release_firmware;
781 /* Firmware running check */
782 for (n = 0; n < 50; ++n) {
783 usleep_range(10000, 11000); /* wait_ms(10); */
784 ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
786 goto release_firmware;
788 if (byte == GCR_A_RUN)
792 netdev_err(priv->net_dev, "firmware can't start\n");
794 goto release_firmware;
800 release_firmware(fw_entry);
802 sdio_release_host(func);
807 static void ks7010_sme_enqueue_events(struct ks_wlan_private *priv)
809 static const u16 init_events[] = {
810 SME_GET_EEPROM_CKSUM, SME_STOP_REQUEST,
811 SME_RTS_THRESHOLD_REQUEST, SME_FRAGMENTATION_THRESHOLD_REQUEST,
812 SME_WEP_INDEX_REQUEST, SME_WEP_KEY1_REQUEST,
813 SME_WEP_KEY2_REQUEST, SME_WEP_KEY3_REQUEST,
814 SME_WEP_KEY4_REQUEST, SME_WEP_FLAG_REQUEST,
815 SME_RSN_ENABLED_REQUEST, SME_MODE_SET_REQUEST,
820 for (ev = 0; ev < ARRAY_SIZE(init_events); ev++)
821 hostif_sme_enqueue(priv, init_events[ev]);
824 static void ks7010_card_init(struct ks_wlan_private *priv)
826 init_completion(&priv->confirm_wait);
828 /* get mac address & firmware version */
829 hostif_sme_enqueue(priv, SME_START);
831 if (!wait_for_completion_interruptible_timeout
832 (&priv->confirm_wait, 5 * HZ)) {
833 netdev_dbg(priv->net_dev, "wait time out!! SME_START\n");
836 if (priv->mac_address_valid && priv->version_size != 0)
837 priv->dev_state = DEVICE_STATE_PREINIT;
839 ks7010_sme_enqueue_events(priv);
841 if (!wait_for_completion_interruptible_timeout
842 (&priv->confirm_wait, 5 * HZ)) {
843 netdev_dbg(priv->net_dev, "wait time out!! wireless parameter set\n");
846 if (priv->dev_state >= DEVICE_STATE_PREINIT) {
847 netdev_dbg(priv->net_dev, "DEVICE READY!!\n");
848 priv->dev_state = DEVICE_STATE_READY;
852 static void ks7010_init_defaults(struct ks_wlan_private *priv)
854 priv->reg.tx_rate = TX_RATE_AUTO;
855 priv->reg.preamble = LONG_PREAMBLE;
856 priv->reg.power_mgmt = POWER_MGMT_ACTIVE;
857 priv->reg.scan_type = ACTIVE_SCAN;
858 priv->reg.beacon_lost_count = 20;
859 priv->reg.rts = 2347UL;
860 priv->reg.fragment = 2346UL;
861 priv->reg.phy_type = D_11BG_COMPATIBLE_MODE;
862 priv->reg.cts_mode = CTS_MODE_FALSE;
863 priv->reg.rate_set.body[11] = TX_RATE_54M;
864 priv->reg.rate_set.body[10] = TX_RATE_48M;
865 priv->reg.rate_set.body[9] = TX_RATE_36M;
866 priv->reg.rate_set.body[8] = TX_RATE_18M;
867 priv->reg.rate_set.body[7] = TX_RATE_9M;
868 priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
869 priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
870 priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
871 priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
872 priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
873 priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
874 priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
875 priv->reg.tx_rate = TX_RATE_FULL_AUTO;
876 priv->reg.rate_set.size = 12;
879 static int ks7010_sdio_setup_irqs(struct sdio_func *func)
883 /* interrupt disable */
884 sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
888 sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
892 /* setup interrupt handler */
893 ret = sdio_claim_irq(func, ks_sdio_interrupt);
899 static void ks7010_sdio_init_irqs(struct sdio_func *func,
900 struct ks_wlan_private *priv)
907 * clear Interrupt status write
908 * (ARMtoSD_InterruptPending FN1:00_0024)
910 sdio_claim_host(func);
911 ret = ks7010_sdio_writeb(priv, INT_PENDING_REG, 0xff);
912 sdio_release_host(func);
914 netdev_err(priv->net_dev, "write INT_PENDING_REG\n");
916 /* enable ks7010sdio interrupt */
917 byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
918 sdio_claim_host(func);
919 ret = ks7010_sdio_writeb(priv, INT_ENABLE_REG, byte);
920 sdio_release_host(func);
922 netdev_err(priv->net_dev, "write INT_ENABLE_REG\n");
925 static void ks7010_private_init(struct ks_wlan_private *priv,
926 struct ks_sdio_card *card,
927 struct net_device *netdev)
929 /* private memory initialize */
932 priv->dev_state = DEVICE_STATE_PREBOOT;
933 priv->net_dev = netdev;
934 priv->firmware_version[0] = '\0';
935 priv->version_size = 0;
936 priv->last_doze = jiffies;
937 priv->last_wakeup = jiffies;
938 memset(&priv->nstats, 0, sizeof(priv->nstats));
939 memset(&priv->wstats, 0, sizeof(priv->wstats));
942 atomic_set(&priv->sleepstatus.doze_request, 0);
943 atomic_set(&priv->sleepstatus.wakeup_request, 0);
944 atomic_set(&priv->sleepstatus.wakeup_request, 0);
946 trx_device_init(priv);
948 ks_wlan_net_start(netdev);
949 ks7010_init_defaults(priv);
952 static int ks7010_sdio_probe(struct sdio_func *func,
953 const struct sdio_device_id *device)
955 struct ks_wlan_private *priv = NULL;
956 struct net_device *netdev = NULL;
957 struct ks_sdio_card *card;
960 card = kzalloc(sizeof(*card), GFP_KERNEL);
966 sdio_claim_host(func);
968 ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
972 dev_dbg(&card->func->dev, "multi_block=%d sdio_set_block_size()=%d %d\n",
973 func->card->cccr.multi_block, func->cur_blksize, ret);
975 ret = sdio_enable_func(func);
979 ret = ks7010_sdio_setup_irqs(func);
981 goto err_disable_func;
983 sdio_release_host(func);
985 sdio_set_drvdata(func, card);
987 dev_dbg(&card->func->dev, "class = 0x%X, vendor = 0x%X, device = 0x%X\n",
988 func->class, func->vendor, func->device);
990 /* private memory allocate */
991 netdev = alloc_etherdev(sizeof(*priv));
993 dev_err(&card->func->dev, "Unable to alloc new net device\n");
994 goto err_release_irq;
997 ret = dev_alloc_name(netdev, "wlan%d");
999 dev_err(&card->func->dev, "Couldn't get name!\n");
1000 goto err_free_netdev;
1003 priv = netdev_priv(netdev);
1006 SET_NETDEV_DEV(netdev, &card->func->dev);
1008 ks7010_private_init(priv, card, netdev);
1010 ret = ks7010_upload_firmware(card);
1012 netdev_err(priv->net_dev,
1013 "firmware load failed !! ret = %d\n", ret);
1014 goto err_free_netdev;
1017 ks7010_sdio_init_irqs(func, priv);
1019 priv->dev_state = DEVICE_STATE_BOOT;
1021 priv->wq = alloc_workqueue("wq", WQ_MEM_RECLAIM, 1);
1023 netdev_err(priv->net_dev, "create_workqueue failed !!\n");
1024 goto err_free_netdev;
1027 INIT_DELAYED_WORK(&priv->rw_dwork, ks7010_rw_function);
1028 ks7010_card_init(priv);
1030 ret = register_netdev(priv->net_dev);
1032 goto err_free_netdev;
1037 free_netdev(netdev);
1039 sdio_claim_host(func);
1040 sdio_release_irq(func);
1042 sdio_disable_func(func);
1044 sdio_release_host(func);
1045 sdio_set_drvdata(func, NULL);
1051 /* send stop request to MAC */
1052 static int send_stop_request(struct sdio_func *func)
1054 struct hostif_stop_request *pp;
1055 struct ks_sdio_card *card;
1058 card = sdio_get_drvdata(func);
1060 pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
1064 size = sizeof(*pp) - sizeof(pp->header.size);
1065 pp->header.size = cpu_to_le16(size);
1066 pp->header.event = cpu_to_le16(HIF_STOP_REQ);
1068 sdio_claim_host(func);
1069 write_to_device(card->priv, (u8 *)pp, hif_align_size(sizeof(*pp)));
1070 sdio_release_host(func);
1076 static void ks7010_sdio_remove(struct sdio_func *func)
1079 struct ks_sdio_card *card;
1080 struct ks_wlan_private *priv;
1082 card = sdio_get_drvdata(func);
1091 ks_wlan_net_stop(priv->net_dev);
1093 /* interrupt disable */
1094 sdio_claim_host(func);
1095 sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
1096 sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
1097 sdio_release_host(func);
1099 ret = send_stop_request(func);
1100 if (ret) /* memory allocation failure */
1104 flush_workqueue(priv->wq);
1105 destroy_workqueue(priv->wq);
1110 unregister_netdev(priv->net_dev);
1112 trx_device_exit(priv);
1113 free_netdev(priv->net_dev);
1116 sdio_claim_host(func);
1117 sdio_release_irq(func);
1118 sdio_disable_func(func);
1119 sdio_release_host(func);
1121 sdio_set_drvdata(func, NULL);
1125 static const struct sdio_device_id ks7010_sdio_ids[] = {
1126 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
1127 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
1130 MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids);
1132 static struct sdio_driver ks7010_sdio_driver = {
1133 .name = "ks7010_sdio",
1134 .id_table = ks7010_sdio_ids,
1135 .probe = ks7010_sdio_probe,
1136 .remove = ks7010_sdio_remove,
1139 module_driver(ks7010_sdio_driver, sdio_register_driver, sdio_unregister_driver);
1140 MODULE_AUTHOR("Sang Engineering, Qi-Hardware, KeyStream");
1141 MODULE_DESCRIPTION("Driver for KeyStream KS7010 based SDIO cards");
1142 MODULE_LICENSE("GPL v2");
1143 MODULE_FIRMWARE(ROM_FILE);