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 } 854