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