1 /* 2 3 Driver for the Marvell 8385 based compact flash WLAN cards. 4 5 (C) 2007 by Holger Schurig <hs4233@mail.mn-solutions.de> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; see the file COPYING. If not, write to 19 the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor, 20 Boston, MA 02110-1301, USA. 21 22 */ 23 24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 25 26 #include <linux/module.h> 27 #include <linux/slab.h> 28 #include <linux/delay.h> 29 #include <linux/moduleparam.h> 30 #include <linux/firmware.h> 31 #include <linux/netdevice.h> 32 33 #include <pcmcia/cistpl.h> 34 #include <pcmcia/ds.h> 35 36 #include <linux/io.h> 37 38 #define DRV_NAME "libertas_cs" 39 40 #include "decl.h" 41 #include "defs.h" 42 #include "dev.h" 43 44 45 /********************************************************************/ 46 /* Module stuff */ 47 /********************************************************************/ 48 49 MODULE_AUTHOR("Holger Schurig <hs4233@mail.mn-solutions.de>"); 50 MODULE_DESCRIPTION("Driver for Marvell 83xx compact flash WLAN cards"); 51 MODULE_LICENSE("GPL"); 52 53 54 55 /********************************************************************/ 56 /* Data structures */ 57 /********************************************************************/ 58 59 struct if_cs_card { 60 struct pcmcia_device *p_dev; 61 struct lbs_private *priv; 62 void __iomem *iobase; 63 bool align_regs; 64 u32 model; 65 }; 66 67 68 enum { 69 MODEL_UNKNOWN = 0x00, 70 MODEL_8305 = 0x01, 71 MODEL_8381 = 0x02, 72 MODEL_8385 = 0x03 73 }; 74 75 static const struct lbs_fw_table fw_table[] = { 76 { MODEL_8305, "libertas/cf8305.bin", NULL }, 77 { MODEL_8305, "libertas_cs_helper.fw", NULL }, 78 { MODEL_8381, "libertas/cf8381_helper.bin", "libertas/cf8381.bin" }, 79 { MODEL_8381, "libertas_cs_helper.fw", "libertas_cs.fw" }, 80 { MODEL_8385, "libertas/cf8385_helper.bin", "libertas/cf8385.bin" }, 81 { MODEL_8385, "libertas_cs_helper.fw", "libertas_cs.fw" }, 82 { 0, NULL, NULL } 83 }; 84 MODULE_FIRMWARE("libertas/cf8305.bin"); 85 MODULE_FIRMWARE("libertas/cf8381_helper.bin"); 86 MODULE_FIRMWARE("libertas/cf8381.bin"); 87 MODULE_FIRMWARE("libertas/cf8385_helper.bin"); 88 MODULE_FIRMWARE("libertas/cf8385.bin"); 89 MODULE_FIRMWARE("libertas_cs_helper.fw"); 90 MODULE_FIRMWARE("libertas_cs.fw"); 91 92 93 /********************************************************************/ 94 /* Hardware access */ 95 /********************************************************************/ 96 97 /* This define enables wrapper functions which allow you 98 to dump all register accesses. You normally won't this, 99 except for development */ 100 /* #define DEBUG_IO */ 101 102 #ifdef DEBUG_IO 103 static int debug_output = 0; 104 #else 105 /* This way the compiler optimizes the printk's away */ 106 #define debug_output 0 107 #endif 108 109 static inline unsigned int if_cs_read8(struct if_cs_card *card, uint reg) 110 { 111 unsigned int val = ioread8(card->iobase + reg); 112 if (debug_output) 113 printk(KERN_INFO "inb %08x<%02x\n", reg, val); 114 return val; 115 } 116 static inline unsigned int if_cs_read16(struct if_cs_card *card, uint reg) 117 { 118 unsigned int val = ioread16(card->iobase + reg); 119 if (debug_output) 120 printk(KERN_INFO "inw %08x<%04x\n", reg, val); 121 return val; 122 } 123 static inline void if_cs_read16_rep( 124 struct if_cs_card *card, 125 uint reg, 126 void *buf, 127 unsigned long count) 128 { 129 if (debug_output) 130 printk(KERN_INFO "insw %08x<(0x%lx words)\n", 131 reg, count); 132 ioread16_rep(card->iobase + reg, buf, count); 133 } 134 135 static inline void if_cs_write8(struct if_cs_card *card, uint reg, u8 val) 136 { 137 if (debug_output) 138 printk(KERN_INFO "outb %08x>%02x\n", reg, val); 139 iowrite8(val, card->iobase + reg); 140 } 141 142 static inline void if_cs_write16(struct if_cs_card *card, uint reg, u16 val) 143 { 144 if (debug_output) 145 printk(KERN_INFO "outw %08x>%04x\n", reg, val); 146 iowrite16(val, card->iobase + reg); 147 } 148 149 static inline void if_cs_write16_rep( 150 struct if_cs_card *card, 151 uint reg, 152 const void *buf, 153 unsigned long count) 154 { 155 if (debug_output) 156 printk(KERN_INFO "outsw %08x>(0x%lx words)\n", 157 reg, count); 158 iowrite16_rep(card->iobase + reg, buf, count); 159 } 160 161 162 /* 163 * I know that polling/delaying is frowned upon. However, this procedure 164 * with polling is needed while downloading the firmware. At this stage, 165 * the hardware does unfortunately not create any interrupts. 166 * 167 * Fortunately, this function is never used once the firmware is in 168 * the card. :-) 169 * 170 * As a reference, see the "Firmware Specification v5.1", page 18 171 * and 19. I did not follow their suggested timing to the word, 172 * but this works nice & fast anyway. 173 */ 174 static int if_cs_poll_while_fw_download(struct if_cs_card *card, uint addr, u8 reg) 175 { 176 int i; 177 178 for (i = 0; i < 100000; i++) { 179 u8 val = if_cs_read8(card, addr); 180 if (val == reg) 181 return 0; 182 udelay(5); 183 } 184 return -ETIME; 185 } 186 187 188 189 /* 190 * First the bitmasks for the host/card interrupt/status registers: 191 */ 192 #define IF_CS_BIT_TX 0x0001 193 #define IF_CS_BIT_RX 0x0002 194 #define IF_CS_BIT_COMMAND 0x0004 195 #define IF_CS_BIT_RESP 0x0008 196 #define IF_CS_BIT_EVENT 0x0010 197 #define IF_CS_BIT_MASK 0x001f 198 199 200 201 /* 202 * It's not really clear to me what the host status register is for. It 203 * needs to be set almost in union with "host int cause". The following 204 * bits from above are used: 205 * 206 * IF_CS_BIT_TX driver downloaded a data packet 207 * IF_CS_BIT_RX driver got a data packet 208 * IF_CS_BIT_COMMAND driver downloaded a command 209 * IF_CS_BIT_RESP not used (has some meaning with powerdown) 210 * IF_CS_BIT_EVENT driver read a host event 211 */ 212 #define IF_CS_HOST_STATUS 0x00000000 213 214 /* 215 * With the host int cause register can the host (that is, Linux) cause 216 * an interrupt in the firmware, to tell the firmware about those events: 217 * 218 * IF_CS_BIT_TX a data packet has been downloaded 219 * IF_CS_BIT_RX a received data packet has retrieved 220 * IF_CS_BIT_COMMAND a firmware block or a command has been downloaded 221 * IF_CS_BIT_RESP not used (has some meaning with powerdown) 222 * IF_CS_BIT_EVENT a host event (link lost etc) has been retrieved 223 */ 224 #define IF_CS_HOST_INT_CAUSE 0x00000002 225 226 /* 227 * The host int mask register is used to enable/disable interrupt. However, 228 * I have the suspicion that disabled interrupts are lost. 229 */ 230 #define IF_CS_HOST_INT_MASK 0x00000004 231 232 /* 233 * Used to send or receive data packets: 234 */ 235 #define IF_CS_WRITE 0x00000016 236 #define IF_CS_WRITE_LEN 0x00000014 237 #define IF_CS_READ 0x00000010 238 #define IF_CS_READ_LEN 0x00000024 239 240 /* 241 * Used to send commands (and to send firmware block) and to 242 * receive command responses: 243 */ 244 #define IF_CS_CMD 0x0000001A 245 #define IF_CS_CMD_LEN 0x00000018 246 #define IF_CS_RESP 0x00000012 247 #define IF_CS_RESP_LEN 0x00000030 248 249 /* 250 * The card status registers shows what the card/firmware actually 251 * accepts: 252 * 253 * IF_CS_BIT_TX you may send a data packet 254 * IF_CS_BIT_RX you may retrieve a data packet 255 * IF_CS_BIT_COMMAND you may send a command 256 * IF_CS_BIT_RESP you may retrieve a command response 257 * IF_CS_BIT_EVENT the card has a event for use (link lost, snr low etc) 258 * 259 * When reading this register several times, you will get back the same 260 * results --- with one exception: the IF_CS_BIT_EVENT clear itself 261 * automatically. 262 * 263 * Not that we don't rely on BIT_RX,_BIT_RESP or BIT_EVENT because 264 * we handle this via the card int cause register. 265 */ 266 #define IF_CS_CARD_STATUS 0x00000020 267 #define IF_CS_CARD_STATUS_MASK 0x7f00 268 269 /* 270 * The card int cause register is used by the card/firmware to notify us 271 * about the following events: 272 * 273 * IF_CS_BIT_TX a data packet has successfully been sentx 274 * IF_CS_BIT_RX a data packet has been received and can be retrieved 275 * IF_CS_BIT_COMMAND not used 276 * IF_CS_BIT_RESP the firmware has a command response for us 277 * IF_CS_BIT_EVENT the card has a event for use (link lost, snr low etc) 278 */ 279 #define IF_CS_CARD_INT_CAUSE 0x00000022 280 281 /* 282 * This is used to for handshaking with the card's bootloader/helper image 283 * to synchronize downloading of firmware blocks. 284 */ 285 #define IF_CS_SQ_READ_LOW 0x00000028 286 #define IF_CS_SQ_HELPER_OK 0x10 287 288 /* 289 * The scratch register tells us ... 290 * 291 * IF_CS_SCRATCH_BOOT_OK the bootloader runs 292 * IF_CS_SCRATCH_HELPER_OK the helper firmware already runs 293 */ 294 #define IF_CS_SCRATCH 0x0000003F 295 #define IF_CS_SCRATCH_BOOT_OK 0x00 296 #define IF_CS_SCRATCH_HELPER_OK 0x5a 297 298 /* 299 * Used to detect ancient chips: 300 */ 301 #define IF_CS_PRODUCT_ID 0x0000001C 302 #define IF_CS_CF8385_B1_REV 0x12 303 #define IF_CS_CF8381_B3_REV 0x04 304 #define IF_CS_CF8305_B1_REV 0x03 305 306 /* 307 * Used to detect other cards than CF8385 since their revisions of silicon 308 * doesn't match those from CF8385, eg. CF8381 B3 works with this driver. 309 */ 310 #define CF8305_MANFID 0x02db 311 #define CF8305_CARDID 0x8103 312 #define CF8381_MANFID 0x02db 313 #define CF8381_CARDID 0x6064 314 #define CF8385_MANFID 0x02df 315 #define CF8385_CARDID 0x8103 316 317 /* 318 * FIXME: just use the 'driver_info' field of 'struct pcmcia_device_id' when 319 * that gets fixed. Currently there's no way to access it from the probe hook. 320 */ 321 static inline u32 get_model(u16 manf_id, u16 card_id) 322 { 323 /* NOTE: keep in sync with if_cs_ids */ 324 if (manf_id == CF8305_MANFID && card_id == CF8305_CARDID) 325 return MODEL_8305; 326 else if (manf_id == CF8381_MANFID && card_id == CF8381_CARDID) 327 return MODEL_8381; 328 else if (manf_id == CF8385_MANFID && card_id == CF8385_CARDID) 329 return MODEL_8385; 330 return MODEL_UNKNOWN; 331 } 332 333 /********************************************************************/ 334 /* I/O and interrupt handling */ 335 /********************************************************************/ 336 337 static inline void if_cs_enable_ints(struct if_cs_card *card) 338 { 339 if_cs_write16(card, IF_CS_HOST_INT_MASK, 0); 340 } 341 342 static inline void if_cs_disable_ints(struct if_cs_card *card) 343 { 344 if_cs_write16(card, IF_CS_HOST_INT_MASK, IF_CS_BIT_MASK); 345 } 346 347 /* 348 * Called from if_cs_host_to_card to send a command to the hardware 349 */ 350 static int if_cs_send_cmd(struct lbs_private *priv, u8 *buf, u16 nb) 351 { 352 struct if_cs_card *card = (struct if_cs_card *)priv->card; 353 int ret = -1; 354 int loops = 0; 355 356 if_cs_disable_ints(card); 357 358 /* Is hardware ready? */ 359 while (1) { 360 u16 status = if_cs_read16(card, IF_CS_CARD_STATUS); 361 if (status & IF_CS_BIT_COMMAND) 362 break; 363 if (++loops > 100) { 364 netdev_err(priv->dev, "card not ready for commands\n"); 365 goto done; 366 } 367 mdelay(1); 368 } 369 370 if_cs_write16(card, IF_CS_CMD_LEN, nb); 371 372 if_cs_write16_rep(card, IF_CS_CMD, buf, nb / 2); 373 /* Are we supposed to transfer an odd amount of bytes? */ 374 if (nb & 1) 375 if_cs_write8(card, IF_CS_CMD, buf[nb-1]); 376 377 /* "Assert the download over interrupt command in the Host 378 * status register" */ 379 if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND); 380 381 /* "Assert the download over interrupt command in the Card 382 * interrupt case register" */ 383 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND); 384 ret = 0; 385 386 done: 387 if_cs_enable_ints(card); 388 return ret; 389 } 390 391 /* 392 * Called from if_cs_host_to_card to send a data to the hardware 393 */ 394 static void if_cs_send_data(struct lbs_private *priv, u8 *buf, u16 nb) 395 { 396 struct if_cs_card *card = (struct if_cs_card *)priv->card; 397 u16 status; 398 399 if_cs_disable_ints(card); 400 401 status = if_cs_read16(card, IF_CS_CARD_STATUS); 402 BUG_ON((status & IF_CS_BIT_TX) == 0); 403 404 if_cs_write16(card, IF_CS_WRITE_LEN, nb); 405 406 /* write even number of bytes, then odd byte if necessary */ 407 if_cs_write16_rep(card, IF_CS_WRITE, buf, nb / 2); 408 if (nb & 1) 409 if_cs_write8(card, IF_CS_WRITE, buf[nb-1]); 410 411 if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_TX); 412 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_TX); 413 if_cs_enable_ints(card); 414 } 415 416 /* 417 * Get the command result out of the card. 418 */ 419 static int if_cs_receive_cmdres(struct lbs_private *priv, u8 *data, u32 *len) 420 { 421 unsigned long flags; 422 int ret = -1; 423 u16 status; 424 425 /* is hardware ready? */ 426 status = if_cs_read16(priv->card, IF_CS_CARD_STATUS); 427 if ((status & IF_CS_BIT_RESP) == 0) { 428 netdev_err(priv->dev, "no cmd response in card\n"); 429 *len = 0; 430 goto out; 431 } 432 433 *len = if_cs_read16(priv->card, IF_CS_RESP_LEN); 434 if ((*len == 0) || (*len > LBS_CMD_BUFFER_SIZE)) { 435 netdev_err(priv->dev, 436 "card cmd buffer has invalid # of bytes (%d)\n", 437 *len); 438 goto out; 439 } 440 441 /* read even number of bytes, then odd byte if necessary */ 442 if_cs_read16_rep(priv->card, IF_CS_RESP, data, *len/sizeof(u16)); 443 if (*len & 1) 444 data[*len-1] = if_cs_read8(priv->card, IF_CS_RESP); 445 446 /* This is a workaround for a firmware that reports too much 447 * bytes */ 448 *len -= 8; 449 ret = 0; 450 451 /* Clear this flag again */ 452 spin_lock_irqsave(&priv->driver_lock, flags); 453 priv->dnld_sent = DNLD_RES_RECEIVED; 454 spin_unlock_irqrestore(&priv->driver_lock, flags); 455 456 out: 457 return ret; 458 } 459 460 static struct sk_buff *if_cs_receive_data(struct lbs_private *priv) 461 { 462 struct sk_buff *skb = NULL; 463 u16 len; 464 u8 *data; 465 466 len = if_cs_read16(priv->card, IF_CS_READ_LEN); 467 if (len == 0 || len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) { 468 netdev_err(priv->dev, 469 "card data buffer has invalid # of bytes (%d)\n", 470 len); 471 priv->dev->stats.rx_dropped++; 472 goto dat_err; 473 } 474 475 skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + 2); 476 if (!skb) 477 goto out; 478 skb_put(skb, len); 479 skb_reserve(skb, 2);/* 16 byte align */ 480 data = skb->data; 481 482 /* read even number of bytes, then odd byte if necessary */ 483 if_cs_read16_rep(priv->card, IF_CS_READ, data, len/sizeof(u16)); 484 if (len & 1) 485 data[len-1] = if_cs_read8(priv->card, IF_CS_READ); 486 487 dat_err: 488 if_cs_write16(priv->card, IF_CS_HOST_STATUS, IF_CS_BIT_RX); 489 if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_RX); 490 491 out: 492 return skb; 493 } 494 495 static irqreturn_t if_cs_interrupt(int irq, void *data) 496 { 497 struct if_cs_card *card = data; 498 struct lbs_private *priv = card->priv; 499 u16 cause; 500 501 /* Ask card interrupt cause register if there is something for us */ 502 cause = if_cs_read16(card, IF_CS_CARD_INT_CAUSE); 503 lbs_deb_cs("cause 0x%04x\n", cause); 504 505 if (cause == 0) { 506 /* Not for us */ 507 return IRQ_NONE; 508 } 509 510 if (cause == 0xffff) { 511 /* Read in junk, the card has probably been removed */ 512 card->priv->surpriseremoved = 1; 513 return IRQ_HANDLED; 514 } 515 516 if (cause & IF_CS_BIT_RX) { 517 struct sk_buff *skb; 518 lbs_deb_cs("rx packet\n"); 519 skb = if_cs_receive_data(priv); 520 if (skb) 521 lbs_process_rxed_packet(priv, skb); 522 } 523 524 if (cause & IF_CS_BIT_TX) { 525 lbs_deb_cs("tx done\n"); 526 lbs_host_to_card_done(priv); 527 } 528 529 if (cause & IF_CS_BIT_RESP) { 530 unsigned long flags; 531 u8 i; 532 533 lbs_deb_cs("cmd resp\n"); 534 spin_lock_irqsave(&priv->driver_lock, flags); 535 i = (priv->resp_idx == 0) ? 1 : 0; 536 spin_unlock_irqrestore(&priv->driver_lock, flags); 537 538 BUG_ON(priv->resp_len[i]); 539 if_cs_receive_cmdres(priv, priv->resp_buf[i], 540 &priv->resp_len[i]); 541 542 spin_lock_irqsave(&priv->driver_lock, flags); 543 lbs_notify_command_response(priv, i); 544 spin_unlock_irqrestore(&priv->driver_lock, flags); 545 } 546 547 if (cause & IF_CS_BIT_EVENT) { 548 u16 status = if_cs_read16(priv->card, IF_CS_CARD_STATUS); 549 if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE, 550 IF_CS_BIT_EVENT); 551 lbs_queue_event(priv, (status & IF_CS_CARD_STATUS_MASK) >> 8); 552 } 553 554 /* Clear interrupt cause */ 555 if_cs_write16(card, IF_CS_CARD_INT_CAUSE, cause & IF_CS_BIT_MASK); 556 557 return IRQ_HANDLED; 558 } 559 560 561 562 563 /********************************************************************/ 564 /* Firmware */ 565 /********************************************************************/ 566 567 /* 568 * Tries to program the helper firmware. 569 * 570 * Return 0 on success 571 */ 572 static int if_cs_prog_helper(struct if_cs_card *card, const struct firmware *fw) 573 { 574 int ret = 0; 575 int sent = 0; 576 u8 scratch; 577 578 /* 579 * This is the only place where an unaligned register access happens on 580 * the CF8305 card, therefore for the sake of speed of the driver, we do 581 * the alignment correction here. 582 */ 583 if (card->align_regs) 584 scratch = if_cs_read16(card, IF_CS_SCRATCH) >> 8; 585 else 586 scratch = if_cs_read8(card, IF_CS_SCRATCH); 587 588 /* "If the value is 0x5a, the firmware is already 589 * downloaded successfully" 590 */ 591 if (scratch == IF_CS_SCRATCH_HELPER_OK) 592 goto done; 593 594 /* "If the value is != 00, it is invalid value of register */ 595 if (scratch != IF_CS_SCRATCH_BOOT_OK) { 596 ret = -ENODEV; 597 goto done; 598 } 599 600 lbs_deb_cs("helper size %td\n", fw->size); 601 602 /* "Set the 5 bytes of the helper image to 0" */ 603 /* Not needed, this contains an ARM branch instruction */ 604 605 for (;;) { 606 /* "the number of bytes to send is 256" */ 607 int count = 256; 608 int remain = fw->size - sent; 609 610 if (remain < count) 611 count = remain; 612 613 /* 614 * "write the number of bytes to be sent to the I/O Command 615 * write length register" 616 */ 617 if_cs_write16(card, IF_CS_CMD_LEN, count); 618 619 /* "write this to I/O Command port register as 16 bit writes */ 620 if (count) 621 if_cs_write16_rep(card, IF_CS_CMD, 622 &fw->data[sent], 623 count >> 1); 624 625 /* 626 * "Assert the download over interrupt command in the Host 627 * status register" 628 */ 629 if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND); 630 631 /* 632 * "Assert the download over interrupt command in the Card 633 * interrupt case register" 634 */ 635 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND); 636 637 /* 638 * "The host polls the Card Status register ... for 50 ms before 639 * declaring a failure" 640 */ 641 ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS, 642 IF_CS_BIT_COMMAND); 643 if (ret < 0) { 644 pr_err("can't download helper at 0x%x, ret %d\n", 645 sent, ret); 646 goto done; 647 } 648 649 if (count == 0) 650 break; 651 652 sent += count; 653 } 654 655 done: 656 return ret; 657 } 658 659 660 static int if_cs_prog_real(struct if_cs_card *card, const struct firmware *fw) 661 { 662 int ret = 0; 663 int retry = 0; 664 int len = 0; 665 int sent; 666 667 lbs_deb_cs("fw size %td\n", fw->size); 668 669 ret = if_cs_poll_while_fw_download(card, IF_CS_SQ_READ_LOW, 670 IF_CS_SQ_HELPER_OK); 671 if (ret < 0) { 672 pr_err("helper firmware doesn't answer\n"); 673 goto done; 674 } 675 676 for (sent = 0; sent < fw->size; sent += len) { 677 len = if_cs_read16(card, IF_CS_SQ_READ_LOW); 678 if (len & 1) { 679 retry++; 680 pr_info("odd, need to retry this firmware block\n"); 681 } else { 682 retry = 0; 683 } 684 685 if (retry > 20) { 686 pr_err("could not download firmware\n"); 687 ret = -ENODEV; 688 goto done; 689 } 690 if (retry) { 691 sent -= len; 692 } 693 694 695 if_cs_write16(card, IF_CS_CMD_LEN, len); 696 697 if_cs_write16_rep(card, IF_CS_CMD, 698 &fw->data[sent], 699 (len+1) >> 1); 700 if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND); 701 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND); 702 703 ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS, 704 IF_CS_BIT_COMMAND); 705 if (ret < 0) { 706 pr_err("can't download firmware at 0x%x\n", sent); 707 goto done; 708 } 709 } 710 711 ret = if_cs_poll_while_fw_download(card, IF_CS_SCRATCH, 0x5a); 712 if (ret < 0) 713 pr_err("firmware download failed\n"); 714 715 done: 716 return ret; 717 } 718 719 static void if_cs_prog_firmware(struct lbs_private *priv, int ret, 720 const struct firmware *helper, 721 const struct firmware *mainfw) 722 { 723 struct if_cs_card *card = priv->card; 724 725 if (ret) { 726 pr_err("failed to find firmware (%d)\n", ret); 727 return; 728 } 729 730 /* Load the firmware */ 731 ret = if_cs_prog_helper(card, helper); 732 if (ret == 0 && (card->model != MODEL_8305)) 733 ret = if_cs_prog_real(card, mainfw); 734 if (ret) 735 return; 736 737 /* Now actually get the IRQ */ 738 ret = request_irq(card->p_dev->irq, if_cs_interrupt, 739 IRQF_SHARED, DRV_NAME, card); 740 if (ret) { 741 pr_err("error in request_irq\n"); 742 return; 743 } 744 745 /* 746 * Clear any interrupt cause that happened while sending 747 * firmware/initializing card 748 */ 749 if_cs_write16(card, IF_CS_CARD_INT_CAUSE, IF_CS_BIT_MASK); 750 if_cs_enable_ints(card); 751 752 /* And finally bring the card up */ 753 priv->fw_ready = 1; 754 if (lbs_start_card(priv) != 0) { 755 pr_err("could not activate card\n"); 756 free_irq(card->p_dev->irq, card); 757 } 758 } 759 760 761 /********************************************************************/ 762 /* Callback functions for libertas.ko */ 763 /********************************************************************/ 764 765 /* Send commands or data packets to the card */ 766 static int if_cs_host_to_card(struct lbs_private *priv, 767 u8 type, 768 u8 *buf, 769 u16 nb) 770 { 771 int ret = -1; 772 773 switch (type) { 774 case MVMS_DAT: 775 priv->dnld_sent = DNLD_DATA_SENT; 776 if_cs_send_data(priv, buf, nb); 777 ret = 0; 778 break; 779 case MVMS_CMD: 780 priv->dnld_sent = DNLD_CMD_SENT; 781 ret = if_cs_send_cmd(priv, buf, nb); 782 break; 783 default: 784 netdev_err(priv->dev, "%s: unsupported type %d\n", 785 __func__, type); 786 } 787 788 return ret; 789 } 790 791 792 static void if_cs_release(struct pcmcia_device *p_dev) 793 { 794 struct if_cs_card *card = p_dev->priv; 795 796 free_irq(p_dev->irq, card); 797 pcmcia_disable_device(p_dev); 798 if (card->iobase) 799 ioport_unmap(card->iobase); 800 } 801 802 803 static int if_cs_ioprobe(struct pcmcia_device *p_dev, void *priv_data) 804 { 805 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; 806 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO; 807 808 if (p_dev->resource[1]->end) { 809 pr_err("wrong CIS (check number of IO windows)\n"); 810 return -ENODEV; 811 } 812 813 /* This reserves IO space but doesn't actually enable it */ 814 return pcmcia_request_io(p_dev); 815 } 816 817 static int if_cs_probe(struct pcmcia_device *p_dev) 818 { 819 int ret = -ENOMEM; 820 unsigned int prod_id; 821 struct lbs_private *priv; 822 struct if_cs_card *card; 823 824 card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL); 825 if (!card) 826 goto out; 827 828 card->p_dev = p_dev; 829 p_dev->priv = card; 830 831 p_dev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO; 832 833 if (pcmcia_loop_config(p_dev, if_cs_ioprobe, NULL)) { 834 pr_err("error in pcmcia_loop_config\n"); 835 goto out1; 836 } 837 838 /* 839 * Allocate an interrupt line. Note that this does not assign 840 * a handler to the interrupt, unless the 'Handler' member of 841 * the irq structure is initialized. 842 */ 843 if (!p_dev->irq) 844 goto out1; 845 846 /* Initialize io access */ 847 card->iobase = ioport_map(p_dev->resource[0]->start, 848 resource_size(p_dev->resource[0])); 849 if (!card->iobase) { 850 pr_err("error in ioport_map\n"); 851 ret = -EIO; 852 goto out1; 853 } 854 855 ret = pcmcia_enable_device(p_dev); 856 if (ret) { 857 pr_err("error in pcmcia_enable_device\n"); 858 goto out2; 859 } 860 861 /* Finally, report what we've done */ 862 lbs_deb_cs("irq %d, io %pR", p_dev->irq, p_dev->resource[0]); 863 864 /* 865 * Most of the libertas cards can do unaligned register access, but some 866 * weird ones cannot. That's especially true for the CF8305 card. 867 */ 868 card->align_regs = false; 869 870 card->model = get_model(p_dev->manf_id, p_dev->card_id); 871 if (card->model == MODEL_UNKNOWN) { 872 pr_err("unsupported manf_id 0x%04x / card_id 0x%04x\n", 873 p_dev->manf_id, p_dev->card_id); 874 ret = -ENODEV; 875 goto out2; 876 } 877 878 /* Check if we have a current silicon */ 879 prod_id = if_cs_read8(card, IF_CS_PRODUCT_ID); 880 if (card->model == MODEL_8305) { 881 card->align_regs = true; 882 if (prod_id < IF_CS_CF8305_B1_REV) { 883 pr_err("8305 rev B0 and older are not supported\n"); 884 ret = -ENODEV; 885 goto out2; 886 } 887 } 888 889 if ((card->model == MODEL_8381) && prod_id < IF_CS_CF8381_B3_REV) { 890 pr_err("8381 rev B2 and older are not supported\n"); 891 ret = -ENODEV; 892 goto out2; 893 } 894 895 if ((card->model == MODEL_8385) && prod_id < IF_CS_CF8385_B1_REV) { 896 pr_err("8385 rev B0 and older are not supported\n"); 897 ret = -ENODEV; 898 goto out2; 899 } 900 901 /* Make this card known to the libertas driver */ 902 priv = lbs_add_card(card, &p_dev->dev); 903 if (!priv) { 904 ret = -ENOMEM; 905 goto out2; 906 } 907 908 /* Set up fields in lbs_private */ 909 card->priv = priv; 910 priv->card = card; 911 priv->hw_host_to_card = if_cs_host_to_card; 912 priv->enter_deep_sleep = NULL; 913 priv->exit_deep_sleep = NULL; 914 priv->reset_deep_sleep_wakeup = NULL; 915 916 /* Get firmware */ 917 ret = lbs_get_firmware_async(priv, &p_dev->dev, card->model, fw_table, 918 if_cs_prog_firmware); 919 if (ret) { 920 pr_err("failed to find firmware (%d)\n", ret); 921 goto out3; 922 } 923 924 goto out; 925 926 out3: 927 lbs_remove_card(priv); 928 out2: 929 ioport_unmap(card->iobase); 930 out1: 931 pcmcia_disable_device(p_dev); 932 out: 933 return ret; 934 } 935 936 937 static void if_cs_detach(struct pcmcia_device *p_dev) 938 { 939 struct if_cs_card *card = p_dev->priv; 940 941 lbs_stop_card(card->priv); 942 lbs_remove_card(card->priv); 943 if_cs_disable_ints(card); 944 if_cs_release(p_dev); 945 kfree(card); 946 } 947 948 949 950 /********************************************************************/ 951 /* Module initialization */ 952 /********************************************************************/ 953 954 static const struct pcmcia_device_id if_cs_ids[] = { 955 PCMCIA_DEVICE_MANF_CARD(CF8305_MANFID, CF8305_CARDID), 956 PCMCIA_DEVICE_MANF_CARD(CF8381_MANFID, CF8381_CARDID), 957 PCMCIA_DEVICE_MANF_CARD(CF8385_MANFID, CF8385_CARDID), 958 /* NOTE: keep in sync with get_model() */ 959 PCMCIA_DEVICE_NULL, 960 }; 961 MODULE_DEVICE_TABLE(pcmcia, if_cs_ids); 962 963 static struct pcmcia_driver lbs_driver = { 964 .owner = THIS_MODULE, 965 .name = DRV_NAME, 966 .probe = if_cs_probe, 967 .remove = if_cs_detach, 968 .id_table = if_cs_ids, 969 }; 970 module_pcmcia_driver(lbs_driver); 971