]> git.karo-electronics.de Git - mv-sheeva.git/blob - drivers/net/wireless/b43/sdio.c
Merge branch 'fix/misc' into for-linus
[mv-sheeva.git] / drivers / net / wireless / b43 / sdio.c
1 /*
2  * Broadcom B43 wireless driver
3  *
4  * SDIO over Sonics Silicon Backplane bus glue for b43.
5  *
6  * Copyright (C) 2009 Albert Herranz
7  * Copyright (C) 2009 Michael Buesch <mb@bu3sch.de>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or (at
12  * your option) any later version.
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/mmc/card.h>
17 #include <linux/mmc/sdio_func.h>
18 #include <linux/mmc/sdio_ids.h>
19 #include <linux/ssb/ssb.h>
20
21 #include "sdio.h"
22 #include "b43.h"
23
24
25 #define HNBU_CHIPID             0x01    /* vendor & device id */
26
27 #define B43_SDIO_BLOCK_SIZE     64      /* rx fifo max size in bytes */
28
29
30 static const struct b43_sdio_quirk {
31         u16 vendor;
32         u16 device;
33         unsigned int quirks;
34 } b43_sdio_quirks[] = {
35         { 0x14E4, 0x4318, SSB_QUIRK_SDIO_READ_AFTER_WRITE32, },
36         { },
37 };
38
39
40 static unsigned int b43_sdio_get_quirks(u16 vendor, u16 device)
41 {
42         const struct b43_sdio_quirk *q;
43
44         for (q = b43_sdio_quirks; q->quirks; q++) {
45                 if (vendor == q->vendor && device == q->device)
46                         return q->quirks;
47         }
48
49         return 0;
50 }
51
52 static void b43_sdio_interrupt_dispatcher(struct sdio_func *func)
53 {
54         struct b43_sdio *sdio = sdio_get_drvdata(func);
55         struct b43_wldev *dev = sdio->irq_handler_opaque;
56
57         if (unlikely(b43_status(dev) < B43_STAT_STARTED))
58                 return;
59
60         sdio_release_host(func);
61         sdio->irq_handler(dev);
62         sdio_claim_host(func);
63 }
64
65 int b43_sdio_request_irq(struct b43_wldev *dev,
66                          void (*handler)(struct b43_wldev *dev))
67 {
68         struct ssb_bus *bus = dev->dev->bus;
69         struct sdio_func *func = bus->host_sdio;
70         struct b43_sdio *sdio = sdio_get_drvdata(func);
71         int err;
72
73         sdio->irq_handler_opaque = dev;
74         sdio->irq_handler = handler;
75         sdio_claim_host(func);
76         err = sdio_claim_irq(func, b43_sdio_interrupt_dispatcher);
77         sdio_release_host(func);
78
79         return err;
80 }
81
82 void b43_sdio_free_irq(struct b43_wldev *dev)
83 {
84         struct ssb_bus *bus = dev->dev->bus;
85         struct sdio_func *func = bus->host_sdio;
86         struct b43_sdio *sdio = sdio_get_drvdata(func);
87
88         sdio_claim_host(func);
89         sdio_release_irq(func);
90         sdio_release_host(func);
91         sdio->irq_handler_opaque = NULL;
92         sdio->irq_handler = NULL;
93 }
94
95 static int b43_sdio_probe(struct sdio_func *func,
96                           const struct sdio_device_id *id)
97 {
98         struct b43_sdio *sdio;
99         struct sdio_func_tuple *tuple;
100         u16 vendor = 0, device = 0;
101         int error;
102
103         /* Look for the card chip identifier. */
104         tuple = func->tuples;
105         while (tuple) {
106                 switch (tuple->code) {
107                 case 0x80:
108                         switch (tuple->data[0]) {
109                         case HNBU_CHIPID:
110                                 if (tuple->size != 5)
111                                         break;
112                                 vendor = tuple->data[1] | (tuple->data[2]<<8);
113                                 device = tuple->data[3] | (tuple->data[4]<<8);
114                                 dev_info(&func->dev, "Chip ID %04x:%04x\n",
115                                          vendor, device);
116                                 break;
117                         default:
118                                 break;
119                         }
120                         break;
121                 default:
122                         break;
123                 }
124                 tuple = tuple->next;
125         }
126         if (!vendor || !device) {
127                 error = -ENODEV;
128                 goto out;
129         }
130
131         sdio_claim_host(func);
132         error = sdio_set_block_size(func, B43_SDIO_BLOCK_SIZE);
133         if (error) {
134                 dev_err(&func->dev, "failed to set block size to %u bytes,"
135                         " error %d\n", B43_SDIO_BLOCK_SIZE, error);
136                 goto err_release_host;
137         }
138         error = sdio_enable_func(func);
139         if (error) {
140                 dev_err(&func->dev, "failed to enable func, error %d\n", error);
141                 goto err_release_host;
142         }
143         sdio_release_host(func);
144
145         sdio = kzalloc(sizeof(*sdio), GFP_KERNEL);
146         if (!sdio) {
147                 error = -ENOMEM;
148                 dev_err(&func->dev, "failed to allocate ssb bus\n");
149                 goto err_disable_func;
150         }
151         error = ssb_bus_sdiobus_register(&sdio->ssb, func,
152                                          b43_sdio_get_quirks(vendor, device));
153         if (error) {
154                 dev_err(&func->dev, "failed to register ssb sdio bus,"
155                         " error %d\n", error);
156                 goto err_free_ssb;
157         }
158         sdio_set_drvdata(func, sdio);
159
160         return 0;
161
162 err_free_ssb:
163         kfree(sdio);
164 err_disable_func:
165         sdio_disable_func(func);
166 err_release_host:
167         sdio_release_host(func);
168 out:
169         return error;
170 }
171
172 static void b43_sdio_remove(struct sdio_func *func)
173 {
174         struct b43_sdio *sdio = sdio_get_drvdata(func);
175
176         ssb_bus_unregister(&sdio->ssb);
177         sdio_disable_func(func);
178         kfree(sdio);
179         sdio_set_drvdata(func, NULL);
180 }
181
182 static const struct sdio_device_id b43_sdio_ids[] = {
183         { SDIO_DEVICE(0x02d0, 0x044b) }, /* Nintendo Wii WLAN daughter card */
184         { },
185 };
186
187 static struct sdio_driver b43_sdio_driver = {
188         .name           = "b43-sdio",
189         .id_table       = b43_sdio_ids,
190         .probe          = b43_sdio_probe,
191         .remove         = b43_sdio_remove,
192 };
193
194 int b43_sdio_init(void)
195 {
196         return sdio_register_driver(&b43_sdio_driver);
197 }
198
199 void b43_sdio_exit(void)
200 {
201         sdio_unregister_driver(&b43_sdio_driver);
202 }