| /* |
| * This file is part of hci_h4p bluetooth driver |
| * |
| * Copyright (C) 2005, 2006 Nokia Corporation. |
| * |
| * Contact: Ville Tervo <ville.tervo@nokia.com> |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
| * 02110-1301 USA |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/skbuff.h> |
| #include <linux/firmware.h> |
| #include <linux/clk.h> |
| |
| #include <net/bluetooth/bluetooth.h> |
| |
| #include "hci_h4p.h" |
| |
| #define FW_NAME_TI1271_PRELE "ti1273_prele.bin" |
| #define FW_NAME_TI1271_LE "ti1273_le.bin" |
| #define FW_NAME_TI1271 "ti1273.bin" |
| #define FW_NAME_BCM2048 "bcmfw.bin" |
| #define FW_NAME_CSR "bc4fw.bin" |
| |
| static int fw_pos; |
| |
| /* Firmware handling */ |
| static int hci_h4p_open_firmware(struct hci_h4p_info *info, |
| const struct firmware **fw_entry) |
| { |
| int err; |
| |
| fw_pos = 0; |
| BT_DBG("Opening firmware man_id 0x%.2x ver_id 0x%.2x", |
| info->man_id, info->ver_id); |
| switch (info->man_id) { |
| case H4P_ID_TI1271: |
| switch (info->ver_id) { |
| case 0xe1: |
| err = request_firmware(fw_entry, FW_NAME_TI1271_PRELE, |
| info->dev); |
| break; |
| case 0xd1: |
| case 0xf1: |
| err = request_firmware(fw_entry, FW_NAME_TI1271_LE, |
| info->dev); |
| break; |
| default: |
| err = request_firmware(fw_entry, FW_NAME_TI1271, |
| info->dev); |
| } |
| break; |
| case H4P_ID_CSR: |
| err = request_firmware(fw_entry, FW_NAME_CSR, info->dev); |
| break; |
| case H4P_ID_BCM2048: |
| err = request_firmware(fw_entry, FW_NAME_BCM2048, info->dev); |
| break; |
| default: |
| dev_err(info->dev, "Invalid chip type\n"); |
| *fw_entry = NULL; |
| err = -EINVAL; |
| } |
| |
| return err; |
| } |
| |
| static void hci_h4p_close_firmware(const struct firmware *fw_entry) |
| { |
| release_firmware(fw_entry); |
| } |
| |
| /* Read fw. Return length of the command. If no more commands in |
| * fw 0 is returned. In error case return value is negative. |
| */ |
| static int hci_h4p_read_fw_cmd(struct hci_h4p_info *info, struct sk_buff **skb, |
| const struct firmware *fw_entry, gfp_t how) |
| { |
| unsigned int cmd_len; |
| |
| if (fw_pos >= fw_entry->size) |
| return 0; |
| |
| if (fw_pos + 2 > fw_entry->size) { |
| dev_err(info->dev, "Corrupted firmware image 1\n"); |
| return -EMSGSIZE; |
| } |
| |
| cmd_len = fw_entry->data[fw_pos++]; |
| cmd_len += fw_entry->data[fw_pos++] << 8; |
| if (cmd_len == 0) |
| return 0; |
| |
| if (fw_pos + cmd_len > fw_entry->size) { |
| dev_err(info->dev, "Corrupted firmware image 2\n"); |
| return -EMSGSIZE; |
| } |
| |
| *skb = bt_skb_alloc(cmd_len, how); |
| if (!*skb) { |
| dev_err(info->dev, "Cannot reserve memory for buffer\n"); |
| return -ENOMEM; |
| } |
| memcpy(skb_put(*skb, cmd_len), &fw_entry->data[fw_pos], cmd_len); |
| |
| fw_pos += cmd_len; |
| |
| return (*skb)->len; |
| } |
| |
| int hci_h4p_read_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue) |
| { |
| const struct firmware *fw_entry = NULL; |
| struct sk_buff *skb = NULL; |
| int err; |
| |
| err = hci_h4p_open_firmware(info, &fw_entry); |
| if (err < 0 || !fw_entry) |
| goto err_clean; |
| |
| while ((err = hci_h4p_read_fw_cmd(info, &skb, fw_entry, GFP_KERNEL))) { |
| if (err < 0 || !skb) |
| goto err_clean; |
| |
| skb_queue_tail(fw_queue, skb); |
| } |
| |
| /* Chip detection code does neg and alive stuff |
| * discard two first skbs */ |
| skb = skb_dequeue(fw_queue); |
| if (!skb) { |
| err = -EMSGSIZE; |
| goto err_clean; |
| } |
| kfree_skb(skb); |
| skb = skb_dequeue(fw_queue); |
| if (!skb) { |
| err = -EMSGSIZE; |
| goto err_clean; |
| } |
| kfree_skb(skb); |
| |
| err_clean: |
| hci_h4p_close_firmware(fw_entry); |
| return err; |
| } |
| |
| int hci_h4p_send_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue) |
| { |
| int err; |
| |
| switch (info->man_id) { |
| case H4P_ID_CSR: |
| err = hci_h4p_bc4_send_fw(info, fw_queue); |
| break; |
| case H4P_ID_TI1271: |
| err = hci_h4p_ti1273_send_fw(info, fw_queue); |
| break; |
| case H4P_ID_BCM2048: |
| err = hci_h4p_bcm_send_fw(info, fw_queue); |
| break; |
| default: |
| dev_err(info->dev, "Don't know how to send firmware\n"); |
| err = -EINVAL; |
| } |
| |
| return err; |
| } |
| |
| void hci_h4p_parse_fw_event(struct hci_h4p_info *info, struct sk_buff *skb) |
| { |
| switch (info->man_id) { |
| case H4P_ID_CSR: |
| hci_h4p_bc4_parse_fw_event(info, skb); |
| break; |
| case H4P_ID_TI1271: |
| hci_h4p_ti1273_parse_fw_event(info, skb); |
| break; |
| case H4P_ID_BCM2048: |
| hci_h4p_bcm_parse_fw_event(info, skb); |
| break; |
| default: |
| dev_err(info->dev, "Don't know how to parse fw event\n"); |
| info->fw_error = -EINVAL; |
| } |
| |
| return; |
| } |
| |
| MODULE_FIRMWARE(FW_NAME_TI1271_PRELE); |
| MODULE_FIRMWARE(FW_NAME_TI1271_LE); |
| MODULE_FIRMWARE(FW_NAME_TI1271); |
| MODULE_FIRMWARE(FW_NAME_BCM2048); |
| MODULE_FIRMWARE(FW_NAME_CSR); |