Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/drivers/net/wireless/at76c50x-usb.c

 /*
  * at76c503/at76c505 USB driver
  *
  * Copyright (c) 2002 - 2003 Oliver Kurth
  * Copyright (c) 2004 Joerg Albert <joerg.albert@gmx.de>
  * Copyright (c) 2004 Nick Jones
  * Copyright (c) 2004 Balint Seeber <n0_5p4m_p13453@hotmail.com>
  * Copyright (c) 2007 Guido Guenther <agx@sigxcpu.org>
  * Copyright (c) 2007 Kalle Valo <kalle.valo@iki.fi>
  * Copyright (c) 2010 Sebastian Smolorz <sesmo@gmx.net>
@@ skipping 637 matching lines @@
                 ret = at76_get_hw_cfg(priv->udev, hwcfg, sizeof(hwcfg->r5));
                 if (ret < 0)
                         goto exit;
                 memcpy(priv->mac_addr, hwcfg->r5.mac_addr, ETH_ALEN);
                 priv->regulatory_domain = hwcfg->r5.regulatory_domain;
         }
 
 exit:
         kfree(hwcfg);
         if (ret < 0)
-                wiphy_err(priv->hw->wiphy, "cannot get hw config (error %d)\n",
+                wiphy_err(priv->hw->wiphy, "cannot get HW Config (error %d)\n",
                           ret);
 
         return ret;
 }
 
 static struct reg_domain const *at76_get_reg_domain(u16 code)
 {
         int i;
         static struct reg_domain const fd_tab[] = {
                 { 0x10, "FCC (USA)", 0x7ff },   /* ch 1-11 */
