SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/wireless/libertas/if_cs.c

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