drivers/staging/nokia_h4p/nokia_fw.c

   1 /*
   2  * This file is part of hci_h4p bluetooth driver
   3  *
   4  * Copyright (C) 2005, 2006 Nokia Corporation.
   5  *
   6  * Contact: Ville Tervo <ville.tervo@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/skbuff.h>
  26 #include <linux/firmware.h>
  27 #include <linux/clk.h>
  28
  29 #include <net/bluetooth/bluetooth.h>
  30
  31 #include "hci_h4p.h"
  32
  33 #define FW_NAME_TI1271_PRELE    "ti1273_prele.bin"
  34 #define FW_NAME_TI1271_LE       "ti1273_le.bin"
  35 #define FW_NAME_TI1271          "ti1273.bin"
  36 #define FW_NAME_BCM2048         "bcmfw.bin"
  37 #define FW_NAME_CSR             "bc4fw.bin"
  38
  39 static int fw_pos;
  40
  41 /* Firmware handling */
  42 static int hci_h4p_open_firmware(struct hci_h4p_info *info,
  43                                  const struct firmware **fw_entry)
  44 {
  45         int err;
  46
  47         fw_pos = 0;
  48         BT_DBG("Opening firmware man_id 0x%.2x ver_id 0x%.2x",
  49                         info->man_id, info->ver_id);
  50         switch (info->man_id) {
  51         case H4P_ID_TI1271:
  52                 switch (info->ver_id) {
  53                 case 0xe1:
  54                         err = request_firmware(fw_entry, FW_NAME_TI1271_PRELE,
  55                                                 info->dev);
  56                         break;
  57                 case 0xd1:
  58                 case 0xf1:
  59                         err = request_firmware(fw_entry, FW_NAME_TI1271_LE,
  60                                                 info->dev);
  61                         break;
  62                 default:
  63                         err = request_firmware(fw_entry, FW_NAME_TI1271,
  64                                                 info->dev);
  65                 }
  66                 break;
  67         case H4P_ID_CSR:
  68                 err = request_firmware(fw_entry, FW_NAME_CSR, info->dev);
  69                 break;
  70         case H4P_ID_BCM2048:
  71                 err = request_firmware(fw_entry, FW_NAME_BCM2048, info->dev);
  72                 break;
  73         default:
  74                 dev_err(info->dev, "Invalid chip type\n");
  75                 *fw_entry = NULL;
  76                 err = -EINVAL;
  77         }
  78
  79         return err;
  80 }
  81
  82 static void hci_h4p_close_firmware(const struct firmware *fw_entry)
  83 {
  84         release_firmware(fw_entry);
  85 }
  86
  87 /* Read fw. Return length of the command. If no more commands in
  88  * fw 0 is returned. In error case return value is negative.
  89  */
  90 static int hci_h4p_read_fw_cmd(struct hci_h4p_info *info, struct sk_buff **skb,
  91                                const struct firmware *fw_entry, gfp_t how)
  92 {
  93         unsigned int cmd_len;
  94
  95         if (fw_pos >= fw_entry->size)
  96                 return 0;
  97
  98         if (fw_pos + 2 > fw_entry->size) {
  99                 dev_err(info->dev, "Corrupted firmware image 1\n");
 100                 return -EMSGSIZE;
 101         }
 102
 103         cmd_len = fw_entry->data[fw_pos++];
 104         cmd_len += fw_entry->data[fw_pos++] << 8;
 105         if (cmd_len == 0)
 106                 return 0;
 107
 108         if (fw_pos + cmd_len > fw_entry->size) {
 109                 dev_err(info->dev, "Corrupted firmware image 2\n");
 110                 return -EMSGSIZE;
 111         }
 112
 113         *skb = bt_skb_alloc(cmd_len, how);
 114         if (!*skb) {
 115                 dev_err(info->dev, "Cannot reserve memory for buffer\n");
 116                 return -ENOMEM;
 117         }
 118         memcpy(skb_put(*skb, cmd_len), &fw_entry->data[fw_pos], cmd_len);
 119
 120         fw_pos += cmd_len;
 121
 122         return (*skb)->len;
 123 }
 124
 125 int hci_h4p_read_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue)
 126 {
 127         const struct firmware *fw_entry = NULL;
 128         struct sk_buff *skb = NULL;
 129         int err;
 130
 131         err = hci_h4p_open_firmware(info, &fw_entry);
 132         if (err < 0 || !fw_entry)
 133                 goto err_clean;
 134
 135         while ((err = hci_h4p_read_fw_cmd(info, &skb, fw_entry, GFP_KERNEL))) {
 136                 if (err < 0 || !skb)
 137                         goto err_clean;
 138
 139                 skb_queue_tail(fw_queue, skb);
 140         }
 141
 142         /* Chip detection code does neg and alive stuff
 143          * discard two first skbs */
 144         skb = skb_dequeue(fw_queue);
 145         if (!skb) {
 146                 err = -EMSGSIZE;
 147                 goto err_clean;
 148         }
 149         kfree_skb(skb);
 150         skb = skb_dequeue(fw_queue);
 151         if (!skb) {
 152                 err = -EMSGSIZE;
 153                 goto err_clean;
 154         }
 155         kfree_skb(skb);
 156
 157 err_clean:
 158         hci_h4p_close_firmware(fw_entry);
 159         return err;
 160 }
 161
 162 int hci_h4p_send_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue)
 163 {
 164         int err;
 165
 166         switch (info->man_id) {
 167         case H4P_ID_CSR:
 168                 err = hci_h4p_bc4_send_fw(info, fw_queue);
 169                 break;
 170         case H4P_ID_TI1271:
 171                 err = hci_h4p_ti1273_send_fw(info, fw_queue);
 172                 break;
 173         case H4P_ID_BCM2048:
 174                 err = hci_h4p_bcm_send_fw(info, fw_queue);
 175                 break;
 176         default:
 177                 dev_err(info->dev, "Don't know how to send firmware\n");
 178                 err = -EINVAL;
 179         }
 180
 181         return err;
 182 }
 183
 184 void hci_h4p_parse_fw_event(struct hci_h4p_info *info, struct sk_buff *skb)
 185 {
 186         switch (info->man_id) {
 187         case H4P_ID_CSR:
 188                 hci_h4p_bc4_parse_fw_event(info, skb);
 189                 break;
 190         case H4P_ID_TI1271:
 191                 hci_h4p_ti1273_parse_fw_event(info, skb);
 192                 break;
 193         case H4P_ID_BCM2048:
 194                 hci_h4p_bcm_parse_fw_event(info, skb);
 195                 break;
 196         default:
 197                 dev_err(info->dev, "Don't know how to parse fw event\n");
 198                 info->fw_error = -EINVAL;
 199         }
 200
 201         return;
 202 }
 203
 204 MODULE_FIRMWARE(FW_NAME_TI1271_PRELE);
 205 MODULE_FIRMWARE(FW_NAME_TI1271_LE);
 206 MODULE_FIRMWARE(FW_NAME_TI1271);
 207 MODULE_FIRMWARE(FW_NAME_BCM2048);
 208 MODULE_FIRMWARE(FW_NAME_CSR);