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