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