]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/staging/ks7010/ks7010_sdio.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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