projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath6kl: remove unused values from htc_hif.h
[deliverable/linux.git] / drivers / net / wireless / ath / ath6kl / sdio.c
CommitLineData
bdcd8170
KV		 1/*
2 * Copyright (c) 2004-2011 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17#include <linux/mmc/card.h>
18#include <linux/mmc/mmc.h>
19#include <linux/mmc/host.h>
20#include <linux/mmc/sdio_func.h>
21#include <linux/mmc/sdio_ids.h>
22#include <linux/mmc/sdio.h>
23#include <linux/mmc/sd.h>
24#include "htc_hif.h"
25#include "hif-ops.h"
26#include "target.h"
27#include "debug.h"
9df337a1 28#include "cfg80211.h"
bdcd8170
KV		 29
30struct ath6kl_sdio {
31 struct sdio_func *func;
32
33 spinlock_t lock;
34
35 /* free list */
36 struct list_head bus_req_freeq;
37
38 /* available bus requests */
39 struct bus_request bus_req[BUS_REQUEST_MAX_NUM];
40
41 struct ath6kl *ar;
42 u8 *dma_buffer;
43
44 /* scatter request list head */
45 struct list_head scat_req;
46
47 spinlock_t scat_lock;
48 bool is_disabled;
49 atomic_t irq_handling;
50 const struct sdio_device_id *id;
51 struct work_struct wr_async_work;
52 struct list_head wr_asyncq;
53 spinlock_t wr_async_lock;
54};
55
56#define CMD53_ARG_READ 0
57#define CMD53_ARG_WRITE 1
58#define CMD53_ARG_BLOCK_BASIS 1
59#define CMD53_ARG_FIXED_ADDRESS 0
60#define CMD53_ARG_INCR_ADDRESS 1
61
62static inline struct ath6kl_sdio *ath6kl_sdio_priv(struct ath6kl *ar)
63{
64 return ar->hif_priv;
65}
66
67/*
68 * Macro to check if DMA buffer is WORD-aligned and DMA-able.
69 * Most host controllers assume the buffer is DMA'able and will
70 * bug-check otherwise (i.e. buffers on the stack). virt_addr_valid
71 * check fails on stack memory.
72 */
73static inline bool buf_needs_bounce(u8 *buf)
74{
75 return ((unsigned long) buf & 0x3) || !virt_addr_valid(buf);
76}
77
78static void ath6kl_sdio_set_mbox_info(struct ath6kl *ar)
79{
80 struct ath6kl_mbox_info *mbox_info = &ar->mbox_info;
81
82 /* EP1 has an extended range */
83 mbox_info->htc_addr = HIF_MBOX_BASE_ADDR;
84 mbox_info->htc_ext_addr = HIF_MBOX0_EXT_BASE_ADDR;
85 mbox_info->htc_ext_sz = HIF_MBOX0_EXT_WIDTH;
86 mbox_info->block_size = HIF_MBOX_BLOCK_SIZE;
87 mbox_info->gmbox_addr = HIF_GMBOX_BASE_ADDR;
88 mbox_info->gmbox_sz = HIF_GMBOX_WIDTH;
89}
90
91static inline void ath6kl_sdio_set_cmd53_arg(u32 *arg, u8 rw, u8 func,
92 u8 mode, u8 opcode, u32 addr,
93 u16 blksz)
94{
95 *arg = (((rw & 1) << 31) |
96 ((func & 0x7) << 28) |
97 ((mode & 1) << 27) |
98 ((opcode & 1) << 26) |
99 ((addr & 0x1FFFF) << 9) |
100 (blksz & 0x1FF));
101}
102
103static inline void ath6kl_sdio_set_cmd52_arg(u32 *arg, u8 write, u8 raw,
104 unsigned int address,
105 unsigned char val)
106{
107 const u8 func = 0;
108
109 *arg = ((write & 1) << 31) |
110 ((func & 0x7) << 28) |
111 ((raw & 1) << 27) |
112 (1 << 26) |
113 ((address & 0x1FFFF) << 9) |
114 (1 << 8) |
115 (val & 0xFF);
116}
117
118static int ath6kl_sdio_func0_cmd52_wr_byte(struct mmc_card *card,
119 unsigned int address,
120 unsigned char byte)
121{
122 struct mmc_command io_cmd;
123
124 memset(&io_cmd, 0, sizeof(io_cmd));
125 ath6kl_sdio_set_cmd52_arg(&io_cmd.arg, 1, 0, address, byte);
126 io_cmd.opcode = SD_IO_RW_DIRECT;
127 io_cmd.flags = MMC_RSP_R5 | MMC_CMD_AC;
128
129 return mmc_wait_for_cmd(card->host, &io_cmd, 0);
130}
131
da220695
VT		 132static int ath6kl_sdio_io(struct sdio_func *func, u32 request, u32 addr,
133 u8 *buf, u32 len)
134{
135 int ret = 0;
136
861dd058
VT		 137 sdio_claim_host(func);
138
da220695 139 if (request & HIF_WRITE) {
f7325b85 140 /* FIXME: looks like ugly workaround for something */
da220695
VT		 141 if (addr >= HIF_MBOX_BASE_ADDR &&
142 addr <= HIF_MBOX_END_ADDR)
143 addr += (HIF_MBOX_WIDTH - len);
144
f7325b85 145 /* FIXME: this also looks like ugly workaround */
da220695
VT		 146 if (addr == HIF_MBOX0_EXT_BASE_ADDR)
147 addr += HIF_MBOX0_EXT_WIDTH - len;
148
149 if (request & HIF_FIXED_ADDRESS)
150 ret = sdio_writesb(func, addr, buf, len);
151 else
152 ret = sdio_memcpy_toio(func, addr, buf, len);
153 } else {
154 if (request & HIF_FIXED_ADDRESS)
155 ret = sdio_readsb(func, buf, addr, len);
156 else
157 ret = sdio_memcpy_fromio(func, buf, addr, len);
158 }
159
861dd058
VT		 160 sdio_release_host(func);
161
f7325b85
KV		 162 ath6kl_dbg(ATH6KL_DBG_SDIO, "%s addr 0x%x%s buf 0x%p len %d\n",
163 request & HIF_WRITE ? "wr" : "rd", addr,
164 request & HIF_FIXED_ADDRESS ? " (fixed)" : "", buf, len);
165 ath6kl_dbg_dump(ATH6KL_DBG_SDIO_DUMP, NULL, "sdio ", buf, len);
166
da220695
VT		 167 return ret;
168}
169
bdcd8170
KV		 170static struct bus_request *ath6kl_sdio_alloc_busreq(struct ath6kl_sdio *ar_sdio)
171{
172 struct bus_request *bus_req;
bdcd8170 173
151bd30b 174 spin_lock_bh(&ar_sdio->lock);
bdcd8170
KV		 175
176 if (list_empty(&ar_sdio->bus_req_freeq)) {
151bd30b 177 spin_unlock_bh(&ar_sdio->lock);
bdcd8170
KV		 178 return NULL;
179 }
180
181 bus_req = list_first_entry(&ar_sdio->bus_req_freeq,
182 struct bus_request, list);
183 list_del(&bus_req->list);
184
151bd30b 185 spin_unlock_bh(&ar_sdio->lock);
f7325b85
KV		 186 ath6kl_dbg(ATH6KL_DBG_SCATTER, "%s: bus request 0x%p\n",
187 __func__, bus_req);
bdcd8170
KV		 188
189 return bus_req;
190}
191
192static void ath6kl_sdio_free_bus_req(struct ath6kl_sdio *ar_sdio,
193 struct bus_request *bus_req)
194{
f7325b85
KV		 195 ath6kl_dbg(ATH6KL_DBG_SCATTER, "%s: bus request 0x%p\n",
196 __func__, bus_req);
bdcd8170 197
151bd30b 198 spin_lock_bh(&ar_sdio->lock);
bdcd8170 199 list_add_tail(&bus_req->list, &ar_sdio->bus_req_freeq);
151bd30b 200 spin_unlock_bh(&ar_sdio->lock);
bdcd8170
KV		 201}
202
203static void ath6kl_sdio_setup_scat_data(struct hif_scatter_req *scat_req,
bdcd8170
KV		 204 struct mmc_data *data)
205{
206 struct scatterlist *sg;
207 int i;
208
209 data->blksz = HIF_MBOX_BLOCK_SIZE;
210 data->blocks = scat_req->len / HIF_MBOX_BLOCK_SIZE;
211
212 ath6kl_dbg(ATH6KL_DBG_SCATTER,
213 "hif-scatter: (%s) addr: 0x%X, (block len: %d, block count: %d) , (tot:%d,sg:%d)\n",
214 (scat_req->req & HIF_WRITE) ? "WR" : "RD", scat_req->addr,
215 data->blksz, data->blocks, scat_req->len,
216 scat_req->scat_entries);
217
218 data->flags = (scat_req->req & HIF_WRITE) ? MMC_DATA_WRITE :
219 MMC_DATA_READ;
220
221 /* fill SG entries */
d4df7890 222 sg = scat_req->sgentries;
bdcd8170
KV		 223 sg_init_table(sg, scat_req->scat_entries);
224
225 /* assemble SG list */
226 for (i = 0; i < scat_req->scat_entries; i++, sg++) {
bdcd8170
KV		 227 ath6kl_dbg(ATH6KL_DBG_SCATTER, "%d: addr:0x%p, len:%d\n",
228 i, scat_req->scat_list[i].buf,
229 scat_req->scat_list[i].len);
230
231 sg_set_buf(sg, scat_req->scat_list[i].buf,
232 scat_req->scat_list[i].len);
233 }
234
235 /* set scatter-gather table for request */
d4df7890 236 data->sg = scat_req->sgentries;
bdcd8170
KV		 237 data->sg_len = scat_req->scat_entries;
238}
239
240static int ath6kl_sdio_scat_rw(struct ath6kl_sdio *ar_sdio,
241 struct bus_request *req)
242{
243 struct mmc_request mmc_req;
244 struct mmc_command cmd;
245 struct mmc_data data;
246 struct hif_scatter_req *scat_req;
247 u8 opcode, rw;
348a8fbc 248 int status, len;
bdcd8170
KV		 249
250 scat_req = req->scat_req;
251
348a8fbc
VT		 252 if (scat_req->virt_scat) {
253 len = scat_req->len;
254 if (scat_req->req & HIF_BLOCK_BASIS)
255 len = round_down(len, HIF_MBOX_BLOCK_SIZE);
256
257 status = ath6kl_sdio_io(ar_sdio->func, scat_req->req,
258 scat_req->addr, scat_req->virt_dma_buf,
259 len);
260 goto scat_complete;
261 }
262
bdcd8170
KV		 263 memset(&mmc_req, 0, sizeof(struct mmc_request));
264 memset(&cmd, 0, sizeof(struct mmc_command));
265 memset(&data, 0, sizeof(struct mmc_data));
266
d4df7890 267 ath6kl_sdio_setup_scat_data(scat_req, &data);
bdcd8170
KV		 268
269 opcode = (scat_req->req & HIF_FIXED_ADDRESS) ?
270 CMD53_ARG_FIXED_ADDRESS : CMD53_ARG_INCR_ADDRESS;
271
272 rw = (scat_req->req & HIF_WRITE) ? CMD53_ARG_WRITE : CMD53_ARG_READ;
273
274 /* Fixup the address so that the last byte will fall on MBOX EOM */
275 if (scat_req->req & HIF_WRITE) {
276 if (scat_req->addr == HIF_MBOX_BASE_ADDR)
277 scat_req->addr += HIF_MBOX_WIDTH - scat_req->len;
278 else
279 /* Uses extended address range */
280 scat_req->addr += HIF_MBOX0_EXT_WIDTH - scat_req->len;
281 }
282
283 /* set command argument */
284 ath6kl_sdio_set_cmd53_arg(&cmd.arg, rw, ar_sdio->func->num,
285 CMD53_ARG_BLOCK_BASIS, opcode, scat_req->addr,
286 data.blocks);
287
288 cmd.opcode = SD_IO_RW_EXTENDED;
289 cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
290
291 mmc_req.cmd = &cmd;
292 mmc_req.data = &data;
293
861dd058
VT		 294 sdio_claim_host(ar_sdio->func);
295
bdcd8170
KV		 296 mmc_set_data_timeout(&data, ar_sdio->func->card);
297 /* synchronous call to process request */
298 mmc_wait_for_req(ar_sdio->func->card->host, &mmc_req);
299
861dd058
VT		 300 sdio_release_host(ar_sdio->func);
301
bdcd8170 302 status = cmd.error ? cmd.error : data.error;
348a8fbc
VT		 303
304scat_complete:
bdcd8170
KV		 305 scat_req->status = status;
306
307 if (scat_req->status)
308 ath6kl_err("Scatter write request failed:%d\n",
309 scat_req->status);
310
311 if (scat_req->req & HIF_ASYNCHRONOUS)
e041c7f9 312 scat_req->complete(ar_sdio->ar->htc_target, scat_req);
bdcd8170
KV		 313
314 return status;
315}
316
3df505ad
VT		 317static int ath6kl_sdio_alloc_prep_scat_req(struct ath6kl_sdio *ar_sdio,
318 int n_scat_entry, int n_scat_req,
319 bool virt_scat)
320{
321 struct hif_scatter_req *s_req;
322 struct bus_request *bus_req;
cfeab10b
VT		 323 int i, scat_req_sz, scat_list_sz, sg_sz, buf_sz;
324 u8 *virt_buf;
3df505ad
VT		 325
326 scat_list_sz = (n_scat_entry - 1) * sizeof(struct hif_scatter_item);
327 scat_req_sz = sizeof(*s_req) + scat_list_sz;
328
329 if (!virt_scat)
330 sg_sz = sizeof(struct scatterlist) * n_scat_entry;
cfeab10b
VT		 331 else
332 buf_sz = 2 * L1_CACHE_BYTES +
333 ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
3df505ad
VT		 334
335 for (i = 0; i < n_scat_req; i++) {
336 /* allocate the scatter request */
337 s_req = kzalloc(scat_req_sz, GFP_KERNEL);
338 if (!s_req)
339 return -ENOMEM;
340
cfeab10b
VT		 341 if (virt_scat) {
342 virt_buf = kzalloc(buf_sz, GFP_KERNEL);
343 if (!virt_buf) {
344 kfree(s_req);
345 return -ENOMEM;
346 }
347
348 s_req->virt_dma_buf =
349 (u8 *)L1_CACHE_ALIGN((unsigned long)virt_buf);
350 } else {
3df505ad
VT		 351 /* allocate sglist */
352 s_req->sgentries = kzalloc(sg_sz, GFP_KERNEL);
353
354 if (!s_req->sgentries) {
355 kfree(s_req);
356 return -ENOMEM;
357 }
358 }
359
360 /* allocate a bus request for this scatter request */
361 bus_req = ath6kl_sdio_alloc_busreq(ar_sdio);
362 if (!bus_req) {
363 kfree(s_req->sgentries);
cfeab10b 364 kfree(s_req->virt_dma_buf);
3df505ad
VT		 365 kfree(s_req);
366 return -ENOMEM;
367 }
368
369 /* assign the scatter request to this bus request */
370 bus_req->scat_req = s_req;
371 s_req->busrequest = bus_req;
372
4a005c3e
VT		 373 s_req->virt_scat = virt_scat;
374
3df505ad
VT		 375 /* add it to the scatter pool */
376 hif_scatter_req_add(ar_sdio->ar, s_req);
377 }
378
379 return 0;
380}
381
bdcd8170
KV		 382static int ath6kl_sdio_read_write_sync(struct ath6kl *ar, u32 addr, u8 *buf,
383 u32 len, u32 request)
384{
385 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
386 u8 *tbuf = NULL;
387 int ret;
388 bool bounced = false;
389
390 if (request & HIF_BLOCK_BASIS)
391 len = round_down(len, HIF_MBOX_BLOCK_SIZE);
392
393 if (buf_needs_bounce(buf)) {
394 if (!ar_sdio->dma_buffer)
395 return -ENOMEM;
396 tbuf = ar_sdio->dma_buffer;
397 memcpy(tbuf, buf, len);
398 bounced = true;
399 } else
400 tbuf = buf;
401
da220695
VT		 402 ret = ath6kl_sdio_io(ar_sdio->func, request, addr, tbuf, len);
403 if ((request & HIF_READ) && bounced)
404 memcpy(buf, tbuf, len);
bdcd8170
KV		 405
406 return ret;
407}
408
409static void __ath6kl_sdio_write_async(struct ath6kl_sdio *ar_sdio,
410 struct bus_request *req)
411{
412 if (req->scat_req)
413 ath6kl_sdio_scat_rw(ar_sdio, req);
414 else {
415 void *context;
416 int status;
417
418 status = ath6kl_sdio_read_write_sync(ar_sdio->ar, req->address,
419 req->buffer, req->length,
420 req->request);
421 context = req->packet;
422 ath6kl_sdio_free_bus_req(ar_sdio, req);
8e8ddb2b 423 ath6kl_hif_rw_comp_handler(context, status);
bdcd8170
KV		 424 }
425}
426
427static void ath6kl_sdio_write_async_work(struct work_struct *work)
428{
429 struct ath6kl_sdio *ar_sdio;
bdcd8170
KV		 430 struct bus_request *req, *tmp_req;
431
432 ar_sdio = container_of(work, struct ath6kl_sdio, wr_async_work);
bdcd8170 433
151bd30b 434 spin_lock_bh(&ar_sdio->wr_async_lock);
bdcd8170
KV		 435 list_for_each_entry_safe(req, tmp_req, &ar_sdio->wr_asyncq, list) {
436 list_del(&req->list);
151bd30b 437 spin_unlock_bh(&ar_sdio->wr_async_lock);
bdcd8170 438 __ath6kl_sdio_write_async(ar_sdio, req);
151bd30b 439 spin_lock_bh(&ar_sdio->wr_async_lock);
bdcd8170 440 }
151bd30b 441 spin_unlock_bh(&ar_sdio->wr_async_lock);
bdcd8170
KV		 442}
443
444static void ath6kl_sdio_irq_handler(struct sdio_func *func)
445{
446 int status;
447 struct ath6kl_sdio *ar_sdio;
448
f7325b85
KV		 449 ath6kl_dbg(ATH6KL_DBG_SDIO, "irq\n");
450
bdcd8170
KV		 451 ar_sdio = sdio_get_drvdata(func);
452 atomic_set(&ar_sdio->irq_handling, 1);
453
454 /*
455 * Release the host during interrups so we can pick it back up when
456 * we process commands.
457 */
458 sdio_release_host(ar_sdio->func);
459
8e8ddb2b 460 status = ath6kl_hif_intr_bh_handler(ar_sdio->ar);
bdcd8170
KV		 461 sdio_claim_host(ar_sdio->func);
462 atomic_set(&ar_sdio->irq_handling, 0);
463 WARN_ON(status && status != -ECANCELED);
464}
465
466static int ath6kl_sdio_power_on(struct ath6kl_sdio *ar_sdio)
467{
468 struct sdio_func *func = ar_sdio->func;
469 int ret = 0;
470
471 if (!ar_sdio->is_disabled)
472 return 0;
473
474 sdio_claim_host(func);
475
476 ret = sdio_enable_func(func);
477 if (ret) {
478 ath6kl_err("Unable to enable sdio func: %d)\n", ret);
479 sdio_release_host(func);
480 return ret;
481 }
482
483 sdio_release_host(func);
484
485 /*
486 * Wait for hardware to initialise. It should take a lot less than
487 * 10 ms but let's be conservative here.
488 */
489 msleep(10);
490
491 ar_sdio->is_disabled = false;
492
493 return ret;
494}
495
496static int ath6kl_sdio_power_off(struct ath6kl_sdio *ar_sdio)
497{
498 int ret;
499
500 if (ar_sdio->is_disabled)
501 return 0;
502
503 /* Disable the card */
504 sdio_claim_host(ar_sdio->func);
505 ret = sdio_disable_func(ar_sdio->func);
506 sdio_release_host(ar_sdio->func);
507
508 if (ret)
509 return ret;
510
511 ar_sdio->is_disabled = true;
512
513 return ret;
514}
515
516static int ath6kl_sdio_write_async(struct ath6kl *ar, u32 address, u8 *buffer,
517 u32 length, u32 request,
518 struct htc_packet *packet)
519{
520 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
521 struct bus_request *bus_req;
bdcd8170
KV		 522
523 bus_req = ath6kl_sdio_alloc_busreq(ar_sdio);
524
525 if (!bus_req)
526 return -ENOMEM;
527
528 bus_req->address = address;
529 bus_req->buffer = buffer;
530 bus_req->length = length;
531 bus_req->request = request;
532 bus_req->packet = packet;
533
151bd30b 534 spin_lock_bh(&ar_sdio->wr_async_lock);
bdcd8170 535 list_add_tail(&bus_req->list, &ar_sdio->wr_asyncq);
151bd30b 536 spin_unlock_bh(&ar_sdio->wr_async_lock);
bdcd8170
KV		 537 queue_work(ar->ath6kl_wq, &ar_sdio->wr_async_work);
538
539 return 0;
540}
541
542static void ath6kl_sdio_irq_enable(struct ath6kl *ar)
543{
544 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
545 int ret;
546
547 sdio_claim_host(ar_sdio->func);
548
549 /* Register the isr */
550 ret = sdio_claim_irq(ar_sdio->func, ath6kl_sdio_irq_handler);
551 if (ret)
552 ath6kl_err("Failed to claim sdio irq: %d\n", ret);
553
554 sdio_release_host(ar_sdio->func);
555}
556
557static void ath6kl_sdio_irq_disable(struct ath6kl *ar)
558{
559 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
560 int ret;
561
562 sdio_claim_host(ar_sdio->func);
563
564 /* Mask our function IRQ */
565 while (atomic_read(&ar_sdio->irq_handling)) {
566 sdio_release_host(ar_sdio->func);
567 schedule_timeout(HZ / 10);
568 sdio_claim_host(ar_sdio->func);
569 }
570
571 ret = sdio_release_irq(ar_sdio->func);
572 if (ret)
573 ath6kl_err("Failed to release sdio irq: %d\n", ret);
574
575 sdio_release_host(ar_sdio->func);
576}
577
578static struct hif_scatter_req *ath6kl_sdio_scatter_req_get(struct ath6kl *ar)
579{
580 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
581 struct hif_scatter_req *node = NULL;
bdcd8170 582
151bd30b 583 spin_lock_bh(&ar_sdio->scat_lock);
bdcd8170
KV		 584
585 if (!list_empty(&ar_sdio->scat_req)) {
586 node = list_first_entry(&ar_sdio->scat_req,
587 struct hif_scatter_req, list);
588 list_del(&node->list);
589 }
590
151bd30b 591 spin_unlock_bh(&ar_sdio->scat_lock);
bdcd8170
KV		 592
593 return node;
594}
595
596static void ath6kl_sdio_scatter_req_add(struct ath6kl *ar,
597 struct hif_scatter_req *s_req)
598{
599 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
bdcd8170 600
151bd30b 601 spin_lock_bh(&ar_sdio->scat_lock);
bdcd8170
KV		 602
603 list_add_tail(&s_req->list, &ar_sdio->scat_req);
604
151bd30b 605 spin_unlock_bh(&ar_sdio->scat_lock);
bdcd8170
KV		 606
607}
608
c630d18a
VT		 609/* scatter gather read write request */
610static int ath6kl_sdio_async_rw_scatter(struct ath6kl *ar,
611 struct hif_scatter_req *scat_req)
612{
613 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
c630d18a
VT		 614 u32 request = scat_req->req;
615 int status = 0;
c630d18a
VT		 616
617 if (!scat_req->len)
618 return -EINVAL;
619
620 ath6kl_dbg(ATH6KL_DBG_SCATTER,
621 "hif-scatter: total len: %d scatter entries: %d\n",
622 scat_req->len, scat_req->scat_entries);
623
861dd058 624 if (request & HIF_SYNCHRONOUS)
d4df7890 625 status = ath6kl_sdio_scat_rw(ar_sdio, scat_req->busrequest);
861dd058 626 else {
151bd30b 627 spin_lock_bh(&ar_sdio->wr_async_lock);
d4df7890 628 list_add_tail(&scat_req->busrequest->list, &ar_sdio->wr_asyncq);
151bd30b 629 spin_unlock_bh(&ar_sdio->wr_async_lock);
c630d18a
VT		 630 queue_work(ar->ath6kl_wq, &ar_sdio->wr_async_work);
631 }
632
633 return status;
634}
635
18a0f93e
VT		 636/* clean up scatter support */
637static void ath6kl_sdio_cleanup_scatter(struct ath6kl *ar)
638{
639 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
640 struct hif_scatter_req *s_req, *tmp_req;
18a0f93e
VT		 641
642 /* empty the free list */
151bd30b 643 spin_lock_bh(&ar_sdio->scat_lock);
18a0f93e
VT		 644 list_for_each_entry_safe(s_req, tmp_req, &ar_sdio->scat_req, list) {
645 list_del(&s_req->list);
151bd30b 646 spin_unlock_bh(&ar_sdio->scat_lock);
18a0f93e
VT		 647
648 if (s_req->busrequest)
649 ath6kl_sdio_free_bus_req(ar_sdio, s_req->busrequest);
650 kfree(s_req->virt_dma_buf);
651 kfree(s_req->sgentries);
652 kfree(s_req);
653
151bd30b 654 spin_lock_bh(&ar_sdio->scat_lock);
18a0f93e 655 }
151bd30b 656 spin_unlock_bh(&ar_sdio->scat_lock);
18a0f93e
VT		 657}
658
659/* setup of HIF scatter resources */
50745af7 660static int ath6kl_sdio_enable_scatter(struct ath6kl *ar)
18a0f93e
VT		 661{
662 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
50745af7 663 struct htc_target *target = ar->htc_target;
cfeab10b
VT		 664 int ret;
665 bool virt_scat = false;
18a0f93e
VT		 666
667 /* check if host supports scatter and it meets our requirements */
668 if (ar_sdio->func->card->host->max_segs < MAX_SCATTER_ENTRIES_PER_REQ) {
cfeab10b 669 ath6kl_err("host only supports scatter of :%d entries, need: %d\n",
18a0f93e
VT		 670 ar_sdio->func->card->host->max_segs,
671 MAX_SCATTER_ENTRIES_PER_REQ);
cfeab10b 672 virt_scat = true;
18a0f93e
VT		 673 }
674
cfeab10b
VT		 675 if (!virt_scat) {
676 ret = ath6kl_sdio_alloc_prep_scat_req(ar_sdio,
677 MAX_SCATTER_ENTRIES_PER_REQ,
678 MAX_SCATTER_REQUESTS, virt_scat);
679
680 if (!ret) {
f7325b85 681 ath6kl_dbg(ATH6KL_DBG_SCATTER,
cfeab10b
VT		 682 "hif-scatter enabled: max scatter req : %d entries: %d\n",
683 MAX_SCATTER_REQUESTS,
684 MAX_SCATTER_ENTRIES_PER_REQ);
685
50745af7
VT		 686 target->max_scat_entries = MAX_SCATTER_ENTRIES_PER_REQ;
687 target->max_xfer_szper_scatreq =
cfeab10b
VT		 688 MAX_SCATTER_REQ_TRANSFER_SIZE;
689 } else {
690 ath6kl_sdio_cleanup_scatter(ar);
691 ath6kl_warn("hif scatter resource setup failed, trying virtual scatter method\n");
692 }
693 }
18a0f93e 694
cfeab10b
VT		 695 if (virt_scat || ret) {
696 ret = ath6kl_sdio_alloc_prep_scat_req(ar_sdio,
697 ATH6KL_SCATTER_ENTRIES_PER_REQ,
698 ATH6KL_SCATTER_REQS, virt_scat);
699
700 if (ret) {
701 ath6kl_err("failed to alloc virtual scatter resources !\n");
702 ath6kl_sdio_cleanup_scatter(ar);
703 return ret;
704 }
705
f7325b85 706 ath6kl_dbg(ATH6KL_DBG_SCATTER,
cfeab10b
VT		 707 "Vitual scatter enabled, max_scat_req:%d, entries:%d\n",
708 ATH6KL_SCATTER_REQS, ATH6KL_SCATTER_ENTRIES_PER_REQ);
709
50745af7
VT		 710 target->max_scat_entries = ATH6KL_SCATTER_ENTRIES_PER_REQ;
711 target->max_xfer_szper_scatreq =
cfeab10b 712 ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
18a0f93e
VT		 713 }
714
18a0f93e
VT		 715 return 0;
716}
717
abcb344b
KV		 718static int ath6kl_sdio_suspend(struct ath6kl *ar)
719{
720 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
721 struct sdio_func *func = ar_sdio->func;
722 mmc_pm_flag_t flags;
723 int ret;
724
725 flags = sdio_get_host_pm_caps(func);
726
727 if (!(flags & MMC_PM_KEEP_POWER))
728 /* as host doesn't support keep power we need to bail out */
f7325b85
KV		 729 ath6kl_dbg(ATH6KL_DBG_SDIO,
730 "func %d doesn't support MMC_PM_KEEP_POWER\n",
731 func->num);
abcb344b
KV		 732 return -EINVAL;
733
734 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
735 if (ret) {
736 printk(KERN_ERR "ath6kl: set sdio pm flags failed: %d\n",
737 ret);
738 return ret;
739 }
740
741 ath6kl_deep_sleep_enable(ar);
742
743 return 0;
744}
745
aa6cffc1
CN		 746static int ath6kl_sdio_resume(struct ath6kl *ar)
747{
748 if (ar->wmi->pwr_mode != ar->wmi->saved_pwr_mode) {
749 if (ath6kl_wmi_powermode_cmd(ar->wmi,
750 ar->wmi->saved_pwr_mode) != 0)
751 ath6kl_warn("ath6kl_sdio_resume: "
752 "wmi_powermode_cmd failed\n");
753 }
754
755 return 0;
756}
757
bdcd8170
KV		 758static const struct ath6kl_hif_ops ath6kl_sdio_ops = {
759 .read_write_sync = ath6kl_sdio_read_write_sync,
760 .write_async = ath6kl_sdio_write_async,
761 .irq_enable = ath6kl_sdio_irq_enable,
762 .irq_disable = ath6kl_sdio_irq_disable,
763 .scatter_req_get = ath6kl_sdio_scatter_req_get,
764 .scatter_req_add = ath6kl_sdio_scatter_req_add,
765 .enable_scatter = ath6kl_sdio_enable_scatter,
f74a7361 766 .scat_req_rw = ath6kl_sdio_async_rw_scatter,
bdcd8170 767 .cleanup_scatter = ath6kl_sdio_cleanup_scatter,
abcb344b 768 .suspend = ath6kl_sdio_suspend,
aa6cffc1 769 .resume = ath6kl_sdio_resume,
bdcd8170
KV		 770};
771
772static int ath6kl_sdio_probe(struct sdio_func *func,
773 const struct sdio_device_id *id)
774{
775 int ret;
776 struct ath6kl_sdio *ar_sdio;
777 struct ath6kl *ar;
778 int count;
779
f7325b85
KV		 780 ath6kl_dbg(ATH6KL_DBG_SDIO,
781 "new func %d vendor 0x%x device 0x%x block 0x%x/0x%x\n",
782 func->num, func->vendor, func->device,
783 func->max_blksize, func->cur_blksize);
bdcd8170
KV		 784
785 ar_sdio = kzalloc(sizeof(struct ath6kl_sdio), GFP_KERNEL);
786 if (!ar_sdio)
787 return -ENOMEM;
788
789 ar_sdio->dma_buffer = kzalloc(HIF_DMA_BUFFER_SIZE, GFP_KERNEL);
790 if (!ar_sdio->dma_buffer) {
791 ret = -ENOMEM;
792 goto err_hif;
793 }
794
795 ar_sdio->func = func;
796 sdio_set_drvdata(func, ar_sdio);
797
798 ar_sdio->id = id;
799 ar_sdio->is_disabled = true;
800
801 spin_lock_init(&ar_sdio->lock);
802 spin_lock_init(&ar_sdio->scat_lock);
803 spin_lock_init(&ar_sdio->wr_async_lock);
804
805 INIT_LIST_HEAD(&ar_sdio->scat_req);
806 INIT_LIST_HEAD(&ar_sdio->bus_req_freeq);
807 INIT_LIST_HEAD(&ar_sdio->wr_asyncq);
808
809 INIT_WORK(&ar_sdio->wr_async_work, ath6kl_sdio_write_async_work);
810
811 for (count = 0; count < BUS_REQUEST_MAX_NUM; count++)
812 ath6kl_sdio_free_bus_req(ar_sdio, &ar_sdio->bus_req[count]);
813
814 ar = ath6kl_core_alloc(&ar_sdio->func->dev);
815 if (!ar) {
816 ath6kl_err("Failed to alloc ath6kl core\n");
817 ret = -ENOMEM;
818 goto err_dma;
819 }
820
821 ar_sdio->ar = ar;
822 ar->hif_priv = ar_sdio;
823 ar->hif_ops = &ath6kl_sdio_ops;
824
825 ath6kl_sdio_set_mbox_info(ar);
826
827 sdio_claim_host(func);
828
829 if ((ar_sdio->id->device & MANUFACTURER_ID_ATH6KL_BASE_MASK) >=
830 MANUFACTURER_ID_AR6003_BASE) {
831 /* enable 4-bit ASYNC interrupt on AR6003 or later */
832 ret = ath6kl_sdio_func0_cmd52_wr_byte(func->card,
833 CCCR_SDIO_IRQ_MODE_REG,
834 SDIO_IRQ_MODE_ASYNC_4BIT_IRQ);
835 if (ret) {
836 ath6kl_err("Failed to enable 4-bit async irq mode %d\n",
837 ret);
838 sdio_release_host(func);
9df337a1 839 goto err_cfg80211;
bdcd8170
KV		 840 }
841
f7325b85 842 ath6kl_dbg(ATH6KL_DBG_SDIO, "4-bit async irq mode enabled\n");
bdcd8170
KV		 843 }
844
845 /* give us some time to enable, in ms */
846 func->enable_timeout = 100;
847
848 sdio_release_host(func);
849
850 ret = ath6kl_sdio_power_on(ar_sdio);
851 if (ret)
9df337a1 852 goto err_cfg80211;
bdcd8170
KV		 853
854 sdio_claim_host(func);
855
856 ret = sdio_set_block_size(func, HIF_MBOX_BLOCK_SIZE);
857 if (ret) {
858 ath6kl_err("Set sdio block size %d failed: %d)\n",
859 HIF_MBOX_BLOCK_SIZE, ret);
860 sdio_release_host(func);
861 goto err_off;
862 }
863
864 sdio_release_host(func);
865
866 ret = ath6kl_core_init(ar);
867 if (ret) {
868 ath6kl_err("Failed to init ath6kl core\n");
869 goto err_off;
870 }
871
872 return ret;
873
874err_off:
875 ath6kl_sdio_power_off(ar_sdio);
9df337a1
VN		 876err_cfg80211:
877 ath6kl_cfg80211_deinit(ar_sdio->ar);
bdcd8170
KV		 878err_dma:
879 kfree(ar_sdio->dma_buffer);
880err_hif:
881 kfree(ar_sdio);
882
883 return ret;
884}
885
886static void ath6kl_sdio_remove(struct sdio_func *func)
887{
888 struct ath6kl_sdio *ar_sdio;
889
f7325b85
KV		 890 ath6kl_dbg(ATH6KL_DBG_SDIO,
891 "removed func %d vendor 0x%x device 0x%x\n",
892 func->num, func->vendor, func->device);
893
bdcd8170
KV		 894 ar_sdio = sdio_get_drvdata(func);
895
896 ath6kl_stop_txrx(ar_sdio->ar);
897 cancel_work_sync(&ar_sdio->wr_async_work);
898
899 ath6kl_unavail_ev(ar_sdio->ar);
900
901 ath6kl_sdio_power_off(ar_sdio);
902
903 kfree(ar_sdio->dma_buffer);
904 kfree(ar_sdio);
905}
906
907static const struct sdio_device_id ath6kl_sdio_devices[] = {
908 {SDIO_DEVICE(MANUFACTURER_CODE, (MANUFACTURER_ID_AR6003_BASE | 0x0))},
909 {SDIO_DEVICE(MANUFACTURER_CODE, (MANUFACTURER_ID_AR6003_BASE | 0x1))},
910 {},
911};
912
913MODULE_DEVICE_TABLE(sdio, ath6kl_sdio_devices);
914
915static struct sdio_driver ath6kl_sdio_driver = {
916 .name = "ath6kl_sdio",
917 .id_table = ath6kl_sdio_devices,
918 .probe = ath6kl_sdio_probe,
919 .remove = ath6kl_sdio_remove,
920};
921
922static int __init ath6kl_sdio_init(void)
923{
924 int ret;
925
926 ret = sdio_register_driver(&ath6kl_sdio_driver);
927 if (ret)
928 ath6kl_err("sdio driver registration failed: %d\n", ret);
929
930 return ret;
931}
932
933static void __exit ath6kl_sdio_exit(void)
934{
935 sdio_unregister_driver(&ath6kl_sdio_driver);
936}
937
938module_init(ath6kl_sdio_init);
939module_exit(ath6kl_sdio_exit);
940
941MODULE_AUTHOR("Atheros Communications, Inc.");
942MODULE_DESCRIPTION("Driver support for Atheros AR600x SDIO devices");
943MODULE_LICENSE("Dual BSD/GPL");
944
945MODULE_FIRMWARE(AR6003_REV2_OTP_FILE);
946MODULE_FIRMWARE(AR6003_REV2_FIRMWARE_FILE);
947MODULE_FIRMWARE(AR6003_REV2_PATCH_FILE);
948MODULE_FIRMWARE(AR6003_REV2_BOARD_DATA_FILE);
949MODULE_FIRMWARE(AR6003_REV2_DEFAULT_BOARD_DATA_FILE);
950MODULE_FIRMWARE(AR6003_REV3_OTP_FILE);
951MODULE_FIRMWARE(AR6003_REV3_FIRMWARE_FILE);
952MODULE_FIRMWARE(AR6003_REV3_PATCH_FILE);
953MODULE_FIRMWARE(AR6003_REV3_BOARD_DATA_FILE);
954MODULE_FIRMWARE(AR6003_REV3_DEFAULT_BOARD_DATA_FILE);
Linux kernel - Deliverables
This page took 0.088782 seconds and 5 git commands to generate.