@@ skipping 284 matching lines @@
         struct mib_mac_addr *m = kmalloc(sizeof(struct mib_mac_addr),
                                          GFP_KERNEL);
 
         if (!m)
                 return;
 
         ret = at76_get_mib(priv->udev, MIB_MAC_ADDR, m,
                            sizeof(struct mib_mac_addr));
         if (ret < 0) {
                 wiphy_err(priv->hw->wiphy,
-                          "at76_get_mib (mac_addr) failed: %d\n", ret);
+                          "at76_get_mib (MAC_ADDR) failed: %d\n", ret);
                 goto exit;
         }
 
         at76_dbg(DBG_MIB, "%s: MIB MAC_ADDR: mac_addr %pM res 0x%x 0x%x",
                  wiphy_name(priv->hw->wiphy),
                  m->mac_addr, m->res[0], m->res[1]);
         for (i = 0; i < ARRAY_SIZE(m->group_addr); i++)
                 at76_dbg(DBG_MIB, "%s: MIB MAC_ADDR: group addr %d: %pM, "
                          "status %d", wiphy_name(priv->hw->wiphy), i,
                          m->group_addr[i], m->group_addr_status[i]);
 exit:
         kfree(m);
 }
 
 static void at76_dump_mib_mac_wep(struct at76_priv *priv)
 {
         int i;
         int ret;
         int key_len;
         struct mib_mac_wep *m = kmalloc(sizeof(struct mib_mac_wep), GFP_KERNEL);
 
         if (!m)
                 return;
 
         ret = at76_get_mib(priv->udev, MIB_MAC_WEP, m,
                            sizeof(struct mib_mac_wep));
         if (ret < 0) {
                 wiphy_err(priv->hw->wiphy,
-                          "at76_get_mib (mac_wep) failed: %d\n", ret);
+                          "at76_get_mib (MAC_WEP) failed: %d\n", ret);
                 goto exit;
         }
 
         at76_dbg(DBG_MIB, "%s: MIB MAC_WEP: priv_invoked %u def_key_id %u "
                  "key_len %u excl_unencr %u wep_icv_err %u wep_excluded %u "
                  "encr_level %u key %d", wiphy_name(priv->hw->wiphy),
                  m->privacy_invoked, m->wep_default_key_id,
                  m->wep_key_mapping_len, m->exclude_unencrypted,
                  le32_to_cpu(m->wep_icv_error_count),
                  le32_to_cpu(m->wep_excluded_count), m->encryption_level,
@@ skipping 16 matching lines @@
         struct mib_mac_mgmt *m = kmalloc(sizeof(struct mib_mac_mgmt),
                                          GFP_KERNEL);
 
         if (!m)
                 return;
 
         ret = at76_get_mib(priv->udev, MIB_MAC_MGMT, m,
                            sizeof(struct mib_mac_mgmt));
         if (ret < 0) {
                 wiphy_err(priv->hw->wiphy,
-                          "at76_get_mib (mac_mgmt) failed: %d\n", ret);
+                          "at76_get_mib (MAC_MGMT) failed: %d\n", ret);
                 goto exit;
         }
 
         at76_dbg(DBG_MIB, "%s: MIB MAC_MGMT: beacon_period %d CFP_max_duration "
                  "%d medium_occupancy_limit %d station_id 0x%x ATIM_window %d "
                  "CFP_mode %d privacy_opt_impl %d DTIM_period %d CFP_period %d "
                  "current_bssid %pM current_essid %s current_bss_type %d "
                  "pm_mode %d ibss_change %d res %d "
                  "multi_domain_capability_implemented %d "
                  "international_roaming %d country_string %.3s",
@@ skipping 15 matching lines @@
 {
         int ret;
         struct mib_mac *m = kmalloc(sizeof(struct mib_mac), GFP_KERNEL);
 
         if (!m)
                 return;
 
         ret = at76_get_mib(priv->udev, MIB_MAC, m, sizeof(struct mib_mac));
         if (ret < 0) {
                 wiphy_err(priv->hw->wiphy,
-                          "at76_get_mib (mac) failed: %d\n", ret);
+                          "at76_get_mib (MAC) failed: %d\n", ret);
                 goto exit;
         }
 
         at76_dbg(DBG_MIB, "%s: MIB MAC: max_tx_msdu_lifetime %d "
                  "max_rx_lifetime %d frag_threshold %d rts_threshold %d "
                  "cwmin %d cwmax %d short_retry_time %d long_retry_time %d "
                  "scan_type %d scan_channel %d probe_delay %u "
                  "min_channel_time %d max_channel_time %d listen_int %d "
                  "desired_ssid %s desired_bssid %pM desired_bsstype %d",
                  wiphy_name(priv->hw->wiphy),
@@ skipping 16 matching lines @@
 {
         int ret;
         struct mib_phy *m = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
 
         if (!m)
                 return;
 
         ret = at76_get_mib(priv->udev, MIB_PHY, m, sizeof(struct mib_phy));
         if (ret < 0) {
                 wiphy_err(priv->hw->wiphy,
-                          "at76_get_mib (phy) failed: %d\n", ret);
+                          "at76_get_mib (PHY) failed: %d\n", ret);
                 goto exit;
         }
 
         at76_dbg(DBG_MIB, "%s: MIB PHY: ed_threshold %d slot_time %d "
                  "sifs_time %d preamble_length %d plcp_header_length %d "
                  "mpdu_max_length %d cca_mode_supported %d operation_rate_set "
                  "0x%x 0x%x 0x%x 0x%x channel_id %d current_cca_mode %d "
                  "phy_type %d current_reg_domain %d",
                  wiphy_name(priv->hw->wiphy), le32_to_cpu(m->ed_threshold),
                  le16_to_cpu(m->slot_time), le16_to_cpu(m->sifs_time),
@@ skipping 12 matching lines @@
 {
         int ret;
         struct mib_local *m = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
 
         if (!m)
                 return;
 
         ret = at76_get_mib(priv->udev, MIB_LOCAL, m, sizeof(struct mib_local));
         if (ret < 0) {
                 wiphy_err(priv->hw->wiphy,
-                          "at76_get_mib (local) failed: %d\n", ret);
+                          "at76_get_mib (LOCAL) failed: %d\n", ret);
                 goto exit;
         }
 
         at76_dbg(DBG_MIB, "%s: MIB LOCAL: beacon_enable %d "
                  "txautorate_fallback %d ssid_size %d promiscuous_mode %d "
                  "preamble_type %d", wiphy_name(priv->hw->wiphy),
                  m->beacon_enable,
                  m->txautorate_fallback, m->ssid_size, m->promiscuous_mode,
                  m->preamble_type);
 exit:
         kfree(m);
 }
 
 static void at76_dump_mib_mdomain(struct at76_priv *priv)
 {
         int ret;
         struct mib_mdomain *m = kmalloc(sizeof(struct mib_mdomain), GFP_KERNEL);
 
         if (!m)
                 return;
 
         ret = at76_get_mib(priv->udev, MIB_MDOMAIN, m,
                            sizeof(struct mib_mdomain));
         if (ret < 0) {
                 wiphy_err(priv->hw->wiphy,
-                          "at76_get_mib (mdomain) failed: %d\n", ret);
+                          "at76_get_mib (MDOMAIN) failed: %d\n", ret);
                 goto exit;
         }
 
         at76_dbg(DBG_MIB, "%s: MIB MDOMAIN: channel_list %s",
                  wiphy_name(priv->hw->wiphy),
                  hex2str(m->channel_list, sizeof(m->channel_list)));
 
         at76_dbg(DBG_MIB, "%s: MIB MDOMAIN: tx_powerlevel %s",
                  wiphy_name(priv->hw->wiphy),
                  hex2str(m->tx_powerlevel, sizeof(m->tx_powerlevel)));
@@ skipping 50 matching lines @@
         tasklet_schedule(&priv->rx_tasklet);
 }
 
 static int at76_submit_rx_urb(struct at76_priv *priv)
 {
         int ret;
         int size;
         struct sk_buff *skb = priv->rx_skb;
 
         if (!priv->rx_urb) {
-                wiphy_err(priv->hw->wiphy, "%s: priv->rx_urb is null\n",
+                wiphy_err(priv->hw->wiphy, "%s: priv->rx_urb is NULL\n",
                           __func__);
                 return -EFAULT;
         }
 
         if (!skb) {
                 skb = dev_alloc_skb(sizeof(struct at76_rx_buffer));
                 if (!skb) {
                         wiphy_err(priv->hw->wiphy,
                                   "cannot allocate rx skbuff\n");
                         ret = -ENOMEM;
@@ skipping 542 matching lines @@
         /* send stuff */
         at76_dbg_dump(DBG_TX_DATA_CONTENT, tx_buffer, submit_len,
                       "%s(): tx_buffer %d bytes:", __func__, submit_len);
         usb_fill_bulk_urb(priv->tx_urb, priv->udev, priv->tx_pipe, tx_buffer,
                           submit_len, at76_mac80211_tx_callback, priv);
         ret = usb_submit_urb(priv->tx_urb, GFP_ATOMIC);
         if (ret) {
                 wiphy_err(priv->hw->wiphy, "error in tx submit urb: %d\n", ret);
                 if (ret == -EINVAL)
                         wiphy_err(priv->hw->wiphy,
-                                  "-einval: tx urb %p hcpriv %p complete %p\n",
+                                  "-EINVAL: tx urb %p hcpriv %p complete %p\n",
                                   priv->tx_urb,
                                   priv->tx_urb->hcpriv, priv->tx_urb->complete);
         }
 
         return 0;
 }
 
 static int at76_mac80211_start(struct ieee80211_hw *hw)
 {
         struct at76_priv *priv = hw->priv;
@@ skipping 497 matching lines @@
 
         ret = ieee80211_register_hw(priv->hw);
         if (ret) {
                 printk(KERN_ERR "cannot register mac80211 hw (status %d)!\n",
                        ret);
                 goto exit;
         }
 
         priv->mac80211_registered = 1;
 
-        wiphy_info(priv->hw->wiphy, "usb %s, mac %pm, firmware %d.%d.%d-%d\n",
+        wiphy_info(priv->hw->wiphy, "USB %s, MAC %pM, firmware %d.%d.%d-%d\n",
                    dev_name(&interface->dev), priv->mac_addr,
                    priv->fw_version.major, priv->fw_version.minor,
                    priv->fw_version.patch, priv->fw_version.build);
         wiphy_info(priv->hw->wiphy, "regulatory domain 0x%02x: %s\n",
                    priv->regulatory_domain, priv->domain->name);
 
 exit:
         return ret;
 }
 
@@ skipping 207 matching lines @@
 MODULE_AUTHOR("Joerg Albert <joerg.albert@gmx.de>");
 MODULE_AUTHOR("Alex <alex@foogod.com>");
 MODULE_AUTHOR("Nick Jones");
 MODULE_AUTHOR("Balint Seeber <n0_5p4m_p13453@hotmail.com>");
 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>");
 MODULE_AUTHOR("Guido Guenther <agx@sigxcpu.org>");
 MODULE_AUTHOR("Kalle Valo <kalle.valo@iki.fi>");
 MODULE_AUTHOR("Sebastian Smolorz <sesmo@gmx.net>");
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");