regmap.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592
  1. /*
  2. * Register map access API
  3. *
  4. * Copyright 2011 Wolfson Microelectronics plc
  5. *
  6. * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License version 2 as
  10. * published by the Free Software Foundation.
  11. */
  12. #include <linux/slab.h>
  13. #include <linux/module.h>
  14. #include <linux/mutex.h>
  15. #include <linux/err.h>
  16. #define CREATE_TRACE_POINTS
  17. #include <trace/events/regmap.h>
  18. #include "internal.h"
  19. bool regmap_writeable(struct regmap *map, unsigned int reg)
  20. {
  21. if (map->max_register && reg > map->max_register)
  22. return false;
  23. if (map->writeable_reg)
  24. return map->writeable_reg(map->dev, reg);
  25. return true;
  26. }
  27. bool regmap_readable(struct regmap *map, unsigned int reg)
  28. {
  29. if (map->max_register && reg > map->max_register)
  30. return false;
  31. if (map->readable_reg)
  32. return map->readable_reg(map->dev, reg);
  33. return true;
  34. }
  35. bool regmap_volatile(struct regmap *map, unsigned int reg)
  36. {
  37. if (map->max_register && reg > map->max_register)
  38. return false;
  39. if (map->volatile_reg)
  40. return map->volatile_reg(map->dev, reg);
  41. return true;
  42. }
  43. bool regmap_precious(struct regmap *map, unsigned int reg)
  44. {
  45. if (map->max_register && reg > map->max_register)
  46. return false;
  47. if (map->precious_reg)
  48. return map->precious_reg(map->dev, reg);
  49. return false;
  50. }
  51. static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
  52. unsigned int num)
  53. {
  54. unsigned int i;
  55. for (i = 0; i < num; i++)
  56. if (!regmap_volatile(map, reg + i))
  57. return false;
  58. return true;
  59. }
  60. static void regmap_format_4_12_write(struct regmap *map,
  61. unsigned int reg, unsigned int val)
  62. {
  63. __be16 *out = map->work_buf;
  64. *out = cpu_to_be16((reg << 12) | val);
  65. }
  66. static void regmap_format_7_9_write(struct regmap *map,
  67. unsigned int reg, unsigned int val)
  68. {
  69. __be16 *out = map->work_buf;
  70. *out = cpu_to_be16((reg << 9) | val);
  71. }
  72. static void regmap_format_8(void *buf, unsigned int val)
  73. {
  74. u8 *b = buf;
  75. b[0] = val;
  76. }
  77. static void regmap_format_16(void *buf, unsigned int val)
  78. {
  79. __be16 *b = buf;
  80. b[0] = cpu_to_be16(val);
  81. }
  82. static unsigned int regmap_parse_8(void *buf)
  83. {
  84. u8 *b = buf;
  85. return b[0];
  86. }
  87. static unsigned int regmap_parse_16(void *buf)
  88. {
  89. __be16 *b = buf;
  90. b[0] = be16_to_cpu(b[0]);
  91. return b[0];
  92. }
  93. /**
  94. * regmap_init(): Initialise register map
  95. *
  96. * @dev: Device that will be interacted with
  97. * @bus: Bus-specific callbacks to use with device
  98. * @config: Configuration for register map
  99. *
  100. * The return value will be an ERR_PTR() on error or a valid pointer to
  101. * a struct regmap. This function should generally not be called
  102. * directly, it should be called by bus-specific init functions.
  103. */
  104. struct regmap *regmap_init(struct device *dev,
  105. const struct regmap_bus *bus,
  106. const struct regmap_config *config)
  107. {
  108. struct regmap *map;
  109. int ret = -EINVAL;
  110. if (!bus || !config)
  111. goto err;
  112. map = kzalloc(sizeof(*map), GFP_KERNEL);
  113. if (map == NULL) {
  114. ret = -ENOMEM;
  115. goto err;
  116. }
  117. mutex_init(&map->lock);
  118. map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
  119. map->format.reg_bytes = config->reg_bits / 8;
  120. map->format.val_bytes = config->val_bits / 8;
  121. map->dev = dev;
  122. map->bus = bus;
  123. map->max_register = config->max_register;
  124. map->writeable_reg = config->writeable_reg;
  125. map->readable_reg = config->readable_reg;
  126. map->volatile_reg = config->volatile_reg;
  127. map->precious_reg = config->precious_reg;
  128. map->cache_type = config->cache_type;
  129. if (config->read_flag_mask || config->write_flag_mask) {
  130. map->read_flag_mask = config->read_flag_mask;
  131. map->write_flag_mask = config->write_flag_mask;
  132. } else {
  133. map->read_flag_mask = bus->read_flag_mask;
  134. }
  135. switch (config->reg_bits) {
  136. case 4:
  137. switch (config->val_bits) {
  138. case 12:
  139. map->format.format_write = regmap_format_4_12_write;
  140. break;
  141. default:
  142. goto err_map;
  143. }
  144. break;
  145. case 7:
  146. switch (config->val_bits) {
  147. case 9:
  148. map->format.format_write = regmap_format_7_9_write;
  149. break;
  150. default:
  151. goto err_map;
  152. }
  153. break;
  154. case 8:
  155. map->format.format_reg = regmap_format_8;
  156. break;
  157. case 16:
  158. map->format.format_reg = regmap_format_16;
  159. break;
  160. default:
  161. goto err_map;
  162. }
  163. switch (config->val_bits) {
  164. case 8:
  165. map->format.format_val = regmap_format_8;
  166. map->format.parse_val = regmap_parse_8;
  167. break;
  168. case 16:
  169. map->format.format_val = regmap_format_16;
  170. map->format.parse_val = regmap_parse_16;
  171. break;
  172. }
  173. if (!map->format.format_write &&
  174. !(map->format.format_reg && map->format.format_val))
  175. goto err_map;
  176. map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
  177. if (map->work_buf == NULL) {
  178. ret = -ENOMEM;
  179. goto err_map;
  180. }
  181. ret = regcache_init(map, config);
  182. if (ret < 0)
  183. goto err_free_workbuf;
  184. regmap_debugfs_init(map);
  185. return map;
  186. err_free_workbuf:
  187. kfree(map->work_buf);
  188. err_map:
  189. kfree(map);
  190. err:
  191. return ERR_PTR(ret);
  192. }
  193. EXPORT_SYMBOL_GPL(regmap_init);
  194. /**
  195. * regmap_exit(): Free a previously allocated register map
  196. */
  197. void regmap_exit(struct regmap *map)
  198. {
  199. regcache_exit(map);
  200. regmap_debugfs_exit(map);
  201. kfree(map->work_buf);
  202. kfree(map);
  203. }
  204. EXPORT_SYMBOL_GPL(regmap_exit);
  205. static int _regmap_raw_write(struct regmap *map, unsigned int reg,
  206. const void *val, size_t val_len)
  207. {
  208. u8 *u8 = map->work_buf;
  209. void *buf;
  210. int ret = -ENOTSUPP;
  211. size_t len;
  212. int i;
  213. /* Check for unwritable registers before we start */
  214. if (map->writeable_reg)
  215. for (i = 0; i < val_len / map->format.val_bytes; i++)
  216. if (!map->writeable_reg(map->dev, reg + i))
  217. return -EINVAL;
  218. map->format.format_reg(map->work_buf, reg);
  219. u8[0] |= map->write_flag_mask;
  220. trace_regmap_hw_write_start(map->dev, reg,
  221. val_len / map->format.val_bytes);
  222. /* If we're doing a single register write we can probably just
  223. * send the work_buf directly, otherwise try to do a gather
  224. * write.
  225. */
  226. if (val == map->work_buf + map->format.reg_bytes)
  227. ret = map->bus->write(map->dev, map->work_buf,
  228. map->format.reg_bytes + val_len);
  229. else if (map->bus->gather_write)
  230. ret = map->bus->gather_write(map->dev, map->work_buf,
  231. map->format.reg_bytes,
  232. val, val_len);
  233. /* If that didn't work fall back on linearising by hand. */
  234. if (ret == -ENOTSUPP) {
  235. len = map->format.reg_bytes + val_len;
  236. buf = kmalloc(len, GFP_KERNEL);
  237. if (!buf)
  238. return -ENOMEM;
  239. memcpy(buf, map->work_buf, map->format.reg_bytes);
  240. memcpy(buf + map->format.reg_bytes, val, val_len);
  241. ret = map->bus->write(map->dev, buf, len);
  242. kfree(buf);
  243. }
  244. trace_regmap_hw_write_done(map->dev, reg,
  245. val_len / map->format.val_bytes);
  246. return ret;
  247. }
  248. int _regmap_write(struct regmap *map, unsigned int reg,
  249. unsigned int val)
  250. {
  251. int ret;
  252. BUG_ON(!map->format.format_write && !map->format.format_val);
  253. if (!map->cache_bypass) {
  254. ret = regcache_write(map, reg, val);
  255. if (ret != 0)
  256. return ret;
  257. if (map->cache_only) {
  258. map->cache_dirty = true;
  259. return 0;
  260. }
  261. }
  262. trace_regmap_reg_write(map->dev, reg, val);
  263. if (map->format.format_write) {
  264. map->format.format_write(map, reg, val);
  265. trace_regmap_hw_write_start(map->dev, reg, 1);
  266. ret = map->bus->write(map->dev, map->work_buf,
  267. map->format.buf_size);
  268. trace_regmap_hw_write_done(map->dev, reg, 1);
  269. return ret;
  270. } else {
  271. map->format.format_val(map->work_buf + map->format.reg_bytes,
  272. val);
  273. return _regmap_raw_write(map, reg,
  274. map->work_buf + map->format.reg_bytes,
  275. map->format.val_bytes);
  276. }
  277. }
  278. /**
  279. * regmap_write(): Write a value to a single register
  280. *
  281. * @map: Register map to write to
  282. * @reg: Register to write to
  283. * @val: Value to be written
  284. *
  285. * A value of zero will be returned on success, a negative errno will
  286. * be returned in error cases.
  287. */
  288. int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
  289. {
  290. int ret;
  291. mutex_lock(&map->lock);
  292. ret = _regmap_write(map, reg, val);
  293. mutex_unlock(&map->lock);
  294. return ret;
  295. }
  296. EXPORT_SYMBOL_GPL(regmap_write);
  297. /**
  298. * regmap_raw_write(): Write raw values to one or more registers
  299. *
  300. * @map: Register map to write to
  301. * @reg: Initial register to write to
  302. * @val: Block of data to be written, laid out for direct transmission to the
  303. * device
  304. * @val_len: Length of data pointed to by val.
  305. *
  306. * This function is intended to be used for things like firmware
  307. * download where a large block of data needs to be transferred to the
  308. * device. No formatting will be done on the data provided.
  309. *
  310. * A value of zero will be returned on success, a negative errno will
  311. * be returned in error cases.
  312. */
  313. int regmap_raw_write(struct regmap *map, unsigned int reg,
  314. const void *val, size_t val_len)
  315. {
  316. size_t val_count = val_len / map->format.val_bytes;
  317. int ret;
  318. WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
  319. map->cache_type != REGCACHE_NONE);
  320. mutex_lock(&map->lock);
  321. ret = _regmap_raw_write(map, reg, val, val_len);
  322. mutex_unlock(&map->lock);
  323. return ret;
  324. }
  325. EXPORT_SYMBOL_GPL(regmap_raw_write);
  326. static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
  327. unsigned int val_len)
  328. {
  329. u8 *u8 = map->work_buf;
  330. int ret;
  331. map->format.format_reg(map->work_buf, reg);
  332. /*
  333. * Some buses or devices flag reads by setting the high bits in the
  334. * register addresss; since it's always the high bits for all
  335. * current formats we can do this here rather than in
  336. * formatting. This may break if we get interesting formats.
  337. */
  338. u8[0] |= map->read_flag_mask;
  339. trace_regmap_hw_read_start(map->dev, reg,
  340. val_len / map->format.val_bytes);
  341. ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
  342. val, val_len);
  343. trace_regmap_hw_read_done(map->dev, reg,
  344. val_len / map->format.val_bytes);
  345. return ret;
  346. }
  347. static int _regmap_read(struct regmap *map, unsigned int reg,
  348. unsigned int *val)
  349. {
  350. int ret;
  351. if (!map->format.parse_val)
  352. return -EINVAL;
  353. if (!map->cache_bypass) {
  354. ret = regcache_read(map, reg, val);
  355. if (ret == 0)
  356. return 0;
  357. }
  358. if (map->cache_only)
  359. return -EBUSY;
  360. ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
  361. if (ret == 0) {
  362. *val = map->format.parse_val(map->work_buf);
  363. trace_regmap_reg_read(map->dev, reg, *val);
  364. }
  365. return ret;
  366. }
  367. /**
  368. * regmap_read(): Read a value from a single register
  369. *
  370. * @map: Register map to write to
  371. * @reg: Register to be read from
  372. * @val: Pointer to store read value
  373. *
  374. * A value of zero will be returned on success, a negative errno will
  375. * be returned in error cases.
  376. */
  377. int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
  378. {
  379. int ret;
  380. mutex_lock(&map->lock);
  381. ret = _regmap_read(map, reg, val);
  382. mutex_unlock(&map->lock);
  383. return ret;
  384. }
  385. EXPORT_SYMBOL_GPL(regmap_read);
  386. /**
  387. * regmap_raw_read(): Read raw data from the device
  388. *
  389. * @map: Register map to write to
  390. * @reg: First register to be read from
  391. * @val: Pointer to store read value
  392. * @val_len: Size of data to read
  393. *
  394. * A value of zero will be returned on success, a negative errno will
  395. * be returned in error cases.
  396. */
  397. int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
  398. size_t val_len)
  399. {
  400. size_t val_count = val_len / map->format.val_bytes;
  401. int ret;
  402. WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
  403. map->cache_type != REGCACHE_NONE);
  404. mutex_lock(&map->lock);
  405. ret = _regmap_raw_read(map, reg, val, val_len);
  406. mutex_unlock(&map->lock);
  407. return ret;
  408. }
  409. EXPORT_SYMBOL_GPL(regmap_raw_read);
  410. /**
  411. * regmap_bulk_read(): Read multiple registers from the device
  412. *
  413. * @map: Register map to write to
  414. * @reg: First register to be read from
  415. * @val: Pointer to store read value, in native register size for device
  416. * @val_count: Number of registers to read
  417. *
  418. * A value of zero will be returned on success, a negative errno will
  419. * be returned in error cases.
  420. */
  421. int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
  422. size_t val_count)
  423. {
  424. int ret, i;
  425. size_t val_bytes = map->format.val_bytes;
  426. bool vol = regmap_volatile_range(map, reg, val_count);
  427. if (!map->format.parse_val)
  428. return -EINVAL;
  429. if (vol || map->cache_type == REGCACHE_NONE) {
  430. ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
  431. if (ret != 0)
  432. return ret;
  433. for (i = 0; i < val_count * val_bytes; i += val_bytes)
  434. map->format.parse_val(val + i);
  435. } else {
  436. for (i = 0; i < val_count; i++) {
  437. ret = regmap_read(map, reg + i, val + (i * val_bytes));
  438. if (ret != 0)
  439. return ret;
  440. }
  441. }
  442. return 0;
  443. }
  444. EXPORT_SYMBOL_GPL(regmap_bulk_read);
  445. /**
  446. * regmap_update_bits: Perform a read/modify/write cycle on the register map
  447. *
  448. * @map: Register map to update
  449. * @reg: Register to update
  450. * @mask: Bitmask to change
  451. * @val: New value for bitmask
  452. *
  453. * Returns zero for success, a negative number on error.
  454. */
  455. int regmap_update_bits(struct regmap *map, unsigned int reg,
  456. unsigned int mask, unsigned int val)
  457. {
  458. int ret;
  459. unsigned int tmp;
  460. mutex_lock(&map->lock);
  461. ret = _regmap_read(map, reg, &tmp);
  462. if (ret != 0)
  463. goto out;
  464. tmp &= ~mask;
  465. tmp |= val & mask;
  466. ret = _regmap_write(map, reg, tmp);
  467. out:
  468. mutex_unlock(&map->lock);
  469. return ret;
  470. }
  471. EXPORT_SYMBOL_GPL(regmap_update_bits);
  472. static int __init regmap_initcall(void)
  473. {
  474. regmap_debugfs_initcall();
  475. return 0;
  476. }
  477. postcore_initcall(regmap_initcall);