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