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