2 * Driver for KeyStream, KS7010 based SDIO cards.
5 * $Id: ks7010_sdio.c 996 2009-09-14 02:54:21Z sekine $
7 * Copyright (C) 2006-2008 KeyStream Corp.
8 * Copyright (C) 2009 Renesas Technology Corp.
10 * This program is free software; you can redistribute it and/or modify
11 * it undr the terms of the GNU General Public License version 2 as
12 * published by the Free Sotware Foundation.
15 #include <linux/workqueue.h>
16 #include <asm/atomic.h>
17 #include <linux/mmc/card.h>
18 #include <linux/mmc/sdio_func.h>
21 #include "ks_wlan_ioctl.h"
22 #include "ks_hostif.h"
24 #include "ks7010_sdio.h"
26 #define KS7010_FUNC_NUM 1
27 #define KS7010_IO_BLOCK_SIZE 512
28 #define KS7010_MAX_CLOCK 25000000
30 static int reg_net = 0;
32 static const struct sdio_device_id if_sdio_ids[] = {
33 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
34 {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
38 static int ks7910_sdio_probe(struct sdio_func *function,
39 const struct sdio_device_id *device);
40 static void ks7910_sdio_remove(struct sdio_func *function);
41 static void ks7010_rw_function(struct work_struct *work);
42 static int ks7010_sdio_read(struct ks_wlan_private *priv, unsigned int address,
43 unsigned char *buffer, int length);
44 static int ks7010_sdio_write(struct ks_wlan_private *priv, unsigned int address,
45 unsigned char *buffer, int length);
48 #define inc_txqhead(priv) \
49 ( priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE )
50 #define inc_txqtail(priv) \
51 ( priv->tx_dev.qtail = (priv->tx_dev.qtail + 1) % TX_DEVICE_BUFF_SIZE )
52 #define cnt_txqbody(priv) \
53 (((priv->tx_dev.qtail + TX_DEVICE_BUFF_SIZE) - (priv->tx_dev.qhead)) % TX_DEVICE_BUFF_SIZE )
55 #define inc_rxqhead(priv) \
56 ( priv->rx_dev.qhead = (priv->rx_dev.qhead + 1) % RX_DEVICE_BUFF_SIZE )
57 #define inc_rxqtail(priv) \
58 ( priv->rx_dev.qtail = (priv->rx_dev.qtail + 1) % RX_DEVICE_BUFF_SIZE )
59 #define cnt_rxqbody(priv) \
60 (((priv->rx_dev.qtail + RX_DEVICE_BUFF_SIZE) - (priv->rx_dev.qhead)) % RX_DEVICE_BUFF_SIZE )
62 void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
64 unsigned char rw_data;
70 atomic_set(&priv->sleepstatus.doze_request, 0);
72 if (atomic_read(&priv->sleepstatus.status) == 0) {
75 ks7010_sdio_write(priv, GCR_B, &rw_data, sizeof(rw_data));
77 DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
80 DPRINTK(4, "PMG SET!! : GCR_B=%02X\n", rw_data);
81 DPRINTK(3, "sleep_mode=SLP_SLEEP\n");
82 atomic_set(&priv->sleepstatus.status, 1);
83 priv->last_doze = jiffies;
85 DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
89 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
93 void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
95 unsigned char rw_data;
101 atomic_set(&priv->sleepstatus.wakeup_request, 0);
103 if (atomic_read(&priv->sleepstatus.status) == 1) {
104 rw_data = WAKEUP_REQ;
106 ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data));
108 DPRINTK(1, " error : WAKEUP=%02X\n", rw_data);
111 DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
112 atomic_set(&priv->sleepstatus.status, 0);
113 priv->last_wakeup = jiffies;
114 ++priv->wakeup_count;
116 DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
120 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
124 void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
126 unsigned char rw_data;
130 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
131 rw_data = WAKEUP_REQ;
133 ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data));
135 DPRINTK(1, " error : WAKEUP=%02X\n", rw_data);
137 DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
138 priv->last_wakeup = jiffies;
139 ++priv->wakeup_count;
141 DPRINTK(1, "psstatus=%d\n",
142 atomic_read(&priv->psstatus.status));
146 int _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
149 unsigned char rw_data;
152 if (priv->reg.powermgt == POWMGT_ACTIVE_MODE)
155 if (priv->reg.operation_mode == MODE_INFRASTRUCTURE &&
156 (priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
158 //DPRINTK(1,"psstatus.status=%d\n",atomic_read(&priv->psstatus.status));
159 if (priv->dev_state == DEVICE_STATE_SLEEP) {
160 switch (atomic_read(&priv->psstatus.status)) {
161 case PS_SNOOZE: /* 4 */
164 DPRINTK(5, "\npsstatus.status=%d\npsstatus.confirm_wait=%d\npsstatus.snooze_guard=%d\ncnt_txqbody=%d\n",
165 atomic_read(&priv->psstatus.status),
166 atomic_read(&priv->psstatus.confirm_wait),
167 atomic_read(&priv->psstatus.snooze_guard),
170 if (!atomic_read(&priv->psstatus.confirm_wait)
171 && !atomic_read(&priv->psstatus.snooze_guard)
172 && !cnt_txqbody(priv)) {
174 ks7010_sdio_read(priv, INT_PENDING,
179 " error : INT_PENDING=%02X\n",
181 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
182 &priv->ks_wlan_hw.rw_wq, 1);
186 rw_data = GCR_B_DOZE;
188 ks7010_sdio_write(priv,
194 " error : GCR_B=%02X\n",
197 (priv->ks_wlan_hw.ks7010sdio_wq,
198 &priv->ks_wlan_hw.rw_wq, 1);
202 "PMG SET!! : GCR_B=%02X\n",
204 atomic_set(&priv->psstatus.
207 "psstatus.status=PS_SNOOZE\n");
209 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
210 &priv->ks_wlan_hw.rw_wq, 1);
213 queue_delayed_work(priv->ks_wlan_hw.
215 &priv->ks_wlan_hw.rw_wq,
227 int ks_wlan_hw_power_save(struct ks_wlan_private *priv)
229 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
230 &priv->ks_wlan_hw.rw_wq, 1);
234 static int ks7010_sdio_read(struct ks_wlan_private *priv, unsigned int address,
235 unsigned char *buffer, int length)
238 struct ks_sdio_card *card;
240 card = priv->ks_wlan_hw.sdio_card;
242 if (length == 1) /* CMD52 */
243 *buffer = sdio_readb(card->func, address, &rc);
244 else /* CMD53 multi-block transfer */
245 rc = sdio_memcpy_fromio(card->func, buffer, address, length);
248 printk("sdio error erorr=%d size=%d\n", rc, length);
249 ++priv->sdio_error_count;
251 priv->sdio_error_count = 0;
257 static int ks7010_sdio_write(struct ks_wlan_private *priv, unsigned int address,
258 unsigned char *buffer, int length)
261 struct ks_sdio_card *card;
263 card = priv->ks_wlan_hw.sdio_card;
265 if (length == 1) /* CMD52 */
266 sdio_writeb(card->func, *buffer, (unsigned int)address, &rc);
268 rc = sdio_memcpy_toio(card->func, (unsigned int)address, buffer,
272 printk("sdio error erorr=%d size=%d\n", rc, length);
273 ++priv->sdio_error_count;
275 priv->sdio_error_count = 0;
281 static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
283 void (*complete_handler) (void *arg1, void *arg2),
284 void *arg1, void *arg2)
286 struct tx_device_buffer *sp;
288 if (priv->dev_state < DEVICE_STATE_BOOT) {
290 if (complete_handler != NULL)
291 (*complete_handler) (arg1, arg2);
295 if ((TX_DEVICE_BUFF_SIZE - 1) <= cnt_txqbody(priv)) {
296 /* in case of buffer overflow */
297 DPRINTK(1, "tx buffer overflow\n");
299 if (complete_handler != NULL)
300 (*complete_handler) (arg1, arg2);
304 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
307 sp->complete_handler = complete_handler;
316 static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer,
320 unsigned char rw_data;
321 struct hostif_hdr *hdr;
322 hdr = (struct hostif_hdr *)buffer;
325 DPRINTK(4, "size=%d\n", hdr->size);
326 if (hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event) {
327 DPRINTK(1, "unknown event=%04X\n", hdr->event);
331 retval = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
333 DPRINTK(1, " write error : retval=%d\n", retval);
337 rw_data = WRITE_STATUS_BUSY;
339 ks7010_sdio_write(priv, WRITE_STATUS, &rw_data, sizeof(rw_data));
341 DPRINTK(1, " error : WRITE_STATUS=%02X\n", rw_data);
348 static void tx_device_task(void *dev)
350 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
351 struct tx_device_buffer *sp;
355 if (cnt_txqbody(priv) > 0
356 && atomic_read(&priv->psstatus.status) != PS_SNOOZE) {
357 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
358 if (priv->dev_state >= DEVICE_STATE_BOOT) {
359 rc = write_to_device(priv, sp->sendp, sp->size);
361 DPRINTK(1, "write_to_device error !!(%d)\n",
363 queue_delayed_work(priv->ks_wlan_hw.
365 &priv->ks_wlan_hw.rw_wq, 1);
370 kfree(sp->sendp); /* allocated memory free */
371 if (sp->complete_handler != NULL) /* TX Complete */
372 (*sp->complete_handler) (sp->arg1, sp->arg2);
375 if (cnt_txqbody(priv) > 0) {
376 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
377 &priv->ks_wlan_hw.rw_wq, 0);
383 int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size,
384 void (*complete_handler) (void *arg1, void *arg2),
385 void *arg1, void *arg2)
388 struct hostif_hdr *hdr;
389 hdr = (struct hostif_hdr *)p;
391 if (hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event) {
392 DPRINTK(1, "unknown event=%04X\n", hdr->event);
396 /* add event to hostt buffer */
397 priv->hostt.buff[priv->hostt.qtail] = hdr->event;
398 priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
400 DPRINTK(4, "event=%04X\n", hdr->event);
401 spin_lock(&priv->tx_dev.tx_dev_lock);
402 result = enqueue_txdev(priv, p, size, complete_handler, arg1, arg2);
403 spin_unlock(&priv->tx_dev.tx_dev_lock);
405 if (cnt_txqbody(priv) > 0) {
406 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
407 &priv->ks_wlan_hw.rw_wq, 0);
412 static void rx_event_task(unsigned long dev)
414 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
415 struct rx_device_buffer *rp;
419 if (cnt_rxqbody(priv) > 0 && priv->dev_state >= DEVICE_STATE_BOOT) {
420 rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
421 hostif_receive(priv, rp->data, rp->size);
424 if (cnt_rxqbody(priv) > 0) {
425 tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);
432 static void ks_wlan_hw_rx(void *dev, uint16_t size)
434 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
436 struct rx_device_buffer *rx_buffer;
437 struct hostif_hdr *hdr;
438 unsigned char read_status;
439 unsigned short event = 0;
444 if (cnt_rxqbody(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
445 /* in case of buffer overflow */
446 DPRINTK(1, "rx buffer overflow \n");
449 rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];
452 ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0],
453 hif_align_size(size));
459 if (size > 2046 || size == 0) {
461 if (KS_WLAN_DEBUG > 5)
462 print_hex_dump_bytes("INVALID DATA dump: ",
464 rx_buffer->data, 32);
466 /* rx_status update */
467 read_status = READ_STATUS_IDLE;
469 ks7010_sdio_write(priv, READ_STATUS, &read_status,
470 sizeof(read_status));
472 DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
477 hdr = (struct hostif_hdr *)&rx_buffer->data[0];
478 rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
482 /* read status update */
483 read_status = READ_STATUS_IDLE;
485 ks7010_sdio_write(priv, READ_STATUS, &read_status,
486 sizeof(read_status));
488 DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
490 DPRINTK(4, "READ_STATUS=%02X\n", read_status);
492 if (atomic_read(&priv->psstatus.confirm_wait)) {
493 if (IS_HIF_CONF(event)) {
494 DPRINTK(4, "IS_HIF_CONF true !!\n");
495 atomic_dec(&priv->psstatus.confirm_wait);
499 /* rx_event_task((void *)priv); */
500 tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);
506 static void ks7010_rw_function(struct work_struct *work)
508 struct hw_info_t *hw;
509 struct ks_wlan_private *priv;
510 unsigned char rw_data;
513 hw = container_of(work, struct hw_info_t, rw_wq.work);
514 priv = container_of(hw, struct ks_wlan_private, ks_wlan_hw);
518 /* wiat after DOZE */
519 if (time_after(priv->last_doze + ((30 * HZ) / 1000), jiffies)) {
520 DPRINTK(4, "wait after DOZE \n");
521 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
522 &priv->ks_wlan_hw.rw_wq, 1);
526 /* wiat after WAKEUP */
527 while (time_after(priv->last_wakeup + ((30 * HZ) / 1000), jiffies)) {
528 DPRINTK(4, "wait after WAKEUP \n");
529 /* queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq,
530 (priv->last_wakeup + ((30*HZ)/1000) - jiffies));*/
531 printk("wake: %lu %lu\n", priv->last_wakeup + (30 * HZ) / 1000,
536 sdio_claim_host(priv->ks_wlan_hw.sdio_card->func);
538 /* power save wakeup */
539 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
540 if (cnt_txqbody(priv) > 0) {
541 ks_wlan_hw_wakeup_request(priv);
542 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
543 &priv->ks_wlan_hw.rw_wq, 1);
548 /* sleep mode doze */
549 if (atomic_read(&priv->sleepstatus.doze_request) == 1) {
550 ks_wlan_hw_sleep_doze_request(priv);
553 /* sleep mode wakeup */
554 if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) {
555 ks_wlan_hw_sleep_wakeup_request(priv);
559 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
561 ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data, sizeof(rw_data));
563 DPRINTK(1, " error : WSTATUS_RSIZE=%02X psstatus=%d\n", rw_data,
564 atomic_read(&priv->psstatus.status));
567 DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);
569 if (rw_data & RSIZE_MASK) { /* Read schedule */
570 ks_wlan_hw_rx((void *)priv,
571 (uint16_t) (((rw_data & RSIZE_MASK) << 4)));
573 if ((rw_data & WSTATUS_MASK)) {
574 tx_device_task((void *)priv);
576 _ks_wlan_hw_power_save(priv);
579 sdio_release_host(priv->ks_wlan_hw.sdio_card->func);
584 static void ks_sdio_interrupt(struct sdio_func *func)
587 struct ks_sdio_card *card;
588 struct ks_wlan_private *priv;
589 unsigned char status, rsize, rw_data;
591 card = sdio_get_drvdata(func);
595 if (priv->dev_state >= DEVICE_STATE_BOOT) {
597 ks7010_sdio_read(priv, INT_PENDING, &status,
600 DPRINTK(1, "read INT_PENDING Failed!!(%d)\n", retval);
603 DPRINTK(4, "INT_PENDING=%02X\n", rw_data);
605 /* schedule task for interrupt status */
606 /* bit7 -> Write General Communication B register */
607 /* read (General Communication B register) */
608 /* bit5 -> Write Status Idle */
609 /* bit2 -> Read Status Busy */
610 if (status & INT_GCR_B
611 || atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
613 ks7010_sdio_read(priv, GCR_B, &rw_data,
616 DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
619 /* DPRINTK(1, "GCR_B=%02X\n", rw_data); */
620 if (rw_data == GCR_B_ACTIVE) {
621 if (atomic_read(&priv->psstatus.status) ==
623 atomic_set(&priv->psstatus.status,
625 priv->wakeup_count = 0;
627 complete(&priv->psstatus.wakeup_wait);
633 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
635 ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data,
638 DPRINTK(1, " error : WSTATUS_RSIZE=%02X\n",
642 DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);
643 rsize = rw_data & RSIZE_MASK;
644 if (rsize) { /* Read schedule */
645 ks_wlan_hw_rx((void *)priv,
646 (uint16_t) (((rsize) << 4)));
648 if (rw_data & WSTATUS_MASK) {
650 if (status & INT_WRITE_STATUS
651 && !cnt_txqbody(priv)) {
652 /* dummy write for interrupt clear */
655 ks7010_sdio_write(priv, DATA_WINDOW,
660 "write DATA_WINDOW Failed!!(%d)\n",
663 status &= ~INT_WRITE_STATUS;
666 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
667 if (cnt_txqbody(priv)) {
668 ks_wlan_hw_wakeup_request(priv);
677 tx_device_task((void *)priv);
687 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
688 &priv->ks_wlan_hw.rw_wq, 0);
692 static int trx_device_init(struct ks_wlan_private *priv)
694 /* initialize values (tx) */
695 priv->tx_dev.qtail = priv->tx_dev.qhead = 0;
697 /* initialize values (rx) */
698 priv->rx_dev.qtail = priv->rx_dev.qhead = 0;
700 /* initialize spinLock (tx,rx) */
701 spin_lock_init(&priv->tx_dev.tx_dev_lock);
702 spin_lock_init(&priv->rx_dev.rx_dev_lock);
704 tasklet_init(&priv->ks_wlan_hw.rx_bh_task, rx_event_task,
705 (unsigned long)priv);
710 static void trx_device_exit(struct ks_wlan_private *priv)
712 struct tx_device_buffer *sp;
714 /* tx buffer clear */
715 while (cnt_txqbody(priv) > 0) {
716 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
717 kfree(sp->sendp); /* allocated memory free */
718 if (sp->complete_handler != NULL) /* TX Complete */
719 (*sp->complete_handler) (sp->arg1, sp->arg2);
723 tasklet_kill(&priv->ks_wlan_hw.rx_bh_task);
728 static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
732 unsigned char *data_buf;
735 data_buf = kmalloc(sizeof(u32), GFP_KERNEL);
741 memcpy(data_buf, &index, sizeof(index));
742 retval = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index));
748 retval = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index));
759 #define ROM_BUFF_SIZE (64*1024)
760 static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
761 unsigned char *data, unsigned int size)
765 unsigned char *read_buf;
767 read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
772 retval = ks7010_sdio_read(priv, address, read_buf, size);
777 retval = memcmp(data, read_buf, size);
780 DPRINTK(0, "data compare error (%d) \n", retval);
790 #include <linux/firmware.h>
791 static int ks79xx_upload_firmware(struct ks_wlan_private *priv,
792 struct ks_sdio_card *card)
794 unsigned int size, offset, n = 0;
795 unsigned char *rom_buf;
796 unsigned char rw_data = 0;
799 const struct firmware *fw_entry = NULL;
803 /* buffer allocate */
804 rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
810 sdio_claim_host(card->func);
812 /* Firmware running ? */
813 retval = ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
814 if (rw_data == GCR_A_RUN) {
815 DPRINTK(0, "MAC firmware running ...\n");
821 (&fw_entry, priv->reg.rom_file,
822 &priv->ks_wlan_hw.sdio_card->func->dev) != 0) {
823 DPRINTK(1, "error request_firmware() file=%s\n",
827 DPRINTK(4, "success request_firmware() file=%s size=%zu\n",
828 priv->reg.rom_file, fw_entry->size);
829 length = fw_entry->size;
834 if (length >= ROM_BUFF_SIZE) {
835 size = ROM_BUFF_SIZE;
836 length = length - ROM_BUFF_SIZE;
841 DPRINTK(4, "size = %d\n", size);
844 memcpy(rom_buf, fw_entry->data + n, size);
845 /* Update write index */
848 ks7010_sdio_update_index(priv,
849 KS7010_IRAM_ADDRESS + offset);
856 retval = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
864 ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size);
874 rw_data = GCR_A_REMAP;
875 retval = ks7010_sdio_write(priv, GCR_A, &rw_data, sizeof(rw_data));
880 DPRINTK(4, " REMAP Request : GCR_A=%02X\n", rw_data);
882 /* Firmware running check */
883 for (n = 0; n < 50; ++n) {
884 mdelay(10); /* wait_ms(10); */
886 ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
891 if (rw_data == GCR_A_RUN)
894 DPRINTK(4, "firmware wakeup (%d)!!!!\n", n);
896 DPRINTK(1, "firmware can't start\n");
904 release_firmware(fw_entry);
906 sdio_release_host(card->func);
912 static void ks7010_card_init(struct ks_wlan_private *priv)
914 DPRINTK(5, "\ncard_init_task()\n");
916 /* init_waitqueue_head(&priv->confirm_wait); */
917 init_completion(&priv->confirm_wait);
919 DPRINTK(5, "init_completion()\n");
921 /* get mac address & firmware version */
922 hostif_sme_enqueue(priv, SME_START);
924 DPRINTK(5, "hostif_sme_enqueu()\n");
926 if (!wait_for_completion_interruptible_timeout
927 (&priv->confirm_wait, 5 * HZ)) {
928 DPRINTK(1, "wait time out!! SME_START\n");
931 if (priv->mac_address_valid && priv->version_size) {
932 priv->dev_state = DEVICE_STATE_PREINIT;
935 hostif_sme_enqueue(priv, SME_GET_EEPROM_CKSUM);
937 /* load initial wireless parameter */
938 hostif_sme_enqueue(priv, SME_STOP_REQUEST);
940 hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_REQUEST);
941 hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_REQUEST);
943 hostif_sme_enqueue(priv, SME_WEP_INDEX_REQUEST);
944 hostif_sme_enqueue(priv, SME_WEP_KEY1_REQUEST);
945 hostif_sme_enqueue(priv, SME_WEP_KEY2_REQUEST);
946 hostif_sme_enqueue(priv, SME_WEP_KEY3_REQUEST);
947 hostif_sme_enqueue(priv, SME_WEP_KEY4_REQUEST);
949 hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
950 hostif_sme_enqueue(priv, SME_RSN_ENABLED_REQUEST);
951 hostif_sme_enqueue(priv, SME_MODE_SET_REQUEST);
952 hostif_sme_enqueue(priv, SME_START_REQUEST);
954 if (!wait_for_completion_interruptible_timeout
955 (&priv->confirm_wait, 5 * HZ)) {
956 DPRINTK(1, "wait time out!! wireless parameter set\n");
959 if (priv->dev_state >= DEVICE_STATE_PREINIT) {
960 DPRINTK(1, "DEVICE READY!!\n");
961 priv->dev_state = DEVICE_STATE_READY;
962 reg_net = register_netdev(priv->net_dev);
963 DPRINTK(3, "register_netdev=%d\n", reg_net);
965 DPRINTK(1, "dev_state=%d\n", priv->dev_state);
969 static struct sdio_driver ks7010_sdio_driver = {
970 .name = "ks7910_sdio",
971 .id_table = if_sdio_ids,
972 .probe = ks7910_sdio_probe,
973 .remove = ks7910_sdio_remove,
976 extern int ks_wlan_net_start(struct net_device *dev);
977 extern int ks_wlan_net_stop(struct net_device *dev);
979 static int ks7910_sdio_probe(struct sdio_func *func,
980 const struct sdio_device_id *device)
982 struct ks_wlan_private *priv;
983 struct ks_sdio_card *card;
984 struct net_device *netdev;
985 unsigned char rw_data;
988 DPRINTK(5, "ks7910_sdio_probe()\n");
993 /* initilize ks_sdio_card */
994 card = kzalloc(sizeof(struct ks_sdio_card), GFP_KERNEL);
999 spin_lock_init(&card->lock);
1001 /*** Initialize SDIO ***/
1002 sdio_claim_host(func);
1005 /* Issue config request to override clock rate */
1007 /* function blocksize set */
1008 ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
1009 DPRINTK(5, "multi_block=%d sdio_set_block_size()=%d %d\n",
1010 func->card->cccr.multi_block, func->cur_blksize, ret);
1012 /* Allocate the slot current */
1014 /* function enable */
1015 ret = sdio_enable_func(func);
1016 DPRINTK(5, "sdio_enable_func() %d\n", ret);
1018 goto error_free_card;
1020 /* interrupt disable */
1021 sdio_writeb(func, 0, INT_ENABLE, &ret);
1023 goto error_free_card;
1024 sdio_writeb(func, 0xff, INT_PENDING, &ret);
1026 goto error_disable_func;
1028 /* setup interrupt handler */
1029 ret = sdio_claim_irq(func, ks_sdio_interrupt);
1031 goto error_disable_func;
1033 sdio_release_host(func);
1035 sdio_set_drvdata(func, card);
1037 DPRINTK(5, "class = 0x%X, vendor = 0x%X, "
1038 "device = 0x%X\n", func->class, func->vendor, func->device);
1040 /* private memory allocate */
1041 netdev = alloc_etherdev(sizeof(*priv));
1042 if (netdev == NULL) {
1043 printk(KERN_ERR "ks79xx : Unable to alloc new net device\n");
1044 goto error_release_irq;
1046 if (dev_alloc_name(netdev, netdev->name) < 0) {
1047 printk(KERN_ERR "ks79xx : Couldn't get name!\n");
1048 goto error_free_netdev;
1051 priv = netdev_priv(netdev);
1054 SET_NETDEV_DEV(netdev, &card->func->dev); /* for create sysfs symlinks */
1056 /* private memory initialize */
1057 priv->ks_wlan_hw.sdio_card = card;
1058 init_completion(&priv->ks_wlan_hw.ks7010_sdio_wait);
1059 priv->ks_wlan_hw.read_buf = NULL;
1060 priv->ks_wlan_hw.read_buf = kmalloc(RX_DATA_SIZE, GFP_KERNEL);
1061 if (!priv->ks_wlan_hw.read_buf) {
1062 goto error_free_netdev;
1064 priv->dev_state = DEVICE_STATE_PREBOOT;
1065 priv->net_dev = netdev;
1066 priv->firmware_version[0] = '\0';
1067 priv->version_size = 0;
1068 priv->last_doze = jiffies; /* set current jiffies */
1069 priv->last_wakeup = jiffies;
1070 memset(&priv->nstats, 0, sizeof(priv->nstats));
1071 memset(&priv->wstats, 0, sizeof(priv->wstats));
1074 atomic_set(&priv->sleepstatus.doze_request, 0);
1075 atomic_set(&priv->sleepstatus.wakeup_request, 0);
1076 atomic_set(&priv->sleepstatus.wakeup_request, 0);
1078 trx_device_init(priv);
1080 ks_wlan_net_start(netdev);
1082 /* Read config file */
1083 ret = ks_wlan_read_config_file(priv);
1086 "ks79xx: read configuration file failed !! retern code = %d\n",
1088 goto error_free_read_buf;
1091 /* Upload firmware */
1092 ret = ks79xx_upload_firmware(priv, card); /* firmware load */
1095 "ks79xx: firmware load failed !! retern code = %d\n",
1097 goto error_free_read_buf;
1100 /* interrupt setting */
1101 /* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */
1103 sdio_claim_host(func);
1104 ret = ks7010_sdio_write(priv, INT_PENDING, &rw_data, sizeof(rw_data));
1105 sdio_release_host(func);
1107 DPRINTK(1, " error : INT_PENDING=%02X\n", rw_data);
1109 DPRINTK(4, " clear Interrupt : INT_PENDING=%02X\n", rw_data);
1111 /* enable ks7010sdio interrupt (INT_GCR_B|INT_READ_STATUS|INT_WRITE_STATUS) */
1112 rw_data = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
1113 sdio_claim_host(func);
1114 ret = ks7010_sdio_write(priv, INT_ENABLE, &rw_data, sizeof(rw_data));
1115 sdio_release_host(func);
1117 DPRINTK(1, " error : INT_ENABLE=%02X\n", rw_data);
1119 DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", rw_data);
1120 priv->dev_state = DEVICE_STATE_BOOT;
1122 priv->ks_wlan_hw.ks7010sdio_wq = create_workqueue("ks7010sdio_wq");
1123 if (!priv->ks_wlan_hw.ks7010sdio_wq) {
1124 DPRINTK(1, "create_workqueue failed !!\n");
1125 goto error_free_read_buf;
1128 INIT_DELAYED_WORK(&priv->ks_wlan_hw.rw_wq, ks7010_rw_function);
1129 ks7010_card_init(priv);
1133 error_free_read_buf:
1134 kfree(priv->ks_wlan_hw.read_buf);
1135 priv->ks_wlan_hw.read_buf = NULL;
1137 free_netdev(priv->net_dev);
1140 sdio_claim_host(func);
1141 sdio_release_irq(func);
1143 sdio_disable_func(func);
1145 sdio_release_host(func);
1146 sdio_set_drvdata(func, NULL);
1152 static void ks7910_sdio_remove(struct sdio_func *func)
1155 struct ks_sdio_card *card;
1156 struct ks_wlan_private *priv;
1157 struct net_device *netdev;
1158 DPRINTK(1, "ks7910_sdio_remove()\n");
1160 card = sdio_get_drvdata(func);
1165 DPRINTK(1, "priv = card->priv\n");
1167 netdev = priv->net_dev;
1169 ks_wlan_net_stop(netdev);
1170 DPRINTK(1, "ks_wlan_net_stop\n");
1172 /* interrupt disable */
1173 sdio_claim_host(func);
1174 sdio_writeb(func, 0, INT_ENABLE, &ret);
1175 sdio_writeb(func, 0xff, INT_PENDING, &ret);
1176 sdio_release_host(func);
1177 DPRINTK(1, "interrupt disable\n");
1179 /* send stop request to MAC */
1181 struct hostif_stop_request_t *pp;
1182 pp = (struct hostif_stop_request_t *)
1183 kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
1185 DPRINTK(3, "allocate memory failed..\n");
1186 return; /* to do goto ni suru */
1189 cpu_to_le16((uint16_t)
1191 sizeof(pp->header.size)));
1192 pp->header.event = cpu_to_le16((uint16_t) HIF_STOP_REQ);
1194 sdio_claim_host(func);
1195 write_to_device(priv, (unsigned char *)pp,
1196 hif_align_size(sizeof(*pp)));
1197 sdio_release_host(func);
1200 DPRINTK(1, "STOP Req\n");
1202 if (priv->ks_wlan_hw.ks7010sdio_wq) {
1203 flush_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
1204 destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
1207 "destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);\n");
1210 DPRINTK(1, "hostif_exit\n");
1213 unregister_netdev(netdev);
1214 DPRINTK(1, "unregister_netdev\n");
1216 trx_device_exit(priv);
1217 if (priv->ks_wlan_hw.read_buf) {
1218 kfree(priv->ks_wlan_hw.read_buf);
1220 free_netdev(priv->net_dev);
1224 sdio_claim_host(func);
1225 sdio_release_irq(func);
1226 DPRINTK(1, "sdio_release_irq()\n");
1227 sdio_disable_func(func);
1228 DPRINTK(1, "sdio_disable_func()\n");
1229 sdio_release_host(func);
1231 sdio_set_drvdata(func, NULL);
1234 DPRINTK(1, "kfree()\n");
1236 DPRINTK(5, " Bye !!\n");
1240 static int __init ks7010_sdio_init(void)
1244 /* register with bus driver core */
1245 status = sdio_register_driver(&ks7010_sdio_driver);
1248 "ks79xx_sdio : failed to register with bus driver, %d\n",
1254 static void __exit ks7010_sdio_exit(void)
1257 sdio_unregister_driver(&ks7010_sdio_driver);
1261 module_init(ks7010_sdio_init);
1262 module_exit(ks7010_sdio_exit);
1264 MODULE_AUTHOR("Qi-Hardware based on KeyStream driver");
1265 MODULE_DESCRIPTION("Driver for KeyStream, KS7010 based SDIO cards. ");
1266 #ifdef MODULE_LICENSE
1267 MODULE_LICENSE("GPL");
1269 MODULE_SUPPORTED_DEVICE("KS7910");