1 /*-
2  * Copyright (c) 2013 Adrian Chadd <adrian@freebsd.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification.
11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
13  *    redistribution must be conditioned upon including a substantially
14  *    similar Disclaimer requirement for further binary redistribution.
15  *
16  * NO WARRANTY
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
20  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
22  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27  * THE POSSIBILITY OF SUCH DAMAGES.
28  */
29 
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <errno.h>
34 #include <string.h>
35 #include <err.h>
36 #include <fcntl.h>
37 #include <sys/endian.h>
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 
41 #include <libusb.h>
42 
43 #include "ath3k_fw.h"
44 #include "ath3k_hw.h"
45 #include "ath3k_dbg.h"
46 
47 #define	XMIN(x, y)	((x) < (y) ? (x) : (y))
48 
49 int
50 ath3k_load_fwfile(struct libusb_device_handle *hdl,
51     const struct ath3k_firmware *fw)
52 {
53 	int size, count, sent = 0;
54 	int ret, r;
55 
56 	count = fw->len;
57 
58 	size = XMIN(count, FW_HDR_SIZE);
59 
60 	ath3k_debug("%s: file=%s, size=%d\n",
61 	    __func__, fw->fwname, count);
62 
63 	/*
64 	 * Flip the device over to configuration mode.
65 	 */
66 	ret = libusb_control_transfer(hdl,
67 	    LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT,
68 	    ATH3K_DNLOAD,
69 	    0,
70 	    0,
71 	    fw->buf + sent,
72 	    size,
73 	    1000);	/* XXX timeout */
74 
75 	if (ret != size) {
76 		fprintf(stderr, "Can't switch to config mode; ret=%d\n",
77 		    ret);
78 		return (-1);
79 	}
80 
81 	sent += size;
82 	count -= size;
83 
84 	/* Load in the rest of the data */
85 	while (count) {
86 		size = XMIN(count, BULK_SIZE);
87 		ath3k_debug("%s: transferring %d bytes, offset %d\n",
88 		    __func__,
89 		    sent,
90 		    size);
91 
92 		ret = libusb_bulk_transfer(hdl,
93 		    0x2,
94 		    fw->buf + sent,
95 		    size,
96 		    &r,
97 		    1000);
98 
99 		if (ret < 0 || r != size) {
100 			fprintf(stderr, "Can't load firmware: err=%s, size=%d\n",
101 			    libusb_strerror(ret),
102 			    size);
103 			return (-1);
104 		}
105 		sent  += size;
106 		count -= size;
107 	}
108 	return (0);
109 }
110 
111 int
112 ath3k_get_state(struct libusb_device_handle *hdl, unsigned char *state)
113 {
114 	int ret;
115 
116 	ret = libusb_control_transfer(hdl,
117 	    LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN,
118 	    ATH3K_GETSTATE,
119 	    0,
120 	    0,
121 	    state,
122 	    1,
123 	    1000);	/* XXX timeout */
124 
125 	if (ret < 0) {
126 		fprintf(stderr,
127 		    "%s: libusb_control_transfer() failed: code=%d\n",
128 		    __func__,
129 		    ret);
130 		return (0);
131 	}
132 
133 	return (ret == 1);
134 }
135 
136 int
137 ath3k_get_version(struct libusb_device_handle *hdl,
138     struct ath3k_version *version)
139 {
140 	int ret;
141 
142 	ret = libusb_control_transfer(hdl,
143 	    LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN,
144 	    ATH3K_GETVERSION,
145 	    0,
146 	    0,
147 	    (unsigned char *) version,
148 	    sizeof(struct ath3k_version),
149 	    1000);	/* XXX timeout */
150 
151 	if (ret < 0) {
152 		fprintf(stderr,
153 		    "%s: libusb_control_transfer() failed: code=%d\n",
154 		    __func__,
155 		    ret);
156 		return (0);
157 	}
158 
159 	/* XXX endian fix! */
160 
161 	return (ret == sizeof(struct ath3k_version));
162 }
163 
164 int
165 ath3k_load_patch(libusb_device_handle *hdl, const char *fw_path)
166 {
167 	int ret;
168 	unsigned char fw_state;
169 	struct ath3k_version fw_ver, pt_ver;
170 	char fwname[FILENAME_MAX];
171 	struct ath3k_firmware fw;
172 	uint32_t tmp;
173 
174 	ret = ath3k_get_state(hdl, &fw_state);
175 	if (ret < 0) {
176 		ath3k_err("%s: Can't get state\n", __func__);
177 		return (ret);
178 	}
179 
180 	if (fw_state & ATH3K_PATCH_UPDATE) {
181 		ath3k_info("%s: Patch already downloaded\n",
182 		    __func__);
183 		return (0);
184 	}
185 
186 	ret = ath3k_get_version(hdl, &fw_ver);
187 	if (ret < 0) {
188 		ath3k_debug("%s: Can't get version\n", __func__);
189 		return (ret);
190 	}
191 
192 	/* XXX path info? */
193 	snprintf(fwname, FILENAME_MAX, "%s/ar3k/AthrBT_0x%08x.dfu",
194 	    fw_path,
195 	    fw_ver.rom_version);
196 
197 	/* Read in the firmware */
198 	if (ath3k_fw_read(&fw, fwname) <= 0) {
199 		ath3k_debug("%s: ath3k_fw_read() failed\n",
200 		    __func__);
201 		return (-1);
202 	}
203 
204 	/*
205 	 * Extract the ROM/build version from the patch file.
206 	 */
207 	memcpy(&tmp, fw.buf + fw.len - 8, sizeof(tmp));
208 	pt_ver.rom_version = le32toh(tmp);
209 	memcpy(&tmp, fw.buf + fw.len - 4, sizeof(tmp));
210 	pt_ver.build_version = le32toh(tmp);
211 
212 	ath3k_info("%s: file %s: rom_ver=%d, build_ver=%d\n",
213 	    __func__,
214 	    fwname,
215 	    (int) pt_ver.rom_version,
216 	    (int) pt_ver.build_version);
217 
218 	/* Check the ROM/build version against the firmware */
219 	if ((pt_ver.rom_version != fw_ver.rom_version) ||
220 	    (pt_ver.build_version <= fw_ver.build_version)) {
221 		ath3k_debug("Patch file version mismatch!\n");
222 		ath3k_fw_free(&fw);
223 		return (-1);
224 	}
225 
226 	/* Load in the firmware */
227 	ret = ath3k_load_fwfile(hdl, &fw);
228 
229 	/* free it */
230 	ath3k_fw_free(&fw);
231 
232 	return (ret);
233 }
234 
235 int
236 ath3k_load_syscfg(libusb_device_handle *hdl, const char *fw_path)
237 {
238 	unsigned char fw_state;
239 	char filename[FILENAME_MAX];
240 	struct ath3k_firmware fw;
241 	struct ath3k_version fw_ver;
242 	int clk_value, ret;
243 
244 	ret = ath3k_get_state(hdl, &fw_state);
245 	if (ret < 0) {
246 		ath3k_err("Can't get state to change to load configuration err");
247 		return (-EBUSY);
248 	}
249 
250 	ret = ath3k_get_version(hdl, &fw_ver);
251 	if (ret < 0) {
252 		ath3k_err("Can't get version to change to load ram patch err");
253 		return (ret);
254 	}
255 
256 	switch (fw_ver.ref_clock) {
257 	case ATH3K_XTAL_FREQ_26M:
258 		clk_value = 26;
259 		break;
260 	case ATH3K_XTAL_FREQ_40M:
261 		clk_value = 40;
262 		break;
263 	case ATH3K_XTAL_FREQ_19P2:
264 		clk_value = 19;
265 		break;
266 	default:
267 		clk_value = 0;
268 		break;
269 }
270 
271 	snprintf(filename, FILENAME_MAX, "%s/ar3k/ramps_0x%08x_%d%s",
272 	    fw_path,
273 	    fw_ver.rom_version,
274 	    clk_value,
275 	    ".dfu");
276 
277 	ath3k_info("%s: syscfg file = %s\n",
278 	    __func__,
279 	    filename);
280 
281 	/* Read in the firmware */
282 	if (ath3k_fw_read(&fw, filename) <= 0) {
283 		ath3k_err("%s: ath3k_fw_read() failed\n",
284 		    __func__);
285 		return (-1);
286 	}
287 
288 	ret = ath3k_load_fwfile(hdl, &fw);
289 
290 	ath3k_fw_free(&fw);
291 	return (ret);
292 }
293 
294 int
295 ath3k_set_normal_mode(libusb_device_handle *hdl)
296 {
297 	int ret;
298 	unsigned char fw_state;
299 
300 	ret = ath3k_get_state(hdl, &fw_state);
301 	if (ret < 0) {
302 		ath3k_err("%s: can't get state\n", __func__);
303 		return (ret);
304 	}
305 
306 	/*
307 	 * This isn't a fatal error - the device may have detached
308 	 * already.
309 	 */
310 	if ((fw_state & ATH3K_MODE_MASK) == ATH3K_NORMAL_MODE) {
311 		ath3k_debug("%s: firmware is already in normal mode\n",
312 		    __func__);
313 		return (0);
314 	}
315 
316 	ret = libusb_control_transfer(hdl,
317 	    LIBUSB_REQUEST_TYPE_VENDOR,		/* XXX out direction? */
318 	    ATH3K_SET_NORMAL_MODE,
319 	    0,
320 	    0,
321 	    NULL,
322 	    0,
323 	    1000);	/* XXX timeout */
324 
325 	if (ret < 0) {
326 		ath3k_err("%s: libusb_control_transfer() failed: code=%d\n",
327 		    __func__,
328 		    ret);
329 		return (0);
330 	}
331 
332 	return (ret == 0);
333 }
334 
335 int
336 ath3k_switch_pid(libusb_device_handle *hdl)
337 {
338 	int ret;
339 	ret = libusb_control_transfer(hdl,
340 	    LIBUSB_REQUEST_TYPE_VENDOR,		/* XXX set an out flag? */
341 	    USB_REG_SWITCH_VID_PID,
342 	    0,
343 	    0,
344 	    NULL,
345 	    0,
346 	    1000);	/* XXX timeout */
347 
348 	if (ret < 0) {
349 		ath3k_debug("%s: libusb_control_transfer() failed: code=%d\n",
350 		    __func__,
351 		    ret);
352 		return (0);
353 	}
354 
355 	return (ret == 0);
356 }
357