firmware.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Linux driver for TerraTec DMX 6Fire USB
  4. *
  5. * Firmware loader
  6. *
  7. * Author: Torsten Schenk <[email protected]>
  8. * Created: Jan 01, 2011
  9. * Copyright: (C) Torsten Schenk
  10. */
  11. #include <linux/firmware.h>
  12. #include <linux/module.h>
  13. #include <linux/bitrev.h>
  14. #include <linux/kernel.h>
  15. #include "firmware.h"
  16. #include "chip.h"
  17. MODULE_FIRMWARE("6fire/dmx6firel2.ihx");
  18. MODULE_FIRMWARE("6fire/dmx6fireap.ihx");
  19. MODULE_FIRMWARE("6fire/dmx6firecf.bin");
  20. enum {
  21. FPGA_BUFSIZE = 512, FPGA_EP = 2
  22. };
  23. /*
  24. * wMaxPacketSize of pcm endpoints.
  25. * keep synced with rates_in_packet_size and rates_out_packet_size in pcm.c
  26. * fpp: frames per isopacket
  27. *
  28. * CAUTION: keep sizeof <= buffer[] in usb6fire_fw_init
  29. */
  30. static const u8 ep_w_max_packet_size[] = {
  31. 0xe4, 0x00, 0xe4, 0x00, /* alt 1: 228 EP2 and EP6 (7 fpp) */
  32. 0xa4, 0x01, 0xa4, 0x01, /* alt 2: 420 EP2 and EP6 (13 fpp)*/
  33. 0x94, 0x01, 0x5c, 0x02 /* alt 3: 404 EP2 and 604 EP6 (25 fpp) */
  34. };
  35. static const u8 known_fw_versions[][2] = {
  36. { 0x03, 0x01 }
  37. };
  38. struct ihex_record {
  39. u16 address;
  40. u8 len;
  41. u8 data[256];
  42. char error; /* true if an error occurred parsing this record */
  43. u8 max_len; /* maximum record length in whole ihex */
  44. /* private */
  45. const char *txt_data;
  46. unsigned int txt_length;
  47. unsigned int txt_offset; /* current position in txt_data */
  48. };
  49. static u8 usb6fire_fw_ihex_hex(const u8 *data, u8 *crc)
  50. {
  51. u8 val = 0;
  52. int hval;
  53. hval = hex_to_bin(data[0]);
  54. if (hval >= 0)
  55. val |= (hval << 4);
  56. hval = hex_to_bin(data[1]);
  57. if (hval >= 0)
  58. val |= hval;
  59. *crc += val;
  60. return val;
  61. }
  62. /*
  63. * returns true if record is available, false otherwise.
  64. * iff an error occurred, false will be returned and record->error will be true.
  65. */
  66. static bool usb6fire_fw_ihex_next_record(struct ihex_record *record)
  67. {
  68. u8 crc = 0;
  69. u8 type;
  70. int i;
  71. record->error = false;
  72. /* find begin of record (marked by a colon) */
  73. while (record->txt_offset < record->txt_length
  74. && record->txt_data[record->txt_offset] != ':')
  75. record->txt_offset++;
  76. if (record->txt_offset == record->txt_length)
  77. return false;
  78. /* number of characters needed for len, addr and type entries */
  79. record->txt_offset++;
  80. if (record->txt_offset + 8 > record->txt_length) {
  81. record->error = true;
  82. return false;
  83. }
  84. record->len = usb6fire_fw_ihex_hex(record->txt_data +
  85. record->txt_offset, &crc);
  86. record->txt_offset += 2;
  87. record->address = usb6fire_fw_ihex_hex(record->txt_data +
  88. record->txt_offset, &crc) << 8;
  89. record->txt_offset += 2;
  90. record->address |= usb6fire_fw_ihex_hex(record->txt_data +
  91. record->txt_offset, &crc);
  92. record->txt_offset += 2;
  93. type = usb6fire_fw_ihex_hex(record->txt_data +
  94. record->txt_offset, &crc);
  95. record->txt_offset += 2;
  96. /* number of characters needed for data and crc entries */
  97. if (record->txt_offset + 2 * (record->len + 1) > record->txt_length) {
  98. record->error = true;
  99. return false;
  100. }
  101. for (i = 0; i < record->len; i++) {
  102. record->data[i] = usb6fire_fw_ihex_hex(record->txt_data
  103. + record->txt_offset, &crc);
  104. record->txt_offset += 2;
  105. }
  106. usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc);
  107. if (crc) {
  108. record->error = true;
  109. return false;
  110. }
  111. if (type == 1 || !record->len) /* eof */
  112. return false;
  113. else if (type == 0)
  114. return true;
  115. else {
  116. record->error = true;
  117. return false;
  118. }
  119. }
  120. static int usb6fire_fw_ihex_init(const struct firmware *fw,
  121. struct ihex_record *record)
  122. {
  123. record->txt_data = fw->data;
  124. record->txt_length = fw->size;
  125. record->txt_offset = 0;
  126. record->max_len = 0;
  127. /* read all records, if loop ends, record->error indicates,
  128. * whether ihex is valid. */
  129. while (usb6fire_fw_ihex_next_record(record))
  130. record->max_len = max(record->len, record->max_len);
  131. if (record->error)
  132. return -EINVAL;
  133. record->txt_offset = 0;
  134. return 0;
  135. }
  136. static int usb6fire_fw_ezusb_write(struct usb_device *device,
  137. int type, int value, char *data, int len)
  138. {
  139. return usb_control_msg_send(device, 0, type,
  140. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  141. value, 0, data, len, 1000, GFP_KERNEL);
  142. }
  143. static int usb6fire_fw_ezusb_read(struct usb_device *device,
  144. int type, int value, char *data, int len)
  145. {
  146. return usb_control_msg_recv(device, 0, type,
  147. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  148. value, 0, data, len, 1000, GFP_KERNEL);
  149. }
  150. static int usb6fire_fw_fpga_write(struct usb_device *device,
  151. char *data, int len)
  152. {
  153. int actual_len;
  154. int ret;
  155. ret = usb_bulk_msg(device, usb_sndbulkpipe(device, FPGA_EP), data, len,
  156. &actual_len, 1000);
  157. if (ret < 0)
  158. return ret;
  159. else if (actual_len != len)
  160. return -EIO;
  161. return 0;
  162. }
  163. static int usb6fire_fw_ezusb_upload(
  164. struct usb_interface *intf, const char *fwname,
  165. unsigned int postaddr, u8 *postdata, unsigned int postlen)
  166. {
  167. int ret;
  168. u8 data;
  169. struct usb_device *device = interface_to_usbdev(intf);
  170. const struct firmware *fw = NULL;
  171. struct ihex_record *rec = kmalloc(sizeof(struct ihex_record),
  172. GFP_KERNEL);
  173. if (!rec)
  174. return -ENOMEM;
  175. ret = request_firmware(&fw, fwname, &device->dev);
  176. if (ret < 0) {
  177. kfree(rec);
  178. dev_err(&intf->dev,
  179. "error requesting ezusb firmware %s.\n", fwname);
  180. return ret;
  181. }
  182. ret = usb6fire_fw_ihex_init(fw, rec);
  183. if (ret < 0) {
  184. kfree(rec);
  185. release_firmware(fw);
  186. dev_err(&intf->dev,
  187. "error validating ezusb firmware %s.\n", fwname);
  188. return ret;
  189. }
  190. /* upload firmware image */
  191. data = 0x01; /* stop ezusb cpu */
  192. ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1);
  193. if (ret) {
  194. kfree(rec);
  195. release_firmware(fw);
  196. dev_err(&intf->dev,
  197. "unable to upload ezusb firmware %s: begin message.\n",
  198. fwname);
  199. return ret;
  200. }
  201. while (usb6fire_fw_ihex_next_record(rec)) { /* write firmware */
  202. ret = usb6fire_fw_ezusb_write(device, 0xa0, rec->address,
  203. rec->data, rec->len);
  204. if (ret) {
  205. kfree(rec);
  206. release_firmware(fw);
  207. dev_err(&intf->dev,
  208. "unable to upload ezusb firmware %s: data urb.\n",
  209. fwname);
  210. return ret;
  211. }
  212. }
  213. release_firmware(fw);
  214. kfree(rec);
  215. if (postdata) { /* write data after firmware has been uploaded */
  216. ret = usb6fire_fw_ezusb_write(device, 0xa0, postaddr,
  217. postdata, postlen);
  218. if (ret) {
  219. dev_err(&intf->dev,
  220. "unable to upload ezusb firmware %s: post urb.\n",
  221. fwname);
  222. return ret;
  223. }
  224. }
  225. data = 0x00; /* resume ezusb cpu */
  226. ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1);
  227. if (ret) {
  228. dev_err(&intf->dev,
  229. "unable to upload ezusb firmware %s: end message.\n",
  230. fwname);
  231. return ret;
  232. }
  233. return 0;
  234. }
  235. static int usb6fire_fw_fpga_upload(
  236. struct usb_interface *intf, const char *fwname)
  237. {
  238. int ret;
  239. int i;
  240. struct usb_device *device = interface_to_usbdev(intf);
  241. u8 *buffer = kmalloc(FPGA_BUFSIZE, GFP_KERNEL);
  242. const char *c;
  243. const char *end;
  244. const struct firmware *fw;
  245. if (!buffer)
  246. return -ENOMEM;
  247. ret = request_firmware(&fw, fwname, &device->dev);
  248. if (ret < 0) {
  249. dev_err(&intf->dev, "unable to get fpga firmware %s.\n",
  250. fwname);
  251. kfree(buffer);
  252. return -EIO;
  253. }
  254. c = fw->data;
  255. end = fw->data + fw->size;
  256. ret = usb6fire_fw_ezusb_write(device, 8, 0, NULL, 0);
  257. if (ret) {
  258. kfree(buffer);
  259. release_firmware(fw);
  260. dev_err(&intf->dev,
  261. "unable to upload fpga firmware: begin urb.\n");
  262. return ret;
  263. }
  264. while (c != end) {
  265. for (i = 0; c != end && i < FPGA_BUFSIZE; i++, c++)
  266. buffer[i] = bitrev8((u8)*c);
  267. ret = usb6fire_fw_fpga_write(device, buffer, i);
  268. if (ret < 0) {
  269. release_firmware(fw);
  270. kfree(buffer);
  271. dev_err(&intf->dev,
  272. "unable to upload fpga firmware: fw urb.\n");
  273. return ret;
  274. }
  275. }
  276. release_firmware(fw);
  277. kfree(buffer);
  278. ret = usb6fire_fw_ezusb_write(device, 9, 0, NULL, 0);
  279. if (ret) {
  280. dev_err(&intf->dev,
  281. "unable to upload fpga firmware: end urb.\n");
  282. return ret;
  283. }
  284. return 0;
  285. }
  286. /* check, if the firmware version the devices has currently loaded
  287. * is known by this driver. 'version' needs to have 4 bytes version
  288. * info data. */
  289. static int usb6fire_fw_check(struct usb_interface *intf, const u8 *version)
  290. {
  291. int i;
  292. for (i = 0; i < ARRAY_SIZE(known_fw_versions); i++)
  293. if (!memcmp(version, known_fw_versions + i, 2))
  294. return 0;
  295. dev_err(&intf->dev, "invalid firmware version in device: %4ph. "
  296. "please reconnect to power. if this failure "
  297. "still happens, check your firmware installation.",
  298. version);
  299. return -EINVAL;
  300. }
  301. int usb6fire_fw_init(struct usb_interface *intf)
  302. {
  303. int i;
  304. int ret;
  305. struct usb_device *device = interface_to_usbdev(intf);
  306. /* buffer: 8 receiving bytes from device and
  307. * sizeof(EP_W_MAX_PACKET_SIZE) bytes for non-const copy */
  308. u8 buffer[12];
  309. ret = usb6fire_fw_ezusb_read(device, 1, 0, buffer, 8);
  310. if (ret) {
  311. dev_err(&intf->dev,
  312. "unable to receive device firmware state.\n");
  313. return ret;
  314. }
  315. if (buffer[0] != 0xeb || buffer[1] != 0xaa || buffer[2] != 0x55) {
  316. dev_err(&intf->dev,
  317. "unknown device firmware state received from device:");
  318. for (i = 0; i < 8; i++)
  319. printk(KERN_CONT "%02x ", buffer[i]);
  320. printk(KERN_CONT "\n");
  321. return -EIO;
  322. }
  323. /* do we need fpga loader ezusb firmware? */
  324. if (buffer[3] == 0x01) {
  325. ret = usb6fire_fw_ezusb_upload(intf,
  326. "6fire/dmx6firel2.ihx", 0, NULL, 0);
  327. if (ret < 0)
  328. return ret;
  329. return FW_NOT_READY;
  330. }
  331. /* do we need fpga firmware and application ezusb firmware? */
  332. else if (buffer[3] == 0x02) {
  333. ret = usb6fire_fw_check(intf, buffer + 4);
  334. if (ret < 0)
  335. return ret;
  336. ret = usb6fire_fw_fpga_upload(intf, "6fire/dmx6firecf.bin");
  337. if (ret < 0)
  338. return ret;
  339. memcpy(buffer, ep_w_max_packet_size,
  340. sizeof(ep_w_max_packet_size));
  341. ret = usb6fire_fw_ezusb_upload(intf, "6fire/dmx6fireap.ihx",
  342. 0x0003, buffer, sizeof(ep_w_max_packet_size));
  343. if (ret < 0)
  344. return ret;
  345. return FW_NOT_READY;
  346. }
  347. /* all fw loaded? */
  348. else if (buffer[3] == 0x03)
  349. return usb6fire_fw_check(intf, buffer + 4);
  350. /* unknown data? */
  351. else {
  352. dev_err(&intf->dev,
  353. "unknown device firmware state received from device: ");
  354. for (i = 0; i < 8; i++)
  355. printk(KERN_CONT "%02x ", buffer[i]);
  356. printk(KERN_CONT "\n");
  357. return -EIO;
  358. }
  359. return 0;
  360. }