2 * Sonics Silicon Backplane
3 * PCMCIA-Hostbus related functions
5 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de>
8 * Licensed under the GNU/GPL. See COPYING for details.
11 #include <linux/ssb/ssb.h>
12 #include <linux/delay.h>
14 #include <linux/etherdevice.h>
16 #include <pcmcia/cs_types.h>
17 #include <pcmcia/cs.h>
18 #include <pcmcia/cistpl.h>
19 #include <pcmcia/ciscode.h>
20 #include <pcmcia/ds.h>
21 #include <pcmcia/cisreg.h>
23 #include "ssb_private.h"
26 /* Define the following to 1 to enable a printk on each coreswitch. */
27 #define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0
30 /* PCMCIA configuration registers */
31 #define SSB_PCMCIA_ADDRESS0 0x2E
32 #define SSB_PCMCIA_ADDRESS1 0x30
33 #define SSB_PCMCIA_ADDRESS2 0x32
34 #define SSB_PCMCIA_MEMSEG 0x34
35 #define SSB_PCMCIA_SPROMCTL 0x36
36 #define SSB_PCMCIA_SPROMCTL_IDLE 0
37 #define SSB_PCMCIA_SPROMCTL_WRITE 1
38 #define SSB_PCMCIA_SPROMCTL_READ 2
39 #define SSB_PCMCIA_SPROMCTL_WRITEEN 4
40 #define SSB_PCMCIA_SPROMCTL_WRITEDIS 7
41 #define SSB_PCMCIA_SPROMCTL_DONE 8
42 #define SSB_PCMCIA_SPROM_DATALO 0x38
43 #define SSB_PCMCIA_SPROM_DATAHI 0x3A
44 #define SSB_PCMCIA_SPROM_ADDRLO 0x3C
45 #define SSB_PCMCIA_SPROM_ADDRHI 0x3E
47 /* Hardware invariants CIS tuples */
48 #define SSB_PCMCIA_CIS 0x80
49 #define SSB_PCMCIA_CIS_ID 0x01
50 #define SSB_PCMCIA_CIS_BOARDREV 0x02
51 #define SSB_PCMCIA_CIS_PA 0x03
52 #define SSB_PCMCIA_CIS_PA_PA0B0_LO 0
53 #define SSB_PCMCIA_CIS_PA_PA0B0_HI 1
54 #define SSB_PCMCIA_CIS_PA_PA0B1_LO 2
55 #define SSB_PCMCIA_CIS_PA_PA0B1_HI 3
56 #define SSB_PCMCIA_CIS_PA_PA0B2_LO 4
57 #define SSB_PCMCIA_CIS_PA_PA0B2_HI 5
58 #define SSB_PCMCIA_CIS_PA_ITSSI 6
59 #define SSB_PCMCIA_CIS_PA_MAXPOW 7
60 #define SSB_PCMCIA_CIS_OEMNAME 0x04
61 #define SSB_PCMCIA_CIS_CCODE 0x05
62 #define SSB_PCMCIA_CIS_ANTENNA 0x06
63 #define SSB_PCMCIA_CIS_ANTGAIN 0x07
64 #define SSB_PCMCIA_CIS_BFLAGS 0x08
65 #define SSB_PCMCIA_CIS_LEDS 0x09
67 /* PCMCIA SPROM size. */
68 #define SSB_PCMCIA_SPROM_SIZE 256
69 #define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16))
72 /* Write to a PCMCIA configuration register. */
73 static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value)
78 memset(®, 0, sizeof(reg));
80 reg.Action = CS_WRITE;
82 res = pcmcia_access_configuration_register(bus->host_pcmcia, ®);
83 if (unlikely(res != CS_SUCCESS))
89 /* Read from a PCMCIA configuration register. */
90 static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value)
95 memset(®, 0, sizeof(reg));
98 res = pcmcia_access_configuration_register(bus->host_pcmcia, ®);
99 if (unlikely(res != CS_SUCCESS))
106 int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
116 addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
118 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0,
119 (addr & 0x0000F000) >> 12);
122 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1,
123 (addr & 0x00FF0000) >> 16);
126 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2,
127 (addr & 0xFF000000) >> 24);
133 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val);
136 read_addr |= ((u32)(val & 0x0F)) << 12;
137 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val);
140 read_addr |= ((u32)val) << 16;
141 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val);
144 read_addr |= ((u32)val) << 24;
146 cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
147 if (cur_core == coreidx)
151 if (attempts++ > SSB_BAR0_MAX_RETRIES)
158 ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
162 int ssb_pcmcia_switch_core(struct ssb_bus *bus,
163 struct ssb_device *dev)
167 #if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
168 ssb_printk(KERN_INFO PFX
169 "Switching to %s core, index %d\n",
170 ssb_core_name(dev->id.coreid),
174 err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
176 bus->mapped_device = dev;
181 int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
187 SSB_WARN_ON((seg != 0) && (seg != 1));
189 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg);
192 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val);
199 if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
203 bus->mapped_pcmcia_seg = seg;
207 ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n");
211 static int select_core_and_segment(struct ssb_device *dev,
214 struct ssb_bus *bus = dev->bus;
218 if (*offset >= 0x800) {
224 if (unlikely(dev != bus->mapped_device)) {
225 err = ssb_pcmcia_switch_core(bus, dev);
229 if (unlikely(need_segment != bus->mapped_pcmcia_seg)) {
230 err = ssb_pcmcia_switch_segment(bus, need_segment);
238 static u8 ssb_pcmcia_read8(struct ssb_device *dev, u16 offset)
240 struct ssb_bus *bus = dev->bus;
245 spin_lock_irqsave(&bus->bar_lock, flags);
246 err = select_core_and_segment(dev, &offset);
248 value = readb(bus->mmio + offset);
249 spin_unlock_irqrestore(&bus->bar_lock, flags);
254 static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset)
256 struct ssb_bus *bus = dev->bus;
261 spin_lock_irqsave(&bus->bar_lock, flags);
262 err = select_core_and_segment(dev, &offset);
264 value = readw(bus->mmio + offset);
265 spin_unlock_irqrestore(&bus->bar_lock, flags);
270 static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset)
272 struct ssb_bus *bus = dev->bus;
275 u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF;
277 spin_lock_irqsave(&bus->bar_lock, flags);
278 err = select_core_and_segment(dev, &offset);
280 lo = readw(bus->mmio + offset);
281 hi = readw(bus->mmio + offset + 2);
283 spin_unlock_irqrestore(&bus->bar_lock, flags);
285 return (lo | (hi << 16));
288 static void ssb_pcmcia_write8(struct ssb_device *dev, u16 offset, u8 value)
290 struct ssb_bus *bus = dev->bus;
294 spin_lock_irqsave(&bus->bar_lock, flags);
295 err = select_core_and_segment(dev, &offset);
297 writeb(value, bus->mmio + offset);
299 spin_unlock_irqrestore(&bus->bar_lock, flags);
302 static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
304 struct ssb_bus *bus = dev->bus;
308 spin_lock_irqsave(&bus->bar_lock, flags);
309 err = select_core_and_segment(dev, &offset);
311 writew(value, bus->mmio + offset);
313 spin_unlock_irqrestore(&bus->bar_lock, flags);
316 static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
318 struct ssb_bus *bus = dev->bus;
322 spin_lock_irqsave(&bus->bar_lock, flags);
323 err = select_core_and_segment(dev, &offset);
325 writew((value & 0x0000FFFF), bus->mmio + offset);
326 writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
329 spin_unlock_irqrestore(&bus->bar_lock, flags);
332 /* Not "static", as it's used in main.c */
333 const struct ssb_bus_ops ssb_pcmcia_ops = {
334 .read8 = ssb_pcmcia_read8,
335 .read16 = ssb_pcmcia_read16,
336 .read32 = ssb_pcmcia_read32,
337 .write8 = ssb_pcmcia_write8,
338 .write16 = ssb_pcmcia_write16,
339 .write32 = ssb_pcmcia_write32,
342 static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command)
348 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command);
351 for (i = 0; i < 1000; i++) {
352 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value);
355 if (value & SSB_PCMCIA_SPROMCTL_DONE)
363 /* offset is the 16bit word offset */
364 static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value)
369 offset *= 2; /* Make byte offset */
371 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
375 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
376 (offset & 0xFF00) >> 8);
379 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ);
382 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo);
385 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi);
388 *value = (lo | (((u16)hi) << 8));
393 /* offset is the 16bit word offset */
394 static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
398 offset *= 2; /* Make byte offset */
400 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
404 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
405 (offset & 0xFF00) >> 8);
408 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO,
412 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI,
413 (value & 0xFF00) >> 8);
416 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE);
424 /* Read the SPROM image. bufsize is in 16bit words. */
425 static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom)
429 for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) {
430 err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]);
438 /* Write the SPROM image. size is in 16bit words. */
439 static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
443 size_t size = SSB_PCMCIA_SPROM_SIZE;
445 ssb_printk(KERN_NOTICE PFX
446 "Writing SPROM. Do NOT turn off the power! "
447 "Please stand by...\n");
448 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
450 ssb_printk(KERN_NOTICE PFX
451 "Could not enable SPROM write access.\n");
454 ssb_printk(KERN_NOTICE PFX "[ 0%%");
456 for (i = 0; i < size; i++) {
459 else if (i == size / 2)
461 else if (i == (size * 3) / 4)
465 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
467 ssb_printk("\n" KERN_NOTICE PFX
468 "Failed to write to SPROM.\n");
473 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
475 ssb_printk("\n" KERN_NOTICE PFX
476 "Could not disable SPROM write access.\n");
481 ssb_printk("100%% ]\n");
482 ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
485 return failed ? -EBUSY : 0;
488 static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
494 #define GOTO_ERROR_ON(condition, description) do { \
495 if (unlikely(condition)) { \
496 error_description = description; \
501 int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
502 struct ssb_init_invariants *iv)
506 unsigned char buf[32];
507 struct ssb_sprom *sprom = &iv->sprom;
508 struct ssb_boardinfo *bi = &iv->boardinfo;
509 const char *error_description;
511 memset(sprom, 0xFF, sizeof(*sprom));
513 sprom->boardflags_lo = 0;
514 sprom->boardflags_hi = 0;
516 /* First fetch the MAC address. */
517 memset(&tuple, 0, sizeof(tuple));
518 tuple.DesiredTuple = CISTPL_FUNCE;
519 tuple.TupleData = buf;
520 tuple.TupleDataMax = sizeof(buf);
521 res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
522 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl");
523 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
524 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl data");
526 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1");
527 if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID)
529 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
530 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl");
531 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
532 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl data");
534 GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size");
535 memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN);
537 /* Fetch the vendor specific tuples. */
538 memset(&tuple, 0, sizeof(tuple));
539 tuple.DesiredTuple = SSB_PCMCIA_CIS;
540 tuple.TupleData = buf;
541 tuple.TupleDataMax = sizeof(buf);
542 res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
543 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl");
544 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
545 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl data");
547 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1");
548 switch (tuple.TupleData[0]) {
549 case SSB_PCMCIA_CIS_ID:
550 GOTO_ERROR_ON((tuple.TupleDataLen != 5) &&
551 (tuple.TupleDataLen != 7),
553 bi->vendor = tuple.TupleData[1] |
554 ((u16)tuple.TupleData[2] << 8);
556 case SSB_PCMCIA_CIS_BOARDREV:
557 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
558 "boardrev tpl size");
559 sprom->board_rev = tuple.TupleData[1];
561 case SSB_PCMCIA_CIS_PA:
562 GOTO_ERROR_ON(tuple.TupleDataLen != 9,
564 sprom->pa0b0 = tuple.TupleData[1] |
565 ((u16)tuple.TupleData[2] << 8);
566 sprom->pa0b1 = tuple.TupleData[3] |
567 ((u16)tuple.TupleData[4] << 8);
568 sprom->pa0b2 = tuple.TupleData[5] |
569 ((u16)tuple.TupleData[6] << 8);
570 sprom->itssi_a = tuple.TupleData[7];
571 sprom->itssi_bg = tuple.TupleData[7];
572 sprom->maxpwr_a = tuple.TupleData[8];
573 sprom->maxpwr_bg = tuple.TupleData[8];
575 case SSB_PCMCIA_CIS_OEMNAME:
576 /* We ignore this. */
578 case SSB_PCMCIA_CIS_CCODE:
579 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
581 sprom->country_code = tuple.TupleData[1];
583 case SSB_PCMCIA_CIS_ANTENNA:
584 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
586 sprom->ant_available_a = tuple.TupleData[1];
587 sprom->ant_available_bg = tuple.TupleData[1];
589 case SSB_PCMCIA_CIS_ANTGAIN:
590 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
592 sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1];
593 sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1];
594 sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1];
595 sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1];
596 sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1];
597 sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1];
598 sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1];
599 sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1];
601 case SSB_PCMCIA_CIS_BFLAGS:
602 GOTO_ERROR_ON(tuple.TupleDataLen != 3,
604 sprom->boardflags_lo = tuple.TupleData[1] |
605 ((u16)tuple.TupleData[2] << 8);
607 case SSB_PCMCIA_CIS_LEDS:
608 GOTO_ERROR_ON(tuple.TupleDataLen != 5,
610 sprom->gpio0 = tuple.TupleData[1];
611 sprom->gpio1 = tuple.TupleData[2];
612 sprom->gpio2 = tuple.TupleData[3];
613 sprom->gpio3 = tuple.TupleData[4];
616 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
617 if (res == CS_NO_MORE_ITEMS)
619 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl");
620 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
621 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl data");
626 ssb_printk(KERN_ERR PFX
627 "PCMCIA: Failed to fetch device invariants: %s\n",
632 static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev,
633 struct device_attribute *attr,
636 struct pcmcia_device *pdev =
637 container_of(pcmciadev, struct pcmcia_device, dev);
640 bus = ssb_pcmcia_dev_to_bus(pdev);
644 return ssb_attr_sprom_show(bus, buf,
645 ssb_pcmcia_sprom_read_all);
648 static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev,
649 struct device_attribute *attr,
650 const char *buf, size_t count)
652 struct pcmcia_device *pdev =
653 container_of(pcmciadev, struct pcmcia_device, dev);
656 bus = ssb_pcmcia_dev_to_bus(pdev);
660 return ssb_attr_sprom_store(bus, buf, count,
661 ssb_pcmcia_sprom_check_crc,
662 ssb_pcmcia_sprom_write_all);
665 static DEVICE_ATTR(ssb_sprom, 0600,
666 ssb_pcmcia_attr_sprom_show,
667 ssb_pcmcia_attr_sprom_store);
669 static int ssb_pcmcia_cor_setup(struct ssb_bus *bus, u8 cor)
674 err = ssb_pcmcia_cfg_read(bus, cor, &val);
677 val &= ~COR_SOFT_RESET;
678 val |= COR_FUNC_ENA | COR_IREQ_ENA | COR_LEVEL_REQ;
679 err = ssb_pcmcia_cfg_write(bus, cor, val);
687 void ssb_pcmcia_exit(struct ssb_bus *bus)
689 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
692 device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
695 int ssb_pcmcia_init(struct ssb_bus *bus)
699 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
702 /* Switch segment to a known state and sync
703 * bus->mapped_pcmcia_seg with hardware state. */
704 ssb_pcmcia_switch_segment(bus, 0);
706 /* Init the COR register. */
707 err = ssb_pcmcia_cor_setup(bus, CISREG_COR);
710 /* Some cards also need this register to get poked. */
711 err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80);
715 bus->sprom_size = SSB_PCMCIA_SPROM_SIZE;
716 mutex_init(&bus->sprom_mutex);
717 err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
723 ssb_printk(KERN_ERR PFX "Failed to initialize PCMCIA host device\n");