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);
37 #define inc_txqhead(priv) \
38 (priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE)
39 #define inc_txqtail(priv) \
40 (priv->tx_dev.qtail = (priv->tx_dev.qtail + 1) % TX_DEVICE_BUFF_SIZE)
41 #define cnt_txqbody(priv) \
42 (((priv->tx_dev.qtail + TX_DEVICE_BUFF_SIZE) - (priv->tx_dev.qhead)) % TX_DEVICE_BUFF_SIZE)
44 #define inc_rxqhead(priv) \
45 (priv->rx_dev.qhead = (priv->rx_dev.qhead + 1) % RX_DEVICE_BUFF_SIZE)
46 #define inc_rxqtail(priv) \
47 (priv->rx_dev.qtail = (priv->rx_dev.qtail + 1) % RX_DEVICE_BUFF_SIZE)
48 #define cnt_rxqbody(priv) \
49 (((priv->rx_dev.qtail + RX_DEVICE_BUFF_SIZE) - (priv->rx_dev.qhead)) % RX_DEVICE_BUFF_SIZE)
51 static int ks7010_sdio_read(struct ks_wlan_private *priv, unsigned int address,
52 unsigned char *buffer, int length)
54 struct ks_sdio_card *card;
57 card = priv->ks_wlan_hw.sdio_card;
59 if (length == 1) /* CMD52 */
60 *buffer = sdio_readb(card->func, address, &rc);
61 else /* CMD53 multi-block transfer */
62 rc = sdio_memcpy_fromio(card->func, buffer, address, length);
65 DPRINTK(1, "sdio error=%d size=%d\n", rc, length);
70 static int ks7010_sdio_write(struct ks_wlan_private *priv, unsigned int address,
71 unsigned char *buffer, int length)
73 struct ks_sdio_card *card;
76 card = priv->ks_wlan_hw.sdio_card;
78 if (length == 1) /* CMD52 */
79 sdio_writeb(card->func, *buffer, (unsigned int)address, &rc);
81 rc = sdio_memcpy_toio(card->func, (unsigned int)address, buffer,
85 DPRINTK(1, "sdio error=%d size=%d\n", rc, length);
90 static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
92 unsigned char rw_data;
98 atomic_set(&priv->sleepstatus.doze_request, 0);
100 if (atomic_read(&priv->sleepstatus.status) == 0) {
101 rw_data = GCR_B_DOZE;
103 ks7010_sdio_write(priv, GCR_B, &rw_data, sizeof(rw_data));
105 DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
108 DPRINTK(4, "PMG SET!! : GCR_B=%02X\n", rw_data);
109 DPRINTK(3, "sleep_mode=SLP_SLEEP\n");
110 atomic_set(&priv->sleepstatus.status, 1);
111 priv->last_doze = jiffies;
113 DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
117 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
120 static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
122 unsigned char rw_data;
128 atomic_set(&priv->sleepstatus.wakeup_request, 0);
130 if (atomic_read(&priv->sleepstatus.status) == 1) {
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);
138 DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
139 atomic_set(&priv->sleepstatus.status, 0);
140 priv->last_wakeup = jiffies;
141 ++priv->wakeup_count;
143 DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
147 priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
150 void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
152 unsigned char rw_data;
156 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
157 rw_data = WAKEUP_REQ;
159 ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data));
161 DPRINTK(1, " error : WAKEUP=%02X\n", rw_data);
163 DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
164 priv->last_wakeup = jiffies;
165 ++priv->wakeup_count;
167 DPRINTK(1, "psstatus=%d\n",
168 atomic_read(&priv->psstatus.status));
172 static int _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
174 unsigned char rw_data;
177 if (priv->reg.powermgt == POWMGT_ACTIVE_MODE)
180 if (priv->reg.operation_mode == MODE_INFRASTRUCTURE &&
181 (priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
182 if (priv->dev_state == DEVICE_STATE_SLEEP) {
183 switch (atomic_read(&priv->psstatus.status)) {
184 case PS_SNOOZE: /* 4 */
187 DPRINTK(5, "\npsstatus.status=%d\npsstatus.confirm_wait=%d\npsstatus.snooze_guard=%d\ncnt_txqbody=%d\n",
188 atomic_read(&priv->psstatus.status),
189 atomic_read(&priv->psstatus.confirm_wait),
190 atomic_read(&priv->psstatus.snooze_guard),
193 if (!atomic_read(&priv->psstatus.confirm_wait)
194 && !atomic_read(&priv->psstatus.snooze_guard)
195 && !cnt_txqbody(priv)) {
197 ks7010_sdio_read(priv, INT_PENDING,
202 " error : INT_PENDING=%02X\n",
204 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
205 &priv->ks_wlan_hw.rw_wq, 1);
209 rw_data = GCR_B_DOZE;
211 ks7010_sdio_write(priv,
217 " error : GCR_B=%02X\n",
220 (priv->ks_wlan_hw.ks7010sdio_wq,
221 &priv->ks_wlan_hw.rw_wq, 1);
225 "PMG SET!! : GCR_B=%02X\n",
227 atomic_set(&priv->psstatus.
230 "psstatus.status=PS_SNOOZE\n");
232 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
233 &priv->ks_wlan_hw.rw_wq, 1);
236 queue_delayed_work(priv->ks_wlan_hw.
238 &priv->ks_wlan_hw.rw_wq,
249 int ks_wlan_hw_power_save(struct ks_wlan_private *priv)
251 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
252 &priv->ks_wlan_hw.rw_wq, 1);
256 static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
258 void (*complete_handler) (void *arg1, void *arg2),
259 void *arg1, void *arg2)
261 struct tx_device_buffer *sp;
263 if (priv->dev_state < DEVICE_STATE_BOOT) {
265 if (complete_handler)
266 (*complete_handler) (arg1, arg2);
270 if ((TX_DEVICE_BUFF_SIZE - 1) <= cnt_txqbody(priv)) {
271 /* in case of buffer overflow */
272 DPRINTK(1, "tx buffer overflow\n");
274 if (complete_handler)
275 (*complete_handler) (arg1, arg2);
279 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
282 sp->complete_handler = complete_handler;
291 static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer,
295 unsigned char rw_data;
296 struct hostif_hdr *hdr;
297 hdr = (struct hostif_hdr *)buffer;
299 DPRINTK(4, "size=%d\n", hdr->size);
300 if (hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event) {
301 DPRINTK(1, "unknown event=%04X\n", hdr->event);
305 retval = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
307 DPRINTK(1, " write error : retval=%d\n", retval);
311 rw_data = WRITE_STATUS_BUSY;
313 ks7010_sdio_write(priv, WRITE_STATUS, &rw_data, sizeof(rw_data));
315 DPRINTK(1, " error : WRITE_STATUS=%02X\n", rw_data);
322 static void tx_device_task(void *dev)
324 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
325 struct tx_device_buffer *sp;
329 if (cnt_txqbody(priv) > 0
330 && atomic_read(&priv->psstatus.status) != PS_SNOOZE) {
331 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
332 if (priv->dev_state >= DEVICE_STATE_BOOT) {
333 rc = write_to_device(priv, sp->sendp, sp->size);
335 DPRINTK(1, "write_to_device error !!(%d)\n",
337 queue_delayed_work(priv->ks_wlan_hw.
339 &priv->ks_wlan_hw.rw_wq, 1);
343 kfree(sp->sendp); /* allocated memory free */
344 if (sp->complete_handler) /* TX Complete */
345 (*sp->complete_handler) (sp->arg1, sp->arg2);
348 if (cnt_txqbody(priv) > 0) {
349 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
350 &priv->ks_wlan_hw.rw_wq, 0);
355 int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size,
356 void (*complete_handler) (void *arg1, void *arg2),
357 void *arg1, void *arg2)
360 struct hostif_hdr *hdr;
361 hdr = (struct hostif_hdr *)p;
363 if (hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event) {
364 DPRINTK(1, "unknown event=%04X\n", hdr->event);
368 /* add event to hostt buffer */
369 priv->hostt.buff[priv->hostt.qtail] = hdr->event;
370 priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
372 DPRINTK(4, "event=%04X\n", hdr->event);
373 spin_lock(&priv->tx_dev.tx_dev_lock);
374 result = enqueue_txdev(priv, p, size, complete_handler, arg1, arg2);
375 spin_unlock(&priv->tx_dev.tx_dev_lock);
377 if (cnt_txqbody(priv) > 0) {
378 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
379 &priv->ks_wlan_hw.rw_wq, 0);
384 static void rx_event_task(unsigned long dev)
386 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
387 struct rx_device_buffer *rp;
391 if (cnt_rxqbody(priv) > 0 && priv->dev_state >= DEVICE_STATE_BOOT) {
392 rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
393 hostif_receive(priv, rp->data, rp->size);
396 if (cnt_rxqbody(priv) > 0)
397 tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);
401 static void ks_wlan_hw_rx(void *dev, uint16_t size)
403 struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
405 struct rx_device_buffer *rx_buffer;
406 struct hostif_hdr *hdr;
407 unsigned char read_status;
408 unsigned short event = 0;
413 if (cnt_rxqbody(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
414 /* in case of buffer overflow */
415 DPRINTK(1, "rx buffer overflow \n");
418 rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];
421 ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0],
422 hif_align_size(size));
427 if (size > 2046 || size == 0) {
429 if (KS_WLAN_DEBUG > 5)
430 print_hex_dump_bytes("INVALID DATA dump: ",
432 rx_buffer->data, 32);
434 /* rx_status update */
435 read_status = READ_STATUS_IDLE;
437 ks7010_sdio_write(priv, READ_STATUS, &read_status,
438 sizeof(read_status));
440 DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
445 hdr = (struct hostif_hdr *)&rx_buffer->data[0];
446 rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
450 /* read status update */
451 read_status = READ_STATUS_IDLE;
453 ks7010_sdio_write(priv, READ_STATUS, &read_status,
454 sizeof(read_status));
456 DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
458 DPRINTK(4, "READ_STATUS=%02X\n", read_status);
460 if (atomic_read(&priv->psstatus.confirm_wait)) {
461 if (IS_HIF_CONF(event)) {
462 DPRINTK(4, "IS_HIF_CONF true !!\n");
463 atomic_dec(&priv->psstatus.confirm_wait);
467 /* rx_event_task((void *)priv); */
468 tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);
474 static void ks7010_rw_function(struct work_struct *work)
476 struct hw_info_t *hw;
477 struct ks_wlan_private *priv;
478 unsigned char rw_data;
481 hw = container_of(work, struct hw_info_t, rw_wq.work);
482 priv = container_of(hw, struct ks_wlan_private, ks_wlan_hw);
486 /* wiat after DOZE */
487 if (time_after(priv->last_doze + ((30 * HZ) / 1000), jiffies)) {
488 DPRINTK(4, "wait after DOZE\n");
489 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
490 &priv->ks_wlan_hw.rw_wq, 1);
494 /* wiat after WAKEUP */
495 while (time_after(priv->last_wakeup + ((30 * HZ) / 1000), jiffies)) {
496 DPRINTK(4, "wait after WAKEUP\n");
497 /* queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq,
498 (priv->last_wakeup + ((30*HZ)/1000) - jiffies));*/
499 dev_info(&priv->ks_wlan_hw.sdio_card->func->dev,
501 priv->last_wakeup + (30 * HZ) / 1000,
506 sdio_claim_host(priv->ks_wlan_hw.sdio_card->func);
508 /* power save wakeup */
509 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
510 if (cnt_txqbody(priv) > 0) {
511 ks_wlan_hw_wakeup_request(priv);
512 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
513 &priv->ks_wlan_hw.rw_wq, 1);
518 /* sleep mode doze */
519 if (atomic_read(&priv->sleepstatus.doze_request) == 1) {
520 ks_wlan_hw_sleep_doze_request(priv);
523 /* sleep mode wakeup */
524 if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) {
525 ks_wlan_hw_sleep_wakeup_request(priv);
529 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
531 ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data, sizeof(rw_data));
533 DPRINTK(1, " error : WSTATUS_RSIZE=%02X psstatus=%d\n", rw_data,
534 atomic_read(&priv->psstatus.status));
537 DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);
539 if (rw_data & RSIZE_MASK) { /* Read schedule */
540 ks_wlan_hw_rx((void *)priv,
541 (uint16_t)((rw_data & RSIZE_MASK) << 4));
543 if ((rw_data & WSTATUS_MASK))
544 tx_device_task((void *)priv);
546 _ks_wlan_hw_power_save(priv);
549 sdio_release_host(priv->ks_wlan_hw.sdio_card->func);
552 static void ks_sdio_interrupt(struct sdio_func *func)
555 struct ks_sdio_card *card;
556 struct ks_wlan_private *priv;
557 unsigned char status, rsize, rw_data;
559 card = sdio_get_drvdata(func);
563 if (priv->dev_state >= DEVICE_STATE_BOOT) {
565 ks7010_sdio_read(priv, INT_PENDING, &status,
568 DPRINTK(1, "read INT_PENDING Failed!!(%d)\n", retval);
571 DPRINTK(4, "INT_PENDING=%02X\n", rw_data);
573 /* schedule task for interrupt status */
574 /* bit7 -> Write General Communication B register */
575 /* read (General Communication B register) */
576 /* bit5 -> Write Status Idle */
577 /* bit2 -> Read Status Busy */
578 if (status & INT_GCR_B
579 || atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
581 ks7010_sdio_read(priv, GCR_B, &rw_data,
584 DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
587 /* DPRINTK(1, "GCR_B=%02X\n", rw_data); */
588 if (rw_data == GCR_B_ACTIVE) {
589 if (atomic_read(&priv->psstatus.status) ==
591 atomic_set(&priv->psstatus.status,
593 priv->wakeup_count = 0;
595 complete(&priv->psstatus.wakeup_wait);
600 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
602 ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data,
605 DPRINTK(1, " error : WSTATUS_RSIZE=%02X\n",
609 DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);
610 rsize = rw_data & RSIZE_MASK;
611 if (rsize) { /* Read schedule */
612 ks_wlan_hw_rx((void *)priv,
613 (uint16_t)(rsize << 4));
615 if (rw_data & WSTATUS_MASK) {
617 if (status & INT_WRITE_STATUS
618 && !cnt_txqbody(priv)) {
619 /* dummy write for interrupt clear */
622 ks7010_sdio_write(priv, DATA_WINDOW,
627 "write DATA_WINDOW Failed!!(%d)\n",
630 status &= ~INT_WRITE_STATUS;
633 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
634 if (cnt_txqbody(priv)) {
635 ks_wlan_hw_wakeup_request(priv);
644 tx_device_task((void *)priv);
654 queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
655 &priv->ks_wlan_hw.rw_wq, 0);
658 static int trx_device_init(struct ks_wlan_private *priv)
660 /* initialize values (tx) */
661 priv->tx_dev.qtail = priv->tx_dev.qhead = 0;
663 /* initialize values (rx) */
664 priv->rx_dev.qtail = priv->rx_dev.qhead = 0;
666 /* initialize spinLock (tx,rx) */
667 spin_lock_init(&priv->tx_dev.tx_dev_lock);
668 spin_lock_init(&priv->rx_dev.rx_dev_lock);
670 tasklet_init(&priv->ks_wlan_hw.rx_bh_task, rx_event_task,
671 (unsigned long)priv);
676 static void trx_device_exit(struct ks_wlan_private *priv)
678 struct tx_device_buffer *sp;
680 /* tx buffer clear */
681 while (cnt_txqbody(priv) > 0) {
682 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
683 kfree(sp->sendp); /* allocated memory free */
684 if (sp->complete_handler) /* TX Complete */
685 (*sp->complete_handler) (sp->arg1, sp->arg2);
689 tasklet_kill(&priv->ks_wlan_hw.rx_bh_task);
692 static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
696 unsigned char *data_buf;
698 data_buf = kmalloc(sizeof(u32), GFP_KERNEL);
704 memcpy(data_buf, &index, sizeof(index));
705 retval = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index));
711 retval = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index));
721 #define ROM_BUFF_SIZE (64*1024)
722 static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
723 unsigned char *data, unsigned int size)
727 unsigned char *read_buf;
729 read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
734 retval = ks7010_sdio_read(priv, address, read_buf, size);
739 retval = memcmp(data, read_buf, size);
742 DPRINTK(0, "data compare error (%d)\n", retval);
751 static int ks7010_upload_firmware(struct ks_wlan_private *priv,
752 struct ks_sdio_card *card)
754 unsigned int size, offset, n = 0;
755 unsigned char *rom_buf;
756 unsigned char rw_data = 0;
759 const struct firmware *fw_entry = NULL;
761 /* buffer allocate */
762 rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
766 sdio_claim_host(card->func);
768 /* Firmware running ? */
769 retval = ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
770 if (rw_data == GCR_A_RUN) {
771 DPRINTK(0, "MAC firmware running ...\n");
776 retval = reject_firmware(&fw_entry, ROM_FILE, &priv->ks_wlan_hw.sdio_card->func->dev);
780 length = fw_entry->size;
785 if (length >= ROM_BUFF_SIZE) {
786 size = ROM_BUFF_SIZE;
787 length = length - ROM_BUFF_SIZE;
792 DPRINTK(4, "size = %d\n", size);
795 memcpy(rom_buf, fw_entry->data + n, size);
796 /* Update write index */
799 ks7010_sdio_update_index(priv,
800 KS7010_IRAM_ADDRESS + offset);
807 retval = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
815 ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size);
825 rw_data = GCR_A_REMAP;
826 retval = ks7010_sdio_write(priv, GCR_A, &rw_data, sizeof(rw_data));
831 DPRINTK(4, " REMAP Request : GCR_A=%02X\n", rw_data);
833 /* Firmware running check */
834 for (n = 0; n < 50; ++n) {
835 mdelay(10); /* wait_ms(10); */
837 ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
842 if (rw_data == GCR_A_RUN)
845 DPRINTK(4, "firmware wakeup (%d)!!!!\n", n);
847 DPRINTK(1, "firmware can't start\n");
855 release_firmware(fw_entry);
857 sdio_release_host(card->func);
862 static void ks7010_card_init(struct ks_wlan_private *priv)
864 DPRINTK(5, "\ncard_init_task()\n");
866 /* init_waitqueue_head(&priv->confirm_wait); */
867 init_completion(&priv->confirm_wait);
869 DPRINTK(5, "init_completion()\n");
871 /* get mac address & firmware version */
872 hostif_sme_enqueue(priv, SME_START);
874 DPRINTK(5, "hostif_sme_enqueu()\n");
876 if (!wait_for_completion_interruptible_timeout
877 (&priv->confirm_wait, 5 * HZ)) {
878 DPRINTK(1, "wait time out!! SME_START\n");
881 if (priv->mac_address_valid && priv->version_size)
882 priv->dev_state = DEVICE_STATE_PREINIT;
885 hostif_sme_enqueue(priv, SME_GET_EEPROM_CKSUM);
887 /* load initial wireless parameter */
888 hostif_sme_enqueue(priv, SME_STOP_REQUEST);
890 hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_REQUEST);
891 hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_REQUEST);
893 hostif_sme_enqueue(priv, SME_WEP_INDEX_REQUEST);
894 hostif_sme_enqueue(priv, SME_WEP_KEY1_REQUEST);
895 hostif_sme_enqueue(priv, SME_WEP_KEY2_REQUEST);
896 hostif_sme_enqueue(priv, SME_WEP_KEY3_REQUEST);
897 hostif_sme_enqueue(priv, SME_WEP_KEY4_REQUEST);
899 hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
900 hostif_sme_enqueue(priv, SME_RSN_ENABLED_REQUEST);
901 hostif_sme_enqueue(priv, SME_MODE_SET_REQUEST);
902 hostif_sme_enqueue(priv, SME_START_REQUEST);
904 if (!wait_for_completion_interruptible_timeout
905 (&priv->confirm_wait, 5 * HZ)) {
906 DPRINTK(1, "wait time out!! wireless parameter set\n");
909 if (priv->dev_state >= DEVICE_STATE_PREINIT) {
910 DPRINTK(1, "DEVICE READY!!\n");
911 priv->dev_state = DEVICE_STATE_READY;
913 DPRINTK(1, "dev_state=%d\n", priv->dev_state);
917 static void ks7010_init_defaults(struct ks_wlan_private *priv)
919 priv->reg.tx_rate = TX_RATE_AUTO;
920 priv->reg.preamble = LONG_PREAMBLE;
921 priv->reg.powermgt = POWMGT_ACTIVE_MODE;
922 priv->reg.scan_type = ACTIVE_SCAN;
923 priv->reg.beacon_lost_count = 20;
924 priv->reg.rts = 2347UL;
925 priv->reg.fragment = 2346UL;
926 priv->reg.phy_type = D_11BG_COMPATIBLE_MODE;
927 priv->reg.cts_mode = CTS_MODE_FALSE;
928 priv->reg.rate_set.body[11] = TX_RATE_54M;
929 priv->reg.rate_set.body[10] = TX_RATE_48M;
930 priv->reg.rate_set.body[9] = TX_RATE_36M;
931 priv->reg.rate_set.body[8] = TX_RATE_18M;
932 priv->reg.rate_set.body[7] = TX_RATE_9M;
933 priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
934 priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
935 priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
936 priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
937 priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
938 priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
939 priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
940 priv->reg.tx_rate = TX_RATE_FULL_AUTO;
941 priv->reg.rate_set.size = 12;
944 static int ks7010_sdio_probe(struct sdio_func *func,
945 const struct sdio_device_id *device)
947 struct ks_wlan_private *priv;
948 struct ks_sdio_card *card;
949 struct net_device *netdev;
950 unsigned char rw_data;
953 DPRINTK(5, "ks7010_sdio_probe()\n");
958 /* initilize ks_sdio_card */
959 card = kzalloc(sizeof(*card), GFP_KERNEL);
964 spin_lock_init(&card->lock);
966 /*** Initialize SDIO ***/
967 sdio_claim_host(func);
970 /* Issue config request to override clock rate */
972 /* function blocksize set */
973 ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
974 DPRINTK(5, "multi_block=%d sdio_set_block_size()=%d %d\n",
975 func->card->cccr.multi_block, func->cur_blksize, ret);
977 /* Allocate the slot current */
979 /* function enable */
980 ret = sdio_enable_func(func);
981 DPRINTK(5, "sdio_enable_func() %d\n", ret);
983 goto error_free_card;
985 /* interrupt disable */
986 sdio_writeb(func, 0, INT_ENABLE, &ret);
988 goto error_free_card;
989 sdio_writeb(func, 0xff, INT_PENDING, &ret);
991 goto error_disable_func;
993 /* setup interrupt handler */
994 ret = sdio_claim_irq(func, ks_sdio_interrupt);
996 goto error_disable_func;
998 sdio_release_host(func);
1000 sdio_set_drvdata(func, card);
1002 DPRINTK(5, "class = 0x%X, vendor = 0x%X, "
1003 "device = 0x%X\n", func->class, func->vendor, func->device);
1005 /* private memory allocate */
1006 netdev = alloc_etherdev(sizeof(*priv));
1008 dev_err(&card->func->dev, "ks7010 : Unable to alloc new net device\n");
1009 goto error_release_irq;
1011 if (dev_alloc_name(netdev, "wlan%d") < 0) {
1012 dev_err(&card->func->dev,
1013 "ks7010 : Couldn't get name!\n");
1014 goto error_free_netdev;
1017 priv = netdev_priv(netdev);
1020 SET_NETDEV_DEV(netdev, &card->func->dev); /* for create sysfs symlinks */
1022 /* private memory initialize */
1023 priv->ks_wlan_hw.sdio_card = card;
1024 init_completion(&priv->ks_wlan_hw.ks7010_sdio_wait);
1025 priv->ks_wlan_hw.read_buf = NULL;
1026 priv->ks_wlan_hw.read_buf = kmalloc(RX_DATA_SIZE, GFP_KERNEL);
1027 if (!priv->ks_wlan_hw.read_buf)
1028 goto error_free_netdev;
1030 priv->dev_state = DEVICE_STATE_PREBOOT;
1031 priv->net_dev = netdev;
1032 priv->firmware_version[0] = '\0';
1033 priv->version_size = 0;
1034 priv->last_doze = jiffies; /* set current jiffies */
1035 priv->last_wakeup = jiffies;
1036 memset(&priv->nstats, 0, sizeof(priv->nstats));
1037 memset(&priv->wstats, 0, sizeof(priv->wstats));
1040 atomic_set(&priv->sleepstatus.status, 0);
1041 atomic_set(&priv->sleepstatus.doze_request, 0);
1042 atomic_set(&priv->sleepstatus.wakeup_request, 0);
1044 trx_device_init(priv);
1046 ks_wlan_net_start(netdev);
1048 ks7010_init_defaults(priv);
1050 /* Upload firmware */
1051 ret = ks7010_upload_firmware(priv, card); /* firmware load */
1053 dev_err(&card->func->dev,
1054 "ks7010: firmware load failed !! return code = %d\n",
1056 goto error_free_read_buf;
1059 /* interrupt setting */
1060 /* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */
1062 sdio_claim_host(func);
1063 ret = ks7010_sdio_write(priv, INT_PENDING, &rw_data, sizeof(rw_data));
1064 sdio_release_host(func);
1066 DPRINTK(1, " error : INT_PENDING=%02X\n", rw_data);
1068 DPRINTK(4, " clear Interrupt : INT_PENDING=%02X\n", rw_data);
1070 /* enable ks7010sdio interrupt (INT_GCR_B|INT_READ_STATUS|INT_WRITE_STATUS) */
1071 rw_data = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
1072 sdio_claim_host(func);
1073 ret = ks7010_sdio_write(priv, INT_ENABLE, &rw_data, sizeof(rw_data));
1074 sdio_release_host(func);
1076 DPRINTK(1, " error : INT_ENABLE=%02X\n", rw_data);
1078 DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", rw_data);
1079 priv->dev_state = DEVICE_STATE_BOOT;
1081 priv->ks_wlan_hw.ks7010sdio_wq = create_workqueue("ks7010sdio_wq");
1082 if (!priv->ks_wlan_hw.ks7010sdio_wq) {
1083 DPRINTK(1, "create_workqueue failed !!\n");
1084 goto error_free_read_buf;
1087 INIT_DELAYED_WORK(&priv->ks_wlan_hw.rw_wq, ks7010_rw_function);
1088 ks7010_card_init(priv);
1090 ret = register_netdev(priv->net_dev);
1092 goto error_free_read_buf;
1096 error_free_read_buf:
1097 kfree(priv->ks_wlan_hw.read_buf);
1098 priv->ks_wlan_hw.read_buf = NULL;
1100 free_netdev(priv->net_dev);
1103 sdio_claim_host(func);
1104 sdio_release_irq(func);
1106 sdio_disable_func(func);
1108 sdio_release_host(func);
1109 sdio_set_drvdata(func, NULL);
1115 static void ks7010_sdio_remove(struct sdio_func *func)
1118 struct ks_sdio_card *card;
1119 struct ks_wlan_private *priv;
1120 DPRINTK(1, "ks7010_sdio_remove()\n");
1122 card = sdio_get_drvdata(func);
1127 DPRINTK(1, "priv = card->priv\n");
1130 struct net_device *netdev = priv->net_dev;
1132 ks_wlan_net_stop(netdev);
1133 DPRINTK(1, "ks_wlan_net_stop\n");
1135 /* interrupt disable */
1136 sdio_claim_host(func);
1137 sdio_writeb(func, 0, INT_ENABLE, &ret);
1138 sdio_writeb(func, 0xff, INT_PENDING, &ret);
1139 sdio_release_host(func);
1140 DPRINTK(1, "interrupt disable\n");
1142 /* send stop request to MAC */
1144 struct hostif_stop_request_t *pp;
1145 pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
1147 DPRINTK(3, "allocate memory failed..\n");
1148 return; /* to do goto ni suru */
1151 cpu_to_le16((uint16_t)
1153 sizeof(pp->header.size)));
1154 pp->header.event = cpu_to_le16((uint16_t)HIF_STOP_REQ);
1156 sdio_claim_host(func);
1157 write_to_device(priv, (unsigned char *)pp,
1158 hif_align_size(sizeof(*pp)));
1159 sdio_release_host(func);
1162 DPRINTK(1, "STOP Req\n");
1164 if (priv->ks_wlan_hw.ks7010sdio_wq) {
1165 flush_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
1166 destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
1169 "destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);\n");
1172 DPRINTK(1, "hostif_exit\n");
1174 unregister_netdev(netdev);
1176 trx_device_exit(priv);
1177 kfree(priv->ks_wlan_hw.read_buf);
1178 free_netdev(priv->net_dev);
1182 sdio_claim_host(func);
1183 sdio_release_irq(func);
1184 DPRINTK(1, "sdio_release_irq()\n");
1185 sdio_disable_func(func);
1186 DPRINTK(1, "sdio_disable_func()\n");
1187 sdio_release_host(func);
1189 sdio_set_drvdata(func, NULL);
1192 DPRINTK(1, "kfree()\n");
1194 DPRINTK(5, " Bye !!\n");
1197 static struct sdio_driver ks7010_sdio_driver = {
1198 .name = "ks7010_sdio",
1199 .id_table = ks7010_sdio_ids,
1200 .probe = ks7010_sdio_probe,
1201 .remove = ks7010_sdio_remove,
1204 module_driver(ks7010_sdio_driver, sdio_register_driver, sdio_unregister_driver);
1205 MODULE_AUTHOR("Sang Engineering, Qi-Hardware, KeyStream");
1206 MODULE_DESCRIPTION("Driver for KeyStream KS7010 based SDIO cards");
1207 MODULE_LICENSE("GPL v2");