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