Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/drivers/net/wireless/mwl8k.c

 /*
  * drivers/net/wireless/mwl8k.c
  * Driver for Marvell TOPDOG 802.11 Wireless cards
  *
  * Copyright (C) 2008, 2009, 2010 Marvell Semiconductor Inc.
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2.  This program is licensed "as is" without any
  * warranty of any kind, whether express or implied.
  */
@@ skipping 892 matching lines @@
         int i;
 
         rxq->rxd_count = 0;
         rxq->head = 0;
         rxq->tail = 0;
 
         size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
 
         rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
         if (rxq->rxd == NULL) {
-                wiphy_err(hw->wiphy, "failed to alloc rx descriptors\n");
+                wiphy_err(hw->wiphy, "failed to alloc RX descriptors\n");
                 return -ENOMEM;
         }
         memset(rxq->rxd, 0, size);
 
         rxq->buf = kmalloc(MWL8K_RX_DESCS * sizeof(*rxq->buf), GFP_KERNEL);
         if (rxq->buf == NULL) {
-                wiphy_err(hw->wiphy, "failed to alloc rx skbuff list\n");
+                wiphy_err(hw->wiphy, "failed to alloc RX skbuff list\n");
                 pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
                 return -ENOMEM;
         }
         memset(rxq->buf, 0, MWL8K_RX_DESCS * sizeof(*rxq->buf));
 
         for (i = 0; i < MWL8K_RX_DESCS; i++) {
                 int desc_size;
                 void *rxd;
                 int nexti;
                 dma_addr_t next_dma_addr;
@@ skipping 207 matching lines @@
         int i;
 
         txq->len = 0;
         txq->head = 0;
         txq->tail = 0;
 
         size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);
 
         txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
         if (txq->txd == NULL) {
-                wiphy_err(hw->wiphy, "failed to alloc tx descriptors\n");
+                wiphy_err(hw->wiphy, "failed to alloc TX descriptors\n");
                 return -ENOMEM;
         }
         memset(txq->txd, 0, size);
 
         txq->skb = kmalloc(MWL8K_TX_DESCS * sizeof(*txq->skb), GFP_KERNEL);
         if (txq->skb == NULL) {
-                wiphy_err(hw->wiphy, "failed to alloc tx skbuff list\n");
+                wiphy_err(hw->wiphy, "failed to alloc TX skbuff list\n");
                 pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
                 return -ENOMEM;
         }
         memset(txq->skb, 0, MWL8K_TX_DESCS * sizeof(*txq->skb));
 
         for (i = 0; i < MWL8K_TX_DESCS; i++) {
                 struct mwl8k_tx_desc *tx_desc;
                 int nexti;
 
                 tx_desc = txq->txd + i;
@@ skipping 400 matching lines @@
                                 msecs_to_jiffies(MWL8K_CMD_TIMEOUT_MS));
 
         priv->hostcmd_wait = NULL;
 
         mwl8k_fw_unlock(hw);
 
         pci_unmap_single(priv->pdev, dma_addr, dma_size,
                                         PCI_DMA_BIDIRECTIONAL);
 
         if (!timeout) {
-                wiphy_err(hw->wiphy, "command %s timeout after %u ms\n",
+                wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n",
                           mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
                           MWL8K_CMD_TIMEOUT_MS);
                 rc = -ETIMEDOUT;
         } else {
                 int ms;
 
                 ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);
 
                 rc = cmd->result ? -EINVAL : 0;
                 if (rc)
-                        wiphy_err(hw->wiphy, "command %s error 0x%x\n",
+                        wiphy_err(hw->wiphy, "Command %s error 0x%x\n",
                                   mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
                                   le16_to_cpu(cmd->result));
                 else if (ms > 2000)
-                        wiphy_notice(hw->wiphy, "command %s took %d ms\n",
+                        wiphy_notice(hw->wiphy, "Command %s took %d ms\n",
                                      mwl8k_cmd_name(cmd->code,
                                                     buf, sizeof(buf)),
                                      ms);
         }
 
         return rc;
 }
 
 static int mwl8k_post_pervif_cmd(struct ieee80211_hw *hw,
                                  struct ieee80211_vif *vif,
@@ skipping 1621 matching lines @@
 }
 
 static int mwl8k_start(struct ieee80211_hw *hw)
 {
         struct mwl8k_priv *priv = hw->priv;
         int rc;
 
         rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
                          IRQF_SHARED, MWL8K_NAME, hw);
         if (rc) {
-                wiphy_err(hw->wiphy, "failed to register irq handler\n");
+                wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
                 return -EIO;
         }
 
         /* Enable TX reclaim and RX tasklets.  */
         tasklet_enable(&priv->poll_tx_task);
         tasklet_enable(&priv->poll_rx_task);
 
         /* Enable interrupts */
         iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
 
