Loading...
1/*
2 * Sonics Silicon Backplane
3 * PCMCIA-Hostbus related functions
4 *
5 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2007-2008 Michael Buesch <m@bues.ch>
7 *
8 * Licensed under the GNU/GPL. See COPYING for details.
9 */
10
11#include "ssb_private.h"
12
13#include <linux/ssb/ssb.h>
14#include <linux/delay.h>
15#include <linux/io.h>
16#include <linux/etherdevice.h>
17
18#include <pcmcia/cistpl.h>
19#include <pcmcia/ciscode.h>
20#include <pcmcia/ds.h>
21#include <pcmcia/cisreg.h>
22
23
24/* Define the following to 1 to enable a printk on each coreswitch. */
25#define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0
26
27
28/* PCMCIA configuration registers */
29#define SSB_PCMCIA_ADDRESS0 0x2E
30#define SSB_PCMCIA_ADDRESS1 0x30
31#define SSB_PCMCIA_ADDRESS2 0x32
32#define SSB_PCMCIA_MEMSEG 0x34
33#define SSB_PCMCIA_SPROMCTL 0x36
34#define SSB_PCMCIA_SPROMCTL_IDLE 0
35#define SSB_PCMCIA_SPROMCTL_WRITE 1
36#define SSB_PCMCIA_SPROMCTL_READ 2
37#define SSB_PCMCIA_SPROMCTL_WRITEEN 4
38#define SSB_PCMCIA_SPROMCTL_WRITEDIS 7
39#define SSB_PCMCIA_SPROMCTL_DONE 8
40#define SSB_PCMCIA_SPROM_DATALO 0x38
41#define SSB_PCMCIA_SPROM_DATAHI 0x3A
42#define SSB_PCMCIA_SPROM_ADDRLO 0x3C
43#define SSB_PCMCIA_SPROM_ADDRHI 0x3E
44
45/* Hardware invariants CIS tuples */
46#define SSB_PCMCIA_CIS 0x80
47#define SSB_PCMCIA_CIS_ID 0x01
48#define SSB_PCMCIA_CIS_BOARDREV 0x02
49#define SSB_PCMCIA_CIS_PA 0x03
50#define SSB_PCMCIA_CIS_PA_PA0B0_LO 0
51#define SSB_PCMCIA_CIS_PA_PA0B0_HI 1
52#define SSB_PCMCIA_CIS_PA_PA0B1_LO 2
53#define SSB_PCMCIA_CIS_PA_PA0B1_HI 3
54#define SSB_PCMCIA_CIS_PA_PA0B2_LO 4
55#define SSB_PCMCIA_CIS_PA_PA0B2_HI 5
56#define SSB_PCMCIA_CIS_PA_ITSSI 6
57#define SSB_PCMCIA_CIS_PA_MAXPOW 7
58#define SSB_PCMCIA_CIS_OEMNAME 0x04
59#define SSB_PCMCIA_CIS_CCODE 0x05
60#define SSB_PCMCIA_CIS_ANTENNA 0x06
61#define SSB_PCMCIA_CIS_ANTGAIN 0x07
62#define SSB_PCMCIA_CIS_BFLAGS 0x08
63#define SSB_PCMCIA_CIS_LEDS 0x09
64
65/* PCMCIA SPROM size. */
66#define SSB_PCMCIA_SPROM_SIZE 256
67#define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16))
68
69
70/* Write to a PCMCIA configuration register. */
71static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value)
72{
73 int res;
74
75 res = pcmcia_write_config_byte(bus->host_pcmcia, offset, value);
76 if (unlikely(res != 0))
77 return -EBUSY;
78
79 return 0;
80}
81
82/* Read from a PCMCIA configuration register. */
83static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value)
84{
85 int res;
86
87 res = pcmcia_read_config_byte(bus->host_pcmcia, offset, value);
88 if (unlikely(res != 0))
89 return -EBUSY;
90
91 return 0;
92}
93
94int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
95 u8 coreidx)
96{
97 int err;
98 int attempts = 0;
99 u32 cur_core;
100 u32 addr;
101 u32 read_addr;
102 u8 val;
103
104 addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
105 while (1) {
106 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0,
107 (addr & 0x0000F000) >> 12);
108 if (err)
109 goto error;
110 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1,
111 (addr & 0x00FF0000) >> 16);
112 if (err)
113 goto error;
114 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2,
115 (addr & 0xFF000000) >> 24);
116 if (err)
117 goto error;
118
119 read_addr = 0;
120
121 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val);
122 if (err)
123 goto error;
124 read_addr |= ((u32)(val & 0x0F)) << 12;
125 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val);
126 if (err)
127 goto error;
128 read_addr |= ((u32)val) << 16;
129 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val);
130 if (err)
131 goto error;
132 read_addr |= ((u32)val) << 24;
133
134 cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
135 if (cur_core == coreidx)
136 break;
137
138 err = -ETIMEDOUT;
139 if (attempts++ > SSB_BAR0_MAX_RETRIES)
140 goto error;
141 udelay(10);
142 }
143
144 return 0;
145error:
146 pr_err("Failed to switch to core %u\n", coreidx);
147 return err;
148}
149
150static int ssb_pcmcia_switch_core(struct ssb_bus *bus, struct ssb_device *dev)
151{
152 int err;
153
154#if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
155 pr_info("Switching to %s core, index %d\n",
156 ssb_core_name(dev->id.coreid), dev->core_index);
157#endif
158
159 err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
160 if (!err)
161 bus->mapped_device = dev;
162
163 return err;
164}
165
166int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
167{
168 int attempts = 0;
169 int err;
170 u8 val;
171
172 WARN_ON((seg != 0) && (seg != 1));
173 while (1) {
174 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg);
175 if (err)
176 goto error;
177 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val);
178 if (err)
179 goto error;
180 if (val == seg)
181 break;
182
183 err = -ETIMEDOUT;
184 if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
185 goto error;
186 udelay(10);
187 }
188 bus->mapped_pcmcia_seg = seg;
189
190 return 0;
191error:
192 pr_err("Failed to switch pcmcia segment\n");
193 return err;
194}
195
196static int select_core_and_segment(struct ssb_device *dev,
197 u16 *offset)
198{
199 struct ssb_bus *bus = dev->bus;
200 int err;
201 u8 need_segment;
202
203 if (*offset >= 0x800) {
204 *offset -= 0x800;
205 need_segment = 1;
206 } else
207 need_segment = 0;
208
209 if (unlikely(dev != bus->mapped_device)) {
210 err = ssb_pcmcia_switch_core(bus, dev);
211 if (unlikely(err))
212 return err;
213 }
214 if (unlikely(need_segment != bus->mapped_pcmcia_seg)) {
215 err = ssb_pcmcia_switch_segment(bus, need_segment);
216 if (unlikely(err))
217 return err;
218 }
219
220 return 0;
221}
222
223static u8 ssb_pcmcia_read8(struct ssb_device *dev, u16 offset)
224{
225 struct ssb_bus *bus = dev->bus;
226 unsigned long flags;
227 int err;
228 u8 value = 0xFF;
229
230 spin_lock_irqsave(&bus->bar_lock, flags);
231 err = select_core_and_segment(dev, &offset);
232 if (likely(!err))
233 value = readb(bus->mmio + offset);
234 spin_unlock_irqrestore(&bus->bar_lock, flags);
235
236 return value;
237}
238
239static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset)
240{
241 struct ssb_bus *bus = dev->bus;
242 unsigned long flags;
243 int err;
244 u16 value = 0xFFFF;
245
246 spin_lock_irqsave(&bus->bar_lock, flags);
247 err = select_core_and_segment(dev, &offset);
248 if (likely(!err))
249 value = readw(bus->mmio + offset);
250 spin_unlock_irqrestore(&bus->bar_lock, flags);
251
252 return value;
253}
254
255static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset)
256{
257 struct ssb_bus *bus = dev->bus;
258 unsigned long flags;
259 int err;
260 u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF;
261
262 spin_lock_irqsave(&bus->bar_lock, flags);
263 err = select_core_and_segment(dev, &offset);
264 if (likely(!err)) {
265 lo = readw(bus->mmio + offset);
266 hi = readw(bus->mmio + offset + 2);
267 }
268 spin_unlock_irqrestore(&bus->bar_lock, flags);
269
270 return (lo | (hi << 16));
271}
272
273#ifdef CONFIG_SSB_BLOCKIO
274static void ssb_pcmcia_block_read(struct ssb_device *dev, void *buffer,
275 size_t count, u16 offset, u8 reg_width)
276{
277 struct ssb_bus *bus = dev->bus;
278 unsigned long flags;
279 void __iomem *addr = bus->mmio + offset;
280 int err;
281
282 spin_lock_irqsave(&bus->bar_lock, flags);
283 err = select_core_and_segment(dev, &offset);
284 if (unlikely(err)) {
285 memset(buffer, 0xFF, count);
286 goto unlock;
287 }
288 switch (reg_width) {
289 case sizeof(u8): {
290 u8 *buf = buffer;
291
292 while (count) {
293 *buf = __raw_readb(addr);
294 buf++;
295 count--;
296 }
297 break;
298 }
299 case sizeof(u16): {
300 __le16 *buf = buffer;
301
302 WARN_ON(count & 1);
303 while (count) {
304 *buf = (__force __le16)__raw_readw(addr);
305 buf++;
306 count -= 2;
307 }
308 break;
309 }
310 case sizeof(u32): {
311 __le16 *buf = buffer;
312
313 WARN_ON(count & 3);
314 while (count) {
315 *buf = (__force __le16)__raw_readw(addr);
316 buf++;
317 *buf = (__force __le16)__raw_readw(addr + 2);
318 buf++;
319 count -= 4;
320 }
321 break;
322 }
323 default:
324 WARN_ON(1);
325 }
326unlock:
327 spin_unlock_irqrestore(&bus->bar_lock, flags);
328}
329#endif /* CONFIG_SSB_BLOCKIO */
330
331static void ssb_pcmcia_write8(struct ssb_device *dev, u16 offset, u8 value)
332{
333 struct ssb_bus *bus = dev->bus;
334 unsigned long flags;
335 int err;
336
337 spin_lock_irqsave(&bus->bar_lock, flags);
338 err = select_core_and_segment(dev, &offset);
339 if (likely(!err))
340 writeb(value, bus->mmio + offset);
341 spin_unlock_irqrestore(&bus->bar_lock, flags);
342}
343
344static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
345{
346 struct ssb_bus *bus = dev->bus;
347 unsigned long flags;
348 int err;
349
350 spin_lock_irqsave(&bus->bar_lock, flags);
351 err = select_core_and_segment(dev, &offset);
352 if (likely(!err))
353 writew(value, bus->mmio + offset);
354 spin_unlock_irqrestore(&bus->bar_lock, flags);
355}
356
357static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
358{
359 struct ssb_bus *bus = dev->bus;
360 unsigned long flags;
361 int err;
362
363 spin_lock_irqsave(&bus->bar_lock, flags);
364 err = select_core_and_segment(dev, &offset);
365 if (likely(!err)) {
366 writew((value & 0x0000FFFF), bus->mmio + offset);
367 writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
368 }
369 spin_unlock_irqrestore(&bus->bar_lock, flags);
370}
371
372#ifdef CONFIG_SSB_BLOCKIO
373static void ssb_pcmcia_block_write(struct ssb_device *dev, const void *buffer,
374 size_t count, u16 offset, u8 reg_width)
375{
376 struct ssb_bus *bus = dev->bus;
377 unsigned long flags;
378 void __iomem *addr = bus->mmio + offset;
379 int err;
380
381 spin_lock_irqsave(&bus->bar_lock, flags);
382 err = select_core_and_segment(dev, &offset);
383 if (unlikely(err))
384 goto unlock;
385 switch (reg_width) {
386 case sizeof(u8): {
387 const u8 *buf = buffer;
388
389 while (count) {
390 __raw_writeb(*buf, addr);
391 buf++;
392 count--;
393 }
394 break;
395 }
396 case sizeof(u16): {
397 const __le16 *buf = buffer;
398
399 WARN_ON(count & 1);
400 while (count) {
401 __raw_writew((__force u16)(*buf), addr);
402 buf++;
403 count -= 2;
404 }
405 break;
406 }
407 case sizeof(u32): {
408 const __le16 *buf = buffer;
409
410 WARN_ON(count & 3);
411 while (count) {
412 __raw_writew((__force u16)(*buf), addr);
413 buf++;
414 __raw_writew((__force u16)(*buf), addr + 2);
415 buf++;
416 count -= 4;
417 }
418 break;
419 }
420 default:
421 WARN_ON(1);
422 }
423unlock:
424 spin_unlock_irqrestore(&bus->bar_lock, flags);
425}
426#endif /* CONFIG_SSB_BLOCKIO */
427
428/* Not "static", as it's used in main.c */
429const struct ssb_bus_ops ssb_pcmcia_ops = {
430 .read8 = ssb_pcmcia_read8,
431 .read16 = ssb_pcmcia_read16,
432 .read32 = ssb_pcmcia_read32,
433 .write8 = ssb_pcmcia_write8,
434 .write16 = ssb_pcmcia_write16,
435 .write32 = ssb_pcmcia_write32,
436#ifdef CONFIG_SSB_BLOCKIO
437 .block_read = ssb_pcmcia_block_read,
438 .block_write = ssb_pcmcia_block_write,
439#endif
440};
441
442static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command)
443{
444 unsigned int i;
445 int err;
446 u8 value;
447
448 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command);
449 if (err)
450 return err;
451 for (i = 0; i < 1000; i++) {
452 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value);
453 if (err)
454 return err;
455 if (value & SSB_PCMCIA_SPROMCTL_DONE)
456 return 0;
457 udelay(10);
458 }
459
460 return -ETIMEDOUT;
461}
462
463/* offset is the 16bit word offset */
464static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value)
465{
466 int err;
467 u8 lo, hi;
468
469 offset *= 2; /* Make byte offset */
470
471 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
472 (offset & 0x00FF));
473 if (err)
474 return err;
475 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
476 (offset & 0xFF00) >> 8);
477 if (err)
478 return err;
479 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ);
480 if (err)
481 return err;
482 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo);
483 if (err)
484 return err;
485 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi);
486 if (err)
487 return err;
488 *value = (lo | (((u16)hi) << 8));
489
490 return 0;
491}
492
493/* offset is the 16bit word offset */
494static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
495{
496 int err;
497
498 offset *= 2; /* Make byte offset */
499
500 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
501 (offset & 0x00FF));
502 if (err)
503 return err;
504 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
505 (offset & 0xFF00) >> 8);
506 if (err)
507 return err;
508 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO,
509 (value & 0x00FF));
510 if (err)
511 return err;
512 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI,
513 (value & 0xFF00) >> 8);
514 if (err)
515 return err;
516 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE);
517 if (err)
518 return err;
519 msleep(20);
520
521 return 0;
522}
523
524/* Read the SPROM image. bufsize is in 16bit words. */
525static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom)
526{
527 int err, i;
528
529 for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) {
530 err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]);
531 if (err)
532 return err;
533 }
534
535 return 0;
536}
537
538/* Write the SPROM image. size is in 16bit words. */
539static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
540{
541 int i, err;
542 bool failed = 0;
543 size_t size = SSB_PCMCIA_SPROM_SIZE;
544
545 pr_notice("Writing SPROM. Do NOT turn off the power! Please stand by...\n");
546 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
547 if (err) {
548 pr_notice("Could not enable SPROM write access\n");
549 return -EBUSY;
550 }
551 pr_notice("[ 0%%");
552 msleep(500);
553 for (i = 0; i < size; i++) {
554 if (i == size / 4)
555 pr_cont("25%%");
556 else if (i == size / 2)
557 pr_cont("50%%");
558 else if (i == (size * 3) / 4)
559 pr_cont("75%%");
560 else if (i % 2)
561 pr_cont(".");
562 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
563 if (err) {
564 pr_notice("Failed to write to SPROM\n");
565 failed = 1;
566 break;
567 }
568 }
569 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
570 if (err) {
571 pr_notice("Could not disable SPROM write access\n");
572 failed = 1;
573 }
574 msleep(500);
575 if (!failed) {
576 pr_cont("100%% ]\n");
577 pr_notice("SPROM written\n");
578 }
579
580 return failed ? -EBUSY : 0;
581}
582
583static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
584{
585 //TODO
586 return 0;
587}
588
589#define GOTO_ERROR_ON(condition, description) do { \
590 if (unlikely(condition)) { \
591 error_description = description; \
592 goto error; \
593 } \
594 } while (0)
595
596static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev,
597 tuple_t *tuple,
598 void *priv)
599{
600 struct ssb_sprom *sprom = priv;
601
602 if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
603 return -EINVAL;
604 if (tuple->TupleDataLen != ETH_ALEN + 2)
605 return -EINVAL;
606 if (tuple->TupleData[1] != ETH_ALEN)
607 return -EINVAL;
608 memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN);
609 return 0;
610};
611
612static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev,
613 tuple_t *tuple,
614 void *priv)
615{
616 struct ssb_init_invariants *iv = priv;
617 struct ssb_sprom *sprom = &iv->sprom;
618 struct ssb_boardinfo *bi = &iv->boardinfo;
619 const char *error_description;
620
621 GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1");
622 switch (tuple->TupleData[0]) {
623 case SSB_PCMCIA_CIS_ID:
624 GOTO_ERROR_ON((tuple->TupleDataLen != 5) &&
625 (tuple->TupleDataLen != 7),
626 "id tpl size");
627 bi->vendor = tuple->TupleData[1] |
628 ((u16)tuple->TupleData[2] << 8);
629 break;
630 case SSB_PCMCIA_CIS_BOARDREV:
631 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
632 "boardrev tpl size");
633 sprom->board_rev = tuple->TupleData[1];
634 break;
635 case SSB_PCMCIA_CIS_PA:
636 GOTO_ERROR_ON((tuple->TupleDataLen != 9) &&
637 (tuple->TupleDataLen != 10),
638 "pa tpl size");
639 sprom->pa0b0 = tuple->TupleData[1] |
640 ((u16)tuple->TupleData[2] << 8);
641 sprom->pa0b1 = tuple->TupleData[3] |
642 ((u16)tuple->TupleData[4] << 8);
643 sprom->pa0b2 = tuple->TupleData[5] |
644 ((u16)tuple->TupleData[6] << 8);
645 sprom->itssi_a = tuple->TupleData[7];
646 sprom->itssi_bg = tuple->TupleData[7];
647 sprom->maxpwr_a = tuple->TupleData[8];
648 sprom->maxpwr_bg = tuple->TupleData[8];
649 break;
650 case SSB_PCMCIA_CIS_OEMNAME:
651 /* We ignore this. */
652 break;
653 case SSB_PCMCIA_CIS_CCODE:
654 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
655 "ccode tpl size");
656 sprom->country_code = tuple->TupleData[1];
657 break;
658 case SSB_PCMCIA_CIS_ANTENNA:
659 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
660 "ant tpl size");
661 sprom->ant_available_a = tuple->TupleData[1];
662 sprom->ant_available_bg = tuple->TupleData[1];
663 break;
664 case SSB_PCMCIA_CIS_ANTGAIN:
665 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
666 "antg tpl size");
667 sprom->antenna_gain.a0 = tuple->TupleData[1];
668 sprom->antenna_gain.a1 = tuple->TupleData[1];
669 sprom->antenna_gain.a2 = tuple->TupleData[1];
670 sprom->antenna_gain.a3 = tuple->TupleData[1];
671 break;
672 case SSB_PCMCIA_CIS_BFLAGS:
673 GOTO_ERROR_ON((tuple->TupleDataLen != 3) &&
674 (tuple->TupleDataLen != 5),
675 "bfl tpl size");
676 sprom->boardflags_lo = tuple->TupleData[1] |
677 ((u16)tuple->TupleData[2] << 8);
678 break;
679 case SSB_PCMCIA_CIS_LEDS:
680 GOTO_ERROR_ON(tuple->TupleDataLen != 5,
681 "leds tpl size");
682 sprom->gpio0 = tuple->TupleData[1];
683 sprom->gpio1 = tuple->TupleData[2];
684 sprom->gpio2 = tuple->TupleData[3];
685 sprom->gpio3 = tuple->TupleData[4];
686 break;
687 }
688 return -ENOSPC; /* continue with next entry */
689
690error:
691 pr_err("PCMCIA: Failed to fetch device invariants: %s\n",
692 error_description);
693 return -ENODEV;
694}
695
696
697int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
698 struct ssb_init_invariants *iv)
699{
700 struct ssb_sprom *sprom = &iv->sprom;
701 int res;
702
703 memset(sprom, 0xFF, sizeof(*sprom));
704 sprom->revision = 1;
705 sprom->boardflags_lo = 0;
706 sprom->boardflags_hi = 0;
707
708 /* First fetch the MAC address. */
709 res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE,
710 ssb_pcmcia_get_mac, sprom);
711 if (res != 0) {
712 pr_err("PCMCIA: Failed to fetch MAC address\n");
713 return -ENODEV;
714 }
715
716 /* Fetch the vendor specific tuples. */
717 res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS,
718 ssb_pcmcia_do_get_invariants, iv);
719 if ((res == 0) || (res == -ENOSPC))
720 return 0;
721
722 pr_err("PCMCIA: Failed to fetch device invariants\n");
723 return -ENODEV;
724}
725
726static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev,
727 struct device_attribute *attr,
728 char *buf)
729{
730 struct pcmcia_device *pdev =
731 container_of(pcmciadev, struct pcmcia_device, dev);
732 struct ssb_bus *bus;
733
734 bus = ssb_pcmcia_dev_to_bus(pdev);
735 if (!bus)
736 return -ENODEV;
737
738 return ssb_attr_sprom_show(bus, buf,
739 ssb_pcmcia_sprom_read_all);
740}
741
742static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev,
743 struct device_attribute *attr,
744 const char *buf, size_t count)
745{
746 struct pcmcia_device *pdev =
747 container_of(pcmciadev, struct pcmcia_device, dev);
748 struct ssb_bus *bus;
749
750 bus = ssb_pcmcia_dev_to_bus(pdev);
751 if (!bus)
752 return -ENODEV;
753
754 return ssb_attr_sprom_store(bus, buf, count,
755 ssb_pcmcia_sprom_check_crc,
756 ssb_pcmcia_sprom_write_all);
757}
758
759static DEVICE_ATTR(ssb_sprom, 0600,
760 ssb_pcmcia_attr_sprom_show,
761 ssb_pcmcia_attr_sprom_store);
762
763static int ssb_pcmcia_cor_setup(struct ssb_bus *bus, u8 cor)
764{
765 u8 val;
766 int err;
767
768 err = ssb_pcmcia_cfg_read(bus, cor, &val);
769 if (err)
770 return err;
771 val &= ~COR_SOFT_RESET;
772 val |= COR_FUNC_ENA | COR_IREQ_ENA | COR_LEVEL_REQ;
773 err = ssb_pcmcia_cfg_write(bus, cor, val);
774 if (err)
775 return err;
776 msleep(40);
777
778 return 0;
779}
780
781/* Initialize the PCMCIA hardware. This is called on Init and Resume. */
782int ssb_pcmcia_hardware_setup(struct ssb_bus *bus)
783{
784 int err;
785
786 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
787 return 0;
788
789 /* Switch segment to a known state and sync
790 * bus->mapped_pcmcia_seg with hardware state. */
791 ssb_pcmcia_switch_segment(bus, 0);
792 /* Init the COR register. */
793 err = ssb_pcmcia_cor_setup(bus, CISREG_COR);
794 if (err)
795 return err;
796 /* Some cards also need this register to get poked. */
797 err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80);
798 if (err)
799 return err;
800
801 return 0;
802}
803
804void ssb_pcmcia_exit(struct ssb_bus *bus)
805{
806 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
807 return;
808
809 device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
810}
811
812int ssb_pcmcia_init(struct ssb_bus *bus)
813{
814 int err;
815
816 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
817 return 0;
818
819 err = ssb_pcmcia_hardware_setup(bus);
820 if (err)
821 goto error;
822
823 bus->sprom_size = SSB_PCMCIA_SPROM_SIZE;
824 mutex_init(&bus->sprom_mutex);
825 err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
826 if (err)
827 goto error;
828
829 return 0;
830error:
831 pr_err("Failed to initialize PCMCIA host device\n");
832 return err;
833}
1/*
2 * Sonics Silicon Backplane
3 * PCMCIA-Hostbus related functions
4 *
5 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2007-2008 Michael Buesch <m@bues.ch>
7 *
8 * Licensed under the GNU/GPL. See COPYING for details.
9 */
10
11#include <linux/ssb/ssb.h>
12#include <linux/delay.h>
13#include <linux/io.h>
14#include <linux/etherdevice.h>
15
16#include <pcmcia/cistpl.h>
17#include <pcmcia/ciscode.h>
18#include <pcmcia/ds.h>
19#include <pcmcia/cisreg.h>
20
21#include "ssb_private.h"
22
23
24/* Define the following to 1 to enable a printk on each coreswitch. */
25#define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0
26
27
28/* PCMCIA configuration registers */
29#define SSB_PCMCIA_ADDRESS0 0x2E
30#define SSB_PCMCIA_ADDRESS1 0x30
31#define SSB_PCMCIA_ADDRESS2 0x32
32#define SSB_PCMCIA_MEMSEG 0x34
33#define SSB_PCMCIA_SPROMCTL 0x36
34#define SSB_PCMCIA_SPROMCTL_IDLE 0
35#define SSB_PCMCIA_SPROMCTL_WRITE 1
36#define SSB_PCMCIA_SPROMCTL_READ 2
37#define SSB_PCMCIA_SPROMCTL_WRITEEN 4
38#define SSB_PCMCIA_SPROMCTL_WRITEDIS 7
39#define SSB_PCMCIA_SPROMCTL_DONE 8
40#define SSB_PCMCIA_SPROM_DATALO 0x38
41#define SSB_PCMCIA_SPROM_DATAHI 0x3A
42#define SSB_PCMCIA_SPROM_ADDRLO 0x3C
43#define SSB_PCMCIA_SPROM_ADDRHI 0x3E
44
45/* Hardware invariants CIS tuples */
46#define SSB_PCMCIA_CIS 0x80
47#define SSB_PCMCIA_CIS_ID 0x01
48#define SSB_PCMCIA_CIS_BOARDREV 0x02
49#define SSB_PCMCIA_CIS_PA 0x03
50#define SSB_PCMCIA_CIS_PA_PA0B0_LO 0
51#define SSB_PCMCIA_CIS_PA_PA0B0_HI 1
52#define SSB_PCMCIA_CIS_PA_PA0B1_LO 2
53#define SSB_PCMCIA_CIS_PA_PA0B1_HI 3
54#define SSB_PCMCIA_CIS_PA_PA0B2_LO 4
55#define SSB_PCMCIA_CIS_PA_PA0B2_HI 5
56#define SSB_PCMCIA_CIS_PA_ITSSI 6
57#define SSB_PCMCIA_CIS_PA_MAXPOW 7
58#define SSB_PCMCIA_CIS_OEMNAME 0x04
59#define SSB_PCMCIA_CIS_CCODE 0x05
60#define SSB_PCMCIA_CIS_ANTENNA 0x06
61#define SSB_PCMCIA_CIS_ANTGAIN 0x07
62#define SSB_PCMCIA_CIS_BFLAGS 0x08
63#define SSB_PCMCIA_CIS_LEDS 0x09
64
65/* PCMCIA SPROM size. */
66#define SSB_PCMCIA_SPROM_SIZE 256
67#define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16))
68
69
70/* Write to a PCMCIA configuration register. */
71static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value)
72{
73 int res;
74
75 res = pcmcia_write_config_byte(bus->host_pcmcia, offset, value);
76 if (unlikely(res != 0))
77 return -EBUSY;
78
79 return 0;
80}
81
82/* Read from a PCMCIA configuration register. */
83static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value)
84{
85 int res;
86
87 res = pcmcia_read_config_byte(bus->host_pcmcia, offset, value);
88 if (unlikely(res != 0))
89 return -EBUSY;
90
91 return 0;
92}
93
94int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
95 u8 coreidx)
96{
97 int err;
98 int attempts = 0;
99 u32 cur_core;
100 u32 addr;
101 u32 read_addr;
102 u8 val;
103
104 addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
105 while (1) {
106 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0,
107 (addr & 0x0000F000) >> 12);
108 if (err)
109 goto error;
110 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1,
111 (addr & 0x00FF0000) >> 16);
112 if (err)
113 goto error;
114 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2,
115 (addr & 0xFF000000) >> 24);
116 if (err)
117 goto error;
118
119 read_addr = 0;
120
121 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val);
122 if (err)
123 goto error;
124 read_addr |= ((u32)(val & 0x0F)) << 12;
125 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val);
126 if (err)
127 goto error;
128 read_addr |= ((u32)val) << 16;
129 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val);
130 if (err)
131 goto error;
132 read_addr |= ((u32)val) << 24;
133
134 cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
135 if (cur_core == coreidx)
136 break;
137
138 err = -ETIMEDOUT;
139 if (attempts++ > SSB_BAR0_MAX_RETRIES)
140 goto error;
141 udelay(10);
142 }
143
144 return 0;
145error:
146 ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
147 return err;
148}
149
150int ssb_pcmcia_switch_core(struct ssb_bus *bus,
151 struct ssb_device *dev)
152{
153 int err;
154
155#if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
156 ssb_printk(KERN_INFO PFX
157 "Switching to %s core, index %d\n",
158 ssb_core_name(dev->id.coreid),
159 dev->core_index);
160#endif
161
162 err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
163 if (!err)
164 bus->mapped_device = dev;
165
166 return err;
167}
168
169int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
170{
171 int attempts = 0;
172 int err;
173 u8 val;
174
175 SSB_WARN_ON((seg != 0) && (seg != 1));
176 while (1) {
177 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg);
178 if (err)
179 goto error;
180 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val);
181 if (err)
182 goto error;
183 if (val == seg)
184 break;
185
186 err = -ETIMEDOUT;
187 if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
188 goto error;
189 udelay(10);
190 }
191 bus->mapped_pcmcia_seg = seg;
192
193 return 0;
194error:
195 ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n");
196 return err;
197}
198
199static int select_core_and_segment(struct ssb_device *dev,
200 u16 *offset)
201{
202 struct ssb_bus *bus = dev->bus;
203 int err;
204 u8 need_segment;
205
206 if (*offset >= 0x800) {
207 *offset -= 0x800;
208 need_segment = 1;
209 } else
210 need_segment = 0;
211
212 if (unlikely(dev != bus->mapped_device)) {
213 err = ssb_pcmcia_switch_core(bus, dev);
214 if (unlikely(err))
215 return err;
216 }
217 if (unlikely(need_segment != bus->mapped_pcmcia_seg)) {
218 err = ssb_pcmcia_switch_segment(bus, need_segment);
219 if (unlikely(err))
220 return err;
221 }
222
223 return 0;
224}
225
226static u8 ssb_pcmcia_read8(struct ssb_device *dev, u16 offset)
227{
228 struct ssb_bus *bus = dev->bus;
229 unsigned long flags;
230 int err;
231 u8 value = 0xFF;
232
233 spin_lock_irqsave(&bus->bar_lock, flags);
234 err = select_core_and_segment(dev, &offset);
235 if (likely(!err))
236 value = readb(bus->mmio + offset);
237 spin_unlock_irqrestore(&bus->bar_lock, flags);
238
239 return value;
240}
241
242static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset)
243{
244 struct ssb_bus *bus = dev->bus;
245 unsigned long flags;
246 int err;
247 u16 value = 0xFFFF;
248
249 spin_lock_irqsave(&bus->bar_lock, flags);
250 err = select_core_and_segment(dev, &offset);
251 if (likely(!err))
252 value = readw(bus->mmio + offset);
253 spin_unlock_irqrestore(&bus->bar_lock, flags);
254
255 return value;
256}
257
258static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset)
259{
260 struct ssb_bus *bus = dev->bus;
261 unsigned long flags;
262 int err;
263 u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF;
264
265 spin_lock_irqsave(&bus->bar_lock, flags);
266 err = select_core_and_segment(dev, &offset);
267 if (likely(!err)) {
268 lo = readw(bus->mmio + offset);
269 hi = readw(bus->mmio + offset + 2);
270 }
271 spin_unlock_irqrestore(&bus->bar_lock, flags);
272
273 return (lo | (hi << 16));
274}
275
276#ifdef CONFIG_SSB_BLOCKIO
277static void ssb_pcmcia_block_read(struct ssb_device *dev, void *buffer,
278 size_t count, u16 offset, u8 reg_width)
279{
280 struct ssb_bus *bus = dev->bus;
281 unsigned long flags;
282 void __iomem *addr = bus->mmio + offset;
283 int err;
284
285 spin_lock_irqsave(&bus->bar_lock, flags);
286 err = select_core_and_segment(dev, &offset);
287 if (unlikely(err)) {
288 memset(buffer, 0xFF, count);
289 goto unlock;
290 }
291 switch (reg_width) {
292 case sizeof(u8): {
293 u8 *buf = buffer;
294
295 while (count) {
296 *buf = __raw_readb(addr);
297 buf++;
298 count--;
299 }
300 break;
301 }
302 case sizeof(u16): {
303 __le16 *buf = buffer;
304
305 SSB_WARN_ON(count & 1);
306 while (count) {
307 *buf = (__force __le16)__raw_readw(addr);
308 buf++;
309 count -= 2;
310 }
311 break;
312 }
313 case sizeof(u32): {
314 __le16 *buf = buffer;
315
316 SSB_WARN_ON(count & 3);
317 while (count) {
318 *buf = (__force __le16)__raw_readw(addr);
319 buf++;
320 *buf = (__force __le16)__raw_readw(addr + 2);
321 buf++;
322 count -= 4;
323 }
324 break;
325 }
326 default:
327 SSB_WARN_ON(1);
328 }
329unlock:
330 spin_unlock_irqrestore(&bus->bar_lock, flags);
331}
332#endif /* CONFIG_SSB_BLOCKIO */
333
334static void ssb_pcmcia_write8(struct ssb_device *dev, u16 offset, u8 value)
335{
336 struct ssb_bus *bus = dev->bus;
337 unsigned long flags;
338 int err;
339
340 spin_lock_irqsave(&bus->bar_lock, flags);
341 err = select_core_and_segment(dev, &offset);
342 if (likely(!err))
343 writeb(value, bus->mmio + offset);
344 mmiowb();
345 spin_unlock_irqrestore(&bus->bar_lock, flags);
346}
347
348static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
349{
350 struct ssb_bus *bus = dev->bus;
351 unsigned long flags;
352 int err;
353
354 spin_lock_irqsave(&bus->bar_lock, flags);
355 err = select_core_and_segment(dev, &offset);
356 if (likely(!err))
357 writew(value, bus->mmio + offset);
358 mmiowb();
359 spin_unlock_irqrestore(&bus->bar_lock, flags);
360}
361
362static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
363{
364 struct ssb_bus *bus = dev->bus;
365 unsigned long flags;
366 int err;
367
368 spin_lock_irqsave(&bus->bar_lock, flags);
369 err = select_core_and_segment(dev, &offset);
370 if (likely(!err)) {
371 writew((value & 0x0000FFFF), bus->mmio + offset);
372 writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
373 }
374 mmiowb();
375 spin_unlock_irqrestore(&bus->bar_lock, flags);
376}
377
378#ifdef CONFIG_SSB_BLOCKIO
379static void ssb_pcmcia_block_write(struct ssb_device *dev, const void *buffer,
380 size_t count, u16 offset, u8 reg_width)
381{
382 struct ssb_bus *bus = dev->bus;
383 unsigned long flags;
384 void __iomem *addr = bus->mmio + offset;
385 int err;
386
387 spin_lock_irqsave(&bus->bar_lock, flags);
388 err = select_core_and_segment(dev, &offset);
389 if (unlikely(err))
390 goto unlock;
391 switch (reg_width) {
392 case sizeof(u8): {
393 const u8 *buf = buffer;
394
395 while (count) {
396 __raw_writeb(*buf, addr);
397 buf++;
398 count--;
399 }
400 break;
401 }
402 case sizeof(u16): {
403 const __le16 *buf = buffer;
404
405 SSB_WARN_ON(count & 1);
406 while (count) {
407 __raw_writew((__force u16)(*buf), addr);
408 buf++;
409 count -= 2;
410 }
411 break;
412 }
413 case sizeof(u32): {
414 const __le16 *buf = buffer;
415
416 SSB_WARN_ON(count & 3);
417 while (count) {
418 __raw_writew((__force u16)(*buf), addr);
419 buf++;
420 __raw_writew((__force u16)(*buf), addr + 2);
421 buf++;
422 count -= 4;
423 }
424 break;
425 }
426 default:
427 SSB_WARN_ON(1);
428 }
429unlock:
430 mmiowb();
431 spin_unlock_irqrestore(&bus->bar_lock, flags);
432}
433#endif /* CONFIG_SSB_BLOCKIO */
434
435/* Not "static", as it's used in main.c */
436const struct ssb_bus_ops ssb_pcmcia_ops = {
437 .read8 = ssb_pcmcia_read8,
438 .read16 = ssb_pcmcia_read16,
439 .read32 = ssb_pcmcia_read32,
440 .write8 = ssb_pcmcia_write8,
441 .write16 = ssb_pcmcia_write16,
442 .write32 = ssb_pcmcia_write32,
443#ifdef CONFIG_SSB_BLOCKIO
444 .block_read = ssb_pcmcia_block_read,
445 .block_write = ssb_pcmcia_block_write,
446#endif
447};
448
449static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command)
450{
451 unsigned int i;
452 int err;
453 u8 value;
454
455 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command);
456 if (err)
457 return err;
458 for (i = 0; i < 1000; i++) {
459 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value);
460 if (err)
461 return err;
462 if (value & SSB_PCMCIA_SPROMCTL_DONE)
463 return 0;
464 udelay(10);
465 }
466
467 return -ETIMEDOUT;
468}
469
470/* offset is the 16bit word offset */
471static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value)
472{
473 int err;
474 u8 lo, hi;
475
476 offset *= 2; /* Make byte offset */
477
478 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
479 (offset & 0x00FF));
480 if (err)
481 return err;
482 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
483 (offset & 0xFF00) >> 8);
484 if (err)
485 return err;
486 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ);
487 if (err)
488 return err;
489 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo);
490 if (err)
491 return err;
492 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi);
493 if (err)
494 return err;
495 *value = (lo | (((u16)hi) << 8));
496
497 return 0;
498}
499
500/* offset is the 16bit word offset */
501static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
502{
503 int err;
504
505 offset *= 2; /* Make byte offset */
506
507 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
508 (offset & 0x00FF));
509 if (err)
510 return err;
511 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
512 (offset & 0xFF00) >> 8);
513 if (err)
514 return err;
515 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO,
516 (value & 0x00FF));
517 if (err)
518 return err;
519 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI,
520 (value & 0xFF00) >> 8);
521 if (err)
522 return err;
523 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE);
524 if (err)
525 return err;
526 msleep(20);
527
528 return 0;
529}
530
531/* Read the SPROM image. bufsize is in 16bit words. */
532static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom)
533{
534 int err, i;
535
536 for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) {
537 err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]);
538 if (err)
539 return err;
540 }
541
542 return 0;
543}
544
545/* Write the SPROM image. size is in 16bit words. */
546static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
547{
548 int i, err;
549 bool failed = 0;
550 size_t size = SSB_PCMCIA_SPROM_SIZE;
551
552 ssb_printk(KERN_NOTICE PFX
553 "Writing SPROM. Do NOT turn off the power! "
554 "Please stand by...\n");
555 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
556 if (err) {
557 ssb_printk(KERN_NOTICE PFX
558 "Could not enable SPROM write access.\n");
559 return -EBUSY;
560 }
561 ssb_printk(KERN_NOTICE PFX "[ 0%%");
562 msleep(500);
563 for (i = 0; i < size; i++) {
564 if (i == size / 4)
565 ssb_printk("25%%");
566 else if (i == size / 2)
567 ssb_printk("50%%");
568 else if (i == (size * 3) / 4)
569 ssb_printk("75%%");
570 else if (i % 2)
571 ssb_printk(".");
572 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
573 if (err) {
574 ssb_printk(KERN_NOTICE PFX
575 "Failed to write to SPROM.\n");
576 failed = 1;
577 break;
578 }
579 }
580 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
581 if (err) {
582 ssb_printk(KERN_NOTICE PFX
583 "Could not disable SPROM write access.\n");
584 failed = 1;
585 }
586 msleep(500);
587 if (!failed) {
588 ssb_printk("100%% ]\n");
589 ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
590 }
591
592 return failed ? -EBUSY : 0;
593}
594
595static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
596{
597 //TODO
598 return 0;
599}
600
601#define GOTO_ERROR_ON(condition, description) do { \
602 if (unlikely(condition)) { \
603 error_description = description; \
604 goto error; \
605 } \
606 } while (0)
607
608static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev,
609 tuple_t *tuple,
610 void *priv)
611{
612 struct ssb_sprom *sprom = priv;
613
614 if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
615 return -EINVAL;
616 if (tuple->TupleDataLen != ETH_ALEN + 2)
617 return -EINVAL;
618 if (tuple->TupleData[1] != ETH_ALEN)
619 return -EINVAL;
620 memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN);
621 return 0;
622};
623
624static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev,
625 tuple_t *tuple,
626 void *priv)
627{
628 struct ssb_init_invariants *iv = priv;
629 struct ssb_sprom *sprom = &iv->sprom;
630 struct ssb_boardinfo *bi = &iv->boardinfo;
631 const char *error_description;
632
633 GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1");
634 switch (tuple->TupleData[0]) {
635 case SSB_PCMCIA_CIS_ID:
636 GOTO_ERROR_ON((tuple->TupleDataLen != 5) &&
637 (tuple->TupleDataLen != 7),
638 "id tpl size");
639 bi->vendor = tuple->TupleData[1] |
640 ((u16)tuple->TupleData[2] << 8);
641 break;
642 case SSB_PCMCIA_CIS_BOARDREV:
643 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
644 "boardrev tpl size");
645 sprom->board_rev = tuple->TupleData[1];
646 break;
647 case SSB_PCMCIA_CIS_PA:
648 GOTO_ERROR_ON((tuple->TupleDataLen != 9) &&
649 (tuple->TupleDataLen != 10),
650 "pa tpl size");
651 sprom->pa0b0 = tuple->TupleData[1] |
652 ((u16)tuple->TupleData[2] << 8);
653 sprom->pa0b1 = tuple->TupleData[3] |
654 ((u16)tuple->TupleData[4] << 8);
655 sprom->pa0b2 = tuple->TupleData[5] |
656 ((u16)tuple->TupleData[6] << 8);
657 sprom->itssi_a = tuple->TupleData[7];
658 sprom->itssi_bg = tuple->TupleData[7];
659 sprom->maxpwr_a = tuple->TupleData[8];
660 sprom->maxpwr_bg = tuple->TupleData[8];
661 break;
662 case SSB_PCMCIA_CIS_OEMNAME:
663 /* We ignore this. */
664 break;
665 case SSB_PCMCIA_CIS_CCODE:
666 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
667 "ccode tpl size");
668 sprom->country_code = tuple->TupleData[1];
669 break;
670 case SSB_PCMCIA_CIS_ANTENNA:
671 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
672 "ant tpl size");
673 sprom->ant_available_a = tuple->TupleData[1];
674 sprom->ant_available_bg = tuple->TupleData[1];
675 break;
676 case SSB_PCMCIA_CIS_ANTGAIN:
677 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
678 "antg tpl size");
679 sprom->antenna_gain.a0 = tuple->TupleData[1];
680 sprom->antenna_gain.a1 = tuple->TupleData[1];
681 sprom->antenna_gain.a2 = tuple->TupleData[1];
682 sprom->antenna_gain.a3 = tuple->TupleData[1];
683 break;
684 case SSB_PCMCIA_CIS_BFLAGS:
685 GOTO_ERROR_ON((tuple->TupleDataLen != 3) &&
686 (tuple->TupleDataLen != 5),
687 "bfl tpl size");
688 sprom->boardflags_lo = tuple->TupleData[1] |
689 ((u16)tuple->TupleData[2] << 8);
690 break;
691 case SSB_PCMCIA_CIS_LEDS:
692 GOTO_ERROR_ON(tuple->TupleDataLen != 5,
693 "leds tpl size");
694 sprom->gpio0 = tuple->TupleData[1];
695 sprom->gpio1 = tuple->TupleData[2];
696 sprom->gpio2 = tuple->TupleData[3];
697 sprom->gpio3 = tuple->TupleData[4];
698 break;
699 }
700 return -ENOSPC; /* continue with next entry */
701
702error:
703 ssb_printk(KERN_ERR PFX
704 "PCMCIA: Failed to fetch device invariants: %s\n",
705 error_description);
706 return -ENODEV;
707}
708
709
710int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
711 struct ssb_init_invariants *iv)
712{
713 struct ssb_sprom *sprom = &iv->sprom;
714 int res;
715
716 memset(sprom, 0xFF, sizeof(*sprom));
717 sprom->revision = 1;
718 sprom->boardflags_lo = 0;
719 sprom->boardflags_hi = 0;
720
721 /* First fetch the MAC address. */
722 res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE,
723 ssb_pcmcia_get_mac, sprom);
724 if (res != 0) {
725 ssb_printk(KERN_ERR PFX
726 "PCMCIA: Failed to fetch MAC address\n");
727 return -ENODEV;
728 }
729
730 /* Fetch the vendor specific tuples. */
731 res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS,
732 ssb_pcmcia_do_get_invariants, iv);
733 if ((res == 0) || (res == -ENOSPC))
734 return 0;
735
736 ssb_printk(KERN_ERR PFX
737 "PCMCIA: Failed to fetch device invariants\n");
738 return -ENODEV;
739}
740
741static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev,
742 struct device_attribute *attr,
743 char *buf)
744{
745 struct pcmcia_device *pdev =
746 container_of(pcmciadev, struct pcmcia_device, dev);
747 struct ssb_bus *bus;
748
749 bus = ssb_pcmcia_dev_to_bus(pdev);
750 if (!bus)
751 return -ENODEV;
752
753 return ssb_attr_sprom_show(bus, buf,
754 ssb_pcmcia_sprom_read_all);
755}
756
757static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev,
758 struct device_attribute *attr,
759 const char *buf, size_t count)
760{
761 struct pcmcia_device *pdev =
762 container_of(pcmciadev, struct pcmcia_device, dev);
763 struct ssb_bus *bus;
764
765 bus = ssb_pcmcia_dev_to_bus(pdev);
766 if (!bus)
767 return -ENODEV;
768
769 return ssb_attr_sprom_store(bus, buf, count,
770 ssb_pcmcia_sprom_check_crc,
771 ssb_pcmcia_sprom_write_all);
772}
773
774static DEVICE_ATTR(ssb_sprom, 0600,
775 ssb_pcmcia_attr_sprom_show,
776 ssb_pcmcia_attr_sprom_store);
777
778static int ssb_pcmcia_cor_setup(struct ssb_bus *bus, u8 cor)
779{
780 u8 val;
781 int err;
782
783 err = ssb_pcmcia_cfg_read(bus, cor, &val);
784 if (err)
785 return err;
786 val &= ~COR_SOFT_RESET;
787 val |= COR_FUNC_ENA | COR_IREQ_ENA | COR_LEVEL_REQ;
788 err = ssb_pcmcia_cfg_write(bus, cor, val);
789 if (err)
790 return err;
791 msleep(40);
792
793 return 0;
794}
795
796/* Initialize the PCMCIA hardware. This is called on Init and Resume. */
797int ssb_pcmcia_hardware_setup(struct ssb_bus *bus)
798{
799 int err;
800
801 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
802 return 0;
803
804 /* Switch segment to a known state and sync
805 * bus->mapped_pcmcia_seg with hardware state. */
806 ssb_pcmcia_switch_segment(bus, 0);
807 /* Init the COR register. */
808 err = ssb_pcmcia_cor_setup(bus, CISREG_COR);
809 if (err)
810 return err;
811 /* Some cards also need this register to get poked. */
812 err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80);
813 if (err)
814 return err;
815
816 return 0;
817}
818
819void ssb_pcmcia_exit(struct ssb_bus *bus)
820{
821 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
822 return;
823
824 device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
825}
826
827int ssb_pcmcia_init(struct ssb_bus *bus)
828{
829 int err;
830
831 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
832 return 0;
833
834 err = ssb_pcmcia_hardware_setup(bus);
835 if (err)
836 goto error;
837
838 bus->sprom_size = SSB_PCMCIA_SPROM_SIZE;
839 mutex_init(&bus->sprom_mutex);
840 err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
841 if (err)
842 goto error;
843
844 return 0;
845error:
846 ssb_printk(KERN_ERR PFX "Failed to initialize PCMCIA host device\n");
847 return err;
848}