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_CORECTL 0x00
32 #define SSB_PCMCIA_CORECTL_RESET 0x80 /* Core reset */
33 #define SSB_PCMCIA_CORECTL_IRQEN 0x04 /* IRQ enable */
34 #define SSB_PCMCIA_CORECTL_FUNCEN 0x01 /* Function enable */
35 #define SSB_PCMCIA_CORECTL2 0x80
36 #define SSB_PCMCIA_ADDRESS0 0x2E
37 #define SSB_PCMCIA_ADDRESS1 0x30
38 #define SSB_PCMCIA_ADDRESS2 0x32
39 #define SSB_PCMCIA_MEMSEG 0x34
40 #define SSB_PCMCIA_SPROMCTL 0x36
41 #define SSB_PCMCIA_SPROMCTL_IDLE 0
42 #define SSB_PCMCIA_SPROMCTL_WRITE 1
43 #define SSB_PCMCIA_SPROMCTL_READ 2
44 #define SSB_PCMCIA_SPROMCTL_WRITEEN 4
45 #define SSB_PCMCIA_SPROMCTL_WRITEDIS 7
46 #define SSB_PCMCIA_SPROMCTL_DONE 8
47 #define SSB_PCMCIA_SPROM_DATALO 0x38
48 #define SSB_PCMCIA_SPROM_DATAHI 0x3A
49 #define SSB_PCMCIA_SPROM_ADDRLO 0x3C
50 #define SSB_PCMCIA_SPROM_ADDRHI 0x3E
52 /* Hardware invariants CIS tuples */
53 #define SSB_PCMCIA_CIS 0x80
54 #define SSB_PCMCIA_CIS_ID 0x01
55 #define SSB_PCMCIA_CIS_BOARDREV 0x02
56 #define SSB_PCMCIA_CIS_PA 0x03
57 #define SSB_PCMCIA_CIS_PA_PA0B0_LO 0
58 #define SSB_PCMCIA_CIS_PA_PA0B0_HI 1
59 #define SSB_PCMCIA_CIS_PA_PA0B1_LO 2
60 #define SSB_PCMCIA_CIS_PA_PA0B1_HI 3
61 #define SSB_PCMCIA_CIS_PA_PA0B2_LO 4
62 #define SSB_PCMCIA_CIS_PA_PA0B2_HI 5
63 #define SSB_PCMCIA_CIS_PA_ITSSI 6
64 #define SSB_PCMCIA_CIS_PA_MAXPOW 7
65 #define SSB_PCMCIA_CIS_OEMNAME 0x04
66 #define SSB_PCMCIA_CIS_CCODE 0x05
67 #define SSB_PCMCIA_CIS_ANTENNA 0x06
68 #define SSB_PCMCIA_CIS_ANTGAIN 0x07
69 #define SSB_PCMCIA_CIS_BFLAGS 0x08
70 #define SSB_PCMCIA_CIS_LEDS 0x09
72 /* PCMCIA SPROM size. */
73 #define SSB_PCMCIA_SPROM_SIZE 256
74 #define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16))
77 /* Write to a PCMCIA configuration register. */
78 static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value)
83 memset(®, 0, sizeof(reg));
85 reg.Action = CS_WRITE;
87 res = pcmcia_access_configuration_register(bus->host_pcmcia, ®);
88 if (unlikely(res != CS_SUCCESS))
94 /* Read from a PCMCIA configuration register. */
95 static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value)
100 memset(®, 0, sizeof(reg));
102 reg.Action = CS_READ;
103 res = pcmcia_access_configuration_register(bus->host_pcmcia, ®);
104 if (unlikely(res != CS_SUCCESS))
111 int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
121 addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
123 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0,
124 (addr & 0x0000F000) >> 12);
127 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1,
128 (addr & 0x00FF0000) >> 16);
131 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2,
132 (addr & 0xFF000000) >> 24);
138 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val);
141 read_addr |= ((u32)(val & 0x0F)) << 12;
142 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val);
145 read_addr |= ((u32)val) << 16;
146 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val);
149 read_addr |= ((u32)val) << 24;
151 cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
152 if (cur_core == coreidx)
156 if (attempts++ > SSB_BAR0_MAX_RETRIES)
163 ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
167 int ssb_pcmcia_switch_core(struct ssb_bus *bus,
168 struct ssb_device *dev)
172 #if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
173 ssb_printk(KERN_INFO PFX
174 "Switching to %s core, index %d\n",
175 ssb_core_name(dev->id.coreid),
179 err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
181 bus->mapped_device = dev;
186 int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
192 SSB_WARN_ON((seg != 0) && (seg != 1));
194 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg);
197 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val);
204 if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
208 bus->mapped_pcmcia_seg = seg;
212 ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n");
216 static int select_core_and_segment(struct ssb_device *dev,
219 struct ssb_bus *bus = dev->bus;
223 if (*offset >= 0x800) {
229 if (unlikely(dev != bus->mapped_device)) {
230 err = ssb_pcmcia_switch_core(bus, dev);
234 if (unlikely(need_segment != bus->mapped_pcmcia_seg)) {
235 err = ssb_pcmcia_switch_segment(bus, need_segment);
243 static u8 ssb_pcmcia_read8(struct ssb_device *dev, u16 offset)
245 struct ssb_bus *bus = dev->bus;
250 spin_lock_irqsave(&bus->bar_lock, flags);
251 err = select_core_and_segment(dev, &offset);
253 value = readb(bus->mmio + offset);
254 spin_unlock_irqrestore(&bus->bar_lock, flags);
259 static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset)
261 struct ssb_bus *bus = dev->bus;
266 spin_lock_irqsave(&bus->bar_lock, flags);
267 err = select_core_and_segment(dev, &offset);
269 value = readw(bus->mmio + offset);
270 spin_unlock_irqrestore(&bus->bar_lock, flags);
275 static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset)
277 struct ssb_bus *bus = dev->bus;
280 u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF;
282 spin_lock_irqsave(&bus->bar_lock, flags);
283 err = select_core_and_segment(dev, &offset);
285 lo = readw(bus->mmio + offset);
286 hi = readw(bus->mmio + offset + 2);
288 spin_unlock_irqrestore(&bus->bar_lock, flags);
290 return (lo | (hi << 16));
293 static void ssb_pcmcia_write8(struct ssb_device *dev, u16 offset, u8 value)
295 struct ssb_bus *bus = dev->bus;
299 spin_lock_irqsave(&bus->bar_lock, flags);
300 err = select_core_and_segment(dev, &offset);
302 writeb(value, bus->mmio + offset);
304 spin_unlock_irqrestore(&bus->bar_lock, flags);
307 static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
309 struct ssb_bus *bus = dev->bus;
313 spin_lock_irqsave(&bus->bar_lock, flags);
314 err = select_core_and_segment(dev, &offset);
316 writew(value, bus->mmio + offset);
318 spin_unlock_irqrestore(&bus->bar_lock, flags);
321 static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
323 struct ssb_bus *bus = dev->bus;
327 spin_lock_irqsave(&bus->bar_lock, flags);
328 err = select_core_and_segment(dev, &offset);
330 writew((value & 0x0000FFFF), bus->mmio + offset);
331 writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
334 spin_unlock_irqrestore(&bus->bar_lock, flags);
337 /* Not "static", as it's used in main.c */
338 const struct ssb_bus_ops ssb_pcmcia_ops = {
339 .read8 = ssb_pcmcia_read8,
340 .read16 = ssb_pcmcia_read16,
341 .read32 = ssb_pcmcia_read32,
342 .write8 = ssb_pcmcia_write8,
343 .write16 = ssb_pcmcia_write16,
344 .write32 = ssb_pcmcia_write32,
347 static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command)
353 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command);
356 for (i = 0; i < 1000; i++) {
357 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value);
360 if (value & SSB_PCMCIA_SPROMCTL_DONE)
368 /* offset is the 16bit word offset */
369 static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value)
374 offset *= 2; /* Make byte offset */
376 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
380 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
381 (offset & 0xFF00) >> 8);
384 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ);
387 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo);
390 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi);
393 *value = (lo | (((u16)hi) << 8));
398 /* offset is the 16bit word offset */
399 static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
403 offset *= 2; /* Make byte offset */
405 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
409 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
410 (offset & 0xFF00) >> 8);
413 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO,
417 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI,
418 (value & 0xFF00) >> 8);
421 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE);
429 /* Read the SPROM image. bufsize is in 16bit words. */
430 static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom)
434 for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) {
435 err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]);
443 /* Write the SPROM image. size is in 16bit words. */
444 static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
448 size_t size = SSB_PCMCIA_SPROM_SIZE;
450 ssb_printk(KERN_NOTICE PFX
451 "Writing SPROM. Do NOT turn off the power! "
452 "Please stand by...\n");
453 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
455 ssb_printk(KERN_NOTICE PFX
456 "Could not enable SPROM write access.\n");
459 ssb_printk(KERN_NOTICE PFX "[ 0%%");
461 for (i = 0; i < size; i++) {
464 else if (i == size / 2)
466 else if (i == (size * 3) / 4)
470 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
472 ssb_printk("\n" KERN_NOTICE PFX
473 "Failed to write to SPROM.\n");
478 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
480 ssb_printk("\n" KERN_NOTICE PFX
481 "Could not disable SPROM write access.\n");
486 ssb_printk("100%% ]\n");
487 ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
490 return failed ? -EBUSY : 0;
493 static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
499 #define GOTO_ERROR_ON(condition, description) do { \
500 if (unlikely(condition)) { \
501 error_description = description; \
506 int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
507 struct ssb_init_invariants *iv)
511 unsigned char buf[32];
512 struct ssb_sprom *sprom = &iv->sprom;
513 struct ssb_boardinfo *bi = &iv->boardinfo;
514 const char *error_description;
516 memset(sprom, 0xFF, sizeof(*sprom));
518 sprom->boardflags_lo = 0;
519 sprom->boardflags_hi = 0;
521 /* First fetch the MAC address. */
522 memset(&tuple, 0, sizeof(tuple));
523 tuple.DesiredTuple = CISTPL_FUNCE;
524 tuple.TupleData = buf;
525 tuple.TupleDataMax = sizeof(buf);
526 res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
527 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl");
528 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
529 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl data");
531 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1");
532 if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID)
534 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
535 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl");
536 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
537 GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl data");
539 GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size");
540 memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN);
542 /* Fetch the vendor specific tuples. */
543 memset(&tuple, 0, sizeof(tuple));
544 tuple.DesiredTuple = SSB_PCMCIA_CIS;
545 tuple.TupleData = buf;
546 tuple.TupleDataMax = sizeof(buf);
547 res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
548 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl");
549 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
550 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl data");
552 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1");
553 switch (tuple.TupleData[0]) {
554 case SSB_PCMCIA_CIS_ID:
555 GOTO_ERROR_ON((tuple.TupleDataLen != 5) &&
556 (tuple.TupleDataLen != 7),
558 bi->vendor = tuple.TupleData[1] |
559 ((u16)tuple.TupleData[2] << 8);
561 case SSB_PCMCIA_CIS_BOARDREV:
562 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
563 "boardrev tpl size");
564 sprom->board_rev = tuple.TupleData[1];
566 case SSB_PCMCIA_CIS_PA:
567 GOTO_ERROR_ON(tuple.TupleDataLen != 9,
569 sprom->pa0b0 = tuple.TupleData[1] |
570 ((u16)tuple.TupleData[2] << 8);
571 sprom->pa0b1 = tuple.TupleData[3] |
572 ((u16)tuple.TupleData[4] << 8);
573 sprom->pa0b2 = tuple.TupleData[5] |
574 ((u16)tuple.TupleData[6] << 8);
575 sprom->itssi_a = tuple.TupleData[7];
576 sprom->itssi_bg = tuple.TupleData[7];
577 sprom->maxpwr_a = tuple.TupleData[8];
578 sprom->maxpwr_bg = tuple.TupleData[8];
580 case SSB_PCMCIA_CIS_OEMNAME:
581 /* We ignore this. */
583 case SSB_PCMCIA_CIS_CCODE:
584 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
586 sprom->country_code = tuple.TupleData[1];
588 case SSB_PCMCIA_CIS_ANTENNA:
589 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
591 sprom->ant_available_a = tuple.TupleData[1];
592 sprom->ant_available_bg = tuple.TupleData[1];
594 case SSB_PCMCIA_CIS_ANTGAIN:
595 GOTO_ERROR_ON(tuple.TupleDataLen != 2,
597 sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1];
598 sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1];
599 sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1];
600 sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1];
601 sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1];
602 sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1];
603 sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1];
604 sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1];
606 case SSB_PCMCIA_CIS_BFLAGS:
607 GOTO_ERROR_ON(tuple.TupleDataLen != 3,
609 sprom->boardflags_lo = tuple.TupleData[1] |
610 ((u16)tuple.TupleData[2] << 8);
612 case SSB_PCMCIA_CIS_LEDS:
613 GOTO_ERROR_ON(tuple.TupleDataLen != 5,
615 sprom->gpio0 = tuple.TupleData[1];
616 sprom->gpio1 = tuple.TupleData[2];
617 sprom->gpio2 = tuple.TupleData[3];
618 sprom->gpio3 = tuple.TupleData[4];
621 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
622 if (res == CS_NO_MORE_ITEMS)
624 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl");
625 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
626 GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl data");
631 ssb_printk(KERN_ERR PFX
632 "PCMCIA: Failed to fetch device invariants: %s\n",
637 static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev,
638 struct device_attribute *attr,
641 struct pcmcia_device *pdev =
642 container_of(pcmciadev, struct pcmcia_device, dev);
645 bus = ssb_pcmcia_dev_to_bus(pdev);
649 return ssb_attr_sprom_show(bus, buf,
650 ssb_pcmcia_sprom_read_all);
653 static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev,
654 struct device_attribute *attr,
655 const char *buf, size_t count)
657 struct pcmcia_device *pdev =
658 container_of(pcmciadev, struct pcmcia_device, dev);
661 bus = ssb_pcmcia_dev_to_bus(pdev);
665 return ssb_attr_sprom_store(bus, buf, count,
666 ssb_pcmcia_sprom_check_crc,
667 ssb_pcmcia_sprom_write_all);
670 static DEVICE_ATTR(ssb_sprom, 0600,
671 ssb_pcmcia_attr_sprom_show,
672 ssb_pcmcia_attr_sprom_store);
674 void ssb_pcmcia_exit(struct ssb_bus *bus)
676 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
679 device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
682 int ssb_pcmcia_init(struct ssb_bus *bus)
687 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
690 /* Switch segment to a known state and sync
691 * bus->mapped_pcmcia_seg with hardware state. */
692 ssb_pcmcia_switch_segment(bus, 0);
694 /* Init IRQ routing */
695 if (bus->chip_id == 0x4306)
696 offset = SSB_PCMCIA_CORECTL;
698 offset = SSB_PCMCIA_CORECTL2;
699 err = ssb_pcmcia_cfg_read(bus, offset, &val);
702 val |= SSB_PCMCIA_CORECTL_IRQEN | SSB_PCMCIA_CORECTL_FUNCEN;
703 err = ssb_pcmcia_cfg_write(bus, offset, val);
707 bus->sprom_size = SSB_PCMCIA_SPROM_SIZE;
708 mutex_init(&bus->sprom_mutex);
709 err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
715 ssb_printk(KERN_ERR PFX "Failed to initialize PCMCIA host device\n");