1 files changed, 129 insertions, 136 deletions

diff --git a/drivers/net/wireless/libertas/if_cs.c b/drivers/net/wireless/libertas/if_cs.c
index 9c298396be50..e26935179861 100644
--- a/drivers/net/wireless/libertas/if_cs.c
+++ b/drivers/net/wireless/libertas/if_cs.c
@@ -21,6 +21,8 @@
 
 */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
@@ -28,7 +30,6 @@
 #include <linux/firmware.h>
 #include <linux/netdevice.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -48,7 +49,6 @@
 MODULE_AUTHOR("Holger Schurig <hs4233@mail.mn-solutions.de>");
 MODULE_DESCRIPTION("Driver for Marvell 83xx compact flash WLAN cards");
 MODULE_LICENSE("GPL");
-MODULE_FIRMWARE("libertas_cs_helper.fw");
 
 
 
@@ -61,9 +61,34 @@ struct if_cs_card {
         struct lbs_private *priv;
         void __iomem *iobase;
         bool align_regs;
+        u32 model;
 };
 
 
+enum {
+        MODEL_UNKNOWN = 0x00,
+        MODEL_8305 = 0x01,
+        MODEL_8381 = 0x02,
+        MODEL_8385 = 0x03
+};
+
+static const struct lbs_fw_table fw_table[] = {
+        { MODEL_8305, "libertas/cf8305.bin", NULL },
+        { MODEL_8305, "libertas_cs_helper.fw", NULL },
+        { MODEL_8381, "libertas/cf8381_helper.bin", "libertas/cf8381.bin" },
+        { MODEL_8381, "libertas_cs_helper.fw", "libertas_cs.fw" },
+        { MODEL_8385, "libertas/cf8385_helper.bin", "libertas/cf8385.bin" },
+        { MODEL_8385, "libertas_cs_helper.fw", "libertas_cs.fw" },
+        { 0, NULL, NULL }
+};
+MODULE_FIRMWARE("libertas/cf8305.bin");
+MODULE_FIRMWARE("libertas/cf8381_helper.bin");
+MODULE_FIRMWARE("libertas/cf8381.bin");
+MODULE_FIRMWARE("libertas/cf8385_helper.bin");
+MODULE_FIRMWARE("libertas/cf8385.bin");
+MODULE_FIRMWARE("libertas_cs_helper.fw");
+MODULE_FIRMWARE("libertas_cs.fw");
+
 
 /********************************************************************/
 /* Hardware access                                                  */
