This source file includes following definitions.
- b43_sdio_get_quirks
- b43_sdio_interrupt_dispatcher
- b43_sdio_request_irq
- b43_sdio_free_irq
- b43_sdio_probe
- b43_sdio_remove
- b43_sdio_init
- b43_sdio_exit
1
2
3
4
5
6
7
8
9
10
11 #include <linux/kernel.h>
12 #include <linux/mmc/card.h>
13 #include <linux/mmc/sdio_func.h>
14 #include <linux/mmc/sdio_ids.h>
15 #include <linux/slab.h>
16 #include <linux/ssb/ssb.h>
17
18 #include "sdio.h"
19 #include "b43.h"
20
21
22 #define HNBU_CHIPID 0x01
23
24 #define B43_SDIO_BLOCK_SIZE 64
25
26
27 static const struct b43_sdio_quirk {
28 u16 vendor;
29 u16 device;
30 unsigned int quirks;
31 } b43_sdio_quirks[] = {
32 { 0x14E4, 0x4318, SSB_QUIRK_SDIO_READ_AFTER_WRITE32, },
33 { },
34 };
35
36
37 static unsigned int b43_sdio_get_quirks(u16 vendor, u16 device)
38 {
39 const struct b43_sdio_quirk *q;
40
41 for (q = b43_sdio_quirks; q->quirks; q++) {
42 if (vendor == q->vendor && device == q->device)
43 return q->quirks;
44 }
45
46 return 0;
47 }
48
49 static void b43_sdio_interrupt_dispatcher(struct sdio_func *func)
50 {
51 struct b43_sdio *sdio = sdio_get_drvdata(func);
52 struct b43_wldev *dev = sdio->irq_handler_opaque;
53
54 if (unlikely(b43_status(dev) < B43_STAT_STARTED))
55 return;
56
57 sdio_release_host(func);
58 sdio->irq_handler(dev);
59 sdio_claim_host(func);
60 }
61
62 int b43_sdio_request_irq(struct b43_wldev *dev,
63 void (*handler)(struct b43_wldev *dev))
64 {
65 struct ssb_bus *bus = dev->dev->sdev->bus;
66 struct sdio_func *func = bus->host_sdio;
67 struct b43_sdio *sdio = sdio_get_drvdata(func);
68 int err;
69
70 sdio->irq_handler_opaque = dev;
71 sdio->irq_handler = handler;
72 sdio_claim_host(func);
73 err = sdio_claim_irq(func, b43_sdio_interrupt_dispatcher);
74 sdio_release_host(func);
75
76 return err;
77 }
78
79 void b43_sdio_free_irq(struct b43_wldev *dev)
80 {
81 struct ssb_bus *bus = dev->dev->sdev->bus;
82 struct sdio_func *func = bus->host_sdio;
83 struct b43_sdio *sdio = sdio_get_drvdata(func);
84
85 sdio_claim_host(func);
86 sdio_release_irq(func);
87 sdio_release_host(func);
88 sdio->irq_handler_opaque = NULL;
89 sdio->irq_handler = NULL;
90 }
91
92 static int b43_sdio_probe(struct sdio_func *func,
93 const struct sdio_device_id *id)
94 {
95 struct b43_sdio *sdio;
96 struct sdio_func_tuple *tuple;
97 u16 vendor = 0, device = 0;
98 int error;
99
100
101 tuple = func->tuples;
102 while (tuple) {
103 switch (tuple->code) {
104 case 0x80:
105 switch (tuple->data[0]) {
106 case HNBU_CHIPID:
107 if (tuple->size != 5)
108 break;
109 vendor = tuple->data[1] | (tuple->data[2]<<8);
110 device = tuple->data[3] | (tuple->data[4]<<8);
111 dev_info(&func->dev, "Chip ID %04x:%04x\n",
112 vendor, device);
113 break;
114 default:
115 break;
116 }
117 break;
118 default:
119 break;
120 }
121 tuple = tuple->next;
122 }
123 if (!vendor || !device) {
124 error = -ENODEV;
125 goto out;
126 }
127
128 sdio_claim_host(func);
129 error = sdio_set_block_size(func, B43_SDIO_BLOCK_SIZE);
130 if (error) {
131 dev_err(&func->dev, "failed to set block size to %u bytes,"
132 " error %d\n", B43_SDIO_BLOCK_SIZE, error);
133 goto err_release_host;
134 }
135 error = sdio_enable_func(func);
136 if (error) {
137 dev_err(&func->dev, "failed to enable func, error %d\n", error);
138 goto err_release_host;
139 }
140 sdio_release_host(func);
141
142 sdio = kzalloc(sizeof(*sdio), GFP_KERNEL);
143 if (!sdio) {
144 error = -ENOMEM;
145 dev_err(&func->dev, "failed to allocate ssb bus\n");
146 goto err_disable_func;
147 }
148 error = ssb_bus_sdiobus_register(&sdio->ssb, func,
149 b43_sdio_get_quirks(vendor, device));
150 if (error) {
151 dev_err(&func->dev, "failed to register ssb sdio bus,"
152 " error %d\n", error);
153 goto err_free_ssb;
154 }
155 sdio_set_drvdata(func, sdio);
156
157 return 0;
158
159 err_free_ssb:
160 kfree(sdio);
161 err_disable_func:
162 sdio_claim_host(func);
163 sdio_disable_func(func);
164 err_release_host:
165 sdio_release_host(func);
166 out:
167 return error;
168 }
169
170 static void b43_sdio_remove(struct sdio_func *func)
171 {
172 struct b43_sdio *sdio = sdio_get_drvdata(func);
173
174 ssb_bus_unregister(&sdio->ssb);
175 sdio_claim_host(func);
176 sdio_disable_func(func);
177 sdio_release_host(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) },
184 { SDIO_DEVICE(0x0092, 0x0004) },
185 { },
186 };
187
188 static struct sdio_driver b43_sdio_driver = {
189 .name = "b43-sdio",
190 .id_table = b43_sdio_ids,
191 .probe = b43_sdio_probe,
192 .remove = b43_sdio_remove,
193 };
194
195 int b43_sdio_init(void)
196 {
197 return sdio_register_driver(&b43_sdio_driver);
198 }
199
200 void b43_sdio_exit(void)
201 {
202 sdio_unregister_driver(&b43_sdio_driver);
203 }