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 }