pcmcia: use pcmica_{read,write}_config_byte
[linux-2.6.git] / drivers / ssb / pcmcia.c
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, sprom);
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 }