@@ skipping 707 matching lines @@
         pci_set_drvdata(pdev, hw);
 
         priv = hw->priv;
         priv->hw = hw;
         priv->pdev = pdev;
         priv->device_info = &mwl8k_info_tbl[id->driver_data];
 
 
         priv->sram = pci_iomap(pdev, 0, 0x10000);
         if (priv->sram == NULL) {
-                wiphy_err(hw->wiphy, "cannot map device sram\n");
+                wiphy_err(hw->wiphy, "Cannot map device SRAM\n");
                 goto err_iounmap;
         }
 
         /*
          * If BAR0 is a 32 bit BAR, the register BAR will be BAR1.
          * If BAR0 is a 64 bit BAR, the register BAR will be BAR2.
          */
         priv->regs = pci_iomap(pdev, 1, 0x10000);
         if (priv->regs == NULL) {
                 priv->regs = pci_iomap(pdev, 2, 0x10000);
                 if (priv->regs == NULL) {
-                        wiphy_err(hw->wiphy, "cannot map device registers\n");
+                        wiphy_err(hw->wiphy, "Cannot map device registers\n");
                         goto err_iounmap;
                 }
         }
 
 
         /* Reset firmware and hardware */
         mwl8k_hw_reset(priv);
 
         /* Ask userland hotplug daemon for the device firmware */
         rc = mwl8k_request_firmware(priv);
         if (rc) {
-                wiphy_err(hw->wiphy, "firmware files not found\n");
+                wiphy_err(hw->wiphy, "Firmware files not found\n");
                 goto err_stop_firmware;
         }
 
         /* Load firmware into hardware */
         rc = mwl8k_load_firmware(hw);
         if (rc) {
-                wiphy_err(hw->wiphy, "cannot start firmware\n");
+                wiphy_err(hw->wiphy, "Cannot start firmware\n");
                 goto err_stop_firmware;
         }
 
         /* Reclaim memory once firmware is successfully loaded */
         mwl8k_release_firmware(priv);
 
 
         if (priv->ap_fw) {
                 priv->rxd_ops = priv->device_info->ap_rxd_ops;
                 if (priv->rxd_ops == NULL) {
@@ skipping 69 matching lines @@
 
         iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
         iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
         iowrite32(MWL8K_A2H_INT_TX_DONE | MWL8K_A2H_INT_RX_READY,
                   priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
         iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);
 
         rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
                          IRQF_SHARED, MWL8K_NAME, hw);
         if (rc) {
-                wiphy_err(hw->wiphy, "failed to register irq handler\n");
+                wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
                 goto err_free_queues;
         }
 
         /*
          * Temporarily enable interrupts.  Initial firmware host
          * commands use interrupts and avoid polling.  Disable
          * interrupts when done.
          */
         iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
 
         /* Get config data, mac addrs etc */
         if (priv->ap_fw) {
                 rc = mwl8k_cmd_get_hw_spec_ap(hw);
                 if (!rc)
                         rc = mwl8k_cmd_set_hw_spec(hw);
         } else {
                 rc = mwl8k_cmd_get_hw_spec_sta(hw);
         }
         if (rc) {
-                wiphy_err(hw->wiphy, "cannot initialise firmware\n");
+                wiphy_err(hw->wiphy, "Cannot initialise firmware\n");
                 goto err_free_irq;
         }
 
         hw->wiphy->interface_modes = 0;
         if (priv->ap_macids_supported)
                 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP);
         if (priv->sta_macids_supported)
                 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_STATION);
 
 
         /* Turn radio off */
         rc = mwl8k_cmd_radio_disable(hw);
         if (rc) {
-                wiphy_err(hw->wiphy, "cannot disable\n");
+                wiphy_err(hw->wiphy, "Cannot disable\n");
                 goto err_free_irq;
         }
 
         /* Clear MAC address */
         rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
         if (rc) {
-                wiphy_err(hw->wiphy, "cannot clear mac address\n");
+                wiphy_err(hw->wiphy, "Cannot clear MAC address\n");
                 goto err_free_irq;
         }
 
         /* Disable interrupts */
         iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
         free_irq(priv->pdev->irq, hw);
 
         rc = ieee80211_register_hw(hw);
         if (rc) {
-                wiphy_err(hw->wiphy, "cannot register device\n");
+                wiphy_err(hw->wiphy, "Cannot register device\n");
                 goto err_free_queues;
         }
 
         wiphy_info(hw->wiphy, "%s v%d, %pm, %s firmware %u.%u.%u.%u\n",
                    priv->device_info->part_name,
                    priv->hw_rev, hw->wiphy->perm_addr,
                    priv->ap_fw ? "AP" : "STA",
                    (priv->fw_rev >> 24) & 0xff, (priv->fw_rev >> 16) & 0xff,
                    (priv->fw_rev >> 8) & 0xff, priv->fw_rev & 0xff);
 
@@ skipping 99 matching lines @@
         pci_unregister_driver(&mwl8k_driver);
 }
 
 module_init(mwl8k_init);
 module_exit(mwl8k_exit);
 
 MODULE_DESCRIPTION(MWL8K_DESC);
 MODULE_VERSION(MWL8K_VERSION);
 MODULE_AUTHOR("Lennert Buytenhek <buytenh@marvell.com>");
 MODULE_LICENSE("GPL");