]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Sonics Silicon Backplane | |
3 | * SDIO-Hostbus related functions | |
4 | * | |
5 | * Copyright 2009 Albert Herranz <albert_herranz@yahoo.es> | |
6 | * | |
7 | * Based on drivers/ssb/pcmcia.c | |
8 | * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> | |
9 | * Copyright 2007-2008 Michael Buesch <m@bues.ch> | |
10 | * | |
11 | * Licensed under the GNU/GPL. See COPYING for details. | |
12 | * | |
13 | */ | |
14 | ||
15 | #include <linux/ssb/ssb.h> | |
16 | #include <linux/delay.h> | |
17 | #include <linux/io.h> | |
18 | #include <linux/etherdevice.h> | |
19 | #include <linux/mmc/sdio_func.h> | |
20 | ||
21 | #include "ssb_private.h" | |
22 | ||
23 | /* Define the following to 1 to enable a printk on each coreswitch. */ | |
24 | #define SSB_VERBOSE_SDIOCORESWITCH_DEBUG 0 | |
25 | ||
26 | ||
27 | /* Hardware invariants CIS tuples */ | |
28 | #define SSB_SDIO_CIS 0x80 | |
29 | #define SSB_SDIO_CIS_SROMREV 0x00 | |
30 | #define SSB_SDIO_CIS_ID 0x01 | |
31 | #define SSB_SDIO_CIS_BOARDREV 0x02 | |
32 | #define SSB_SDIO_CIS_PA 0x03 | |
33 | #define SSB_SDIO_CIS_PA_PA0B0_LO 0 | |
34 | #define SSB_SDIO_CIS_PA_PA0B0_HI 1 | |
35 | #define SSB_SDIO_CIS_PA_PA0B1_LO 2 | |
36 | #define SSB_SDIO_CIS_PA_PA0B1_HI 3 | |
37 | #define SSB_SDIO_CIS_PA_PA0B2_LO 4 | |
38 | #define SSB_SDIO_CIS_PA_PA0B2_HI 5 | |
39 | #define SSB_SDIO_CIS_PA_ITSSI 6 | |
40 | #define SSB_SDIO_CIS_PA_MAXPOW 7 | |
41 | #define SSB_SDIO_CIS_OEMNAME 0x04 | |
42 | #define SSB_SDIO_CIS_CCODE 0x05 | |
43 | #define SSB_SDIO_CIS_ANTENNA 0x06 | |
44 | #define SSB_SDIO_CIS_ANTGAIN 0x07 | |
45 | #define SSB_SDIO_CIS_BFLAGS 0x08 | |
46 | #define SSB_SDIO_CIS_LEDS 0x09 | |
47 | ||
48 | #define CISTPL_FUNCE_LAN_NODE_ID 0x04 /* same as in PCMCIA */ | |
49 | ||
50 | ||
51 | /* | |
52 | * Function 1 miscellaneous registers. | |
53 | * | |
54 | * Definitions match src/include/sbsdio.h from the | |
55 | * Android Open Source Project | |
56 | * http://android.git.kernel.org/?p=platform/system/wlan/broadcom.git | |
57 | * | |
58 | */ | |
59 | #define SBSDIO_FUNC1_SBADDRLOW 0x1000a /* SB Address window Low (b15) */ | |
60 | #define SBSDIO_FUNC1_SBADDRMID 0x1000b /* SB Address window Mid (b23-b16) */ | |
61 | #define SBSDIO_FUNC1_SBADDRHIGH 0x1000c /* SB Address window High (b24-b31) */ | |
62 | ||
63 | /* valid bits in SBSDIO_FUNC1_SBADDRxxx regs */ | |
64 | #define SBSDIO_SBADDRLOW_MASK 0x80 /* Valid address bits in SBADDRLOW */ | |
65 | #define SBSDIO_SBADDRMID_MASK 0xff /* Valid address bits in SBADDRMID */ | |
66 | #define SBSDIO_SBADDRHIGH_MASK 0xff /* Valid address bits in SBADDRHIGH */ | |
67 | ||
68 | #define SBSDIO_SB_OFT_ADDR_MASK 0x7FFF /* sb offset addr is <= 15 bits, 32k */ | |
69 | ||
70 | /* REVISIT: this flag doesn't seem to matter */ | |
71 | #define SBSDIO_SB_ACCESS_2_4B_FLAG 0x8000 /* forces 32-bit SB access */ | |
72 | ||
73 | ||
74 | /* | |
75 | * Address map within the SDIO function address space (128K). | |
76 | * | |
77 | * Start End Description | |
78 | * ------- ------- ------------------------------------------ | |
79 | * 0x00000 0x0ffff selected backplane address window (64K) | |
80 | * 0x10000 0x1ffff backplane control registers (max 64K) | |
81 | * | |
82 | * The current address window is configured by writing to registers | |
83 | * SBADDRLOW, SBADDRMID and SBADDRHIGH. | |
84 | * | |
85 | * In order to access the contents of a 32-bit Silicon Backplane address | |
86 | * the backplane address window must be first loaded with the highest | |
87 | * 16 bits of the target address. Then, an access must be done to the | |
88 | * SDIO function address space using the lower 15 bits of the address. | |
89 | * Bit 15 of the address must be set when doing 32 bit accesses. | |
90 | * | |
91 | * 10987654321098765432109876543210 | |
92 | * WWWWWWWWWWWWWWWWW SB Address Window | |
93 | * OOOOOOOOOOOOOOOO Offset within SB Address Window | |
94 | * a 32-bit access flag | |
95 | */ | |
96 | ||
97 | ||
98 | /* | |
99 | * SSB I/O via SDIO. | |
100 | * | |
101 | * NOTE: SDIO address @addr is 17 bits long (SDIO address space is 128K). | |
102 | */ | |
103 | ||
104 | static inline struct device *ssb_sdio_dev(struct ssb_bus *bus) | |
105 | { | |
106 | return &bus->host_sdio->dev; | |
107 | } | |
108 | ||
109 | /* host claimed */ | |
110 | static int ssb_sdio_writeb(struct ssb_bus *bus, unsigned int addr, u8 val) | |
111 | { | |
112 | int error = 0; | |
113 | ||
114 | sdio_writeb(bus->host_sdio, val, addr, &error); | |
115 | if (unlikely(error)) { | |
116 | dev_dbg(ssb_sdio_dev(bus), "%08X <- %02x, error %d\n", | |
117 | addr, val, error); | |
118 | } | |
119 | ||
120 | return error; | |
121 | } | |
122 | ||
123 | #if 0 | |
124 | static u8 ssb_sdio_readb(struct ssb_bus *bus, unsigned int addr) | |
125 | { | |
126 | u8 val; | |
127 | int error = 0; | |
128 | ||
129 | val = sdio_readb(bus->host_sdio, addr, &error); | |
130 | if (unlikely(error)) { | |
131 | dev_dbg(ssb_sdio_dev(bus), "%08X -> %02x, error %d\n", | |
132 | addr, val, error); | |
133 | } | |
134 | ||
135 | return val; | |
136 | } | |
137 | #endif | |
138 | ||
139 | /* host claimed */ | |
140 | static int ssb_sdio_set_sbaddr_window(struct ssb_bus *bus, u32 address) | |
141 | { | |
142 | int error; | |
143 | ||
144 | error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRLOW, | |
145 | (address >> 8) & SBSDIO_SBADDRLOW_MASK); | |
146 | if (error) | |
147 | goto out; | |
148 | error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRMID, | |
149 | (address >> 16) & SBSDIO_SBADDRMID_MASK); | |
150 | if (error) | |
151 | goto out; | |
152 | error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRHIGH, | |
153 | (address >> 24) & SBSDIO_SBADDRHIGH_MASK); | |
154 | if (error) | |
155 | goto out; | |
156 | bus->sdio_sbaddr = address; | |
157 | out: | |
158 | if (error) { | |
159 | dev_dbg(ssb_sdio_dev(bus), "failed to set address window" | |
160 | " to 0x%08x, error %d\n", address, error); | |
161 | } | |
162 | ||
163 | return error; | |
164 | } | |
165 | ||
166 | /* for enumeration use only */ | |
167 | u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset) | |
168 | { | |
169 | u32 val; | |
170 | int error; | |
171 | ||
172 | sdio_claim_host(bus->host_sdio); | |
173 | val = sdio_readl(bus->host_sdio, offset, &error); | |
174 | sdio_release_host(bus->host_sdio); | |
175 | if (unlikely(error)) { | |
176 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", | |
177 | bus->sdio_sbaddr >> 16, offset, val, error); | |
178 | } | |
179 | ||
180 | return val; | |
181 | } | |
182 | ||
183 | /* for enumeration use only */ | |
184 | int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx) | |
185 | { | |
186 | u32 sbaddr; | |
187 | int error; | |
188 | ||
189 | sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; | |
190 | sdio_claim_host(bus->host_sdio); | |
191 | error = ssb_sdio_set_sbaddr_window(bus, sbaddr); | |
192 | sdio_release_host(bus->host_sdio); | |
193 | if (error) { | |
194 | dev_err(ssb_sdio_dev(bus), "failed to switch to core %u," | |
195 | " error %d\n", coreidx, error); | |
196 | goto out; | |
197 | } | |
198 | out: | |
199 | return error; | |
200 | } | |
201 | ||
202 | /* host must be already claimed */ | |
203 | int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev) | |
204 | { | |
205 | u8 coreidx = dev->core_index; | |
206 | u32 sbaddr; | |
207 | int error = 0; | |
208 | ||
209 | sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; | |
210 | if (unlikely(bus->sdio_sbaddr != sbaddr)) { | |
211 | #if SSB_VERBOSE_SDIOCORESWITCH_DEBUG | |
212 | dev_info(ssb_sdio_dev(bus), | |
213 | "switching to %s core, index %d\n", | |
214 | ssb_core_name(dev->id.coreid), coreidx); | |
215 | #endif | |
216 | error = ssb_sdio_set_sbaddr_window(bus, sbaddr); | |
217 | if (error) { | |
218 | dev_dbg(ssb_sdio_dev(bus), "failed to switch to" | |
219 | " core %u, error %d\n", coreidx, error); | |
220 | goto out; | |
221 | } | |
222 | bus->mapped_device = dev; | |
223 | } | |
224 | ||
225 | out: | |
226 | return error; | |
227 | } | |
228 | ||
229 | static u8 ssb_sdio_read8(struct ssb_device *dev, u16 offset) | |
230 | { | |
231 | struct ssb_bus *bus = dev->bus; | |
232 | u8 val = 0xff; | |
233 | int error = 0; | |
234 | ||
235 | sdio_claim_host(bus->host_sdio); | |
236 | if (unlikely(ssb_sdio_switch_core(bus, dev))) | |
237 | goto out; | |
238 | offset |= bus->sdio_sbaddr & 0xffff; | |
239 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
240 | val = sdio_readb(bus->host_sdio, offset, &error); | |
241 | if (error) { | |
242 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %02x, error %d\n", | |
243 | bus->sdio_sbaddr >> 16, offset, val, error); | |
244 | } | |
245 | out: | |
246 | sdio_release_host(bus->host_sdio); | |
247 | ||
248 | return val; | |
249 | } | |
250 | ||
251 | static u16 ssb_sdio_read16(struct ssb_device *dev, u16 offset) | |
252 | { | |
253 | struct ssb_bus *bus = dev->bus; | |
254 | u16 val = 0xffff; | |
255 | int error = 0; | |
256 | ||
257 | sdio_claim_host(bus->host_sdio); | |
258 | if (unlikely(ssb_sdio_switch_core(bus, dev))) | |
259 | goto out; | |
260 | offset |= bus->sdio_sbaddr & 0xffff; | |
261 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
262 | val = sdio_readw(bus->host_sdio, offset, &error); | |
263 | if (error) { | |
264 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %04x, error %d\n", | |
265 | bus->sdio_sbaddr >> 16, offset, val, error); | |
266 | } | |
267 | out: | |
268 | sdio_release_host(bus->host_sdio); | |
269 | ||
270 | return val; | |
271 | } | |
272 | ||
273 | static u32 ssb_sdio_read32(struct ssb_device *dev, u16 offset) | |
274 | { | |
275 | struct ssb_bus *bus = dev->bus; | |
276 | u32 val = 0xffffffff; | |
277 | int error = 0; | |
278 | ||
279 | sdio_claim_host(bus->host_sdio); | |
280 | if (unlikely(ssb_sdio_switch_core(bus, dev))) | |
281 | goto out; | |
282 | offset |= bus->sdio_sbaddr & 0xffff; | |
283 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
284 | offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ | |
285 | val = sdio_readl(bus->host_sdio, offset, &error); | |
286 | if (error) { | |
287 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", | |
288 | bus->sdio_sbaddr >> 16, offset, val, error); | |
289 | } | |
290 | out: | |
291 | sdio_release_host(bus->host_sdio); | |
292 | ||
293 | return val; | |
294 | } | |
295 | ||
296 | #ifdef CONFIG_SSB_BLOCKIO | |
297 | static void ssb_sdio_block_read(struct ssb_device *dev, void *buffer, | |
298 | size_t count, u16 offset, u8 reg_width) | |
299 | { | |
300 | size_t saved_count = count; | |
301 | struct ssb_bus *bus = dev->bus; | |
302 | int error = 0; | |
303 | ||
304 | sdio_claim_host(bus->host_sdio); | |
305 | if (unlikely(ssb_sdio_switch_core(bus, dev))) { | |
306 | error = -EIO; | |
307 | memset(buffer, 0xff, count); | |
308 | goto err_out; | |
309 | } | |
310 | offset |= bus->sdio_sbaddr & 0xffff; | |
311 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
312 | ||
313 | switch (reg_width) { | |
314 | case sizeof(u8): { | |
315 | error = sdio_readsb(bus->host_sdio, buffer, offset, count); | |
316 | break; | |
317 | } | |
318 | case sizeof(u16): { | |
319 | SSB_WARN_ON(count & 1); | |
320 | error = sdio_readsb(bus->host_sdio, buffer, offset, count); | |
321 | break; | |
322 | } | |
323 | case sizeof(u32): { | |
324 | SSB_WARN_ON(count & 3); | |
325 | offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ | |
326 | error = sdio_readsb(bus->host_sdio, buffer, offset, count); | |
327 | break; | |
328 | } | |
329 | default: | |
330 | SSB_WARN_ON(1); | |
331 | } | |
332 | if (!error) | |
333 | goto out; | |
334 | ||
335 | err_out: | |
336 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", | |
337 | bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); | |
338 | out: | |
339 | sdio_release_host(bus->host_sdio); | |
340 | } | |
341 | #endif /* CONFIG_SSB_BLOCKIO */ | |
342 | ||
343 | static void ssb_sdio_write8(struct ssb_device *dev, u16 offset, u8 val) | |
344 | { | |
345 | struct ssb_bus *bus = dev->bus; | |
346 | int error = 0; | |
347 | ||
348 | sdio_claim_host(bus->host_sdio); | |
349 | if (unlikely(ssb_sdio_switch_core(bus, dev))) | |
350 | goto out; | |
351 | offset |= bus->sdio_sbaddr & 0xffff; | |
352 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
353 | sdio_writeb(bus->host_sdio, val, offset, &error); | |
354 | if (error) { | |
355 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %02x, error %d\n", | |
356 | bus->sdio_sbaddr >> 16, offset, val, error); | |
357 | } | |
358 | out: | |
359 | sdio_release_host(bus->host_sdio); | |
360 | } | |
361 | ||
362 | static void ssb_sdio_write16(struct ssb_device *dev, u16 offset, u16 val) | |
363 | { | |
364 | struct ssb_bus *bus = dev->bus; | |
365 | int error = 0; | |
366 | ||
367 | sdio_claim_host(bus->host_sdio); | |
368 | if (unlikely(ssb_sdio_switch_core(bus, dev))) | |
369 | goto out; | |
370 | offset |= bus->sdio_sbaddr & 0xffff; | |
371 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
372 | sdio_writew(bus->host_sdio, val, offset, &error); | |
373 | if (error) { | |
374 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %04x, error %d\n", | |
375 | bus->sdio_sbaddr >> 16, offset, val, error); | |
376 | } | |
377 | out: | |
378 | sdio_release_host(bus->host_sdio); | |
379 | } | |
380 | ||
381 | static void ssb_sdio_write32(struct ssb_device *dev, u16 offset, u32 val) | |
382 | { | |
383 | struct ssb_bus *bus = dev->bus; | |
384 | int error = 0; | |
385 | ||
386 | sdio_claim_host(bus->host_sdio); | |
387 | if (unlikely(ssb_sdio_switch_core(bus, dev))) | |
388 | goto out; | |
389 | offset |= bus->sdio_sbaddr & 0xffff; | |
390 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
391 | offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ | |
392 | sdio_writel(bus->host_sdio, val, offset, &error); | |
393 | if (error) { | |
394 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %08x, error %d\n", | |
395 | bus->sdio_sbaddr >> 16, offset, val, error); | |
396 | } | |
397 | if (bus->quirks & SSB_QUIRK_SDIO_READ_AFTER_WRITE32) | |
398 | sdio_readl(bus->host_sdio, 0, &error); | |
399 | out: | |
400 | sdio_release_host(bus->host_sdio); | |
401 | } | |
402 | ||
403 | #ifdef CONFIG_SSB_BLOCKIO | |
404 | static void ssb_sdio_block_write(struct ssb_device *dev, const void *buffer, | |
405 | size_t count, u16 offset, u8 reg_width) | |
406 | { | |
407 | size_t saved_count = count; | |
408 | struct ssb_bus *bus = dev->bus; | |
409 | int error = 0; | |
410 | ||
411 | sdio_claim_host(bus->host_sdio); | |
412 | if (unlikely(ssb_sdio_switch_core(bus, dev))) { | |
413 | error = -EIO; | |
414 | memset((void *)buffer, 0xff, count); | |
415 | goto err_out; | |
416 | } | |
417 | offset |= bus->sdio_sbaddr & 0xffff; | |
418 | offset &= SBSDIO_SB_OFT_ADDR_MASK; | |
419 | ||
420 | switch (reg_width) { | |
421 | case sizeof(u8): | |
422 | error = sdio_writesb(bus->host_sdio, offset, | |
423 | (void *)buffer, count); | |
424 | break; | |
425 | case sizeof(u16): | |
426 | SSB_WARN_ON(count & 1); | |
427 | error = sdio_writesb(bus->host_sdio, offset, | |
428 | (void *)buffer, count); | |
429 | break; | |
430 | case sizeof(u32): | |
431 | SSB_WARN_ON(count & 3); | |
432 | offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ | |
433 | error = sdio_writesb(bus->host_sdio, offset, | |
434 | (void *)buffer, count); | |
435 | break; | |
436 | default: | |
437 | SSB_WARN_ON(1); | |
438 | } | |
439 | if (!error) | |
440 | goto out; | |
441 | ||
442 | err_out: | |
443 | dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", | |
444 | bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); | |
445 | out: | |
446 | sdio_release_host(bus->host_sdio); | |
447 | } | |
448 | ||
449 | #endif /* CONFIG_SSB_BLOCKIO */ | |
450 | ||
451 | /* Not "static", as it's used in main.c */ | |
452 | const struct ssb_bus_ops ssb_sdio_ops = { | |
453 | .read8 = ssb_sdio_read8, | |
454 | .read16 = ssb_sdio_read16, | |
455 | .read32 = ssb_sdio_read32, | |
456 | .write8 = ssb_sdio_write8, | |
457 | .write16 = ssb_sdio_write16, | |
458 | .write32 = ssb_sdio_write32, | |
459 | #ifdef CONFIG_SSB_BLOCKIO | |
460 | .block_read = ssb_sdio_block_read, | |
461 | .block_write = ssb_sdio_block_write, | |
462 | #endif | |
463 | }; | |
464 | ||
465 | #define GOTO_ERROR_ON(condition, description) do { \ | |
466 | if (unlikely(condition)) { \ | |
467 | error_description = description; \ | |
468 | goto error; \ | |
469 | } \ | |
470 | } while (0) | |
471 | ||
472 | int ssb_sdio_get_invariants(struct ssb_bus *bus, | |
473 | struct ssb_init_invariants *iv) | |
474 | { | |
475 | struct ssb_sprom *sprom = &iv->sprom; | |
476 | struct ssb_boardinfo *bi = &iv->boardinfo; | |
477 | const char *error_description = "none"; | |
478 | struct sdio_func_tuple *tuple; | |
479 | void *mac; | |
480 | ||
481 | memset(sprom, 0xFF, sizeof(*sprom)); | |
482 | sprom->boardflags_lo = 0; | |
483 | sprom->boardflags_hi = 0; | |
484 | ||
485 | tuple = bus->host_sdio->tuples; | |
486 | while (tuple) { | |
487 | switch (tuple->code) { | |
488 | case 0x22: /* extended function */ | |
489 | switch (tuple->data[0]) { | |
490 | case CISTPL_FUNCE_LAN_NODE_ID: | |
491 | GOTO_ERROR_ON((tuple->size != 7) && | |
492 | (tuple->data[1] != 6), | |
493 | "mac tpl size"); | |
494 | /* fetch the MAC address. */ | |
495 | mac = tuple->data + 2; | |
496 | memcpy(sprom->il0mac, mac, ETH_ALEN); | |
497 | memcpy(sprom->et1mac, mac, ETH_ALEN); | |
498 | break; | |
499 | default: | |
500 | break; | |
501 | } | |
502 | break; | |
503 | case 0x80: /* vendor specific tuple */ | |
504 | switch (tuple->data[0]) { | |
505 | case SSB_SDIO_CIS_SROMREV: | |
506 | GOTO_ERROR_ON(tuple->size != 2, | |
507 | "sromrev tpl size"); | |
508 | sprom->revision = tuple->data[1]; | |
509 | break; | |
510 | case SSB_SDIO_CIS_ID: | |
511 | GOTO_ERROR_ON((tuple->size != 5) && | |
512 | (tuple->size != 7), | |
513 | "id tpl size"); | |
514 | bi->vendor = tuple->data[1] | | |
515 | (tuple->data[2]<<8); | |
516 | break; | |
517 | case SSB_SDIO_CIS_BOARDREV: | |
518 | GOTO_ERROR_ON(tuple->size != 2, | |
519 | "boardrev tpl size"); | |
520 | sprom->board_rev = tuple->data[1]; | |
521 | break; | |
522 | case SSB_SDIO_CIS_PA: | |
523 | GOTO_ERROR_ON((tuple->size != 9) && | |
524 | (tuple->size != 10), | |
525 | "pa tpl size"); | |
526 | sprom->pa0b0 = tuple->data[1] | | |
527 | ((u16)tuple->data[2] << 8); | |
528 | sprom->pa0b1 = tuple->data[3] | | |
529 | ((u16)tuple->data[4] << 8); | |
530 | sprom->pa0b2 = tuple->data[5] | | |
531 | ((u16)tuple->data[6] << 8); | |
532 | sprom->itssi_a = tuple->data[7]; | |
533 | sprom->itssi_bg = tuple->data[7]; | |
534 | sprom->maxpwr_a = tuple->data[8]; | |
535 | sprom->maxpwr_bg = tuple->data[8]; | |
536 | break; | |
537 | case SSB_SDIO_CIS_OEMNAME: | |
538 | /* Not present */ | |
539 | break; | |
540 | case SSB_SDIO_CIS_CCODE: | |
541 | GOTO_ERROR_ON(tuple->size != 2, | |
542 | "ccode tpl size"); | |
543 | sprom->country_code = tuple->data[1]; | |
544 | break; | |
545 | case SSB_SDIO_CIS_ANTENNA: | |
546 | GOTO_ERROR_ON(tuple->size != 2, | |
547 | "ant tpl size"); | |
548 | sprom->ant_available_a = tuple->data[1]; | |
549 | sprom->ant_available_bg = tuple->data[1]; | |
550 | break; | |
551 | case SSB_SDIO_CIS_ANTGAIN: | |
552 | GOTO_ERROR_ON(tuple->size != 2, | |
553 | "antg tpl size"); | |
554 | sprom->antenna_gain.ghz24.a0 = tuple->data[1]; | |
555 | sprom->antenna_gain.ghz24.a1 = tuple->data[1]; | |
556 | sprom->antenna_gain.ghz24.a2 = tuple->data[1]; | |
557 | sprom->antenna_gain.ghz24.a3 = tuple->data[1]; | |
558 | sprom->antenna_gain.ghz5.a0 = tuple->data[1]; | |
559 | sprom->antenna_gain.ghz5.a1 = tuple->data[1]; | |
560 | sprom->antenna_gain.ghz5.a2 = tuple->data[1]; | |
561 | sprom->antenna_gain.ghz5.a3 = tuple->data[1]; | |
562 | break; | |
563 | case SSB_SDIO_CIS_BFLAGS: | |
564 | GOTO_ERROR_ON((tuple->size != 3) && | |
565 | (tuple->size != 5), | |
566 | "bfl tpl size"); | |
567 | sprom->boardflags_lo = tuple->data[1] | | |
568 | ((u16)tuple->data[2] << 8); | |
569 | break; | |
570 | case SSB_SDIO_CIS_LEDS: | |
571 | GOTO_ERROR_ON(tuple->size != 5, | |
572 | "leds tpl size"); | |
573 | sprom->gpio0 = tuple->data[1]; | |
574 | sprom->gpio1 = tuple->data[2]; | |
575 | sprom->gpio2 = tuple->data[3]; | |
576 | sprom->gpio3 = tuple->data[4]; | |
577 | break; | |
578 | default: | |
579 | break; | |
580 | } | |
581 | break; | |
582 | default: | |
583 | break; | |
584 | } | |
585 | tuple = tuple->next; | |
586 | } | |
587 | ||
588 | return 0; | |
589 | error: | |
590 | dev_err(ssb_sdio_dev(bus), "failed to fetch device invariants: %s\n", | |
591 | error_description); | |
592 | return -ENODEV; | |
593 | } | |
594 | ||
595 | void ssb_sdio_exit(struct ssb_bus *bus) | |
596 | { | |
597 | if (bus->bustype != SSB_BUSTYPE_SDIO) | |
598 | return; | |
599 | /* Nothing to do here. */ | |
600 | } | |
601 | ||
602 | int ssb_sdio_init(struct ssb_bus *bus) | |
603 | { | |
604 | if (bus->bustype != SSB_BUSTYPE_SDIO) | |
605 | return 0; | |
606 | ||
607 | bus->sdio_sbaddr = ~0; | |
608 | ||
609 | return 0; | |
610 | } |