regmap.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2015 Google, Inc
  4. * Written by Simon Glass <sjg@chromium.org>
  5. */
  6. #include <common.h>
  7. #include <dm.h>
  8. #include <errno.h>
  9. #include <linux/libfdt.h>
  10. #include <malloc.h>
  11. #include <mapmem.h>
  12. #include <regmap.h>
  13. #include <asm/io.h>
  14. #include <dm/of_addr.h>
  15. #include <linux/ioport.h>
  16. DECLARE_GLOBAL_DATA_PTR;
  17. /**
  18. * regmap_alloc() - Allocate a regmap with a given number of ranges.
  19. *
  20. * @count: Number of ranges to be allocated for the regmap.
  21. * Return: A pointer to the newly allocated regmap, or NULL on error.
  22. */
  23. static struct regmap *regmap_alloc(int count)
  24. {
  25. struct regmap *map;
  26. map = malloc(sizeof(*map) + sizeof(map->ranges[0]) * count);
  27. if (!map)
  28. return NULL;
  29. map->range_count = count;
  30. return map;
  31. }
  32. #if CONFIG_IS_ENABLED(OF_PLATDATA)
  33. int regmap_init_mem_platdata(struct udevice *dev, fdt_val_t *reg, int count,
  34. struct regmap **mapp)
  35. {
  36. struct regmap_range *range;
  37. struct regmap *map;
  38. map = regmap_alloc(count);
  39. if (!map)
  40. return -ENOMEM;
  41. for (range = map->ranges; count > 0; reg += 2, range++, count--) {
  42. range->start = *reg;
  43. range->size = reg[1];
  44. }
  45. *mapp = map;
  46. return 0;
  47. }
  48. #else
  49. /**
  50. * init_range() - Initialize a single range of a regmap
  51. * @node: Device node that will use the map in question
  52. * @range: Pointer to a regmap_range structure that will be initialized
  53. * @addr_len: The length of the addr parts of the reg property
  54. * @size_len: The length of the size parts of the reg property
  55. * @index: The index of the range to initialize
  56. *
  57. * This function will read the necessary 'reg' information from the device tree
  58. * (the 'addr' part, and the 'length' part), and initialize the range in
  59. * quesion.
  60. *
  61. * Return: 0 if OK, -ve on error
  62. */
  63. static int init_range(ofnode node, struct regmap_range *range, int addr_len,
  64. int size_len, int index)
  65. {
  66. fdt_size_t sz;
  67. struct resource r;
  68. if (of_live_active()) {
  69. int ret;
  70. ret = of_address_to_resource(ofnode_to_np(node),
  71. index, &r);
  72. if (ret) {
  73. debug("%s: Could not read resource of range %d (ret = %d)\n",
  74. ofnode_get_name(node), index, ret);
  75. return ret;
  76. }
  77. range->start = r.start;
  78. range->size = r.end - r.start + 1;
  79. } else {
  80. int offset = ofnode_to_offset(node);
  81. range->start = fdtdec_get_addr_size_fixed(gd->fdt_blob, offset,
  82. "reg", index,
  83. addr_len, size_len,
  84. &sz, true);
  85. if (range->start == FDT_ADDR_T_NONE) {
  86. debug("%s: Could not read start of range %d\n",
  87. ofnode_get_name(node), index);
  88. return -EINVAL;
  89. }
  90. range->size = sz;
  91. }
  92. return 0;
  93. }
  94. int regmap_init_mem_index(ofnode node, struct regmap **mapp, int index)
  95. {
  96. struct regmap *map;
  97. int addr_len, size_len;
  98. int ret;
  99. addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
  100. if (addr_len < 0) {
  101. debug("%s: Error while reading the addr length (ret = %d)\n",
  102. ofnode_get_name(node), addr_len);
  103. return addr_len;
  104. }
  105. size_len = ofnode_read_simple_size_cells(ofnode_get_parent(node));
  106. if (size_len < 0) {
  107. debug("%s: Error while reading the size length: (ret = %d)\n",
  108. ofnode_get_name(node), size_len);
  109. return size_len;
  110. }
  111. map = regmap_alloc(1);
  112. if (!map)
  113. return -ENOMEM;
  114. ret = init_range(node, map->ranges, addr_len, size_len, index);
  115. if (ret)
  116. goto err;
  117. if (ofnode_read_bool(node, "little-endian"))
  118. map->endianness = REGMAP_LITTLE_ENDIAN;
  119. else if (ofnode_read_bool(node, "big-endian"))
  120. map->endianness = REGMAP_BIG_ENDIAN;
  121. else if (ofnode_read_bool(node, "native-endian"))
  122. map->endianness = REGMAP_NATIVE_ENDIAN;
  123. else /* Default: native endianness */
  124. map->endianness = REGMAP_NATIVE_ENDIAN;
  125. *mapp = map;
  126. return 0;
  127. err:
  128. regmap_uninit(map);
  129. return ret;
  130. }
  131. int regmap_init_mem(ofnode node, struct regmap **mapp)
  132. {
  133. struct regmap_range *range;
  134. struct regmap *map;
  135. int count;
  136. int addr_len, size_len, both_len;
  137. int len;
  138. int index;
  139. int ret;
  140. addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
  141. if (addr_len < 0) {
  142. debug("%s: Error while reading the addr length (ret = %d)\n",
  143. ofnode_get_name(node), addr_len);
  144. return addr_len;
  145. }
  146. size_len = ofnode_read_simple_size_cells(ofnode_get_parent(node));
  147. if (size_len < 0) {
  148. debug("%s: Error while reading the size length: (ret = %d)\n",
  149. ofnode_get_name(node), size_len);
  150. return size_len;
  151. }
  152. both_len = addr_len + size_len;
  153. if (!both_len) {
  154. debug("%s: Both addr and size length are zero\n",
  155. ofnode_get_name(node));
  156. return -EINVAL;
  157. }
  158. len = ofnode_read_size(node, "reg");
  159. if (len < 0) {
  160. debug("%s: Error while reading reg size (ret = %d)\n",
  161. ofnode_get_name(node), len);
  162. return len;
  163. }
  164. len /= sizeof(fdt32_t);
  165. count = len / both_len;
  166. if (!count) {
  167. debug("%s: Not enough data in reg property\n",
  168. ofnode_get_name(node));
  169. return -EINVAL;
  170. }
  171. map = regmap_alloc(count);
  172. if (!map)
  173. return -ENOMEM;
  174. for (range = map->ranges, index = 0; count > 0;
  175. count--, range++, index++) {
  176. ret = init_range(node, range, addr_len, size_len, index);
  177. if (ret)
  178. goto err;
  179. }
  180. if (ofnode_read_bool(node, "little-endian"))
  181. map->endianness = REGMAP_LITTLE_ENDIAN;
  182. else if (ofnode_read_bool(node, "big-endian"))
  183. map->endianness = REGMAP_BIG_ENDIAN;
  184. else if (ofnode_read_bool(node, "native-endian"))
  185. map->endianness = REGMAP_NATIVE_ENDIAN;
  186. else /* Default: native endianness */
  187. map->endianness = REGMAP_NATIVE_ENDIAN;
  188. *mapp = map;
  189. return 0;
  190. err:
  191. regmap_uninit(map);
  192. return ret;
  193. }
  194. #endif
  195. void *regmap_get_range(struct regmap *map, unsigned int range_num)
  196. {
  197. struct regmap_range *range;
  198. if (range_num >= map->range_count)
  199. return NULL;
  200. range = &map->ranges[range_num];
  201. return map_sysmem(range->start, range->size);
  202. }
  203. int regmap_uninit(struct regmap *map)
  204. {
  205. free(map);
  206. return 0;
  207. }
  208. static inline u8 __read_8(u8 *addr, enum regmap_endianness_t endianness)
  209. {
  210. return readb(addr);
  211. }
  212. static inline u16 __read_16(u16 *addr, enum regmap_endianness_t endianness)
  213. {
  214. switch (endianness) {
  215. case REGMAP_LITTLE_ENDIAN:
  216. return in_le16(addr);
  217. case REGMAP_BIG_ENDIAN:
  218. return in_be16(addr);
  219. case REGMAP_NATIVE_ENDIAN:
  220. return readw(addr);
  221. }
  222. return readw(addr);
  223. }
  224. static inline u32 __read_32(u32 *addr, enum regmap_endianness_t endianness)
  225. {
  226. switch (endianness) {
  227. case REGMAP_LITTLE_ENDIAN:
  228. return in_le32(addr);
  229. case REGMAP_BIG_ENDIAN:
  230. return in_be32(addr);
  231. case REGMAP_NATIVE_ENDIAN:
  232. return readl(addr);
  233. }
  234. return readl(addr);
  235. }
  236. #if defined(in_le64) && defined(in_be64) && defined(readq)
  237. static inline u64 __read_64(u64 *addr, enum regmap_endianness_t endianness)
  238. {
  239. switch (endianness) {
  240. case REGMAP_LITTLE_ENDIAN:
  241. return in_le64(addr);
  242. case REGMAP_BIG_ENDIAN:
  243. return in_be64(addr);
  244. case REGMAP_NATIVE_ENDIAN:
  245. return readq(addr);
  246. }
  247. return readq(addr);
  248. }
  249. #endif
  250. int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
  251. void *valp, size_t val_len)
  252. {
  253. struct regmap_range *range;
  254. void *ptr;
  255. if (range_num >= map->range_count) {
  256. debug("%s: range index %d larger than range count\n",
  257. __func__, range_num);
  258. return -ERANGE;
  259. }
  260. range = &map->ranges[range_num];
  261. ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
  262. if (offset + val_len > range->size) {
  263. debug("%s: offset/size combination invalid\n", __func__);
  264. return -ERANGE;
  265. }
  266. switch (val_len) {
  267. case REGMAP_SIZE_8:
  268. *((u8 *)valp) = __read_8(ptr, map->endianness);
  269. break;
  270. case REGMAP_SIZE_16:
  271. *((u16 *)valp) = __read_16(ptr, map->endianness);
  272. break;
  273. case REGMAP_SIZE_32:
  274. *((u32 *)valp) = __read_32(ptr, map->endianness);
  275. break;
  276. #if defined(in_le64) && defined(in_be64) && defined(readq)
  277. case REGMAP_SIZE_64:
  278. *((u64 *)valp) = __read_64(ptr, map->endianness);
  279. break;
  280. #endif
  281. default:
  282. debug("%s: regmap size %zu unknown\n", __func__, val_len);
  283. return -EINVAL;
  284. }
  285. return 0;
  286. }
  287. int regmap_raw_read(struct regmap *map, uint offset, void *valp, size_t val_len)
  288. {
  289. return regmap_raw_read_range(map, 0, offset, valp, val_len);
  290. }
  291. int regmap_read(struct regmap *map, uint offset, uint *valp)
  292. {
  293. return regmap_raw_read(map, offset, valp, REGMAP_SIZE_32);
  294. }
  295. static inline void __write_8(u8 *addr, const u8 *val,
  296. enum regmap_endianness_t endianness)
  297. {
  298. writeb(*val, addr);
  299. }
  300. static inline void __write_16(u16 *addr, const u16 *val,
  301. enum regmap_endianness_t endianness)
  302. {
  303. switch (endianness) {
  304. case REGMAP_NATIVE_ENDIAN:
  305. writew(*val, addr);
  306. break;
  307. case REGMAP_LITTLE_ENDIAN:
  308. out_le16(addr, *val);
  309. break;
  310. case REGMAP_BIG_ENDIAN:
  311. out_be16(addr, *val);
  312. break;
  313. }
  314. }
  315. static inline void __write_32(u32 *addr, const u32 *val,
  316. enum regmap_endianness_t endianness)
  317. {
  318. switch (endianness) {
  319. case REGMAP_NATIVE_ENDIAN:
  320. writel(*val, addr);
  321. break;
  322. case REGMAP_LITTLE_ENDIAN:
  323. out_le32(addr, *val);
  324. break;
  325. case REGMAP_BIG_ENDIAN:
  326. out_be32(addr, *val);
  327. break;
  328. }
  329. }
  330. #if defined(out_le64) && defined(out_be64) && defined(writeq)
  331. static inline void __write_64(u64 *addr, const u64 *val,
  332. enum regmap_endianness_t endianness)
  333. {
  334. switch (endianness) {
  335. case REGMAP_NATIVE_ENDIAN:
  336. writeq(*val, addr);
  337. break;
  338. case REGMAP_LITTLE_ENDIAN:
  339. out_le64(addr, *val);
  340. break;
  341. case REGMAP_BIG_ENDIAN:
  342. out_be64(addr, *val);
  343. break;
  344. }
  345. }
  346. #endif
  347. int regmap_raw_write_range(struct regmap *map, uint range_num, uint offset,
  348. const void *val, size_t val_len)
  349. {
  350. struct regmap_range *range;
  351. void *ptr;
  352. if (range_num >= map->range_count) {
  353. debug("%s: range index %d larger than range count\n",
  354. __func__, range_num);
  355. return -ERANGE;
  356. }
  357. range = &map->ranges[range_num];
  358. ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
  359. if (offset + val_len > range->size) {
  360. debug("%s: offset/size combination invalid\n", __func__);
  361. return -ERANGE;
  362. }
  363. switch (val_len) {
  364. case REGMAP_SIZE_8:
  365. __write_8(ptr, val, map->endianness);
  366. break;
  367. case REGMAP_SIZE_16:
  368. __write_16(ptr, val, map->endianness);
  369. break;
  370. case REGMAP_SIZE_32:
  371. __write_32(ptr, val, map->endianness);
  372. break;
  373. #if defined(out_le64) && defined(out_be64) && defined(writeq)
  374. case REGMAP_SIZE_64:
  375. __write_64(ptr, val, map->endianness);
  376. break;
  377. #endif
  378. default:
  379. debug("%s: regmap size %zu unknown\n", __func__, val_len);
  380. return -EINVAL;
  381. }
  382. return 0;
  383. }
  384. int regmap_raw_write(struct regmap *map, uint offset, const void *val,
  385. size_t val_len)
  386. {
  387. return regmap_raw_write_range(map, 0, offset, val, val_len);
  388. }
  389. int regmap_write(struct regmap *map, uint offset, uint val)
  390. {
  391. return regmap_raw_write(map, offset, &val, REGMAP_SIZE_32);
  392. }
  393. int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val)
  394. {
  395. uint reg;
  396. int ret;
  397. ret = regmap_read(map, offset, &reg);
  398. if (ret)
  399. return ret;
  400. reg &= ~mask;
  401. return regmap_write(map, offset, reg | (val & mask));
  402. }