@@ -289,22 +314,20 @@ static int if_cs_poll_while_fw_download(struct if_cs_card *card, uint addr, u8 r
 #define CF8385_MANFID           0x02df
 #define CF8385_CARDID           0x8103
 
-static inline int if_cs_hw_is_cf8305(struct pcmcia_device *p_dev)
-{
-        return (p_dev->manf_id == CF8305_MANFID &&
-                p_dev->card_id == CF8305_CARDID);
-}
-
-static inline int if_cs_hw_is_cf8381(struct pcmcia_device *p_dev)
-{
-        return (p_dev->manf_id == CF8381_MANFID &&
-                p_dev->card_id == CF8381_CARDID);
-}
-
-static inline int if_cs_hw_is_cf8385(struct pcmcia_device *p_dev)
+/*
+ * FIXME: just use the 'driver_info' field of 'struct pcmcia_device_id' when
+ * that gets fixed.  Currently there's no way to access it from the probe hook.
+ */
+static inline u32 get_model(u16 manf_id, u16 card_id)
 {
-        return (p_dev->manf_id == CF8385_MANFID &&
-                p_dev->card_id == CF8385_CARDID);
+        /* NOTE: keep in sync with if_cs_ids */
+        if (manf_id == CF8305_MANFID && card_id == CF8305_CARDID)
+                return MODEL_8305;
+        else if (manf_id == CF8381_MANFID && card_id == CF8381_CARDID)
+                return MODEL_8381;
+        else if (manf_id == CF8385_MANFID && card_id == CF8385_CARDID)
+                return MODEL_8385;
+        return MODEL_UNKNOWN;
 }
 
 /********************************************************************/
@@ -341,7 +364,7 @@ static int if_cs_send_cmd(struct lbs_private *priv, u8 *buf, u16 nb)
                 if (status & IF_CS_BIT_COMMAND)
                         break;
                 if (++loops > 100) {
-                        lbs_pr_err("card not ready for commands\n");
+                        netdev_err(priv->dev, "card not ready for commands\n");
                         goto done;
                 }
                 mdelay(1);
@@ -411,14 +434,16 @@ static int if_cs_receive_cmdres(struct lbs_private *priv, u8 *data, u32 *len)
         /* is hardware ready? */
         status = if_cs_read16(priv->card, IF_CS_CARD_STATUS);
         if ((status & IF_CS_BIT_RESP) == 0) {
-                lbs_pr_err("no cmd response in card\n");
+                netdev_err(priv->dev, "no cmd response in card\n");
                 *len = 0;
                 goto out;
         }
 
         *len = if_cs_read16(priv->card, IF_CS_RESP_LEN);
         if ((*len == 0) || (*len > LBS_CMD_BUFFER_SIZE)) {
-                lbs_pr_err("card cmd buffer has invalid # of bytes (%d)\n", *len);
+                netdev_err(priv->dev,
+                           "card cmd buffer has invalid # of bytes (%d)\n",
+                           *len);
                 goto out;
         }
 
@@ -452,7 +477,9 @@ static struct sk_buff *if_cs_receive_data(struct lbs_private *priv)
 
         len = if_cs_read16(priv->card, IF_CS_READ_LEN);
         if (len == 0 || len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
-                lbs_pr_err("card data buffer has invalid # of bytes (%d)\n", len);
+                netdev_err(priv->dev,
+                           "card data buffer has invalid # of bytes (%d)\n",
+                           len);
                 priv->dev->stats.rx_dropped++;
                 goto dat_err;
         }
@@ -558,12 +585,11 @@ static irqreturn_t if_cs_interrupt(int irq, void *data)
  *
  * Return 0 on success
  */
-static int if_cs_prog_helper(struct if_cs_card *card)
+static int if_cs_prog_helper(struct if_cs_card *card, const struct firmware *fw)
 {
         int ret = 0;
         int sent = 0;
         u8  scratch;
-        const struct firmware *fw;
 
         lbs_deb_enter(LBS_DEB_CS);
 
@@ -589,14 +615,6 @@ static int if_cs_prog_helper(struct if_cs_card *card)
                 goto done;
         }
 
-        /* TODO: make firmware file configurable */
-        ret = request_firmware(&fw, "libertas_cs_helper.fw",
-                &card->p_dev->dev);
-        if (ret) {
-                lbs_pr_err("can't load helper firmware\n");
-                ret = -ENODEV;
-                goto done;
-        }
         lbs_deb_cs("helper size %td\n", fw->size);
 
         /* "Set the 5 bytes of the helper image to 0" */
@@ -610,8 +628,10 @@ static int if_cs_prog_helper(struct if_cs_card *card)
                 if (remain < count)
                         count = remain;
 
-                /* "write the number of bytes to be sent to the I/O Command
-                 * write length register" */
+                /*
+                 * "write the number of bytes to be sent to the I/O Command
+                 * write length register"
+                 */
                 if_cs_write16(card, IF_CS_CMD_LEN, count);
 
                 /* "write this to I/O Command port register as 16 bit writes */
@@ -620,22 +640,28 @@ static int if_cs_prog_helper(struct if_cs_card *card)
                                 &fw->data[sent],
                                 count >> 1);
 
-                /* "Assert the download over interrupt command in the Host
-                 * status register" */
+                /*
+                 * "Assert the download over interrupt command in the Host
+                 * status register"
+                 */
                 if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
 
-                /* "Assert the download over interrupt command in the Card
-                 * interrupt case register" */
+                /*
+                 * "Assert the download over interrupt command in the Card
+                 * interrupt case register"
+                 */
                 if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
 
