Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/drivers/bluetooth/btusb.c

 /*
  *
  *  Generic Bluetooth USB driver
  *
  *  Copyright (C) 2005-2008  Marcel Holtmann <marcel@holtmann.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
@@ skipping 16 matching lines @@
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/skbuff.h>
 
 #include <linux/usb.h>
 
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>
+#include "fwload.h"
 
 #define VERSION "0.6"
 
 static int ignore_dga;
 static int ignore_csr;
 static int ignore_sniffer;
 static int disable_scofix;
 static int force_scofix;
 
 static int reset = 1;
 
 static struct usb_driver btusb_driver;
 
 #define BTUSB_IGNORE            0x01
 #define BTUSB_DIGIANSWER        0x02
 #define BTUSB_CSR               0x04
 #define BTUSB_SNIFFER           0x08
 #define BTUSB_BCM92035          0x10
 #define BTUSB_BROKEN_ISOC       0x20
 #define BTUSB_WRONG_SCO_MTU     0x40
 
+static struct usb_device_id ath_table[] = {
+        /* Atheros AR3011 */
+        { USB_DEVICE(0x0CF3, 0x3002) },
+        { USB_DEVICE(0x13D3, 0x3304) },
+        { }     /* Terminating entry */
+};
+
+/* Add firmware file, load and unload function
+ * to download the firmware to target RAM
+ */
+static struct fw_cb_config btusb_fwcbs[] = {
+        {
+                .fwfile = "ath3k-1.fw",
+                .usb_id_table = ath_table,
+                .fwload = ath_fw_load,
+                .fwunload = ath_fw_unload
+        },
+        {}
+};
+
 static struct usb_device_id btusb_table[] = {
         /* Generic Bluetooth USB device */
         { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
 
         /* Apple iMac11,1 */
         { USB_DEVICE(0x05ac, 0x8215) },
 
         /* AVM BlueFRITZ! USB v2.0 */
         { USB_DEVICE(0x057c, 0x3800) },
 
@@ skipping 788 matching lines @@
         usb_autopm_put_interface(data->intf);
 }
 
 static int btusb_probe(struct usb_interface *intf,
                                 const struct usb_device_id *id)
 {
         struct usb_endpoint_descriptor *ep_desc;
         struct btusb_data *data;
         struct hci_dev *hdev;
         int i, err;
+        const struct usb_device_id *match;
 
         BT_DBG("intf %p id %p", intf, id);
 
         /* interface numbers are hardcoded in the spec */
         if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
                 return -ENODEV;
 
         if (!id->driver_info) {
                 const struct usb_device_id *match;
                 match = usb_match_id(intf, blacklist_table);
@@ skipping 39 matching lines @@
         if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {
                 kfree(data);
                 return -ENODEV;
         }
 
         data->cmdreq_type = USB_TYPE_CLASS;
 
         data->udev = interface_to_usbdev(intf);
         data->intf = intf;
 
+        for (i = 0; btusb_fwcbs[i].fwfile; i++) {
+                match = usb_match_id(intf, btusb_fwcbs[i].usb_id_table);
+                if (match) {
+                        if (btusb_fwcbs[i].fwload) {
+                                btusb_fwcbs[i].data =
+                                        btusb_fwcbs[i].fwload(intf,
+                                                btusb_fwcbs[i].fwfile,
+                                                &btusb_fwcbs[i].bsuspend);
+                        }
+                        break;
+                }
+        }
+
         spin_lock_init(&data->lock);
 
         INIT_WORK(&data->work, btusb_work);
         INIT_WORK(&data->waker, btusb_waker);
         spin_lock_init(&data->txlock);
 
         init_usb_anchor(&data->tx_anchor);
         init_usb_anchor(&data->intr_anchor);
         init_usb_anchor(&data->bulk_anchor);
         init_usb_anchor(&data->isoc_anchor);
@@ skipping 88 matching lines @@
 
         usb_set_intfdata(intf, data);
 
         return 0;
 }
 
 static void btusb_disconnect(struct usb_interface *intf)
 {
         struct btusb_data *data = usb_get_intfdata(intf);
         struct hci_dev *hdev;
+        const struct usb_device_id *match;
+        int i;
 
         BT_DBG("intf %p", intf);
 
         if (!data)
                 return;
 
+        for (i = 0; btusb_fwcbs[i].fwfile; i++) {
+                match = usb_match_id(intf, btusb_fwcbs[i].usb_id_table);
+                if (match) {
+                        if (btusb_fwcbs[i].fwunload) {
+                                btusb_fwcbs[i].fwunload(btusb_fwcbs[i].data,
+                                                btusb_fwcbs[i].bsuspend);
+                                btusb_fwcbs[i].data = NULL;
+                        }
+                        break;
+                }
+        }
+
         hdev = data->hdev;
 
         __hci_dev_hold(hdev);
 
         usb_set_intfdata(data->intf, NULL);
 
         if (data->isoc)
                 usb_set_intfdata(data->isoc, NULL);
 
         hci_unregister_dev(hdev);
 
         if (intf == data->isoc)
                 usb_driver_release_interface(&btusb_driver, data->intf);
         else if (data->isoc)
                 usb_driver_release_interface(&btusb_driver, data->isoc);
 
         __hci_dev_put(hdev);
 
         hci_free_dev(hdev);
 }
 
 #ifdef CONFIG_PM
 static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct btusb_data *data = usb_get_intfdata(intf);
+        const struct usb_device_id *match;
+        int i;
 
         BT_DBG("intf %p", intf);
 
         if (data->suspend_count++)
                 return 0;
 
+        for (i = 0; btusb_fwcbs[i].fwfile; i++) {
+                match = usb_match_id(intf, btusb_fwcbs[i].usb_id_table);
+                if (match) {
+                        btusb_fwcbs[i].bsuspend = 1;
+                        break;
+                }
+        }
+
         spin_lock_irq(&data->txlock);
         if (!((message.event & PM_EVENT_AUTO) && data->tx_in_flight)) {
                 set_bit(BTUSB_SUSPENDING, &data->flags);
                 spin_unlock_irq(&data->txlock);
         } else {
                 spin_unlock_irq(&data->txlock);
                 data->suspend_count--;
                 return -EBUSY;
         }
 
@@ skipping 92 matching lines @@
 
 static int __init btusb_init(void)
 {
         BT_INFO("Generic Bluetooth USB driver ver %s", VERSION);
 
         return usb_register(&btusb_driver);
 }
 
 static void __exit btusb_exit(void)
 {
+        int i;
+        for (i = 0; btusb_fwcbs[i].fwfile; i++) {
+                if (btusb_fwcbs[i].fwunload && btusb_fwcbs[i].data) {
+                        btusb_fwcbs[i].fwunload(btusb_fwcbs[i].data,
+                                        btusb_fwcbs[i].bsuspend);
+                        btusb_fwcbs[i].data = NULL;
+                }
+        }
         usb_deregister(&btusb_driver);
 }
 
 module_init(btusb_init);
 module_exit(btusb_exit);
 
 module_param(ignore_dga, bool, 0644);
 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
 
 module_param(ignore_csr, bool, 0644);
 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
 
 module_param(ignore_sniffer, bool, 0644);
 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
 
 module_param(disable_scofix, bool, 0644);
 MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
 
 module_param(force_scofix, bool, 0644);
 MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
 
 module_param(reset, bool, 0644);
 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
 
 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
 MODULE_VERSION(VERSION);
 MODULE_LICENSE("GPL");