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