pic32_flash.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015
  4. * Cristian Birsan <cristian.birsan@microchip.com>
  5. * Purna Chandra Mandal <purna.mandal@microchip.com>
  6. */
  7. #include <common.h>
  8. #include <cpu_func.h>
  9. #include <dm.h>
  10. #include <fdt_support.h>
  11. #include <flash.h>
  12. #include <irq_func.h>
  13. #include <mach/pic32.h>
  14. #include <wait_bit.h>
  15. DECLARE_GLOBAL_DATA_PTR;
  16. /* NVM Controller registers */
  17. struct pic32_reg_nvm {
  18. struct pic32_reg_atomic ctrl;
  19. struct pic32_reg_atomic key;
  20. struct pic32_reg_atomic addr;
  21. struct pic32_reg_atomic data;
  22. };
  23. /* NVM operations */
  24. #define NVMOP_NOP 0
  25. #define NVMOP_WORD_WRITE 1
  26. #define NVMOP_PAGE_ERASE 4
  27. /* NVM control bits */
  28. #define NVM_WR BIT(15)
  29. #define NVM_WREN BIT(14)
  30. #define NVM_WRERR BIT(13)
  31. #define NVM_LVDERR BIT(12)
  32. /* NVM programming unlock register */
  33. #define LOCK_KEY 0x0
  34. #define UNLOCK_KEY1 0xaa996655
  35. #define UNLOCK_KEY2 0x556699aa
  36. /*
  37. * PIC32 flash banks consist of number of pages, each page
  38. * into number of rows and rows into number of words.
  39. * Here we will maintain page information instead of sector.
  40. */
  41. flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
  42. static struct pic32_reg_nvm *nvm_regs_p;
  43. static inline void flash_initiate_operation(u32 nvmop)
  44. {
  45. /* set operation */
  46. writel(nvmop, &nvm_regs_p->ctrl.raw);
  47. /* enable flash write */
  48. writel(NVM_WREN, &nvm_regs_p->ctrl.set);
  49. /* unlock sequence */
  50. writel(LOCK_KEY, &nvm_regs_p->key.raw);
  51. writel(UNLOCK_KEY1, &nvm_regs_p->key.raw);
  52. writel(UNLOCK_KEY2, &nvm_regs_p->key.raw);
  53. /* initiate operation */
  54. writel(NVM_WR, &nvm_regs_p->ctrl.set);
  55. }
  56. static int flash_wait_till_busy(const char *func, ulong timeout)
  57. {
  58. int ret = wait_for_bit_le32(&nvm_regs_p->ctrl.raw,
  59. NVM_WR, false, timeout, false);
  60. return ret ? ERR_TIMEOUT : ERR_OK;
  61. }
  62. static inline int flash_complete_operation(void)
  63. {
  64. u32 tmp;
  65. tmp = readl(&nvm_regs_p->ctrl.raw);
  66. if (tmp & NVM_WRERR) {
  67. printf("Error in Block Erase - Lock Bit may be set!\n");
  68. flash_initiate_operation(NVMOP_NOP);
  69. return ERR_PROTECTED;
  70. }
  71. if (tmp & NVM_LVDERR) {
  72. printf("Error in Block Erase - low-vol detected!\n");
  73. flash_initiate_operation(NVMOP_NOP);
  74. return ERR_NOT_ERASED;
  75. }
  76. /* disable flash write or erase operation */
  77. writel(NVM_WREN, &nvm_regs_p->ctrl.clr);
  78. return ERR_OK;
  79. }
  80. /*
  81. * Erase flash sectors, returns:
  82. * ERR_OK - OK
  83. * ERR_INVAL - invalid sector arguments
  84. * ERR_TIMEOUT - write timeout
  85. * ERR_NOT_ERASED - Flash not erased
  86. * ERR_UNKNOWN_FLASH_VENDOR - incorrect flash
  87. */
  88. int flash_erase(flash_info_t *info, int s_first, int s_last)
  89. {
  90. ulong sect_start, sect_end, flags;
  91. int prot, sect;
  92. int rc;
  93. if ((info->flash_id & FLASH_VENDMASK) != FLASH_MAN_MCHP) {
  94. printf("Can't erase unknown flash type %08lx - aborted\n",
  95. info->flash_id);
  96. return ERR_UNKNOWN_FLASH_VENDOR;
  97. }
  98. if ((s_first < 0) || (s_first > s_last)) {
  99. printf("- no sectors to erase\n");
  100. return ERR_INVAL;
  101. }
  102. prot = 0;
  103. for (sect = s_first; sect <= s_last; ++sect) {
  104. if (info->protect[sect])
  105. prot++;
  106. }
  107. if (prot)
  108. printf("- Warning: %d protected sectors will not be erased!\n",
  109. prot);
  110. else
  111. printf("\n");
  112. /* erase on unprotected sectors */
  113. for (sect = s_first; sect <= s_last; sect++) {
  114. if (info->protect[sect])
  115. continue;
  116. /* disable interrupts */
  117. flags = disable_interrupts();
  118. /* write destination page address (physical) */
  119. sect_start = CPHYSADDR(info->start[sect]);
  120. writel(sect_start, &nvm_regs_p->addr.raw);
  121. /* page erase */
  122. flash_initiate_operation(NVMOP_PAGE_ERASE);
  123. /* wait */
  124. rc = flash_wait_till_busy(__func__,
  125. CONFIG_SYS_FLASH_ERASE_TOUT);
  126. /* re-enable interrupts if necessary */
  127. if (flags)
  128. enable_interrupts();
  129. if (rc != ERR_OK)
  130. return rc;
  131. rc = flash_complete_operation();
  132. if (rc != ERR_OK)
  133. return rc;
  134. /*
  135. * flash content is updated but cache might contain stale
  136. * data, so invalidate dcache.
  137. */
  138. sect_end = info->start[sect] + info->size / info->sector_count;
  139. invalidate_dcache_range(info->start[sect], sect_end);
  140. }
  141. printf(" done\n");
  142. return ERR_OK;
  143. }
  144. int page_erase(flash_info_t *info, int sect)
  145. {
  146. return 0;
  147. }
  148. /* Write a word to flash */
  149. static int write_word(flash_info_t *info, ulong dest, ulong word)
  150. {
  151. ulong flags;
  152. int rc;
  153. /* read flash to check if it is sufficiently erased */
  154. if ((readl((void __iomem *)dest) & word) != word) {
  155. printf("Error, Flash not erased!\n");
  156. return ERR_NOT_ERASED;
  157. }
  158. /* disable interrupts */
  159. flags = disable_interrupts();
  160. /* update destination page address (physical) */
  161. writel(CPHYSADDR(dest), &nvm_regs_p->addr.raw);
  162. writel(word, &nvm_regs_p->data.raw);
  163. /* word write */
  164. flash_initiate_operation(NVMOP_WORD_WRITE);
  165. /* wait for operation to complete */
  166. rc = flash_wait_till_busy(__func__, CONFIG_SYS_FLASH_WRITE_TOUT);
  167. /* re-enable interrupts if necessary */
  168. if (flags)
  169. enable_interrupts();
  170. if (rc != ERR_OK)
  171. return rc;
  172. return flash_complete_operation();
  173. }
  174. /*
  175. * Copy memory to flash, returns:
  176. * ERR_OK - OK
  177. * ERR_TIMEOUT - write timeout
  178. * ERR_NOT_ERASED - Flash not erased
  179. */
  180. int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
  181. {
  182. ulong dst, tmp_le, len = cnt;
  183. int i, l, rc;
  184. uchar *cp;
  185. /* get lower word aligned address */
  186. dst = (addr & ~3);
  187. /* handle unaligned start bytes */
  188. l = addr - dst;
  189. if (l != 0) {
  190. tmp_le = 0;
  191. for (i = 0, cp = (uchar *)dst; i < l; ++i, ++cp)
  192. tmp_le |= *cp << (i * 8);
  193. for (; (i < 4) && (cnt > 0); ++i, ++src, --cnt, ++cp)
  194. tmp_le |= *src << (i * 8);
  195. for (; (cnt == 0) && (i < 4); ++i, ++cp)
  196. tmp_le |= *cp << (i * 8);
  197. rc = write_word(info, dst, tmp_le);
  198. if (rc)
  199. goto out;
  200. dst += 4;
  201. }
  202. /* handle word aligned part */
  203. while (cnt >= 4) {
  204. tmp_le = src[0] | src[1] << 8 | src[2] << 16 | src[3] << 24;
  205. rc = write_word(info, dst, tmp_le);
  206. if (rc)
  207. goto out;
  208. src += 4;
  209. dst += 4;
  210. cnt -= 4;
  211. }
  212. if (cnt == 0) {
  213. rc = ERR_OK;
  214. goto out;
  215. }
  216. /* handle unaligned tail bytes */
  217. tmp_le = 0;
  218. for (i = 0, cp = (uchar *)dst; (i < 4) && (cnt > 0); ++i, ++cp) {
  219. tmp_le |= *src++ << (i * 8);
  220. --cnt;
  221. }
  222. for (; i < 4; ++i, ++cp)
  223. tmp_le |= *cp << (i * 8);
  224. rc = write_word(info, dst, tmp_le);
  225. out:
  226. /*
  227. * flash content updated by nvm controller but CPU cache might
  228. * have stale data, so invalidate dcache.
  229. */
  230. invalidate_dcache_range(addr, addr + len);
  231. printf(" done\n");
  232. return rc;
  233. }
  234. void flash_print_info(flash_info_t *info)
  235. {
  236. int i;
  237. if (info->flash_id == FLASH_UNKNOWN) {
  238. printf("missing or unknown FLASH type\n");
  239. return;
  240. }
  241. switch (info->flash_id & FLASH_VENDMASK) {
  242. case FLASH_MAN_MCHP:
  243. printf("Microchip Technology ");
  244. break;
  245. default:
  246. printf("Unknown Vendor ");
  247. break;
  248. }
  249. switch (info->flash_id & FLASH_TYPEMASK) {
  250. case FLASH_MCHP100T:
  251. printf("Internal (8 Mbit, 64 x 16k)\n");
  252. break;
  253. default:
  254. printf("Unknown Chip Type\n");
  255. break;
  256. }
  257. printf(" Size: %ld MB in %d Sectors\n",
  258. info->size >> 20, info->sector_count);
  259. printf(" Sector Start Addresses:");
  260. for (i = 0; i < info->sector_count; ++i) {
  261. if ((i % 5) == 0)
  262. printf("\n ");
  263. printf(" %08lX%s", info->start[i],
  264. info->protect[i] ? " (RO)" : " ");
  265. }
  266. printf("\n");
  267. }
  268. unsigned long flash_init(void)
  269. {
  270. unsigned long size = 0;
  271. struct udevice *dev;
  272. int bank;
  273. /* probe every MTD device */
  274. for (uclass_first_device(UCLASS_MTD, &dev); dev;
  275. uclass_next_device(&dev)) {
  276. /* nop */
  277. }
  278. /* calc total flash size */
  279. for (bank = 0; bank < CONFIG_SYS_MAX_FLASH_BANKS; ++bank)
  280. size += flash_info[bank].size;
  281. return size;
  282. }
  283. static void pic32_flash_bank_init(flash_info_t *info,
  284. ulong base, ulong size)
  285. {
  286. ulong sect_size;
  287. int sect;
  288. /* device & manufacturer code */
  289. info->flash_id = FLASH_MAN_MCHP | FLASH_MCHP100T;
  290. info->sector_count = CONFIG_SYS_MAX_FLASH_SECT;
  291. info->size = size;
  292. /* update sector (i.e page) info */
  293. sect_size = info->size / info->sector_count;
  294. for (sect = 0; sect < info->sector_count; sect++) {
  295. info->start[sect] = base;
  296. /* protect each sector by default */
  297. info->protect[sect] = 1;
  298. base += sect_size;
  299. }
  300. }
  301. static int pic32_flash_probe(struct udevice *dev)
  302. {
  303. void *blob = (void *)gd->fdt_blob;
  304. int node = dev_of_offset(dev);
  305. const char *list, *end;
  306. const fdt32_t *cell;
  307. unsigned long addr, size;
  308. int parent, addrc, sizec;
  309. flash_info_t *info;
  310. int len, idx;
  311. /*
  312. * decode regs. there are multiple reg tuples, and they need to
  313. * match with reg-names.
  314. */
  315. parent = fdt_parent_offset(blob, node);
  316. fdt_support_default_count_cells(blob, parent, &addrc, &sizec);
  317. list = fdt_getprop(blob, node, "reg-names", &len);
  318. if (!list)
  319. return -ENOENT;
  320. end = list + len;
  321. cell = fdt_getprop(blob, node, "reg", &len);
  322. if (!cell)
  323. return -ENOENT;
  324. for (idx = 0, info = &flash_info[0]; list < end;) {
  325. addr = fdt_translate_address((void *)blob, node, cell + idx);
  326. size = fdt_addr_to_cpu(cell[idx + addrc]);
  327. len = strlen(list);
  328. if (!strncmp(list, "nvm", len)) {
  329. /* NVM controller */
  330. nvm_regs_p = ioremap(addr, size);
  331. } else if (!strncmp(list, "bank", 4)) {
  332. /* Flash bank: use kseg0 cached address */
  333. pic32_flash_bank_init(info, CKSEG0ADDR(addr), size);
  334. info++;
  335. }
  336. idx += addrc + sizec;
  337. list += len + 1;
  338. }
  339. /* disable flash write/erase operations */
  340. writel(NVM_WREN, &nvm_regs_p->ctrl.clr);
  341. #if (CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE)
  342. /* monitor protection ON by default */
  343. flash_protect(FLAG_PROTECT_SET,
  344. CONFIG_SYS_MONITOR_BASE,
  345. CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1,
  346. &flash_info[0]);
  347. #endif
  348. #ifdef CONFIG_ENV_IS_IN_FLASH
  349. /* ENV protection ON by default */
  350. flash_protect(FLAG_PROTECT_SET,
  351. CONFIG_ENV_ADDR,
  352. CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1,
  353. &flash_info[0]);
  354. #endif
  355. return 0;
  356. }
  357. static const struct udevice_id pic32_flash_ids[] = {
  358. { .compatible = "microchip,pic32mzda-flash" },
  359. {}
  360. };
  361. U_BOOT_DRIVER(pic32_flash) = {
  362. .name = "pic32_flash",
  363. .id = UCLASS_MTD,
  364. .of_match = pic32_flash_ids,
  365. .probe = pic32_flash_probe,
  366. };