1
2
3
4
5
6
7
8
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
25#define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0
26
27
28
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
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
66#define SSB_PCMCIA_SPROM_SIZE 256
67#define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16))
68
69
70
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
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_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 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
167int 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;
192error:
193 ssb_err("Failed to switch pcmcia segment\n");
194 return err;
195}
196
197static 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
224static 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
240static 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
256static 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
275static 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 }
327unlock:
328 spin_unlock_irqrestore(&bus->bar_lock, flags);
329}
330#endif
331
332static 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
346static 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
360static 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
377static 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 }
427unlock:
428 mmiowb();
429 spin_unlock_irqrestore(&bus->bar_lock, flags);
430}
431#endif
432
433
434const 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
447static 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
469static 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;
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
499static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
500{
501 int err;
502
503 offset *= 2;
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
530static 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
544static 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
588static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
589{
590
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
601static 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
617static 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
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;
694
695error:
696 ssb_err(
697 "PCMCIA: Failed to fetch device invariants: %s\n",
698 error_description);
699 return -ENODEV;
700}
701
702
703int 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
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
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
734static 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
750static 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
767static DEVICE_ATTR(ssb_sprom, 0600,
768 ssb_pcmcia_attr_sprom_show,
769 ssb_pcmcia_attr_sprom_store);
770
771static 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
790int 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
798
799 ssb_pcmcia_switch_segment(bus, 0);
800
801 err = ssb_pcmcia_cor_setup(bus, CISREG_COR);
802 if (err)
803 return err;
804
805 err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80);
806 if (err)
807 return err;
808
809 return 0;
810}
811
812void 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
820int 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;
838error:
839 ssb_err("Failed to initialize PCMCIA host device\n");
840 return err;
841}
842