-                /* "The host polls the Card Status register ... for 50 ms before
-                   declaring a failure */
+                /*
+                 * "The host polls the Card Status register ... for 50 ms before
+                 * declaring a failure"
+                 */
                 ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS,
                         IF_CS_BIT_COMMAND);
                 if (ret < 0) {
-                        lbs_pr_err("can't download helper at 0x%x, ret %d\n",
-                                sent, ret);
-                        goto err_release;
+                        pr_err("can't download helper at 0x%x, ret %d\n",
+                               sent, ret);
+                        goto done;
                 }
 
                 if (count == 0)
@@ -644,17 +670,14 @@ static int if_cs_prog_helper(struct if_cs_card *card)
                 sent += count;
         }
 
-err_release:
-        release_firmware(fw);
 done:
         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
         return ret;
 }
 
 
-static int if_cs_prog_real(struct if_cs_card *card)
+static int if_cs_prog_real(struct if_cs_card *card, const struct firmware *fw)
 {
-        const struct firmware *fw;
         int ret = 0;
         int retry = 0;
         int len = 0;
@@ -662,36 +685,28 @@ static int if_cs_prog_real(struct if_cs_card *card)
 
         lbs_deb_enter(LBS_DEB_CS);
 
-        /* TODO: make firmware file configurable */
-        ret = request_firmware(&fw, "libertas_cs.fw",
-                &card->p_dev->dev);
-        if (ret) {
-                lbs_pr_err("can't load firmware\n");
-                ret = -ENODEV;
-                goto done;
-        }
         lbs_deb_cs("fw size %td\n", fw->size);
 
         ret = if_cs_poll_while_fw_download(card, IF_CS_SQ_READ_LOW,
                 IF_CS_SQ_HELPER_OK);
         if (ret < 0) {
-                lbs_pr_err("helper firmware doesn't answer\n");
-                goto err_release;
+                pr_err("helper firmware doesn't answer\n");
+                goto done;
         }
 
         for (sent = 0; sent < fw->size; sent += len) {
                 len = if_cs_read16(card, IF_CS_SQ_READ_LOW);
                 if (len & 1) {
                         retry++;
-                        lbs_pr_info("odd, need to retry this firmware block\n");
+                        pr_info("odd, need to retry this firmware block\n");
                 } else {
                         retry = 0;
                 }
 
                 if (retry > 20) {
-                        lbs_pr_err("could not download firmware\n");
+                        pr_err("could not download firmware\n");
                         ret = -ENODEV;
-                        goto err_release;
+                        goto done;
                 }
                 if (retry) {
                         sent -= len;
@@ -709,17 +724,14 @@ static int if_cs_prog_real(struct if_cs_card *card)
                 ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS,
                         IF_CS_BIT_COMMAND);
                 if (ret < 0) {
-                        lbs_pr_err("can't download firmware at 0x%x\n", sent);
-                        goto err_release;
+                        pr_err("can't download firmware at 0x%x\n", sent);
+                        goto done;
                 }
         }
 
         ret = if_cs_poll_while_fw_download(card, IF_CS_SCRATCH, 0x5a);
         if (ret < 0)
-                lbs_pr_err("firmware download failed\n");
-
-err_release:
-        release_firmware(fw);
+                pr_err("firmware download failed\n");
 
 done:
         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
@@ -753,7 +765,8 @@ static int if_cs_host_to_card(struct lbs_private *priv,
                 ret = if_cs_send_cmd(priv, buf, nb);
                 break;
         default:
-                lbs_pr_err("%s: unsupported type %d\n", __func__, type);
+                netdev_err(priv->dev, "%s: unsupported type %d\n",
+                           __func__, type);
         }
 
         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
@@ -761,15 +774,6 @@ static int if_cs_host_to_card(struct lbs_private *priv,
 }
 
 
-/********************************************************************/
-/* Card Services                                                    */
-/********************************************************************/
-
-/*
- * After a card is removed, if_cs_release() will unregister the
- * device, and release the PCMCIA configuration.  If the device is
- * still open, this will be postponed until it is closed.
- */
 static void if_cs_release(struct pcmcia_device *p_dev)
 {
         struct if_cs_card *card = p_dev->priv;
@@ -785,32 +789,13 @@ static void if_cs_release(struct pcmcia_device *p_dev)
 }
 
 
-/*
- * This creates an "instance" of the driver, allocating local data
- * structures for one device.  The device is registered with Card
- * Services.
- *
- * The dev_link structure is initialized, but we don't actually
- * configure the card at this point -- we wait until we receive a card
- * insertion event.
- */
-
-static int if_cs_ioprobe(struct pcmcia_device *p_dev,
-                         cistpl_cftable_entry_t *cfg,
-                         cistpl_cftable_entry_t *dflt,
-                         unsigned int vcc,
-                         void *priv_data)
+static int if_cs_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
 {
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
 
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        if (cfg->io.nwin != 1) {
-                lbs_pr_err("wrong CIS (check number of IO windows)\n");
+        if (p_dev->resource[1]->end) {
+                pr_err("wrong CIS (check number of IO windows)\n");
                 return -ENODEV;
         }
 
@@ -824,26 +809,26 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
         unsigned int prod_id;
         struct lbs_private *priv;
         struct if_cs_card *card;
+        const struct firmware *helper = NULL;
+        const struct firmware *mainfw = NULL;
 
         lbs_deb_enter(LBS_DEB_CS);
 
         card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL);
         if (!card) {
-                lbs_pr_err("error in kzalloc\n");
+                pr_err("error in kzalloc\n");
                 goto out;
         }
         card->p_dev = p_dev;
         p_dev->priv = card;
 
-        p_dev->conf.Attributes = 0;
-        p_dev->conf.IntType = INT_MEMORY_AND_IO;
+        p_dev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
         if (pcmcia_loop_config(p_dev, if_cs_ioprobe, NULL)) {
-                lbs_pr_err("error in pcmcia_loop_config\n");
+                pr_err("error in pcmcia_loop_config\n");
                 goto out1;
         }
 
-
         /*
          * Allocate an interrupt line.  Note that this does not assign
          * a handler to the interrupt, unless the 'Handler' member of
@@ -856,19 +841,14 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
         card->iobase = ioport_map(p_dev->resource[0]->start,
                                 resource_size(p_dev->resource[0]));
         if (!card->iobase) {
-                lbs_pr_err("error in ioport_map\n");
+                pr_err("error in ioport_map\n");
                 ret = -EIO;
                 goto out1;
         }
 
-        /*
-         * This actually configures the PCMCIA socket -- setting up
-         * the I/O windows and the interrupt mapping, and putting the
-         * card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(p_dev, &p_dev->conf);
+        ret = pcmcia_enable_device(p_dev);
         if (ret) {
-                lbs_pr_err("error in pcmcia_request_configuration\n");
+                pr_err("error in pcmcia_enable_device\n");
                 goto out2;
         }
 
@@ -877,38 +857,51 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
 
         /*
          * Most of the libertas cards can do unaligned register access, but some
-         * weird ones can not. That's especially true for the CF8305 card.
+         * weird ones cannot. That's especially true for the CF8305 card.
          */
         card->align_regs = 0;
 
+        card->model = get_model(p_dev->manf_id, p_dev->card_id);
+        if (card->model == MODEL_UNKNOWN) {
+                pr_err("unsupported manf_id 0x%04x / card_id 0x%04x\n",
+                       p_dev->manf_id, p_dev->card_id);
+                goto out2;
+        }
+
         /* Check if we have a current silicon */
         prod_id = if_cs_read8(card, IF_CS_PRODUCT_ID);
-        if (if_cs_hw_is_cf8305(p_dev)) {
+        if (card->model == MODEL_8305) {
                 card->align_regs = 1;
                 if (prod_id < IF_CS_CF8305_B1_REV) {
-                        lbs_pr_err("old chips like 8305 rev B3 "
-                                "aren't supported\n");
+                        pr_err("8305 rev B0 and older are not supported\n");
                         ret = -ENODEV;
                         goto out2;
                 }
         }
 
-        if (if_cs_hw_is_cf8381(p_dev) && prod_id < IF_CS_CF8381_B3_REV) {
-                lbs_pr_err("old chips like 8381 rev B3 aren't supported\n");
+        if ((card->model == MODEL_8381) && prod_id < IF_CS_CF8381_B3_REV) {
+                pr_err("8381 rev B2 and older are not supported\n");
                 ret = -ENODEV;
                 goto out2;
         }
 
-        if (if_cs_hw_is_cf8385(p_dev) && prod_id < IF_CS_CF8385_B1_REV) {
-                lbs_pr_err("old chips like 8385 rev B1 aren't supported\n");
+        if ((card->model == MODEL_8385) && prod_id < IF_CS_CF8385_B1_REV) {
+                pr_err("8385 rev B0 and older are not supported\n");
                 ret = -ENODEV;
                 goto out2;
         }
 
+        ret = lbs_get_firmware(&p_dev->dev, NULL, NULL, card->model,
+                                &fw_table[0], &helper, &mainfw);
+        if (ret) {
+                pr_err("failed to find firmware (%d)\n", ret);
+                goto out2;
+        }
+
         /* Load the firmware early, before calling into libertas.ko */
-        ret = if_cs_prog_helper(card);
-        if (ret == 0 && !if_cs_hw_is_cf8305(p_dev))
-                ret = if_cs_prog_real(card);
+        ret = if_cs_prog_helper(card, helper);
+        if (ret == 0 && (card->model != MODEL_8305))
+                ret = if_cs_prog_real(card, mainfw);
         if (ret)
                 goto out2;
 
@@ -932,18 +925,20 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
         ret = request_irq(p_dev->irq, if_cs_interrupt,
                 IRQF_SHARED, DRV_NAME, card);
         if (ret) {
-                lbs_pr_err("error in request_irq\n");
+                pr_err("error in request_irq\n");
                 goto out3;
         }
 
-        /* Clear any interrupt cause that happend while sending
-         * firmware/initializing card */
+        /*
+         * Clear any interrupt cause that happened while sending
+         * firmware/initializing card
+         */
         if_cs_write16(card, IF_CS_CARD_INT_CAUSE, IF_CS_BIT_MASK);
         if_cs_enable_ints(card);
 
         /* And finally bring the card up */
         if (lbs_start_card(priv) != 0) {
-                lbs_pr_err("could not activate card\n");
+                pr_err("could not activate card\n");
                 goto out3;
         }
 
@@ -957,17 +952,16 @@ out2:
 out1:
         pcmcia_disable_device(p_dev);
 out:
+        if (helper)
+                release_firmware(helper);
+        if (mainfw)
+                release_firmware(mainfw);
+
         lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);
         return ret;
 }
 
 
-/*
- * This deletes a driver "instance".  The device is de-registered with
- * Card Services.  If it has been released, all local data structures
- * are freed.  Otherwise, the structures will be freed when the device
- * is released.
- */
 static void if_cs_detach(struct pcmcia_device *p_dev)
 {
         struct if_cs_card *card = p_dev->priv;
@@ -989,10 +983,11 @@ static void if_cs_detach(struct pcmcia_device *p_dev)
 /* Module initialization                                            */
 /********************************************************************/
 
-static struct pcmcia_device_id if_cs_ids[] = {
+static const struct pcmcia_device_id if_cs_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(CF8305_MANFID, CF8305_CARDID),
         PCMCIA_DEVICE_MANF_CARD(CF8381_MANFID, CF8381_CARDID),
         PCMCIA_DEVICE_MANF_CARD(CF8385_MANFID, CF8385_CARDID),
+        /* NOTE: keep in sync with get_model() */
         PCMCIA_DEVICE_NULL,
 };
 MODULE_DEVICE_TABLE(pcmcia, if_cs_ids);
@@ -1000,9 +995,7 @@ MODULE_DEVICE_TABLE(pcmcia, if_cs_ids);
 
 static struct pcmcia_driver lbs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = DRV_NAME,
-        },
+        .name           = DRV_NAME,
         .probe          = if_cs_probe,
         .remove         = if_cs_detach,
         .id_table       = if_cs_ids,