]>
Commit | Line | Data |
---|---|---|
83e81961 BYTK |
1 | /* |
2 | * Bluetooth supports for Qualcomm Atheros chips | |
3 | * | |
4 | * Copyright (c) 2015 The Linux Foundation. All rights reserved. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 | |
8 | * as published by the Free Software Foundation | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 | * | |
19 | */ | |
20 | #include <linux/module.h> | |
21 | #include <linux/firmware.h> | |
22 | ||
23 | #include <net/bluetooth/bluetooth.h> | |
24 | #include <net/bluetooth/hci_core.h> | |
25 | ||
26 | #include "btqca.h" | |
27 | ||
28 | #define VERSION "0.1" | |
29 | ||
30 | static int rome_patch_ver_req(struct hci_dev *hdev, u32 *rome_version) | |
31 | { | |
32 | struct sk_buff *skb; | |
33 | struct edl_event_hdr *edl; | |
34 | struct rome_version *ver; | |
35 | char cmd; | |
36 | int err = 0; | |
37 | ||
38 | BT_DBG("%s: ROME Patch Version Request", hdev->name); | |
39 | ||
40 | cmd = EDL_PATCH_VER_REQ_CMD; | |
41 | skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, EDL_PATCH_CMD_LEN, | |
42 | &cmd, HCI_VENDOR_PKT, HCI_INIT_TIMEOUT); | |
43 | if (IS_ERR(skb)) { | |
44 | err = PTR_ERR(skb); | |
45 | BT_ERR("%s: Failed to read version of ROME (%d)", hdev->name, | |
46 | err); | |
47 | return err; | |
48 | } | |
49 | ||
50 | if (skb->len != sizeof(*edl) + sizeof(*ver)) { | |
51 | BT_ERR("%s: Version size mismatch len %d", hdev->name, | |
52 | skb->len); | |
53 | err = -EILSEQ; | |
54 | goto out; | |
55 | } | |
56 | ||
57 | edl = (struct edl_event_hdr *)(skb->data); | |
0676cab4 CIK |
58 | if (!edl) { |
59 | BT_ERR("%s: TLV with no header", hdev->name); | |
83e81961 BYTK |
60 | err = -EILSEQ; |
61 | goto out; | |
62 | } | |
63 | ||
64 | if (edl->cresp != EDL_CMD_REQ_RES_EVT || | |
65 | edl->rtype != EDL_APP_VER_RES_EVT) { | |
66 | BT_ERR("%s: Wrong packet received %d %d", hdev->name, | |
67 | edl->cresp, edl->rtype); | |
68 | err = -EIO; | |
69 | goto out; | |
70 | } | |
71 | ||
72 | ver = (struct rome_version *)(edl->data); | |
73 | ||
74 | BT_DBG("%s: Product:0x%08x", hdev->name, le32_to_cpu(ver->product_id)); | |
75 | BT_DBG("%s: Patch :0x%08x", hdev->name, le16_to_cpu(ver->patch_ver)); | |
76 | BT_DBG("%s: ROM :0x%08x", hdev->name, le16_to_cpu(ver->rome_ver)); | |
77 | BT_DBG("%s: SOC :0x%08x", hdev->name, le32_to_cpu(ver->soc_id)); | |
78 | ||
79 | /* ROME chipset version can be decided by patch and SoC | |
80 | * version, combination with upper 2 bytes from SoC | |
81 | * and lower 2 bytes from patch will be used. | |
82 | */ | |
83 | *rome_version = (le32_to_cpu(ver->soc_id) << 16) | | |
2193a980 | 84 | (le16_to_cpu(ver->rome_ver) & 0x0000ffff); |
83e81961 BYTK |
85 | |
86 | out: | |
87 | kfree_skb(skb); | |
88 | ||
89 | return err; | |
90 | } | |
91 | ||
92 | static int rome_reset(struct hci_dev *hdev) | |
93 | { | |
94 | struct sk_buff *skb; | |
95 | int err; | |
96 | ||
97 | BT_DBG("%s: ROME HCI_RESET", hdev->name); | |
98 | ||
99 | skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT); | |
100 | if (IS_ERR(skb)) { | |
101 | err = PTR_ERR(skb); | |
102 | BT_ERR("%s: Reset failed (%d)", hdev->name, err); | |
103 | return err; | |
104 | } | |
105 | ||
106 | kfree_skb(skb); | |
107 | ||
108 | return 0; | |
109 | } | |
110 | ||
111 | static void rome_tlv_check_data(struct rome_config *config, | |
112 | const struct firmware *fw) | |
113 | { | |
114 | const u8 *data; | |
115 | u32 type_len; | |
116 | u16 tag_id, tag_len; | |
117 | int idx, length; | |
118 | struct tlv_type_hdr *tlv; | |
119 | struct tlv_type_patch *tlv_patch; | |
120 | struct tlv_type_nvm *tlv_nvm; | |
121 | ||
122 | tlv = (struct tlv_type_hdr *)fw->data; | |
123 | ||
124 | type_len = le32_to_cpu(tlv->type_len); | |
125 | length = (type_len >> 8) & 0x00ffffff; | |
126 | ||
127 | BT_DBG("TLV Type\t\t : 0x%x", type_len & 0x000000ff); | |
128 | BT_DBG("Length\t\t : %d bytes", length); | |
129 | ||
6e03126a LP |
130 | config->dnld_mode = ROME_SKIP_EVT_NONE; |
131 | ||
83e81961 BYTK |
132 | switch (config->type) { |
133 | case TLV_TYPE_PATCH: | |
134 | tlv_patch = (struct tlv_type_patch *)tlv->data; | |
6e03126a LP |
135 | |
136 | /* For Rome version 1.1 to 3.1, all segment commands | |
137 | * are acked by a vendor specific event (VSE). | |
138 | * For Rome >= 3.2, the download mode field indicates | |
139 | * if VSE is skipped by the controller. | |
140 | * In case VSE is skipped, only the last segment is acked. | |
141 | */ | |
142 | config->dnld_mode = tlv_patch->download_mode; | |
143 | ||
144 | BT_DBG("Total Length : %d bytes", | |
83e81961 | 145 | le32_to_cpu(tlv_patch->total_size)); |
6e03126a | 146 | BT_DBG("Patch Data Length : %d bytes", |
83e81961 BYTK |
147 | le32_to_cpu(tlv_patch->data_length)); |
148 | BT_DBG("Signing Format Version : 0x%x", | |
149 | tlv_patch->format_version); | |
6e03126a | 150 | BT_DBG("Signature Algorithm : 0x%x", |
83e81961 | 151 | tlv_patch->signature); |
6e03126a LP |
152 | BT_DBG("Download mode : 0x%x", |
153 | tlv_patch->download_mode); | |
154 | BT_DBG("Reserved : 0x%x", | |
155 | tlv_patch->reserved1); | |
156 | BT_DBG("Product ID : 0x%04x", | |
83e81961 | 157 | le16_to_cpu(tlv_patch->product_id)); |
6e03126a | 158 | BT_DBG("Rom Build Version : 0x%04x", |
83e81961 | 159 | le16_to_cpu(tlv_patch->rom_build)); |
6e03126a | 160 | BT_DBG("Patch Version : 0x%04x", |
83e81961 | 161 | le16_to_cpu(tlv_patch->patch_version)); |
6e03126a | 162 | BT_DBG("Reserved : 0x%x", |
83e81961 | 163 | le16_to_cpu(tlv_patch->reserved2)); |
6e03126a | 164 | BT_DBG("Patch Entry Address : 0x%x", |
83e81961 BYTK |
165 | le32_to_cpu(tlv_patch->entry)); |
166 | break; | |
167 | ||
168 | case TLV_TYPE_NVM: | |
169 | idx = 0; | |
170 | data = tlv->data; | |
171 | while (idx < length) { | |
172 | tlv_nvm = (struct tlv_type_nvm *)(data + idx); | |
173 | ||
174 | tag_id = le16_to_cpu(tlv_nvm->tag_id); | |
175 | tag_len = le16_to_cpu(tlv_nvm->tag_len); | |
176 | ||
177 | /* Update NVM tags as needed */ | |
178 | switch (tag_id) { | |
179 | case EDL_TAG_ID_HCI: | |
180 | /* HCI transport layer parameters | |
181 | * enabling software inband sleep | |
182 | * onto controller side. | |
183 | */ | |
184 | tlv_nvm->data[0] |= 0x80; | |
185 | ||
186 | /* UART Baud Rate */ | |
187 | tlv_nvm->data[2] = config->user_baud_rate; | |
188 | ||
189 | break; | |
190 | ||
191 | case EDL_TAG_ID_DEEP_SLEEP: | |
192 | /* Sleep enable mask | |
193 | * enabling deep sleep feature on controller. | |
194 | */ | |
195 | tlv_nvm->data[0] |= 0x01; | |
196 | ||
197 | break; | |
198 | } | |
199 | ||
200 | idx += (sizeof(u16) + sizeof(u16) + 8 + tag_len); | |
201 | } | |
202 | break; | |
203 | ||
204 | default: | |
205 | BT_ERR("Unknown TLV type %d", config->type); | |
206 | break; | |
207 | } | |
208 | } | |
209 | ||
6e03126a LP |
210 | static int rome_tlv_send_segment(struct hci_dev *hdev, int seg_size, |
211 | const u8 *data, enum rome_tlv_dnld_mode mode) | |
83e81961 BYTK |
212 | { |
213 | struct sk_buff *skb; | |
214 | struct edl_event_hdr *edl; | |
215 | struct tlv_seg_resp *tlv_resp; | |
216 | u8 cmd[MAX_SIZE_PER_TLV_SEGMENT + 2]; | |
217 | int err = 0; | |
218 | ||
83e81961 BYTK |
219 | cmd[0] = EDL_PATCH_TLV_REQ_CMD; |
220 | cmd[1] = seg_size; | |
221 | memcpy(cmd + 2, data, seg_size); | |
222 | ||
6e03126a LP |
223 | if (mode == ROME_SKIP_EVT_VSE_CC || mode == ROME_SKIP_EVT_VSE) |
224 | return __hci_cmd_send(hdev, EDL_PATCH_CMD_OPCODE, seg_size + 2, | |
225 | cmd); | |
226 | ||
83e81961 BYTK |
227 | skb = __hci_cmd_sync_ev(hdev, EDL_PATCH_CMD_OPCODE, seg_size + 2, cmd, |
228 | HCI_VENDOR_PKT, HCI_INIT_TIMEOUT); | |
229 | if (IS_ERR(skb)) { | |
230 | err = PTR_ERR(skb); | |
231 | BT_ERR("%s: Failed to send TLV segment (%d)", hdev->name, err); | |
232 | return err; | |
233 | } | |
234 | ||
235 | if (skb->len != sizeof(*edl) + sizeof(*tlv_resp)) { | |
236 | BT_ERR("%s: TLV response size mismatch", hdev->name); | |
237 | err = -EILSEQ; | |
238 | goto out; | |
239 | } | |
240 | ||
241 | edl = (struct edl_event_hdr *)(skb->data); | |
0676cab4 CIK |
242 | if (!edl) { |
243 | BT_ERR("%s: TLV with no header", hdev->name); | |
83e81961 BYTK |
244 | err = -EILSEQ; |
245 | goto out; | |
246 | } | |
247 | ||
248 | tlv_resp = (struct tlv_seg_resp *)(edl->data); | |
249 | ||
250 | if (edl->cresp != EDL_CMD_REQ_RES_EVT || | |
251 | edl->rtype != EDL_TVL_DNLD_RES_EVT || tlv_resp->result != 0x00) { | |
252 | BT_ERR("%s: TLV with error stat 0x%x rtype 0x%x (0x%x)", | |
253 | hdev->name, edl->cresp, edl->rtype, tlv_resp->result); | |
254 | err = -EIO; | |
255 | } | |
256 | ||
257 | out: | |
258 | kfree_skb(skb); | |
259 | ||
260 | return err; | |
261 | } | |
262 | ||
83e81961 BYTK |
263 | static int rome_download_firmware(struct hci_dev *hdev, |
264 | struct rome_config *config) | |
265 | { | |
266 | const struct firmware *fw; | |
6e03126a LP |
267 | const u8 *segment; |
268 | int ret, remain, i = 0; | |
83e81961 | 269 | |
2064ee33 | 270 | bt_dev_info(hdev, "ROME Downloading %s", config->fwname); |
83e81961 BYTK |
271 | |
272 | ret = request_firmware(&fw, config->fwname, &hdev->dev); | |
273 | if (ret) { | |
274 | BT_ERR("%s: Failed to request file: %s (%d)", hdev->name, | |
275 | config->fwname, ret); | |
276 | return ret; | |
277 | } | |
278 | ||
279 | rome_tlv_check_data(config, fw); | |
280 | ||
6e03126a LP |
281 | segment = fw->data; |
282 | remain = fw->size; | |
283 | while (remain > 0) { | |
284 | int segsize = min(MAX_SIZE_PER_TLV_SEGMENT, remain); | |
285 | ||
286 | bt_dev_dbg(hdev, "Send segment %d, size %d", i++, segsize); | |
287 | ||
288 | remain -= segsize; | |
289 | /* The last segment is always acked regardless download mode */ | |
290 | if (!remain || segsize < MAX_SIZE_PER_TLV_SEGMENT) | |
291 | config->dnld_mode = ROME_SKIP_EVT_NONE; | |
292 | ||
293 | ret = rome_tlv_send_segment(hdev, segsize, segment, | |
294 | config->dnld_mode); | |
295 | if (ret) | |
296 | break; | |
297 | ||
298 | segment += segsize; | |
83e81961 BYTK |
299 | } |
300 | ||
301 | release_firmware(fw); | |
302 | ||
303 | return ret; | |
304 | } | |
305 | ||
306 | int qca_set_bdaddr_rome(struct hci_dev *hdev, const bdaddr_t *bdaddr) | |
307 | { | |
308 | struct sk_buff *skb; | |
309 | u8 cmd[9]; | |
310 | int err; | |
311 | ||
312 | cmd[0] = EDL_NVM_ACCESS_SET_REQ_CMD; | |
313 | cmd[1] = 0x02; /* TAG ID */ | |
314 | cmd[2] = sizeof(bdaddr_t); /* size */ | |
315 | memcpy(cmd + 3, bdaddr, sizeof(bdaddr_t)); | |
316 | skb = __hci_cmd_sync_ev(hdev, EDL_NVM_ACCESS_OPCODE, sizeof(cmd), cmd, | |
317 | HCI_VENDOR_PKT, HCI_INIT_TIMEOUT); | |
318 | if (IS_ERR(skb)) { | |
319 | err = PTR_ERR(skb); | |
320 | BT_ERR("%s: Change address command failed (%d)", | |
321 | hdev->name, err); | |
322 | return err; | |
323 | } | |
324 | ||
325 | kfree_skb(skb); | |
326 | ||
327 | return 0; | |
328 | } | |
329 | EXPORT_SYMBOL_GPL(qca_set_bdaddr_rome); | |
330 | ||
331 | int qca_uart_setup_rome(struct hci_dev *hdev, uint8_t baudrate) | |
332 | { | |
333 | u32 rome_ver = 0; | |
334 | struct rome_config config; | |
335 | int err; | |
336 | ||
337 | BT_DBG("%s: ROME setup on UART", hdev->name); | |
338 | ||
339 | config.user_baud_rate = baudrate; | |
340 | ||
341 | /* Get ROME version information */ | |
342 | err = rome_patch_ver_req(hdev, &rome_ver); | |
343 | if (err < 0 || rome_ver == 0) { | |
344 | BT_ERR("%s: Failed to get version 0x%x", hdev->name, err); | |
345 | return err; | |
346 | } | |
347 | ||
2064ee33 | 348 | bt_dev_info(hdev, "ROME controller version 0x%08x", rome_ver); |
83e81961 BYTK |
349 | |
350 | /* Download rampatch file */ | |
351 | config.type = TLV_TYPE_PATCH; | |
352 | snprintf(config.fwname, sizeof(config.fwname), "qca/rampatch_%08x.bin", | |
353 | rome_ver); | |
354 | err = rome_download_firmware(hdev, &config); | |
355 | if (err < 0) { | |
356 | BT_ERR("%s: Failed to download patch (%d)", hdev->name, err); | |
357 | return err; | |
358 | } | |
359 | ||
360 | /* Download NVM configuration */ | |
361 | config.type = TLV_TYPE_NVM; | |
362 | snprintf(config.fwname, sizeof(config.fwname), "qca/nvm_%08x.bin", | |
363 | rome_ver); | |
364 | err = rome_download_firmware(hdev, &config); | |
365 | if (err < 0) { | |
366 | BT_ERR("%s: Failed to download NVM (%d)", hdev->name, err); | |
367 | return err; | |
368 | } | |
369 | ||
370 | /* Perform HCI reset */ | |
371 | err = rome_reset(hdev); | |
372 | if (err < 0) { | |
373 | BT_ERR("%s: Failed to run HCI_RESET (%d)", hdev->name, err); | |
374 | return err; | |
375 | } | |
376 | ||
2064ee33 | 377 | bt_dev_info(hdev, "ROME setup on UART is completed"); |
83e81961 BYTK |
378 | |
379 | return 0; | |
380 | } | |
381 | EXPORT_SYMBOL_GPL(qca_uart_setup_rome); | |
382 | ||
383 | MODULE_AUTHOR("Ben Young Tae Kim <ytkim@qca.qualcomm.com>"); | |
384 | MODULE_DESCRIPTION("Bluetooth support for Qualcomm Atheros family ver " VERSION); | |
385 | MODULE_VERSION(VERSION); | |
386 | MODULE_LICENSE("GPL"); |