2 * Copyright (c) 2004-2011 Atheros Communications Inc.
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.
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.
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>
31 struct sdio_func *func;
36 struct list_head bus_req_freeq;
38 /* available bus requests */
39 struct bus_request bus_req[BUS_REQUEST_MAX_NUM];
44 /* scatter request list head */
45 struct list_head scat_req;
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;
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
62 static inline struct ath6kl_sdio *ath6kl_sdio_priv(struct ath6kl *ar)
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.
73 static inline bool buf_needs_bounce(u8 *buf)
75 return ((unsigned long) buf & 0x3) || !virt_addr_valid(buf);
78 static void ath6kl_sdio_set_mbox_info(struct ath6kl *ar)
80 struct ath6kl_mbox_info *mbox_info = &ar->mbox_info;
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;
91 static inline void ath6kl_sdio_set_cmd53_arg(u32 *arg, u8 rw, u8 func,
92 u8 mode, u8 opcode, u32 addr,
95 *arg = (((rw & 1) << 31) |
96 ((func & 0x7) << 28) |
98 ((opcode & 1) << 26) |
99 ((addr & 0x1FFFF) << 9) |
103 static inline void ath6kl_sdio_set_cmd52_arg(u32 *arg, u8 write, u8 raw,
104 unsigned int address,
109 *arg = ((write & 1) << 31) |
110 ((func & 0x7) << 28) |
113 ((address & 0x1FFFF) << 9) |
118 static int ath6kl_sdio_func0_cmd52_wr_byte(struct mmc_card *card,
119 unsigned int address,
122 struct mmc_command io_cmd;
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;
129 return mmc_wait_for_cmd(card->host, &io_cmd, 0);
132 static int ath6kl_sdio_io(struct sdio_func *func, u32 request, u32 addr,
137 sdio_claim_host(func);
139 if (request & HIF_WRITE) {
140 /* FIXME: looks like ugly workaround for something */
141 if (addr >= HIF_MBOX_BASE_ADDR &&
142 addr <= HIF_MBOX_END_ADDR)
143 addr += (HIF_MBOX_WIDTH - len);
145 /* FIXME: this also looks like ugly workaround */
146 if (addr == HIF_MBOX0_EXT_BASE_ADDR)
147 addr += HIF_MBOX0_EXT_WIDTH - len;
149 if (request & HIF_FIXED_ADDRESS)
150 ret = sdio_writesb(func, addr, buf, len);
152 ret = sdio_memcpy_toio(func, addr, buf, len);
154 if (request & HIF_FIXED_ADDRESS)
155 ret = sdio_readsb(func, buf, addr, len);
157 ret = sdio_memcpy_fromio(func, buf, addr, len);
160 sdio_release_host(func);
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);
170 static struct bus_request *ath6kl_sdio_alloc_busreq(struct ath6kl_sdio *ar_sdio)
172 struct bus_request *bus_req;
174 spin_lock_bh(&ar_sdio->lock);
176 if (list_empty(&ar_sdio->bus_req_freeq)) {
177 spin_unlock_bh(&ar_sdio->lock);
181 bus_req = list_first_entry(&ar_sdio->bus_req_freeq,
182 struct bus_request, list);
183 list_del(&bus_req->list);
185 spin_unlock_bh(&ar_sdio->lock);
186 ath6kl_dbg(ATH6KL_DBG_SCATTER, "%s: bus request 0x%p\n",
192 static void ath6kl_sdio_free_bus_req(struct ath6kl_sdio *ar_sdio,
193 struct bus_request *bus_req)
195 ath6kl_dbg(ATH6KL_DBG_SCATTER, "%s: bus request 0x%p\n",
198 spin_lock_bh(&ar_sdio->lock);
199 list_add_tail(&bus_req->list, &ar_sdio->bus_req_freeq);
200 spin_unlock_bh(&ar_sdio->lock);
203 static void ath6kl_sdio_setup_scat_data(struct hif_scatter_req *scat_req,
204 struct mmc_data *data)
206 struct scatterlist *sg;
209 data->blksz = HIF_MBOX_BLOCK_SIZE;
210 data->blocks = scat_req->len / HIF_MBOX_BLOCK_SIZE;
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);
218 data->flags = (scat_req->req & HIF_WRITE) ? MMC_DATA_WRITE :
221 /* fill SG entries */
222 sg = scat_req->sgentries;
223 sg_init_table(sg, scat_req->scat_entries);
225 /* assemble SG list */
226 for (i = 0; i < scat_req->scat_entries; i++, sg++) {
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);
231 sg_set_buf(sg, scat_req->scat_list[i].buf,
232 scat_req->scat_list[i].len);
235 /* set scatter-gather table for request */
236 data->sg = scat_req->sgentries;
237 data->sg_len = scat_req->scat_entries;
240 static int ath6kl_sdio_scat_rw(struct ath6kl_sdio *ar_sdio,
241 struct bus_request *req)
243 struct mmc_request mmc_req;
244 struct mmc_command cmd;
245 struct mmc_data data;
246 struct hif_scatter_req *scat_req;
250 scat_req = req->scat_req;
252 if (scat_req->virt_scat) {
254 if (scat_req->req & HIF_BLOCK_BASIS)
255 len = round_down(len, HIF_MBOX_BLOCK_SIZE);
257 status = ath6kl_sdio_io(ar_sdio->func, scat_req->req,
258 scat_req->addr, scat_req->virt_dma_buf,
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));
267 ath6kl_sdio_setup_scat_data(scat_req, &data);
269 opcode = (scat_req->req & HIF_FIXED_ADDRESS) ?
270 CMD53_ARG_FIXED_ADDRESS : CMD53_ARG_INCR_ADDRESS;
272 rw = (scat_req->req & HIF_WRITE) ? CMD53_ARG_WRITE : CMD53_ARG_READ;
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;
279 /* Uses extended address range */
280 scat_req->addr += HIF_MBOX0_EXT_WIDTH - scat_req->len;
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,
288 cmd.opcode = SD_IO_RW_EXTENDED;
289 cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
292 mmc_req.data = &data;
294 sdio_claim_host(ar_sdio->func);
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);
300 sdio_release_host(ar_sdio->func);
302 status = cmd.error ? cmd.error : data.error;
305 scat_req->status = status;
307 if (scat_req->status)
308 ath6kl_err("Scatter write request failed:%d\n",
311 if (scat_req->req & HIF_ASYNCHRONOUS)
312 scat_req->complete(ar_sdio->ar->htc_target, scat_req);
317 static int ath6kl_sdio_alloc_prep_scat_req(struct ath6kl_sdio *ar_sdio,
318 int n_scat_entry, int n_scat_req,
321 struct hif_scatter_req *s_req;
322 struct bus_request *bus_req;
323 int i, scat_req_sz, scat_list_sz, sg_sz, buf_sz;
326 scat_list_sz = (n_scat_entry - 1) * sizeof(struct hif_scatter_item);
327 scat_req_sz = sizeof(*s_req) + scat_list_sz;
330 sg_sz = sizeof(struct scatterlist) * n_scat_entry;
332 buf_sz = 2 * L1_CACHE_BYTES +
333 ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
335 for (i = 0; i < n_scat_req; i++) {
336 /* allocate the scatter request */
337 s_req = kzalloc(scat_req_sz, GFP_KERNEL);
342 virt_buf = kzalloc(buf_sz, GFP_KERNEL);
348 s_req->virt_dma_buf =
349 (u8 *)L1_CACHE_ALIGN((unsigned long)virt_buf);
351 /* allocate sglist */
352 s_req->sgentries = kzalloc(sg_sz, GFP_KERNEL);
354 if (!s_req->sgentries) {
360 /* allocate a bus request for this scatter request */
361 bus_req = ath6kl_sdio_alloc_busreq(ar_sdio);
363 kfree(s_req->sgentries);
364 kfree(s_req->virt_dma_buf);
369 /* assign the scatter request to this bus request */
370 bus_req->scat_req = s_req;
371 s_req->busrequest = bus_req;
373 s_req->virt_scat = virt_scat;
375 /* add it to the scatter pool */
376 hif_scatter_req_add(ar_sdio->ar, s_req);
382 static int ath6kl_sdio_read_write_sync(struct ath6kl *ar, u32 addr, u8 *buf,
383 u32 len, u32 request)
385 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
388 bool bounced = false;
390 if (request & HIF_BLOCK_BASIS)
391 len = round_down(len, HIF_MBOX_BLOCK_SIZE);
393 if (buf_needs_bounce(buf)) {
394 if (!ar_sdio->dma_buffer)
396 tbuf = ar_sdio->dma_buffer;
397 memcpy(tbuf, buf, len);
402 ret = ath6kl_sdio_io(ar_sdio->func, request, addr, tbuf, len);
403 if ((request & HIF_READ) && bounced)
404 memcpy(buf, tbuf, len);
409 static void __ath6kl_sdio_write_async(struct ath6kl_sdio *ar_sdio,
410 struct bus_request *req)
413 ath6kl_sdio_scat_rw(ar_sdio, req);
418 status = ath6kl_sdio_read_write_sync(ar_sdio->ar, req->address,
419 req->buffer, req->length,
421 context = req->packet;
422 ath6kl_sdio_free_bus_req(ar_sdio, req);
423 ath6kl_hif_rw_comp_handler(context, status);
427 static void ath6kl_sdio_write_async_work(struct work_struct *work)
429 struct ath6kl_sdio *ar_sdio;
430 struct bus_request *req, *tmp_req;
432 ar_sdio = container_of(work, struct ath6kl_sdio, wr_async_work);
434 spin_lock_bh(&ar_sdio->wr_async_lock);
435 list_for_each_entry_safe(req, tmp_req, &ar_sdio->wr_asyncq, list) {
436 list_del(&req->list);
437 spin_unlock_bh(&ar_sdio->wr_async_lock);
438 __ath6kl_sdio_write_async(ar_sdio, req);
439 spin_lock_bh(&ar_sdio->wr_async_lock);
441 spin_unlock_bh(&ar_sdio->wr_async_lock);
444 static void ath6kl_sdio_irq_handler(struct sdio_func *func)
447 struct ath6kl_sdio *ar_sdio;
449 ath6kl_dbg(ATH6KL_DBG_SDIO, "irq\n");
451 ar_sdio = sdio_get_drvdata(func);
452 atomic_set(&ar_sdio->irq_handling, 1);
455 * Release the host during interrups so we can pick it back up when
456 * we process commands.
458 sdio_release_host(ar_sdio->func);
460 status = ath6kl_hif_intr_bh_handler(ar_sdio->ar);
461 sdio_claim_host(ar_sdio->func);
462 atomic_set(&ar_sdio->irq_handling, 0);
463 WARN_ON(status && status != -ECANCELED);
466 static int ath6kl_sdio_power_on(struct ath6kl_sdio *ar_sdio)
468 struct sdio_func *func = ar_sdio->func;
471 if (!ar_sdio->is_disabled)
474 sdio_claim_host(func);
476 ret = sdio_enable_func(func);
478 ath6kl_err("Unable to enable sdio func: %d)\n", ret);
479 sdio_release_host(func);
483 sdio_release_host(func);
486 * Wait for hardware to initialise. It should take a lot less than
487 * 10 ms but let's be conservative here.
491 ar_sdio->is_disabled = false;
496 static int ath6kl_sdio_power_off(struct ath6kl_sdio *ar_sdio)
500 if (ar_sdio->is_disabled)
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);
511 ar_sdio->is_disabled = true;
516 static int ath6kl_sdio_write_async(struct ath6kl *ar, u32 address, u8 *buffer,
517 u32 length, u32 request,
518 struct htc_packet *packet)
520 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
521 struct bus_request *bus_req;
523 bus_req = ath6kl_sdio_alloc_busreq(ar_sdio);
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;
534 spin_lock_bh(&ar_sdio->wr_async_lock);
535 list_add_tail(&bus_req->list, &ar_sdio->wr_asyncq);
536 spin_unlock_bh(&ar_sdio->wr_async_lock);
537 queue_work(ar->ath6kl_wq, &ar_sdio->wr_async_work);
542 static void ath6kl_sdio_irq_enable(struct ath6kl *ar)
544 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
547 sdio_claim_host(ar_sdio->func);
549 /* Register the isr */
550 ret = sdio_claim_irq(ar_sdio->func, ath6kl_sdio_irq_handler);
552 ath6kl_err("Failed to claim sdio irq: %d\n", ret);
554 sdio_release_host(ar_sdio->func);
557 static void ath6kl_sdio_irq_disable(struct ath6kl *ar)
559 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
562 sdio_claim_host(ar_sdio->func);
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);
571 ret = sdio_release_irq(ar_sdio->func);
573 ath6kl_err("Failed to release sdio irq: %d\n", ret);
575 sdio_release_host(ar_sdio->func);
578 static struct hif_scatter_req *ath6kl_sdio_scatter_req_get(struct ath6kl *ar)
580 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
581 struct hif_scatter_req *node = NULL;
583 spin_lock_bh(&ar_sdio->scat_lock);
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);
591 spin_unlock_bh(&ar_sdio->scat_lock);
596 static void ath6kl_sdio_scatter_req_add(struct ath6kl *ar,
597 struct hif_scatter_req *s_req)
599 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
601 spin_lock_bh(&ar_sdio->scat_lock);
603 list_add_tail(&s_req->list, &ar_sdio->scat_req);
605 spin_unlock_bh(&ar_sdio->scat_lock);
609 /* scatter gather read write request */
610 static int ath6kl_sdio_async_rw_scatter(struct ath6kl *ar,
611 struct hif_scatter_req *scat_req)
613 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
614 u32 request = scat_req->req;
620 ath6kl_dbg(ATH6KL_DBG_SCATTER,
621 "hif-scatter: total len: %d scatter entries: %d\n",
622 scat_req->len, scat_req->scat_entries);
624 if (request & HIF_SYNCHRONOUS)
625 status = ath6kl_sdio_scat_rw(ar_sdio, scat_req->busrequest);
627 spin_lock_bh(&ar_sdio->wr_async_lock);
628 list_add_tail(&scat_req->busrequest->list, &ar_sdio->wr_asyncq);
629 spin_unlock_bh(&ar_sdio->wr_async_lock);
630 queue_work(ar->ath6kl_wq, &ar_sdio->wr_async_work);
636 /* clean up scatter support */
637 static void ath6kl_sdio_cleanup_scatter(struct ath6kl *ar)
639 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
640 struct hif_scatter_req *s_req, *tmp_req;
642 /* empty the free list */
643 spin_lock_bh(&ar_sdio->scat_lock);
644 list_for_each_entry_safe(s_req, tmp_req, &ar_sdio->scat_req, list) {
645 list_del(&s_req->list);
646 spin_unlock_bh(&ar_sdio->scat_lock);
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);
654 spin_lock_bh(&ar_sdio->scat_lock);
656 spin_unlock_bh(&ar_sdio->scat_lock);
659 /* setup of HIF scatter resources */
660 static int ath6kl_sdio_enable_scatter(struct ath6kl *ar)
662 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
663 struct htc_target *target = ar->htc_target;
665 bool virt_scat = false;
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) {
669 ath6kl_err("host only supports scatter of :%d entries, need: %d\n",
670 ar_sdio->func->card->host->max_segs,
671 MAX_SCATTER_ENTRIES_PER_REQ);
676 ret = ath6kl_sdio_alloc_prep_scat_req(ar_sdio,
677 MAX_SCATTER_ENTRIES_PER_REQ,
678 MAX_SCATTER_REQUESTS, virt_scat);
681 ath6kl_dbg(ATH6KL_DBG_SCATTER,
682 "hif-scatter enabled: max scatter req : %d entries: %d\n",
683 MAX_SCATTER_REQUESTS,
684 MAX_SCATTER_ENTRIES_PER_REQ);
686 target->max_scat_entries = MAX_SCATTER_ENTRIES_PER_REQ;
687 target->max_xfer_szper_scatreq =
688 MAX_SCATTER_REQ_TRANSFER_SIZE;
690 ath6kl_sdio_cleanup_scatter(ar);
691 ath6kl_warn("hif scatter resource setup failed, trying virtual scatter method\n");
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);
701 ath6kl_err("failed to alloc virtual scatter resources !\n");
702 ath6kl_sdio_cleanup_scatter(ar);
706 ath6kl_dbg(ATH6KL_DBG_SCATTER,
707 "Vitual scatter enabled, max_scat_req:%d, entries:%d\n",
708 ATH6KL_SCATTER_REQS, ATH6KL_SCATTER_ENTRIES_PER_REQ);
710 target->max_scat_entries = ATH6KL_SCATTER_ENTRIES_PER_REQ;
711 target->max_xfer_szper_scatreq =
712 ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
718 static int ath6kl_sdio_suspend(struct ath6kl *ar)
720 struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
721 struct sdio_func *func = ar_sdio->func;
725 flags = sdio_get_host_pm_caps(func);
727 if (!(flags & MMC_PM_KEEP_POWER))
728 /* as host doesn't support keep power we need to bail out */
729 ath6kl_dbg(ATH6KL_DBG_SDIO,
730 "func %d doesn't support MMC_PM_KEEP_POWER\n",
734 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
736 printk(KERN_ERR "ath6kl: set sdio pm flags failed: %d\n",
741 ath6kl_deep_sleep_enable(ar);
746 static int ath6kl_sdio_resume(struct ath6kl *ar)
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");
758 static 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,
766 .scat_req_rw = ath6kl_sdio_async_rw_scatter,
767 .cleanup_scatter = ath6kl_sdio_cleanup_scatter,
768 .suspend = ath6kl_sdio_suspend,
769 .resume = ath6kl_sdio_resume,
772 static int ath6kl_sdio_probe(struct sdio_func *func,
773 const struct sdio_device_id *id)
776 struct ath6kl_sdio *ar_sdio;
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);
785 ar_sdio = kzalloc(sizeof(struct ath6kl_sdio), GFP_KERNEL);
789 ar_sdio->dma_buffer = kzalloc(HIF_DMA_BUFFER_SIZE, GFP_KERNEL);
790 if (!ar_sdio->dma_buffer) {
795 ar_sdio->func = func;
796 sdio_set_drvdata(func, ar_sdio);
799 ar_sdio->is_disabled = true;
801 spin_lock_init(&ar_sdio->lock);
802 spin_lock_init(&ar_sdio->scat_lock);
803 spin_lock_init(&ar_sdio->wr_async_lock);
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);
809 INIT_WORK(&ar_sdio->wr_async_work, ath6kl_sdio_write_async_work);
811 for (count = 0; count < BUS_REQUEST_MAX_NUM; count++)
812 ath6kl_sdio_free_bus_req(ar_sdio, &ar_sdio->bus_req[count]);
814 ar = ath6kl_core_alloc(&ar_sdio->func->dev);
816 ath6kl_err("Failed to alloc ath6kl core\n");
822 ar->hif_priv = ar_sdio;
823 ar->hif_ops = &ath6kl_sdio_ops;
825 ath6kl_sdio_set_mbox_info(ar);
827 sdio_claim_host(func);
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);
836 ath6kl_err("Failed to enable 4-bit async irq mode %d\n",
838 sdio_release_host(func);
842 ath6kl_dbg(ATH6KL_DBG_SDIO, "4-bit async irq mode enabled\n");
845 /* give us some time to enable, in ms */
846 func->enable_timeout = 100;
848 sdio_release_host(func);
850 ret = ath6kl_sdio_power_on(ar_sdio);
854 sdio_claim_host(func);
856 ret = sdio_set_block_size(func, HIF_MBOX_BLOCK_SIZE);
858 ath6kl_err("Set sdio block size %d failed: %d)\n",
859 HIF_MBOX_BLOCK_SIZE, ret);
860 sdio_release_host(func);
864 sdio_release_host(func);
866 ret = ath6kl_core_init(ar);
868 ath6kl_err("Failed to init ath6kl core\n");
875 ath6kl_sdio_power_off(ar_sdio);
877 ath6kl_cfg80211_deinit(ar_sdio->ar);
879 kfree(ar_sdio->dma_buffer);
886 static void ath6kl_sdio_remove(struct sdio_func *func)
888 struct ath6kl_sdio *ar_sdio;
890 ath6kl_dbg(ATH6KL_DBG_SDIO,
891 "removed func %d vendor 0x%x device 0x%x\n",
892 func->num, func->vendor, func->device);
894 ar_sdio = sdio_get_drvdata(func);
896 ath6kl_stop_txrx(ar_sdio->ar);
897 cancel_work_sync(&ar_sdio->wr_async_work);
899 ath6kl_unavail_ev(ar_sdio->ar);
901 ath6kl_sdio_power_off(ar_sdio);
903 kfree(ar_sdio->dma_buffer);
907 static 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))},
913 MODULE_DEVICE_TABLE(sdio, ath6kl_sdio_devices);
915 static 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,
922 static int __init ath6kl_sdio_init(void)
926 ret = sdio_register_driver(&ath6kl_sdio_driver);
928 ath6kl_err("sdio driver registration failed: %d\n", ret);
933 static void __exit ath6kl_sdio_exit(void)
935 sdio_unregister_driver(&ath6kl_sdio_driver);
938 module_init(ath6kl_sdio_init);
939 module_exit(ath6kl_sdio_exit);
941 MODULE_AUTHOR("Atheros Communications, Inc.");
942 MODULE_DESCRIPTION("Driver support for Atheros AR600x SDIO devices");
943 MODULE_LICENSE("Dual BSD/GPL");
945 MODULE_FIRMWARE(AR6003_REV2_OTP_FILE);
946 MODULE_FIRMWARE(AR6003_REV2_FIRMWARE_FILE);
947 MODULE_FIRMWARE(AR6003_REV2_PATCH_FILE);
948 MODULE_FIRMWARE(AR6003_REV2_BOARD_DATA_FILE);
949 MODULE_FIRMWARE(AR6003_REV2_DEFAULT_BOARD_DATA_FILE);
950 MODULE_FIRMWARE(AR6003_REV3_OTP_FILE);
951 MODULE_FIRMWARE(AR6003_REV3_FIRMWARE_FILE);
952 MODULE_FIRMWARE(AR6003_REV3_PATCH_FILE);
953 MODULE_FIRMWARE(AR6003_REV3_BOARD_DATA_FILE);
954 MODULE_FIRMWARE(AR6003_REV3_DEFAULT_BOARD_DATA_FILE);