?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge 5.0-rc6 into driver-core-next
[linux/fpc-iii.git] / drivers / ssb / pcmcia.c
blob567013f8a8be9bde6b4fc1f68d8a53171d91f939
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. */
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 pr_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 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
166 int 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;
191 error:
192 pr_err("Failed to switch pcmcia segment\n");
193 return err;
194 }
195
196 static 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
223 static 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
239 static 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
255 static 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
274 static 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 }
326 unlock:
327 spin_unlock_irqrestore(&bus->bar_lock, flags);
328 }
329 #endif /* CONFIG_SSB_BLOCKIO */
330
331 static 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 mmiowb();
342 spin_unlock_irqrestore(&bus->bar_lock, flags);
343 }
344
345 static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
346 {
347 struct ssb_bus *bus = dev->bus;
348 unsigned long flags;
349 int err;
350
351 spin_lock_irqsave(&bus->bar_lock, flags);
352 err = select_core_and_segment(dev, &offset);
353 if (likely(!err))
354 writew(value, bus->mmio + offset);
355 mmiowb();
356 spin_unlock_irqrestore(&bus->bar_lock, flags);
357 }
358
359 static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
360 {
361 struct ssb_bus *bus = dev->bus;
362 unsigned long flags;
363 int err;
364
365 spin_lock_irqsave(&bus->bar_lock, flags);
366 err = select_core_and_segment(dev, &offset);
367 if (likely(!err)) {
368 writew((value & 0x0000FFFF), bus->mmio + offset);
369 writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
370 }
371 mmiowb();
372 spin_unlock_irqrestore(&bus->bar_lock, flags);
373 }
374
375 #ifdef CONFIG_SSB_BLOCKIO
376 static void ssb_pcmcia_block_write(struct ssb_device *dev, const void *buffer,
377 size_t count, u16 offset, u8 reg_width)
378 {
379 struct ssb_bus *bus = dev->bus;
380 unsigned long flags;
381 void __iomem *addr = bus->mmio + offset;
382 int err;
383
384 spin_lock_irqsave(&bus->bar_lock, flags);
385 err = select_core_and_segment(dev, &offset);
386 if (unlikely(err))
387 goto unlock;
388 switch (reg_width) {
389 case sizeof(u8): {
390 const u8 *buf = buffer;
391
392 while (count) {
393 __raw_writeb(*buf, addr);
394 buf++;
395 count--;
396 }
397 break;
398 }
399 case sizeof(u16): {
400 const __le16 *buf = buffer;
401
402 WARN_ON(count & 1);
403 while (count) {
404 __raw_writew((__force u16)(*buf), addr);
405 buf++;
406 count -= 2;
407 }
408 break;
409 }
410 case sizeof(u32): {
411 const __le16 *buf = buffer;
412
413 WARN_ON(count & 3);
414 while (count) {
415 __raw_writew((__force u16)(*buf), addr);
416 buf++;
417 __raw_writew((__force u16)(*buf), addr + 2);
418 buf++;
419 count -= 4;
420 }
421 break;
422 }
423 default:
424 WARN_ON(1);
425 }
426 unlock:
427 mmiowb();
428 spin_unlock_irqrestore(&bus->bar_lock, flags);
429 }
430 #endif /* CONFIG_SSB_BLOCKIO */
431
432 /* Not "static", as it's used in main.c */
433 const struct ssb_bus_ops ssb_pcmcia_ops = {
434 .read8 = ssb_pcmcia_read8,
435 .read16 = ssb_pcmcia_read16,
436 .read32 = ssb_pcmcia_read32,
437 .write8 = ssb_pcmcia_write8,
438 .write16 = ssb_pcmcia_write16,
439 .write32 = ssb_pcmcia_write32,
440 #ifdef CONFIG_SSB_BLOCKIO
441 .block_read = ssb_pcmcia_block_read,
442 .block_write = ssb_pcmcia_block_write,
443 #endif
444 };
445
446 static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command)
447 {
448 unsigned int i;
449 int err;
450 u8 value;
451
452 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command);
453 if (err)
454 return err;
455 for (i = 0; i < 1000; i++) {
456 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value);
457 if (err)
458 return err;
459 if (value & SSB_PCMCIA_SPROMCTL_DONE)
460 return 0;
461 udelay(10);
462 }
463
464 return -ETIMEDOUT;
465 }
466
467 /* offset is the 16bit word offset */
468 static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value)
469 {
470 int err;
471 u8 lo, hi;
472
473 offset *= 2; /* Make byte offset */
474
475 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
476 (offset & 0x00FF));
477 if (err)
478 return err;
479 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
480 (offset & 0xFF00) >> 8);
481 if (err)
482 return err;
483 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ);
484 if (err)
485 return err;
486 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo);
487 if (err)
488 return err;
489 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi);
490 if (err)
491 return err;
492 *value = (lo | (((u16)hi) << 8));
493
494 return 0;
495 }
496
497 /* offset is the 16bit word offset */
498 static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
499 {
500 int err;
501
502 offset *= 2; /* Make byte offset */
503
504 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
505 (offset & 0x00FF));
506 if (err)
507 return err;
508 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
509 (offset & 0xFF00) >> 8);
510 if (err)
511 return err;
512 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO,
513 (value & 0x00FF));
514 if (err)
515 return err;
516 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI,
517 (value & 0xFF00) >> 8);
518 if (err)
519 return err;
520 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE);
521 if (err)
522 return err;
523 msleep(20);
524
525 return 0;
526 }
527
528 /* Read the SPROM image. bufsize is in 16bit words. */
529 static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom)
530 {
531 int err, i;
532
533 for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) {
534 err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]);
535 if (err)
536 return err;
537 }
538
539 return 0;
540 }
541
542 /* Write the SPROM image. size is in 16bit words. */
543 static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
544 {
545 int i, err;
546 bool failed = 0;
547 size_t size = SSB_PCMCIA_SPROM_SIZE;
548
549 pr_notice("Writing SPROM. Do NOT turn off the power! Please stand by...\n");
550 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
551 if (err) {
552 pr_notice("Could not enable SPROM write access\n");
553 return -EBUSY;
554 }
555 pr_notice("[ 0%%");
556 msleep(500);
557 for (i = 0; i < size; i++) {
558 if (i == size / 4)
559 pr_cont("25%%");
560 else if (i == size / 2)
561 pr_cont("50%%");
562 else if (i == (size * 3) / 4)
563 pr_cont("75%%");
564 else if (i % 2)
565 pr_cont(".");
566 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
567 if (err) {
568 pr_notice("Failed to write to SPROM\n");
569 failed = 1;
570 break;
571 }
572 }
573 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
574 if (err) {
575 pr_notice("Could not disable SPROM write access\n");
576 failed = 1;
577 }
578 msleep(500);
579 if (!failed) {
580 pr_cont("100%% ]\n");
581 pr_notice("SPROM written\n");
582 }
583
584 return failed ? -EBUSY : 0;
585 }
586
587 static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
588 {
589 //TODO
590 return 0;
591 }
592
593 #define GOTO_ERROR_ON(condition, description) do { \
594 if (unlikely(condition)) { \
595 error_description = description; \
596 goto error; \
597 } \
598 } while (0)
599
600 static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev,
601 tuple_t *tuple,
602 void *priv)
603 {
604 struct ssb_sprom *sprom = priv;
605
606 if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
607 return -EINVAL;
608 if (tuple->TupleDataLen != ETH_ALEN + 2)
609 return -EINVAL;
610 if (tuple->TupleData[1] != ETH_ALEN)
611 return -EINVAL;
612 memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN);
613 return 0;
614 };
615
616 static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev,
617 tuple_t *tuple,
618 void *priv)
619 {
620 struct ssb_init_invariants *iv = priv;
621 struct ssb_sprom *sprom = &iv->sprom;
622 struct ssb_boardinfo *bi = &iv->boardinfo;
623 const char *error_description;
624
625 GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1");
626 switch (tuple->TupleData[0]) {
627 case SSB_PCMCIA_CIS_ID:
628 GOTO_ERROR_ON((tuple->TupleDataLen != 5) &&
629 (tuple->TupleDataLen != 7),
630 "id tpl size");
631 bi->vendor = tuple->TupleData[1] |
632 ((u16)tuple->TupleData[2] << 8);
633 break;
634 case SSB_PCMCIA_CIS_BOARDREV:
635 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
636 "boardrev tpl size");
637 sprom->board_rev = tuple->TupleData[1];
638 break;
639 case SSB_PCMCIA_CIS_PA:
640 GOTO_ERROR_ON((tuple->TupleDataLen != 9) &&
641 (tuple->TupleDataLen != 10),
642 "pa tpl size");
643 sprom->pa0b0 = tuple->TupleData[1] |
644 ((u16)tuple->TupleData[2] << 8);
645 sprom->pa0b1 = tuple->TupleData[3] |
646 ((u16)tuple->TupleData[4] << 8);
647 sprom->pa0b2 = tuple->TupleData[5] |
648 ((u16)tuple->TupleData[6] << 8);
649 sprom->itssi_a = tuple->TupleData[7];
650 sprom->itssi_bg = tuple->TupleData[7];
651 sprom->maxpwr_a = tuple->TupleData[8];
652 sprom->maxpwr_bg = tuple->TupleData[8];
653 break;
654 case SSB_PCMCIA_CIS_OEMNAME:
655 /* We ignore this. */
656 break;
657 case SSB_PCMCIA_CIS_CCODE:
658 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
659 "ccode tpl size");
660 sprom->country_code = tuple->TupleData[1];
661 break;
662 case SSB_PCMCIA_CIS_ANTENNA:
663 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
664 "ant tpl size");
665 sprom->ant_available_a = tuple->TupleData[1];
666 sprom->ant_available_bg = tuple->TupleData[1];
667 break;
668 case SSB_PCMCIA_CIS_ANTGAIN:
669 GOTO_ERROR_ON(tuple->TupleDataLen != 2,
670 "antg tpl size");
671 sprom->antenna_gain.a0 = tuple->TupleData[1];
672 sprom->antenna_gain.a1 = tuple->TupleData[1];
673 sprom->antenna_gain.a2 = tuple->TupleData[1];
674 sprom->antenna_gain.a3 = tuple->TupleData[1];
675 break;
676 case SSB_PCMCIA_CIS_BFLAGS:
677 GOTO_ERROR_ON((tuple->TupleDataLen != 3) &&
678 (tuple->TupleDataLen != 5),
679 "bfl tpl size");
680 sprom->boardflags_lo = tuple->TupleData[1] |
681 ((u16)tuple->TupleData[2] << 8);
682 break;
683 case SSB_PCMCIA_CIS_LEDS:
684 GOTO_ERROR_ON(tuple->TupleDataLen != 5,
685 "leds tpl size");
686 sprom->gpio0 = tuple->TupleData[1];
687 sprom->gpio1 = tuple->TupleData[2];
688 sprom->gpio2 = tuple->TupleData[3];
689 sprom->gpio3 = tuple->TupleData[4];
690 break;
691 }
692 return -ENOSPC; /* continue with next entry */
693
694 error:
695 pr_err("PCMCIA: Failed to fetch device invariants: %s\n",
696 error_description);
697 return -ENODEV;
698 }
699
700
701 int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
702 struct ssb_init_invariants *iv)
703 {
704 struct ssb_sprom *sprom = &iv->sprom;
705 int res;
706
707 memset(sprom, 0xFF, sizeof(*sprom));
708 sprom->revision = 1;
709 sprom->boardflags_lo = 0;
710 sprom->boardflags_hi = 0;
711
712 /* First fetch the MAC address. */
713 res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE,
714 ssb_pcmcia_get_mac, sprom);
715 if (res != 0) {
716 pr_err("PCMCIA: Failed to fetch MAC address\n");
717 return -ENODEV;
718 }
719
720 /* Fetch the vendor specific tuples. */
721 res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS,
722 ssb_pcmcia_do_get_invariants, iv);
723 if ((res == 0) || (res == -ENOSPC))
724 return 0;
725
726 pr_err("PCMCIA: Failed to fetch device invariants\n");
727 return -ENODEV;
728 }
729
730 static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev,
731 struct device_attribute *attr,
732 char *buf)
733 {
734 struct pcmcia_device *pdev =
735 container_of(pcmciadev, struct pcmcia_device, dev);
736 struct ssb_bus *bus;
737
738 bus = ssb_pcmcia_dev_to_bus(pdev);
739 if (!bus)
740 return -ENODEV;
741
742 return ssb_attr_sprom_show(bus, buf,
743 ssb_pcmcia_sprom_read_all);
744 }
745
746 static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev,
747 struct device_attribute *attr,
748 const char *buf, size_t count)
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_store(bus, buf, count,
759 ssb_pcmcia_sprom_check_crc,
760 ssb_pcmcia_sprom_write_all);
761 }
762
763 static DEVICE_ATTR(ssb_sprom, 0600,
764 ssb_pcmcia_attr_sprom_show,
765 ssb_pcmcia_attr_sprom_store);
766
767 static int ssb_pcmcia_cor_setup(struct ssb_bus *bus, u8 cor)
768 {
769 u8 val;
770 int err;
771
772 err = ssb_pcmcia_cfg_read(bus, cor, &val);
773 if (err)
774 return err;
775 val &= ~COR_SOFT_RESET;
776 val |= COR_FUNC_ENA | COR_IREQ_ENA | COR_LEVEL_REQ;
777 err = ssb_pcmcia_cfg_write(bus, cor, val);
778 if (err)
779 return err;
780 msleep(40);
781
782 return 0;
783 }
784
785 /* Initialize the PCMCIA hardware. This is called on Init and Resume. */
786 int ssb_pcmcia_hardware_setup(struct ssb_bus *bus)
787 {
788 int err;
789
790 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
791 return 0;
792
793 /* Switch segment to a known state and sync
794 * bus->mapped_pcmcia_seg with hardware state. */
795 ssb_pcmcia_switch_segment(bus, 0);
796 /* Init the COR register. */
797 err = ssb_pcmcia_cor_setup(bus, CISREG_COR);
798 if (err)
799 return err;
800 /* Some cards also need this register to get poked. */
801 err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80);
802 if (err)
803 return err;
804
805 return 0;
806 }
807
808 void ssb_pcmcia_exit(struct ssb_bus *bus)
809 {
810 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
811 return;
812
813 device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
814 }
815
816 int ssb_pcmcia_init(struct ssb_bus *bus)
817 {
818 int err;
819
820 if (bus->bustype != SSB_BUSTYPE_PCMCIA)
821 return 0;
822
823 err = ssb_pcmcia_hardware_setup(bus);
824 if (err)
825 goto error;
826
827 bus->sprom_size = SSB_PCMCIA_SPROM_SIZE;
828 mutex_init(&bus->sprom_mutex);
829 err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
830 if (err)
831 goto error;
832
833 return 0;
834 error:
835 pr_err("Failed to initialize PCMCIA host device\n");
836 return err;
837 }
Linux with added FPC-III support