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_types.h> 17 #include <pcmcia/cs.h> 18 #include <pcmcia/cistpl.h> 19 #include <pcmcia/ciscode.h> 20 #include <pcmcia/ds.h> 21 #include <pcmcia/cisreg.h> 22 23 #include "ssb_private.h" 24 25 26 /* Define the following to 1 to enable a printk on each coreswitch. */ 27 #define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0 28 29 30 /* PCMCIA configuration registers */ 31 #define SSB_PCMCIA_ADDRESS0 0x2E 32 #define SSB_PCMCIA_ADDRESS1 0x30 33 #define SSB_PCMCIA_ADDRESS2 0x32 34 #define SSB_PCMCIA_MEMSEG 0x34 35 #define SSB_PCMCIA_SPROMCTL 0x36 36 #define SSB_PCMCIA_SPROMCTL_IDLE 0 37 #define SSB_PCMCIA_SPROMCTL_WRITE 1 38 #define SSB_PCMCIA_SPROMCTL_READ 2 39 #define SSB_PCMCIA_SPROMCTL_WRITEEN 4 40 #define SSB_PCMCIA_SPROMCTL_WRITEDIS 7 41 #define SSB_PCMCIA_SPROMCTL_DONE 8 42 #define SSB_PCMCIA_SPROM_DATALO 0x38 43 #define SSB_PCMCIA_SPROM_DATAHI 0x3A 44 #define SSB_PCMCIA_SPROM_ADDRLO 0x3C 45 #define SSB_PCMCIA_SPROM_ADDRHI 0x3E 46 47 /* Hardware invariants CIS tuples */ 48 #define SSB_PCMCIA_CIS 0x80 49 #define SSB_PCMCIA_CIS_ID 0x01 50 #define SSB_PCMCIA_CIS_BOARDREV 0x02 51 #define SSB_PCMCIA_CIS_PA 0x03 52 #define SSB_PCMCIA_CIS_PA_PA0B0_LO 0 53 #define SSB_PCMCIA_CIS_PA_PA0B0_HI 1 54 #define SSB_PCMCIA_CIS_PA_PA0B1_LO 2 55 #define SSB_PCMCIA_CIS_PA_PA0B1_HI 3 56 #define SSB_PCMCIA_CIS_PA_PA0B2_LO 4 57 #define SSB_PCMCIA_CIS_PA_PA0B2_HI 5 58 #define SSB_PCMCIA_CIS_PA_ITSSI 6 59 #define SSB_PCMCIA_CIS_PA_MAXPOW 7 60 #define SSB_PCMCIA_CIS_OEMNAME 0x04 61 #define SSB_PCMCIA_CIS_CCODE 0x05 62 #define SSB_PCMCIA_CIS_ANTENNA 0x06 63 #define SSB_PCMCIA_CIS_ANTGAIN 0x07 64 #define SSB_PCMCIA_CIS_BFLAGS 0x08 65 #define SSB_PCMCIA_CIS_LEDS 0x09 66 67 /* PCMCIA SPROM size. */ 68 #define SSB_PCMCIA_SPROM_SIZE 256 69 #define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16)) 70 71 72 /* Write to a PCMCIA configuration register. */ 73 static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value) 74 { 75 conf_reg_t reg; 76 int res; 77 78 memset(®, 0, sizeof(reg)); 79 reg.Offset = offset; 80 reg.Action = CS_WRITE; 81 reg.Value = value; 82 res = pcmcia_access_configuration_register(bus->host_pcmcia, ®); 83 if (unlikely(res != 0)) 84 return -EBUSY; 85 86 return 0; 87 } 88 89 /* Read from a PCMCIA configuration register. */ 90 static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value) 91 { 92 conf_reg_t reg; 93 int res; 94 95 memset(®, 0, sizeof(reg)); 96 reg.Offset = offset; 97 reg.Action = CS_READ; 98 res = pcmcia_access_configuration_register(bus->host_pcmcia, ®); 99 if (unlikely(res != 0)) 100 return -EBUSY; 101 *value = reg.Value; 102 103 return 0; 104 } 105 106 int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus, 107 u8 coreidx) 108 { 109 int err; 110 int attempts = 0; 111 u32 cur_core; 112 u32 addr; 113 u32 read_addr; 114 u8 val; 115 116 addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 117 while (1) { 118 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0, 119 (addr & 0x0000F000) >> 12); 120 if (err) 121 goto error; 122 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1, 123 (addr & 0x00FF0000) >> 16); 124 if (err) 125 goto error; 126 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2, 127 (addr & 0xFF000000) >> 24); 128 if (err) 129 goto error; 130 131 read_addr = 0; 132 133 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val); 134 if (err) 135 goto error; 136 read_addr |= ((u32)(val & 0x0F)) << 12; 137 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val); 138 if (err) 139 goto error; 140 read_addr |= ((u32)val) << 16; 141 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val); 142 if (err) 143 goto error; 144 read_addr |= ((u32)val) << 24; 145 146 cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE; 147 if (cur_core == coreidx) 148 break; 149 150 err = -ETIMEDOUT; 151 if (attempts++ > SSB_BAR0_MAX_RETRIES) 152 goto error; 153 udelay(10); 154 } 155 156 return 0; 157 error: 158 ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx); 159 return err; 160 } 161 162 int ssb_pcmcia_switch_core(struct ssb_bus *bus, 163 struct ssb_device *dev) 164 { 165 int err; 166 167 #if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 168 ssb_printk(KERN_INFO PFX 169 "Switching to %s core, index %d\n", 170 ssb_core_name(dev->id.coreid), 171 dev->core_index); 172 #endif 173 174 err = ssb_pcmcia_switch_coreidx(bus, dev->core_index); 175 if (!err) 176 bus->mapped_device = dev; 177 178 return err; 179 } 180 181 int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg) 182 { 183 int attempts = 0; 184 int err; 185 u8 val; 186 187 SSB_WARN_ON((seg != 0) && (seg != 1)); 188 while (1) { 189 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg); 190 if (err) 191 goto error; 192 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val); 193 if (err) 194 goto error; 195 if (val == seg) 196 break; 197 198 err = -ETIMEDOUT; 199 if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES)) 200 goto error; 201 udelay(10); 202 } 203 bus->mapped_pcmcia_seg = seg; 204 205 return 0; 206 error: 207 ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n"); 208 return err; 209 } 210 211 static int select_core_and_segment(struct ssb_device *dev, 212 u16 *offset) 213 { 214 struct ssb_bus *bus = dev->bus; 215 int err; 216 u8 need_segment; 217 218 if (*offset >= 0x800) { 219 *offset -= 0x800; 220 need_segment = 1; 221 } else 222 need_segment = 0; 223 224 if (unlikely(dev != bus->mapped_device)) { 225 err = ssb_pcmcia_switch_core(bus, dev); 226 if (unlikely(err)) 227 return err; 228 } 229 if (unlikely(need_segment != bus->mapped_pcmcia_seg)) { 230 err = ssb_pcmcia_switch_segment(bus, need_segment); 231 if (unlikely(err)) 232 return err; 233 } 234 235 return 0; 236 } 237 238 static u8 ssb_pcmcia_read8(struct ssb_device *dev, u16 offset) 239 { 240 struct ssb_bus *bus = dev->bus; 241 unsigned long flags; 242 int err; 243 u8 value = 0xFF; 244 245 spin_lock_irqsave(&bus->bar_lock, flags); 246 err = select_core_and_segment(dev, &offset); 247 if (likely(!err)) 248 value = readb(bus->mmio + offset); 249 spin_unlock_irqrestore(&bus->bar_lock, flags); 250 251 return value; 252 } 253 254 static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset) 255 { 256 struct ssb_bus *bus = dev->bus; 257 unsigned long flags; 258 int err; 259 u16 value = 0xFFFF; 260 261 spin_lock_irqsave(&bus->bar_lock, flags); 262 err = select_core_and_segment(dev, &offset); 263 if (likely(!err)) 264 value = readw(bus->mmio + offset); 265 spin_unlock_irqrestore(&bus->bar_lock, flags); 266 267 return value; 268 } 269 270 static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset) 271 { 272 struct ssb_bus *bus = dev->bus; 273 unsigned long flags; 274 int err; 275 u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF; 276 277 spin_lock_irqsave(&bus->bar_lock, flags); 278 err = select_core_and_segment(dev, &offset); 279 if (likely(!err)) { 280 lo = readw(bus->mmio + offset); 281 hi = readw(bus->mmio + offset + 2); 282 } 283 spin_unlock_irqrestore(&bus->bar_lock, flags); 284 285 return (lo | (hi << 16)); 286 } 287 288 #ifdef CONFIG_SSB_BLOCKIO 289 static void ssb_pcmcia_block_read(struct ssb_device *dev, void *buffer, 290 size_t count, u16 offset, u8 reg_width) 291 { 292 struct ssb_bus *bus = dev->bus; 293 unsigned long flags; 294 void __iomem *addr = bus->mmio + offset; 295 int err; 296 297 spin_lock_irqsave(&bus->bar_lock, flags); 298 err = select_core_and_segment(dev, &offset); 299 if (unlikely(err)) { 300 memset(buffer, 0xFF, count); 301 goto unlock; 302 } 303 switch (reg_width) { 304 case sizeof(u8): { 305 u8 *buf = buffer; 306 307 while (count) { 308 *buf = __raw_readb(addr); 309 buf++; 310 count--; 311 } 312 break; 313 } 314 case sizeof(u16): { 315 __le16 *buf = buffer; 316 317 SSB_WARN_ON(count & 1); 318 while (count) { 319 *buf = (__force __le16)__raw_readw(addr); 320 buf++; 321 count -= 2; 322 } 323 break; 324 } 325 case sizeof(u32): { 326 __le16 *buf = buffer; 327 328 SSB_WARN_ON(count & 3); 329 while (count) { 330 *buf = (__force __le16)__raw_readw(addr); 331 buf++; 332 *buf = (__force __le16)__raw_readw(addr + 2); 333 buf++; 334 count -= 4; 335 } 336 break; 337 } 338 default: 339 SSB_WARN_ON(1); 340 } 341 unlock: 342 spin_unlock_irqrestore(&bus->bar_lock, flags); 343 } 344 #endif /* CONFIG_SSB_BLOCKIO */ 345 346 static void ssb_pcmcia_write8(struct ssb_device *dev, u16 offset, u8 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 writeb(value, bus->mmio + offset); 356 mmiowb(); 357 spin_unlock_irqrestore(&bus->bar_lock, flags); 358 } 359 360 static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 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, bus->mmio + offset); 370 mmiowb(); 371 spin_unlock_irqrestore(&bus->bar_lock, flags); 372 } 373 374 static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value) 375 { 376 struct ssb_bus *bus = dev->bus; 377 unsigned long flags; 378 int err; 379 380 spin_lock_irqsave(&bus->bar_lock, flags); 381 err = select_core_and_segment(dev, &offset); 382 if (likely(!err)) { 383 writew((value & 0x0000FFFF), bus->mmio + offset); 384 writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2); 385 } 386 mmiowb(); 387 spin_unlock_irqrestore(&bus->bar_lock, flags); 388 } 389 390 #ifdef CONFIG_SSB_BLOCKIO 391 static void ssb_pcmcia_block_write(struct ssb_device *dev, const void *buffer, 392 size_t count, u16 offset, u8 reg_width) 393 { 394 struct ssb_bus *bus = dev->bus; 395 unsigned long flags; 396 void __iomem *addr = bus->mmio + offset; 397 int err; 398 399 spin_lock_irqsave(&bus->bar_lock, flags); 400 err = select_core_and_segment(dev, &offset); 401 if (unlikely(err)) 402 goto unlock; 403 switch (reg_width) { 404 case sizeof(u8): { 405 const u8 *buf = buffer; 406 407 while (count) { 408 __raw_writeb(*buf, addr); 409 buf++; 410 count--; 411 } 412 break; 413 } 414 case sizeof(u16): { 415 const __le16 *buf = buffer; 416 417 SSB_WARN_ON(count & 1); 418 while (count) { 419 __raw_writew((__force u16)(*buf), addr); 420 buf++; 421 count -= 2; 422 } 423 break; 424 } 425 case sizeof(u32): { 426 const __le16 *buf = buffer; 427 428 SSB_WARN_ON(count & 3); 429 while (count) { 430 __raw_writew((__force u16)(*buf), addr); 431 buf++; 432 __raw_writew((__force u16)(*buf), addr + 2); 433 buf++; 434 count -= 4; 435 } 436 break; 437 } 438 default: 439 SSB_WARN_ON(1); 440 } 441 unlock: 442 mmiowb(); 443 spin_unlock_irqrestore(&bus->bar_lock, flags); 444 } 445 #endif /* CONFIG_SSB_BLOCKIO */ 446 447 /* Not "static", as it's used in main.c */ 448 const struct ssb_bus_ops ssb_pcmcia_ops = { 449 .read8 = ssb_pcmcia_read8, 450 .read16 = ssb_pcmcia_read16, 451 .read32 = ssb_pcmcia_read32, 452 .write8 = ssb_pcmcia_write8, 453 .write16 = ssb_pcmcia_write16, 454 .write32 = ssb_pcmcia_write32, 455 #ifdef CONFIG_SSB_BLOCKIO 456 .block_read = ssb_pcmcia_block_read, 457 .block_write = ssb_pcmcia_block_write, 458 #endif 459 }; 460 461 static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command) 462 { 463 unsigned int i; 464 int err; 465 u8 value; 466 467 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command); 468 if (err) 469 return err; 470 for (i = 0; i < 1000; i++) { 471 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value); 472 if (err) 473 return err; 474 if (value & SSB_PCMCIA_SPROMCTL_DONE) 475 return 0; 476 udelay(10); 477 } 478 479 return -ETIMEDOUT; 480 } 481 482 /* offset is the 16bit word offset */ 483 static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value) 484 { 485 int err; 486 u8 lo, hi; 487 488 offset *= 2; /* Make byte offset */ 489 490 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO, 491 (offset & 0x00FF)); 492 if (err) 493 return err; 494 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI, 495 (offset & 0xFF00) >> 8); 496 if (err) 497 return err; 498 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ); 499 if (err) 500 return err; 501 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo); 502 if (err) 503 return err; 504 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi); 505 if (err) 506 return err; 507 *value = (lo | (((u16)hi) << 8)); 508 509 return 0; 510 } 511 512 /* offset is the 16bit word offset */ 513 static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value) 514 { 515 int err; 516 517 offset *= 2; /* Make byte offset */ 518 519 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO, 520 (offset & 0x00FF)); 521 if (err) 522 return err; 523 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI, 524 (offset & 0xFF00) >> 8); 525 if (err) 526 return err; 527 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO, 528 (value & 0x00FF)); 529 if (err) 530 return err; 531 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI, 532 (value & 0xFF00) >> 8); 533 if (err) 534 return err; 535 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE); 536 if (err) 537 return err; 538 msleep(20); 539 540 return 0; 541 } 542 543 /* Read the SPROM image. bufsize is in 16bit words. */ 544 static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom) 545 { 546 int err, i; 547 548 for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) { 549 err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]); 550 if (err) 551 return err; 552 } 553 554 return 0; 555 } 556 557 /* Write the SPROM image. size is in 16bit words. */ 558 static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom) 559 { 560 int i, err; 561 bool failed = 0; 562 size_t size = SSB_PCMCIA_SPROM_SIZE; 563 564 ssb_printk(KERN_NOTICE PFX 565 "Writing SPROM. Do NOT turn off the power! " 566 "Please stand by...\n"); 567 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN); 568 if (err) { 569 ssb_printk(KERN_NOTICE PFX 570 "Could not enable SPROM write access.\n"); 571 return -EBUSY; 572 } 573 ssb_printk(KERN_NOTICE PFX "[ 0%%"); 574 msleep(500); 575 for (i = 0; i < size; i++) { 576 if (i == size / 4) 577 ssb_printk("25%%"); 578 else if (i == size / 2) 579 ssb_printk("50%%"); 580 else if (i == (size * 3) / 4) 581 ssb_printk("75%%"); 582 else if (i % 2) 583 ssb_printk("."); 584 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]); 585 if (err) { 586 ssb_printk(KERN_NOTICE PFX 587 "Failed to write to SPROM.\n"); 588 failed = 1; 589 break; 590 } 591 } 592 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS); 593 if (err) { 594 ssb_printk(KERN_NOTICE PFX 595 "Could not disable SPROM write access.\n"); 596 failed = 1; 597 } 598 msleep(500); 599 if (!failed) { 600 ssb_printk("100%% ]\n"); 601 ssb_printk(KERN_NOTICE PFX "SPROM written.\n"); 602 } 603 604 return failed ? -EBUSY : 0; 605 } 606 607 static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size) 608 { 609 //TODO 610 return 0; 611 } 612 613 #define GOTO_ERROR_ON(condition, description) do { \ 614 if (unlikely(condition)) { \ 615 error_description = description; \ 616 goto error; \ 617 } \ 618 } while (0) 619 620 int ssb_pcmcia_get_invariants(struct ssb_bus *bus, 621 struct ssb_init_invariants *iv) 622 { 623 tuple_t tuple; 624 int res; 625 unsigned char buf[32]; 626 struct ssb_sprom *sprom = &iv->sprom; 627 struct ssb_boardinfo *bi = &iv->boardinfo; 628 const char *error_description; 629 630 memset(sprom, 0xFF, sizeof(*sprom)); 631 sprom->revision = 1; 632 sprom->boardflags_lo = 0; 633 sprom->boardflags_hi = 0; 634 635 /* First fetch the MAC address. */ 636 memset(&tuple, 0, sizeof(tuple)); 637 tuple.DesiredTuple = CISTPL_FUNCE; 638 tuple.TupleData = buf; 639 tuple.TupleDataMax = sizeof(buf); 640 res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple); 641 GOTO_ERROR_ON(res != 0, "MAC first tpl"); 642 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 643 GOTO_ERROR_ON(res != 0, "MAC first tpl data"); 644 while (1) { 645 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1"); 646 if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID) 647 break; 648 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple); 649 GOTO_ERROR_ON(res != 0, "MAC next tpl"); 650 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 651 GOTO_ERROR_ON(res != 0, "MAC next tpl data"); 652 } 653 GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size"); 654 memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN); 655 656 /* Fetch the vendor specific tuples. */ 657 memset(&tuple, 0, sizeof(tuple)); 658 tuple.DesiredTuple = SSB_PCMCIA_CIS; 659 tuple.TupleData = buf; 660 tuple.TupleDataMax = sizeof(buf); 661 res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple); 662 GOTO_ERROR_ON(res != 0, "VEN first tpl"); 663 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 664 GOTO_ERROR_ON(res != 0, "VEN first tpl data"); 665 while (1) { 666 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1"); 667 switch (tuple.TupleData[0]) { 668 case SSB_PCMCIA_CIS_ID: 669 GOTO_ERROR_ON((tuple.TupleDataLen != 5) && 670 (tuple.TupleDataLen != 7), 671 "id tpl size"); 672 bi->vendor = tuple.TupleData[1] | 673 ((u16)tuple.TupleData[2] << 8); 674 break; 675 case SSB_PCMCIA_CIS_BOARDREV: 676 GOTO_ERROR_ON(tuple.TupleDataLen != 2, 677 "boardrev tpl size"); 678 sprom->board_rev = tuple.TupleData[1]; 679 break; 680 case SSB_PCMCIA_CIS_PA: 681 GOTO_ERROR_ON((tuple.TupleDataLen != 9) && 682 (tuple.TupleDataLen != 10), 683 "pa tpl size"); 684 sprom->pa0b0 = tuple.TupleData[1] | 685 ((u16)tuple.TupleData[2] << 8); 686 sprom->pa0b1 = tuple.TupleData[3] | 687 ((u16)tuple.TupleData[4] << 8); 688 sprom->pa0b2 = tuple.TupleData[5] | 689 ((u16)tuple.TupleData[6] << 8); 690 sprom->itssi_a = tuple.TupleData[7]; 691 sprom->itssi_bg = tuple.TupleData[7]; 692 sprom->maxpwr_a = tuple.TupleData[8]; 693 sprom->maxpwr_bg = tuple.TupleData[8]; 694 break; 695 case SSB_PCMCIA_CIS_OEMNAME: 696 /* We ignore this. */ 697 break; 698 case SSB_PCMCIA_CIS_CCODE: 699 GOTO_ERROR_ON(tuple.TupleDataLen != 2, 700 "ccode tpl size"); 701 sprom->country_code = tuple.TupleData[1]; 702 break; 703 case SSB_PCMCIA_CIS_ANTENNA: 704 GOTO_ERROR_ON(tuple.TupleDataLen != 2, 705 "ant tpl size"); 706 sprom->ant_available_a = tuple.TupleData[1]; 707 sprom->ant_available_bg = tuple.TupleData[1]; 708 break; 709 case SSB_PCMCIA_CIS_ANTGAIN: 710 GOTO_ERROR_ON(tuple.TupleDataLen != 2, 711 "antg tpl size"); 712 sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1]; 713 sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1]; 714 sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1]; 715 sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1]; 716 sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1]; 717 sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1]; 718 sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1]; 719 sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1]; 720 break; 721 case SSB_PCMCIA_CIS_BFLAGS: 722 GOTO_ERROR_ON((tuple.TupleDataLen != 3) && 723 (tuple.TupleDataLen != 5), 724 "bfl tpl size"); 725 sprom->boardflags_lo = tuple.TupleData[1] | 726 ((u16)tuple.TupleData[2] << 8); 727 break; 728 case SSB_PCMCIA_CIS_LEDS: 729 GOTO_ERROR_ON(tuple.TupleDataLen != 5, 730 "leds tpl size"); 731 sprom->gpio0 = tuple.TupleData[1]; 732 sprom->gpio1 = tuple.TupleData[2]; 733 sprom->gpio2 = tuple.TupleData[3]; 734 sprom->gpio3 = tuple.TupleData[4]; 735 break; 736 } 737 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple); 738 if (res == -ENOSPC) 739 break; 740 GOTO_ERROR_ON(res != 0, "VEN next tpl"); 741 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 742 GOTO_ERROR_ON(res != 0, "VEN next tpl data"); 743 } 744 745 return 0; 746 error: 747 ssb_printk(KERN_ERR PFX 748 "PCMCIA: Failed to fetch device invariants: %s\n", 749 error_description); 750 return -ENODEV; 751 } 752 753 static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev, 754 struct device_attribute *attr, 755 char *buf) 756 { 757 struct pcmcia_device *pdev = 758 container_of(pcmciadev, struct pcmcia_device, dev); 759 struct ssb_bus *bus; 760 761 bus = ssb_pcmcia_dev_to_bus(pdev); 762 if (!bus) 763 return -ENODEV; 764 765 return ssb_attr_sprom_show(bus, buf, 766 ssb_pcmcia_sprom_read_all); 767 } 768 769 static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev, 770 struct device_attribute *attr, 771 const char *buf, size_t count) 772 { 773 struct pcmcia_device *pdev = 774 container_of(pcmciadev, struct pcmcia_device, dev); 775 struct ssb_bus *bus; 776 777 bus = ssb_pcmcia_dev_to_bus(pdev); 778 if (!bus) 779 return -ENODEV; 780 781 return ssb_attr_sprom_store(bus, buf, count, 782 ssb_pcmcia_sprom_check_crc, 783 ssb_pcmcia_sprom_write_all); 784 } 785 786 static DEVICE_ATTR(ssb_sprom, 0600, 787 ssb_pcmcia_attr_sprom_show, 788 ssb_pcmcia_attr_sprom_store); 789 790 static int ssb_pcmcia_cor_setup(struct ssb_bus *bus, u8 cor) 791 { 792 u8 val; 793 int err; 794 795 err = ssb_pcmcia_cfg_read(bus, cor, &val); 796 if (err) 797 return err; 798 val &= ~COR_SOFT_RESET; 799 val |= COR_FUNC_ENA | COR_IREQ_ENA | COR_LEVEL_REQ; 800 err = ssb_pcmcia_cfg_write(bus, cor, val); 801 if (err) 802 return err; 803 msleep(40); 804 805 return 0; 806 } 807 808 /* Initialize the PCMCIA hardware. This is called on Init and Resume. */ 809 int ssb_pcmcia_hardware_setup(struct ssb_bus *bus) 810 { 811 int err; 812 813 if (bus->bustype != SSB_BUSTYPE_PCMCIA) 814 return 0; 815 816 /* Switch segment to a known state and sync 817 * bus->mapped_pcmcia_seg with hardware state. */ 818 ssb_pcmcia_switch_segment(bus, 0); 819 /* Init the COR register. */ 820 err = ssb_pcmcia_cor_setup(bus, CISREG_COR); 821 if (err) 822 return err; 823 /* Some cards also need this register to get poked. */ 824 err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80); 825 if (err) 826 return err; 827 828 return 0; 829 } 830 831 void ssb_pcmcia_exit(struct ssb_bus *bus) 832 { 833 if (bus->bustype != SSB_BUSTYPE_PCMCIA) 834 return; 835 836 device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom); 837 } 838 839 int ssb_pcmcia_init(struct ssb_bus *bus) 840 { 841 int err; 842 843 if (bus->bustype != SSB_BUSTYPE_PCMCIA) 844 return 0; 845 846 err = ssb_pcmcia_hardware_setup(bus); 847 if (err) 848 goto error; 849 850 bus->sprom_size = SSB_PCMCIA_SPROM_SIZE; 851 mutex_init(&bus->sprom_mutex); 852 err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom); 853 if (err) 854 goto error; 855 856 return 0; 857 error: 858 ssb_printk(KERN_ERR PFX "Failed to initialize PCMCIA host device\n"); 859 return err; 860 } 861