regmap.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688
  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 <log.h>
  10. #include <asm/global_data.h>
  11. #include <linux/libfdt.h>
  12. #include <malloc.h>
  13. #include <mapmem.h>
  14. #include <regmap.h>
  15. #include <asm/io.h>
  16. #include <dm/of_addr.h>
  17. #include <dm/devres.h>
  18. #include <linux/ioport.h>
  19. #include <linux/compat.h>
  20. #include <linux/err.h>
  21. #include <linux/bitops.h>
  22. /*
  23. * Internal representation of a regmap field. Instead of storing the MSB and
  24. * LSB, store the shift and mask. This makes the code a bit cleaner and faster
  25. * because the shift and mask don't have to be calculated every time.
  26. */
  27. struct regmap_field {
  28. struct regmap *regmap;
  29. unsigned int mask;
  30. /* lsb */
  31. unsigned int shift;
  32. unsigned int reg;
  33. };
  34. DECLARE_GLOBAL_DATA_PTR;
  35. /**
  36. * regmap_alloc() - Allocate a regmap with a given number of ranges.
  37. *
  38. * @count: Number of ranges to be allocated for the regmap.
  39. *
  40. * The default regmap width is set to REGMAP_SIZE_32. Callers can override it
  41. * if they need.
  42. *
  43. * Return: A pointer to the newly allocated regmap, or NULL on error.
  44. */
  45. static struct regmap *regmap_alloc(int count)
  46. {
  47. struct regmap *map;
  48. size_t size = sizeof(*map) + sizeof(map->ranges[0]) * count;
  49. map = calloc(1, size);
  50. if (!map)
  51. return NULL;
  52. map->range_count = count;
  53. map->width = REGMAP_SIZE_32;
  54. return map;
  55. }
  56. #if CONFIG_IS_ENABLED(OF_PLATDATA)
  57. int regmap_init_mem_plat(struct udevice *dev, fdt_val_t *reg, int count,
  58. struct regmap **mapp)
  59. {
  60. struct regmap_range *range;
  61. struct regmap *map;
  62. map = regmap_alloc(count);
  63. if (!map)
  64. return -ENOMEM;
  65. for (range = map->ranges; count > 0; reg += 2, range++, count--) {
  66. range->start = *reg;
  67. range->size = reg[1];
  68. }
  69. *mapp = map;
  70. return 0;
  71. }
  72. #else
  73. /**
  74. * init_range() - Initialize a single range of a regmap
  75. * @node: Device node that will use the map in question
  76. * @range: Pointer to a regmap_range structure that will be initialized
  77. * @addr_len: The length of the addr parts of the reg property
  78. * @size_len: The length of the size parts of the reg property
  79. * @index: The index of the range to initialize
  80. *
  81. * This function will read the necessary 'reg' information from the device tree
  82. * (the 'addr' part, and the 'length' part), and initialize the range in
  83. * quesion.
  84. *
  85. * Return: 0 if OK, -ve on error
  86. */
  87. static int init_range(ofnode node, struct regmap_range *range, int addr_len,
  88. int size_len, int index)
  89. {
  90. fdt_size_t sz;
  91. struct resource r;
  92. if (of_live_active()) {
  93. int ret;
  94. ret = of_address_to_resource(ofnode_to_np(node),
  95. index, &r);
  96. if (ret) {
  97. debug("%s: Could not read resource of range %d (ret = %d)\n",
  98. ofnode_get_name(node), index, ret);
  99. return ret;
  100. }
  101. range->start = r.start;
  102. range->size = r.end - r.start + 1;
  103. } else {
  104. int offset = ofnode_to_offset(node);
  105. range->start = fdtdec_get_addr_size_fixed(gd->fdt_blob, offset,
  106. "reg", index,
  107. addr_len, size_len,
  108. &sz, true);
  109. if (range->start == FDT_ADDR_T_NONE) {
  110. debug("%s: Could not read start of range %d\n",
  111. ofnode_get_name(node), index);
  112. return -EINVAL;
  113. }
  114. range->size = sz;
  115. }
  116. return 0;
  117. }
  118. int regmap_init_mem_index(ofnode node, struct regmap **mapp, int index)
  119. {
  120. struct regmap *map;
  121. int addr_len, size_len;
  122. int ret;
  123. addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
  124. if (addr_len < 0) {
  125. debug("%s: Error while reading the addr length (ret = %d)\n",
  126. ofnode_get_name(node), addr_len);
  127. return addr_len;
  128. }
  129. size_len = ofnode_read_simple_size_cells(ofnode_get_parent(node));
  130. if (size_len < 0) {
  131. debug("%s: Error while reading the size length: (ret = %d)\n",
  132. ofnode_get_name(node), size_len);
  133. return size_len;
  134. }
  135. map = regmap_alloc(1);
  136. if (!map)
  137. return -ENOMEM;
  138. ret = init_range(node, map->ranges, addr_len, size_len, index);
  139. if (ret)
  140. goto err;
  141. if (ofnode_read_bool(node, "little-endian"))
  142. map->endianness = REGMAP_LITTLE_ENDIAN;
  143. else if (ofnode_read_bool(node, "big-endian"))
  144. map->endianness = REGMAP_BIG_ENDIAN;
  145. else if (ofnode_read_bool(node, "native-endian"))
  146. map->endianness = REGMAP_NATIVE_ENDIAN;
  147. else /* Default: native endianness */
  148. map->endianness = REGMAP_NATIVE_ENDIAN;
  149. *mapp = map;
  150. return 0;
  151. err:
  152. regmap_uninit(map);
  153. return ret;
  154. }
  155. int regmap_init_mem_range(ofnode node, ulong r_start, ulong r_size,
  156. struct regmap **mapp)
  157. {
  158. struct regmap *map;
  159. struct regmap_range *range;
  160. map = regmap_alloc(1);
  161. if (!map)
  162. return -ENOMEM;
  163. range = &map->ranges[0];
  164. range->start = r_start;
  165. range->size = r_size;
  166. if (ofnode_read_bool(node, "little-endian"))
  167. map->endianness = REGMAP_LITTLE_ENDIAN;
  168. else if (ofnode_read_bool(node, "big-endian"))
  169. map->endianness = REGMAP_BIG_ENDIAN;
  170. else if (ofnode_read_bool(node, "native-endian"))
  171. map->endianness = REGMAP_NATIVE_ENDIAN;
  172. else /* Default: native endianness */
  173. map->endianness = REGMAP_NATIVE_ENDIAN;
  174. *mapp = map;
  175. return 0;
  176. }
  177. int regmap_init_mem(ofnode node, struct regmap **mapp)
  178. {
  179. struct regmap_range *range;
  180. struct regmap *map;
  181. int count;
  182. int addr_len, size_len, both_len;
  183. int len;
  184. int index;
  185. int ret;
  186. addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
  187. if (addr_len < 0) {
  188. debug("%s: Error while reading the addr length (ret = %d)\n",
  189. ofnode_get_name(node), addr_len);
  190. return addr_len;
  191. }
  192. size_len = ofnode_read_simple_size_cells(ofnode_get_parent(node));
  193. if (size_len < 0) {
  194. debug("%s: Error while reading the size length: (ret = %d)\n",
  195. ofnode_get_name(node), size_len);
  196. return size_len;
  197. }
  198. both_len = addr_len + size_len;
  199. if (!both_len) {
  200. debug("%s: Both addr and size length are zero\n",
  201. ofnode_get_name(node));
  202. return -EINVAL;
  203. }
  204. len = ofnode_read_size(node, "reg");
  205. if (len < 0) {
  206. debug("%s: Error while reading reg size (ret = %d)\n",
  207. ofnode_get_name(node), len);
  208. return len;
  209. }
  210. len /= sizeof(fdt32_t);
  211. count = len / both_len;
  212. if (!count) {
  213. debug("%s: Not enough data in reg property\n",
  214. ofnode_get_name(node));
  215. return -EINVAL;
  216. }
  217. map = regmap_alloc(count);
  218. if (!map)
  219. return -ENOMEM;
  220. for (range = map->ranges, index = 0; count > 0;
  221. count--, range++, index++) {
  222. ret = init_range(node, range, addr_len, size_len, index);
  223. if (ret)
  224. goto err;
  225. }
  226. if (ofnode_read_bool(node, "little-endian"))
  227. map->endianness = REGMAP_LITTLE_ENDIAN;
  228. else if (ofnode_read_bool(node, "big-endian"))
  229. map->endianness = REGMAP_BIG_ENDIAN;
  230. else if (ofnode_read_bool(node, "native-endian"))
  231. map->endianness = REGMAP_NATIVE_ENDIAN;
  232. else /* Default: native endianness */
  233. map->endianness = REGMAP_NATIVE_ENDIAN;
  234. *mapp = map;
  235. return 0;
  236. err:
  237. regmap_uninit(map);
  238. return ret;
  239. }
  240. static void devm_regmap_release(struct udevice *dev, void *res)
  241. {
  242. regmap_uninit(*(struct regmap **)res);
  243. }
  244. struct regmap *devm_regmap_init(struct udevice *dev,
  245. const struct regmap_bus *bus,
  246. void *bus_context,
  247. const struct regmap_config *config)
  248. {
  249. int rc;
  250. struct regmap **mapp, *map;
  251. mapp = devres_alloc(devm_regmap_release, sizeof(struct regmap *),
  252. __GFP_ZERO);
  253. if (unlikely(!mapp))
  254. return ERR_PTR(-ENOMEM);
  255. if (config && config->r_size != 0)
  256. rc = regmap_init_mem_range(dev_ofnode(dev), config->r_start,
  257. config->r_size, mapp);
  258. else
  259. rc = regmap_init_mem(dev_ofnode(dev), mapp);
  260. if (rc)
  261. return ERR_PTR(rc);
  262. map = *mapp;
  263. if (config) {
  264. map->width = config->width;
  265. map->reg_offset_shift = config->reg_offset_shift;
  266. }
  267. devres_add(dev, mapp);
  268. return *mapp;
  269. }
  270. #endif
  271. void *regmap_get_range(struct regmap *map, unsigned int range_num)
  272. {
  273. struct regmap_range *range;
  274. if (range_num >= map->range_count)
  275. return NULL;
  276. range = &map->ranges[range_num];
  277. return map_sysmem(range->start, range->size);
  278. }
  279. int regmap_uninit(struct regmap *map)
  280. {
  281. free(map);
  282. return 0;
  283. }
  284. static inline u8 __read_8(u8 *addr, enum regmap_endianness_t endianness)
  285. {
  286. return readb(addr);
  287. }
  288. static inline u16 __read_16(u16 *addr, enum regmap_endianness_t endianness)
  289. {
  290. switch (endianness) {
  291. case REGMAP_LITTLE_ENDIAN:
  292. return in_le16(addr);
  293. case REGMAP_BIG_ENDIAN:
  294. return in_be16(addr);
  295. case REGMAP_NATIVE_ENDIAN:
  296. return readw(addr);
  297. }
  298. return readw(addr);
  299. }
  300. static inline u32 __read_32(u32 *addr, enum regmap_endianness_t endianness)
  301. {
  302. switch (endianness) {
  303. case REGMAP_LITTLE_ENDIAN:
  304. return in_le32(addr);
  305. case REGMAP_BIG_ENDIAN:
  306. return in_be32(addr);
  307. case REGMAP_NATIVE_ENDIAN:
  308. return readl(addr);
  309. }
  310. return readl(addr);
  311. }
  312. #if defined(in_le64) && defined(in_be64) && defined(readq)
  313. static inline u64 __read_64(u64 *addr, enum regmap_endianness_t endianness)
  314. {
  315. switch (endianness) {
  316. case REGMAP_LITTLE_ENDIAN:
  317. return in_le64(addr);
  318. case REGMAP_BIG_ENDIAN:
  319. return in_be64(addr);
  320. case REGMAP_NATIVE_ENDIAN:
  321. return readq(addr);
  322. }
  323. return readq(addr);
  324. }
  325. #endif
  326. int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
  327. void *valp, size_t val_len)
  328. {
  329. struct regmap_range *range;
  330. void *ptr;
  331. if (range_num >= map->range_count) {
  332. debug("%s: range index %d larger than range count\n",
  333. __func__, range_num);
  334. return -ERANGE;
  335. }
  336. range = &map->ranges[range_num];
  337. offset <<= map->reg_offset_shift;
  338. if (offset + val_len > range->size) {
  339. debug("%s: offset/size combination invalid\n", __func__);
  340. return -ERANGE;
  341. }
  342. ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
  343. switch (val_len) {
  344. case REGMAP_SIZE_8:
  345. *((u8 *)valp) = __read_8(ptr, map->endianness);
  346. break;
  347. case REGMAP_SIZE_16:
  348. *((u16 *)valp) = __read_16(ptr, map->endianness);
  349. break;
  350. case REGMAP_SIZE_32:
  351. *((u32 *)valp) = __read_32(ptr, map->endianness);
  352. break;
  353. #if defined(in_le64) && defined(in_be64) && defined(readq)
  354. case REGMAP_SIZE_64:
  355. *((u64 *)valp) = __read_64(ptr, map->endianness);
  356. break;
  357. #endif
  358. default:
  359. debug("%s: regmap size %zu unknown\n", __func__, val_len);
  360. return -EINVAL;
  361. }
  362. return 0;
  363. }
  364. int regmap_raw_read(struct regmap *map, uint offset, void *valp, size_t val_len)
  365. {
  366. return regmap_raw_read_range(map, 0, offset, valp, val_len);
  367. }
  368. int regmap_read(struct regmap *map, uint offset, uint *valp)
  369. {
  370. union {
  371. u8 v8;
  372. u16 v16;
  373. u32 v32;
  374. u64 v64;
  375. } u;
  376. int res;
  377. res = regmap_raw_read(map, offset, &u, map->width);
  378. if (res)
  379. return res;
  380. switch (map->width) {
  381. case REGMAP_SIZE_8:
  382. *valp = u.v8;
  383. break;
  384. case REGMAP_SIZE_16:
  385. *valp = u.v16;
  386. break;
  387. case REGMAP_SIZE_32:
  388. *valp = u.v32;
  389. break;
  390. case REGMAP_SIZE_64:
  391. *valp = u.v64;
  392. break;
  393. default:
  394. unreachable();
  395. }
  396. return 0;
  397. }
  398. static inline void __write_8(u8 *addr, const u8 *val,
  399. enum regmap_endianness_t endianness)
  400. {
  401. writeb(*val, addr);
  402. }
  403. static inline void __write_16(u16 *addr, const u16 *val,
  404. enum regmap_endianness_t endianness)
  405. {
  406. switch (endianness) {
  407. case REGMAP_NATIVE_ENDIAN:
  408. writew(*val, addr);
  409. break;
  410. case REGMAP_LITTLE_ENDIAN:
  411. out_le16(addr, *val);
  412. break;
  413. case REGMAP_BIG_ENDIAN:
  414. out_be16(addr, *val);
  415. break;
  416. }
  417. }
  418. static inline void __write_32(u32 *addr, const u32 *val,
  419. enum regmap_endianness_t endianness)
  420. {
  421. switch (endianness) {
  422. case REGMAP_NATIVE_ENDIAN:
  423. writel(*val, addr);
  424. break;
  425. case REGMAP_LITTLE_ENDIAN:
  426. out_le32(addr, *val);
  427. break;
  428. case REGMAP_BIG_ENDIAN:
  429. out_be32(addr, *val);
  430. break;
  431. }
  432. }
  433. #if defined(out_le64) && defined(out_be64) && defined(writeq)
  434. static inline void __write_64(u64 *addr, const u64 *val,
  435. enum regmap_endianness_t endianness)
  436. {
  437. switch (endianness) {
  438. case REGMAP_NATIVE_ENDIAN:
  439. writeq(*val, addr);
  440. break;
  441. case REGMAP_LITTLE_ENDIAN:
  442. out_le64(addr, *val);
  443. break;
  444. case REGMAP_BIG_ENDIAN:
  445. out_be64(addr, *val);
  446. break;
  447. }
  448. }
  449. #endif
  450. int regmap_raw_write_range(struct regmap *map, uint range_num, uint offset,
  451. const void *val, size_t val_len)
  452. {
  453. struct regmap_range *range;
  454. void *ptr;
  455. if (range_num >= map->range_count) {
  456. debug("%s: range index %d larger than range count\n",
  457. __func__, range_num);
  458. return -ERANGE;
  459. }
  460. range = &map->ranges[range_num];
  461. offset <<= map->reg_offset_shift;
  462. if (offset + val_len > range->size) {
  463. debug("%s: offset/size combination invalid\n", __func__);
  464. return -ERANGE;
  465. }
  466. ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
  467. switch (val_len) {
  468. case REGMAP_SIZE_8:
  469. __write_8(ptr, val, map->endianness);
  470. break;
  471. case REGMAP_SIZE_16:
  472. __write_16(ptr, val, map->endianness);
  473. break;
  474. case REGMAP_SIZE_32:
  475. __write_32(ptr, val, map->endianness);
  476. break;
  477. #if defined(out_le64) && defined(out_be64) && defined(writeq)
  478. case REGMAP_SIZE_64:
  479. __write_64(ptr, val, map->endianness);
  480. break;
  481. #endif
  482. default:
  483. debug("%s: regmap size %zu unknown\n", __func__, val_len);
  484. return -EINVAL;
  485. }
  486. return 0;
  487. }
  488. int regmap_raw_write(struct regmap *map, uint offset, const void *val,
  489. size_t val_len)
  490. {
  491. return regmap_raw_write_range(map, 0, offset, val, val_len);
  492. }
  493. int regmap_write(struct regmap *map, uint offset, uint val)
  494. {
  495. union {
  496. u8 v8;
  497. u16 v16;
  498. u32 v32;
  499. u64 v64;
  500. } u;
  501. switch (map->width) {
  502. case REGMAP_SIZE_8:
  503. u.v8 = val;
  504. break;
  505. case REGMAP_SIZE_16:
  506. u.v16 = val;
  507. break;
  508. case REGMAP_SIZE_32:
  509. u.v32 = val;
  510. break;
  511. case REGMAP_SIZE_64:
  512. u.v64 = val;
  513. break;
  514. default:
  515. debug("%s: regmap size %zu unknown\n", __func__,
  516. (size_t)map->width);
  517. return -EINVAL;
  518. }
  519. return regmap_raw_write(map, offset, &u, map->width);
  520. }
  521. int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val)
  522. {
  523. uint reg;
  524. int ret;
  525. ret = regmap_read(map, offset, &reg);
  526. if (ret)
  527. return ret;
  528. reg &= ~mask;
  529. return regmap_write(map, offset, reg | (val & mask));
  530. }
  531. int regmap_field_read(struct regmap_field *field, unsigned int *val)
  532. {
  533. int ret;
  534. unsigned int reg_val;
  535. ret = regmap_read(field->regmap, field->reg, &reg_val);
  536. if (ret != 0)
  537. return ret;
  538. reg_val &= field->mask;
  539. reg_val >>= field->shift;
  540. *val = reg_val;
  541. return ret;
  542. }
  543. int regmap_field_write(struct regmap_field *field, unsigned int val)
  544. {
  545. return regmap_update_bits(field->regmap, field->reg, field->mask,
  546. val << field->shift);
  547. }
  548. static void regmap_field_init(struct regmap_field *rm_field,
  549. struct regmap *regmap,
  550. struct reg_field reg_field)
  551. {
  552. rm_field->regmap = regmap;
  553. rm_field->reg = reg_field.reg;
  554. rm_field->shift = reg_field.lsb;
  555. rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
  556. }
  557. struct regmap_field *devm_regmap_field_alloc(struct udevice *dev,
  558. struct regmap *regmap,
  559. struct reg_field reg_field)
  560. {
  561. struct regmap_field *rm_field = devm_kzalloc(dev, sizeof(*rm_field),
  562. GFP_KERNEL);
  563. if (!rm_field)
  564. return ERR_PTR(-ENOMEM);
  565. regmap_field_init(rm_field, regmap, reg_field);
  566. return rm_field;
  567. }
  568. void devm_regmap_field_free(struct udevice *dev, struct regmap_field *field)
  569. {
  570. devm_kfree(dev, field);
  571. }
  572. struct regmap_field *regmap_field_alloc(struct regmap *regmap,
  573. struct reg_field reg_field)
  574. {
  575. struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
  576. if (!rm_field)
  577. return ERR_PTR(-ENOMEM);
  578. regmap_field_init(rm_field, regmap, reg_field);
  579. return rm_field;
  580. }
  581. void regmap_field_free(struct regmap_field *field)
  582. {
  583. kfree(field);
  584. }