Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/drivers/net/wireless/rtl818x/rtl8180_dev.c

 
 /*
  * Linux device driver for RTL8180 / RTL8185
  *
  * Copyright 2007 Michael Wu <flamingice@sourmilk.net>
  * Copyright 2007 Andrea Merello <andreamrl@tiscali.it>
  *
  * Based on the r8180 driver, which is:
  * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
  *
@@ skipping 427 matching lines @@
 {
         struct rtl8180_priv *priv = dev->priv;
         struct rtl8180_rx_desc *entry;
         int i;
 
         priv->rx_ring = pci_alloc_consistent(priv->pdev,
                                              sizeof(*priv->rx_ring) * 32,
                                              &priv->rx_ring_dma);
 
         if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
-                wiphy_err(dev->wiphy, "cannot allocate rx ring\n");
+                wiphy_err(dev->wiphy, "Cannot allocate RX ring\n");
                 return -ENOMEM;
         }
 
         memset(priv->rx_ring, 0, sizeof(*priv->rx_ring) * 32);
         priv->rx_idx = 0;
 
         for (i = 0; i < 32; i++) {
                 struct sk_buff *skb = dev_alloc_skb(MAX_RX_SIZE);
                 dma_addr_t *mapping;
                 entry = &priv->rx_ring[i];
@@ skipping 36 matching lines @@
 static int rtl8180_init_tx_ring(struct ieee80211_hw *dev,
                                 unsigned int prio, unsigned int entries)
 {
         struct rtl8180_priv *priv = dev->priv;
         struct rtl8180_tx_desc *ring;
         dma_addr_t dma;
         int i;
 
         ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
         if (!ring || (unsigned long)ring & 0xFF) {
-                wiphy_err(dev->wiphy, "cannot allocate tx ring (prio = %d)\n",
+                wiphy_err(dev->wiphy, "Cannot allocate TX ring (prio = %d)\n",
                           prio);
                 return -ENOMEM;
         }
 
         memset(ring, 0, sizeof(*ring)*entries);
         priv->tx_ring[prio].desc = ring;
         priv->tx_ring[prio].dma = dma;
         priv->tx_ring[prio].idx = 0;
         priv->tx_ring[prio].entries = entries;
         skb_queue_head_init(&priv->tx_ring[prio].queue);
@@ skipping 45 matching lines @@
 
         rtl818x_iowrite32(priv, &priv->map->RDSAR, priv->rx_ring_dma);
         rtl818x_iowrite32(priv, &priv->map->TBDA, priv->tx_ring[3].dma);
         rtl818x_iowrite32(priv, &priv->map->THPDA, priv->tx_ring[2].dma);
         rtl818x_iowrite32(priv, &priv->map->TNPDA, priv->tx_ring[1].dma);
         rtl818x_iowrite32(priv, &priv->map->TLPDA, priv->tx_ring[0].dma);
 
         ret = request_irq(priv->pdev->irq, rtl8180_interrupt,
                           IRQF_SHARED, KBUILD_MODNAME, dev);
         if (ret) {
-                wiphy_err(dev->wiphy, "failed to register irq handler\n");
+                wiphy_err(dev->wiphy, "failed to register IRQ handler\n");
                 goto err_free_rings;
         }
 
         rtl818x_iowrite16(priv, &priv->map->INT_MASK, 0xFFFF);
 
         rtl818x_iowrite32(priv, &priv->map->MAR[0], ~0);
         rtl818x_iowrite32(priv, &priv->map->MAR[1], ~0);
 
         reg = RTL818X_RX_CONF_ONLYERLPKT |
               RTL818X_RX_CONF_RX_AUTORESETPHY |
@@ skipping 603 matching lines @@
         return pci_register_driver(&rtl8180_driver);
 }
 
 static void __exit rtl8180_exit(void)
 {
         pci_unregister_driver(&rtl8180_driver);
 }
 
 module_init(rtl8180_init);
 module_exit(rtl8180_exit);