e3556ff43bb9a0cb1412f356a3ce923e1dad234e
[linux-2.6.git] / drivers / staging / brcm80211 / brcmfmac / bcmsdh_linux.c
1 /*
2  * Copyright (c) 2010 Broadcom Corporation
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 ANY
11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16
17 /**
18  * @file bcmsdh_linux.c
19  */
20
21 #define __UNDEF_NO_VERSION__
22
23 #include <linux/netdevice.h>
24 #include <linux/pci.h>
25 #include <linux/completion.h>
26
27 #include <pcicfg.h>
28 #include <bcmdefs.h>
29 #include <bcmdevs.h>
30 #include <bcmutils.h>
31
32 #if defined(OOB_INTR_ONLY)
33 #include <linux/irq.h>
34 extern void dhdsdio_isr(void *args);
35 #include <dngl_stats.h>
36 #include <dhd.h>
37 #endif                          /* defined(OOB_INTR_ONLY) */
38 #if defined(CONFIG_MACH_SANDGATE2G) || defined(CONFIG_MACH_LOGICPD_PXA270)
39 #if !defined(BCMPLATFORM_BUS)
40 #define BCMPLATFORM_BUS
41 #endif                          /* !defined(BCMPLATFORM_BUS) */
42
43 #include <linux/platform_device.h>
44 #endif                          /* CONFIG_MACH_SANDGATE2G */
45
46 /**
47  * SDIO Host Controller info
48  */
49 typedef struct bcmsdh_hc bcmsdh_hc_t;
50
51 struct bcmsdh_hc {
52         bcmsdh_hc_t *next;
53 #ifdef BCMPLATFORM_BUS
54         struct device *dev;     /* platform device handle */
55 #else
56         struct pci_dev *dev;    /* pci device handle */
57 #endif                          /* BCMPLATFORM_BUS */
58         void *regs;             /* SDIO Host Controller address */
59         bcmsdh_info_t *sdh;     /* SDIO Host Controller handle */
60         void *ch;
61         unsigned int oob_irq;
62         unsigned long oob_flags;        /* OOB Host specifiction
63                                         as edge and etc */
64         bool oob_irq_registered;
65 #if defined(OOB_INTR_ONLY)
66         spinlock_t irq_lock;
67 #endif
68 };
69 static bcmsdh_hc_t *sdhcinfo;
70
71 /* driver info, initialized when bcmsdh_register is called */
72 static bcmsdh_driver_t drvinfo = { NULL, NULL };
73
74 /* debugging macros */
75 #define SDLX_MSG(x)
76
77 /**
78  * Checks to see if vendor and device IDs match a supported SDIO Host Controller.
79  */
80 bool bcmsdh_chipmatch(u16 vendor, u16 device)
81 {
82         /* Add other vendors and devices as required */
83
84 #ifdef BCMSDIOH_STD
85         /* Check for Arasan host controller */
86         if (vendor == VENDOR_SI_IMAGE)
87                 return true;
88
89         /* Check for BRCM 27XX Standard host controller */
90         if (device == BCM27XX_SDIOH_ID && vendor == VENDOR_BROADCOM)
91                 return true;
92
93         /* Check for BRCM Standard host controller */
94         if (device == SDIOH_FPGA_ID && vendor == VENDOR_BROADCOM)
95                 return true;
96
97         /* Check for TI PCIxx21 Standard host controller */
98         if (device == PCIXX21_SDIOH_ID && vendor == VENDOR_TI)
99                 return true;
100
101         if (device == PCIXX21_SDIOH0_ID && vendor == VENDOR_TI)
102                 return true;
103
104         /* Ricoh R5C822 Standard SDIO Host */
105         if (device == R5C822_SDIOH_ID && vendor == VENDOR_RICOH)
106                 return true;
107
108         /* JMicron Standard SDIO Host */
109         if (device == JMICRON_SDIOH_ID && vendor == VENDOR_JMICRON)
110                 return true;
111 #endif                          /* BCMSDIOH_STD */
112 #ifdef BCMSDIOH_SPI
113         /* This is the PciSpiHost. */
114         if (device == SPIH_FPGA_ID && vendor == VENDOR_BROADCOM) {
115                 WL_NONE("Found PCI SPI Host Controller\n");
116                 return true;
117         }
118 #endif                          /* BCMSDIOH_SPI */
119
120         return false;
121 }
122
123 #if defined(BCMPLATFORM_BUS)
124 #if defined(BCMLXSDMMC)
125 /* forward declarations */
126 int bcmsdh_probe(struct device *dev);
127 EXPORT_SYMBOL(bcmsdh_probe);
128
129 int bcmsdh_remove(struct device *dev);
130 EXPORT_SYMBOL(bcmsdh_remove);
131
132 #else
133 /* forward declarations */
134 static int __devinit bcmsdh_probe(struct device *dev);
135 static int __devexit bcmsdh_remove(struct device *dev);
136 #endif                          /* BCMLXSDMMC */
137
138 #ifndef BCMLXSDMMC
139 static
140 #endif                          /* BCMLXSDMMC */
141 int bcmsdh_probe(struct device *dev)
142 {
143         bcmsdh_hc_t *sdhc = NULL;
144         unsigned long regs = 0;
145         bcmsdh_info_t *sdh = NULL;
146 #if !defined(BCMLXSDMMC) && defined(BCMPLATFORM_BUS)
147         struct platform_device *pdev;
148         struct resource *r;
149 #endif                          /* BCMLXSDMMC */
150         int irq = 0;
151         u32 vendevid;
152         unsigned long irq_flags = 0;
153
154 #if !defined(BCMLXSDMMC) && defined(BCMPLATFORM_BUS)
155         pdev = to_platform_device(dev);
156         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
157         irq = platform_get_irq(pdev, 0);
158         if (!r || irq == NO_IRQ)
159                 return -ENXIO;
160 #endif                          /* BCMLXSDMMC */
161
162 #if defined(OOB_INTR_ONLY)
163 #ifdef HW_OOB
164         irq_flags =
165             IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL |
166             IORESOURCE_IRQ_SHAREABLE;
167 #else
168         irq_flags = IRQF_TRIGGER_FALLING;
169 #endif                          /* HW_OOB */
170         irq = dhd_customer_oob_irq_map(&irq_flags);
171         if (irq < 0) {
172                 SDLX_MSG(("%s: Host irq is not defined\n", __func__));
173                 return 1;
174         }
175 #endif                          /* defined(OOB_INTR_ONLY) */
176         /* allocate SDIO Host Controller state info */
177         sdhc = kzalloc(sizeof(bcmsdh_hc_t), GFP_ATOMIC);
178         if (!sdhc) {
179                 SDLX_MSG(("%s: out of memory\n", __func__));
180                 goto err;
181         }
182         sdhc->dev = (void *)dev;
183
184 #ifdef BCMLXSDMMC
185         sdh = bcmsdh_attach((void *)0, (void **)&regs, irq);
186         if (!sdh) {
187                 SDLX_MSG(("%s: bcmsdh_attach failed\n", __func__));
188                 goto err;
189         }
190 #else
191         sdh = bcmsdh_attach((void *)r->start, (void **)&regs, irq);
192         if (!sdh) {
193                 SDLX_MSG(("%s: bcmsdh_attach failed\n", __func__));
194                 goto err;
195         }
196 #endif                          /* BCMLXSDMMC */
197         sdhc->sdh = sdh;
198         sdhc->oob_irq = irq;
199         sdhc->oob_flags = irq_flags;
200         sdhc->oob_irq_registered = false;       /* to make sure.. */
201 #if defined(OOB_INTR_ONLY)
202         spin_lock_init(&sdhc->irq_lock);
203 #endif
204
205         /* chain SDIO Host Controller info together */
206         sdhc->next = sdhcinfo;
207         sdhcinfo = sdhc;
208         /* Read the vendor/device ID from the CIS */
209         vendevid = bcmsdh_query_device(sdh);
210
211         /* try to attach to the target device */
212         sdhc->ch = drvinfo.attach((vendevid >> 16), (vendevid & 0xFFFF),
213                                   0, 0, 0, 0, (void *)regs, sdh);
214         if (!sdhc->ch) {
215                 SDLX_MSG(("%s: device attach failed\n", __func__));
216                 goto err;
217         }
218
219         return 0;
220
221         /* error handling */
222 err:
223         if (sdhc) {
224                 if (sdhc->sdh)
225                         bcmsdh_detach(sdhc->sdh);
226                 kfree(sdhc);
227         }
228
229         return -ENODEV;
230 }
231
232 #ifndef BCMLXSDMMC
233 static
234 #endif                          /* BCMLXSDMMC */
235 int bcmsdh_remove(struct device *dev)
236 {
237         bcmsdh_hc_t *sdhc, *prev;
238
239         sdhc = sdhcinfo;
240         drvinfo.detach(sdhc->ch);
241         bcmsdh_detach(sdhc->sdh);
242         /* find the SDIO Host Controller state for this pdev
243                  and take it out from the list */
244         for (sdhc = sdhcinfo, prev = NULL; sdhc; sdhc = sdhc->next) {
245                 if (sdhc->dev == (void *)dev) {
246                         if (prev)
247                                 prev->next = sdhc->next;
248                         else
249                                 sdhcinfo = NULL;
250                         break;
251                 }
252                 prev = sdhc;
253         }
254         if (!sdhc) {
255                 SDLX_MSG(("%s: failed\n", __func__));
256                 return 0;
257         }
258
259         /* release SDIO Host Controller info */
260         kfree(sdhc);
261
262 #if !defined(BCMLXSDMMC)
263         dev_set_drvdata(dev, NULL);
264 #endif                          /* !defined(BCMLXSDMMC) */
265
266         return 0;
267 }
268 #endif                          /* BCMPLATFORM_BUS */
269
270 extern int sdio_function_init(void);
271
272 int bcmsdh_register(bcmsdh_driver_t *driver)
273 {
274         drvinfo = *driver;
275
276         SDLX_MSG(("Linux Kernel SDIO/MMC Driver\n"));
277         return sdio_function_init();
278 }
279
280 extern void sdio_function_cleanup(void);
281
282 void bcmsdh_unregister(void)
283 {
284         sdio_function_cleanup();
285 }
286
287 #if defined(OOB_INTR_ONLY)
288 void bcmsdh_oob_intr_set(bool enable)
289 {
290         static bool curstate = 1;
291         unsigned long flags;
292
293         spin_lock_irqsave(&sdhcinfo->irq_lock, flags);
294         if (curstate != enable) {
295                 if (enable)
296                         enable_irq(sdhcinfo->oob_irq);
297                 else
298                         disable_irq_nosync(sdhcinfo->oob_irq);
299                 curstate = enable;
300         }
301         spin_unlock_irqrestore(&sdhcinfo->irq_lock, flags);
302 }
303
304 static irqreturn_t wlan_oob_irq(int irq, void *dev_id)
305 {
306         dhd_pub_t *dhdp;
307
308         dhdp = (dhd_pub_t *) dev_get_drvdata(sdhcinfo->dev);
309
310         bcmsdh_oob_intr_set(0);
311
312         if (dhdp == NULL) {
313                 SDLX_MSG(("Out of band GPIO interrupt fired way too early\n"));
314                 return IRQ_HANDLED;
315         }
316
317         dhdsdio_isr((void *)dhdp->bus);
318
319         return IRQ_HANDLED;
320 }
321
322 int bcmsdh_register_oob_intr(void *dhdp)
323 {
324         int error = 0;
325
326         SDLX_MSG(("%s Enter\n", __func__));
327
328         sdhcinfo->oob_flags =
329             IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL |
330             IORESOURCE_IRQ_SHAREABLE;
331         dev_set_drvdata(sdhcinfo->dev, dhdp);
332
333         if (!sdhcinfo->oob_irq_registered) {
334                 SDLX_MSG(("%s IRQ=%d Type=%X\n", __func__,
335                           (int)sdhcinfo->oob_irq, (int)sdhcinfo->oob_flags));
336                 /* Refer to customer Host IRQ docs about
337                          proper irqflags definition */
338                 error =
339                     request_irq(sdhcinfo->oob_irq, wlan_oob_irq,
340                                 sdhcinfo->oob_flags, "bcmsdh_sdmmc", NULL);
341                 if (error)
342                         return -ENODEV;
343
344                 set_irq_wake(sdhcinfo->oob_irq, 1);
345                 sdhcinfo->oob_irq_registered = true;
346         }
347
348         return 0;
349 }
350
351 void bcmsdh_unregister_oob_intr(void)
352 {
353         SDLX_MSG(("%s: Enter\n", __func__));
354
355         set_irq_wake(sdhcinfo->oob_irq, 0);
356         disable_irq(sdhcinfo->oob_irq); /* just in case.. */
357         free_irq(sdhcinfo->oob_irq, NULL);
358         sdhcinfo->oob_irq_registered = false;
359 }
360 #endif                          /* defined(OOB_INTR_ONLY) */
361 /* Module parameters specific to each host-controller driver */
362
363 extern uint sd_msglevel;        /* Debug message level */
364 module_param(sd_msglevel, uint, 0);
365
366 extern uint sd_power;           /* 0 = SD Power OFF,
367                                          1 = SD Power ON. */
368 module_param(sd_power, uint, 0);
369
370 extern uint sd_clock;           /* SD Clock Control, 0 = SD Clock OFF,
371                                  1 = SD Clock ON */
372 module_param(sd_clock, uint, 0);
373
374 extern uint sd_divisor;         /* Divisor (-1 means external clock) */
375 module_param(sd_divisor, uint, 0);
376
377 extern uint sd_sdmode;          /* Default is SD4, 0=SPI, 1=SD1, 2=SD4 */
378 module_param(sd_sdmode, uint, 0);
379
380 extern uint sd_hiok;            /* Ok to use hi-speed mode */
381 module_param(sd_hiok, uint, 0);
382
383 extern uint sd_f2_blocksize;
384 module_param(sd_f2_blocksize, int, 0);