gs_fpgaboot.c 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394
  1. // SPDX-License-Identifier: GPL-2.0+
  2. #include <linux/kernel.h>
  3. #include <linux/init.h>
  4. #include <linux/module.h>
  5. #include <linux/types.h>
  6. #include <linux/device.h>
  7. #include <linux/string.h>
  8. #include <linux/slab.h>
  9. #include <linux/fs.h>
  10. #include <linux/platform_device.h>
  11. #include <linux/of.h>
  12. #include <linux/delay.h>
  13. #include <linux/io.h>
  14. #include <linux/firmware.h>
  15. #include <asm/unaligned.h>
  16. #include "gs_fpgaboot.h"
  17. #include "io.h"
  18. #define DEVICE_NAME "device"
  19. #define CLASS_NAME "fpgaboot"
  20. static u8 bits_magic[] = {
  21. 0x0, 0x9, 0xf, 0xf0, 0xf, 0xf0,
  22. 0xf, 0xf0, 0xf, 0xf0, 0x0, 0x0, 0x1};
  23. /* fake device for request_firmware */
  24. static struct platform_device *firmware_pdev;
  25. static char *file = "xlinx_fpga_firmware.bit";
  26. module_param(file, charp, 0444);
  27. MODULE_PARM_DESC(file, "Xilinx FPGA firmware file.");
  28. static void read_bitstream(u8 *bitdata, u8 *buf, int *offset, int rdsize)
  29. {
  30. memcpy(buf, bitdata + *offset, rdsize);
  31. *offset += rdsize;
  32. }
  33. static int readinfo_bitstream(u8 *bitdata, u8 *buf, int size, int *offset)
  34. {
  35. u8 tbuf[2];
  36. u16 len;
  37. /* read section char */
  38. read_bitstream(bitdata, tbuf, offset, 1);
  39. /* read length */
  40. read_bitstream(bitdata, tbuf, offset, 2);
  41. len = get_unaligned_be16(tbuf);
  42. if (len >= size) {
  43. pr_err("error: readinfo buffer too small\n");
  44. return -EINVAL;
  45. }
  46. read_bitstream(bitdata, buf, offset, len);
  47. buf[len] = '\0';
  48. return 0;
  49. }
  50. /*
  51. * read bitdata length
  52. */
  53. static int readlength_bitstream(u8 *bitdata, int *lendata, int *offset)
  54. {
  55. u8 tbuf[4];
  56. /* read section char */
  57. read_bitstream(bitdata, tbuf, offset, 1);
  58. /* make sure it is section 'e' */
  59. if (tbuf[0] != 'e') {
  60. pr_err("error: length section is not 'e', but %c\n", tbuf[0]);
  61. return -EINVAL;
  62. }
  63. /* read 4bytes length */
  64. read_bitstream(bitdata, tbuf, offset, 4);
  65. *lendata = get_unaligned_be32(tbuf);
  66. return 0;
  67. }
  68. /*
  69. * read first 13 bytes to check bitstream magic number
  70. */
  71. static int readmagic_bitstream(u8 *bitdata, int *offset)
  72. {
  73. u8 buf[13];
  74. int r;
  75. read_bitstream(bitdata, buf, offset, 13);
  76. r = memcmp(buf, bits_magic, 13);
  77. if (r) {
  78. pr_err("error: corrupted header\n");
  79. return -EINVAL;
  80. }
  81. pr_info("bitstream file magic number Ok\n");
  82. *offset = 13; /* magic length */
  83. return 0;
  84. }
  85. /*
  86. * NOTE: supports only bitstream format
  87. */
  88. static enum fmt_image get_imageformat(void)
  89. {
  90. return f_bit;
  91. }
  92. static void gs_print_header(struct fpgaimage *fimage)
  93. {
  94. pr_info("file: %s\n", fimage->filename);
  95. pr_info("part: %s\n", fimage->part);
  96. pr_info("date: %s\n", fimage->date);
  97. pr_info("time: %s\n", fimage->time);
  98. pr_info("lendata: %d\n", fimage->lendata);
  99. }
  100. static int gs_read_bitstream(struct fpgaimage *fimage)
  101. {
  102. u8 *bitdata;
  103. int offset;
  104. int err;
  105. offset = 0;
  106. bitdata = (u8 *)fimage->fw_entry->data;
  107. err = readmagic_bitstream(bitdata, &offset);
  108. if (err)
  109. return err;
  110. err = readinfo_bitstream(bitdata, fimage->filename, MAX_STR, &offset);
  111. if (err)
  112. return err;
  113. err = readinfo_bitstream(bitdata, fimage->part, MAX_STR, &offset);
  114. if (err)
  115. return err;
  116. err = readinfo_bitstream(bitdata, fimage->date, MAX_STR, &offset);
  117. if (err)
  118. return err;
  119. err = readinfo_bitstream(bitdata, fimage->time, MAX_STR, &offset);
  120. if (err)
  121. return err;
  122. err = readlength_bitstream(bitdata, &fimage->lendata, &offset);
  123. if (err)
  124. return err;
  125. fimage->fpgadata = bitdata + offset;
  126. return 0;
  127. }
  128. static int gs_read_image(struct fpgaimage *fimage)
  129. {
  130. int img_fmt;
  131. int err;
  132. img_fmt = get_imageformat();
  133. switch (img_fmt) {
  134. case f_bit:
  135. pr_info("image is bitstream format\n");
  136. err = gs_read_bitstream(fimage);
  137. if (err)
  138. return err;
  139. break;
  140. default:
  141. pr_err("unsupported fpga image format\n");
  142. return -EINVAL;
  143. }
  144. gs_print_header(fimage);
  145. return 0;
  146. }
  147. static int gs_load_image(struct fpgaimage *fimage, char *fw_file)
  148. {
  149. int err;
  150. pr_info("load fpgaimage %s\n", fw_file);
  151. err = request_firmware(&fimage->fw_entry, fw_file, &firmware_pdev->dev);
  152. if (err != 0) {
  153. pr_err("firmware %s is missing, cannot continue.\n", fw_file);
  154. return err;
  155. }
  156. return 0;
  157. }
  158. static int gs_download_image(struct fpgaimage *fimage, enum wbus bus_bytes)
  159. {
  160. u8 *bitdata;
  161. int size, i, cnt;
  162. cnt = 0;
  163. bitdata = (u8 *)fimage->fpgadata;
  164. size = fimage->lendata;
  165. #ifdef DEBUG_FPGA
  166. print_hex_dump_bytes("bitfile sample: ", DUMP_PREFIX_OFFSET,
  167. bitdata, 0x100);
  168. #endif /* DEBUG_FPGA */
  169. if (!xl_supported_prog_bus_width(bus_bytes)) {
  170. pr_err("unsupported program bus width %d\n",
  171. bus_bytes);
  172. return -EINVAL;
  173. }
  174. /* Bring csi_b, rdwr_b Low and program_b High */
  175. xl_program_b(1);
  176. xl_rdwr_b(0);
  177. xl_csi_b(0);
  178. /* Configuration reset */
  179. xl_program_b(0);
  180. msleep(20);
  181. xl_program_b(1);
  182. /* Wait for Device Initialization */
  183. while (xl_get_init_b() == 0)
  184. ;
  185. pr_info("device init done\n");
  186. for (i = 0; i < size; i += bus_bytes)
  187. xl_shift_bytes_out(bus_bytes, bitdata + i);
  188. pr_info("program done\n");
  189. /* Check INIT_B */
  190. if (xl_get_init_b() == 0) {
  191. pr_err("init_b 0\n");
  192. return -EIO;
  193. }
  194. while (xl_get_done_b() == 0) {
  195. if (cnt++ > MAX_WAIT_DONE) {
  196. pr_err("init_B %d\n", xl_get_init_b());
  197. break;
  198. }
  199. }
  200. if (cnt > MAX_WAIT_DONE) {
  201. pr_err("fpga download fail\n");
  202. return -EIO;
  203. }
  204. pr_info("download fpgaimage\n");
  205. /* Compensate for Special Startup Conditions */
  206. xl_shift_cclk(8);
  207. return 0;
  208. }
  209. static int gs_release_image(struct fpgaimage *fimage)
  210. {
  211. release_firmware(fimage->fw_entry);
  212. pr_info("release fpgaimage\n");
  213. return 0;
  214. }
  215. /*
  216. * NOTE: supports systemmap parallel programming
  217. */
  218. static int gs_set_download_method(struct fpgaimage *fimage)
  219. {
  220. pr_info("set program method\n");
  221. fimage->dmethod = m_systemmap;
  222. pr_info("systemmap program method\n");
  223. return 0;
  224. }
  225. static int init_driver(void)
  226. {
  227. firmware_pdev = platform_device_register_simple("fpgaboot", -1,
  228. NULL, 0);
  229. return PTR_ERR_OR_ZERO(firmware_pdev);
  230. }
  231. static int gs_fpgaboot(void)
  232. {
  233. int err;
  234. struct fpgaimage *fimage;
  235. fimage = kmalloc(sizeof(*fimage), GFP_KERNEL);
  236. if (!fimage)
  237. return -ENOMEM;
  238. err = gs_load_image(fimage, file);
  239. if (err) {
  240. pr_err("gs_load_image error\n");
  241. goto err_out1;
  242. }
  243. err = gs_read_image(fimage);
  244. if (err) {
  245. pr_err("gs_read_image error\n");
  246. goto err_out2;
  247. }
  248. err = gs_set_download_method(fimage);
  249. if (err) {
  250. pr_err("gs_set_download_method error\n");
  251. goto err_out2;
  252. }
  253. err = gs_download_image(fimage, bus_2byte);
  254. if (err) {
  255. pr_err("gs_download_image error\n");
  256. goto err_out2;
  257. }
  258. err = gs_release_image(fimage);
  259. if (err) {
  260. pr_err("gs_release_image error\n");
  261. goto err_out1;
  262. }
  263. kfree(fimage);
  264. return 0;
  265. err_out2:
  266. err = gs_release_image(fimage);
  267. if (err)
  268. pr_err("gs_release_image error\n");
  269. err_out1:
  270. kfree(fimage);
  271. return err;
  272. }
  273. static int __init gs_fpgaboot_init(void)
  274. {
  275. int err;
  276. pr_info("FPGA DOWNLOAD --->\n");
  277. pr_info("FPGA image file name: %s\n", file);
  278. err = init_driver();
  279. if (err) {
  280. pr_err("FPGA DRIVER INIT FAIL!!\n");
  281. return err;
  282. }
  283. err = xl_init_io();
  284. if (err) {
  285. pr_err("GPIO INIT FAIL!!\n");
  286. goto errout;
  287. }
  288. err = gs_fpgaboot();
  289. if (err) {
  290. pr_err("FPGA DOWNLOAD FAIL!!\n");
  291. goto errout;
  292. }
  293. pr_info("FPGA DOWNLOAD DONE <---\n");
  294. return 0;
  295. errout:
  296. platform_device_unregister(firmware_pdev);
  297. return err;
  298. }
  299. static void __exit gs_fpgaboot_exit(void)
  300. {
  301. platform_device_unregister(firmware_pdev);
  302. pr_info("FPGA image download module removed\n");
  303. }
  304. module_init(gs_fpgaboot_init);
  305. module_exit(gs_fpgaboot_exit);
  306. MODULE_AUTHOR("Insop Song");
  307. MODULE_DESCRIPTION("Xlinix FPGA firmware download");
  308. MODULE_LICENSE("GPL");