Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sdio.c
Go to the documentation of this file.
1 /*
2  * Sonics Silicon Backplane
3  * SDIO-Hostbus related functions
4  *
5  * Copyright 2009 Albert Herranz <[email protected]>
6  *
7  * Based on drivers/ssb/pcmcia.c
8  * Copyright 2006 Johannes Berg <[email protected]>
9  * Copyright 2007-2008 Michael Buesch <[email protected]>
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.a0 = tuple->data[1];
555  sprom->antenna_gain.a1 = tuple->data[1];
556  sprom->antenna_gain.a2 = tuple->data[1];
557  sprom->antenna_gain.a3 = tuple->data[1];
558  break;
559  case SSB_SDIO_CIS_BFLAGS:
560  GOTO_ERROR_ON((tuple->size != 3) &&
561  (tuple->size != 5),
562  "bfl tpl size");
563  sprom->boardflags_lo = tuple->data[1] |
564  ((u16)tuple->data[2] << 8);
565  break;
566  case SSB_SDIO_CIS_LEDS:
567  GOTO_ERROR_ON(tuple->size != 5,
568  "leds tpl size");
569  sprom->gpio0 = tuple->data[1];
570  sprom->gpio1 = tuple->data[2];
571  sprom->gpio2 = tuple->data[3];
572  sprom->gpio3 = tuple->data[4];
573  break;
574  default:
575  break;
576  }
577  break;
578  default:
579  break;
580  }
581  tuple = tuple->next;
582  }
583 
584  return 0;
585 error:
586  dev_err(ssb_sdio_dev(bus), "failed to fetch device invariants: %s\n",
587  error_description);
588  return -ENODEV;
589 }
590 
591 void ssb_sdio_exit(struct ssb_bus *bus)
592 {
593  if (bus->bustype != SSB_BUSTYPE_SDIO)
594  return;
595  /* Nothing to do here. */
596 }
597 
598 int ssb_sdio_init(struct ssb_bus *bus)
599 {
600  if (bus->bustype != SSB_BUSTYPE_SDIO)
601  return 0;
602 
603  bus->sdio_sbaddr = ~0;
604 
605  return 0;
606 }
Generated on Thu Jan 10 2013 13:55:37 for Linux Kernel by   doxygen 1.8.2