isl29501.c 23 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * isl29501.c: ISL29501 Time of Flight sensor driver.
  4. *
  5. * Copyright (C) 2018
  6. * Author: Mathieu Othacehe <m.othacehe@gmail.com>
  7. *
  8. * 7-bit I2C slave address: 0x57
  9. */
  10. #include <linux/kernel.h>
  11. #include <linux/module.h>
  12. #include <linux/i2c.h>
  13. #include <linux/err.h>
  14. #include <linux/of_device.h>
  15. #include <linux/iio/iio.h>
  16. #include <linux/iio/sysfs.h>
  17. #include <linux/iio/trigger_consumer.h>
  18. #include <linux/iio/buffer.h>
  19. #include <linux/iio/triggered_buffer.h>
  20. /* Control, setting and status registers */
  21. #define ISL29501_DEVICE_ID 0x00
  22. #define ISL29501_ID 0x0A
  23. /* Sampling control registers */
  24. #define ISL29501_INTEGRATION_PERIOD 0x10
  25. #define ISL29501_SAMPLE_PERIOD 0x11
  26. /* Closed loop calibration registers */
  27. #define ISL29501_CROSSTALK_I_MSB 0x24
  28. #define ISL29501_CROSSTALK_I_LSB 0x25
  29. #define ISL29501_CROSSTALK_I_EXPONENT 0x26
  30. #define ISL29501_CROSSTALK_Q_MSB 0x27
  31. #define ISL29501_CROSSTALK_Q_LSB 0x28
  32. #define ISL29501_CROSSTALK_Q_EXPONENT 0x29
  33. #define ISL29501_CROSSTALK_GAIN_MSB 0x2A
  34. #define ISL29501_CROSSTALK_GAIN_LSB 0x2B
  35. #define ISL29501_MAGNITUDE_REF_EXP 0x2C
  36. #define ISL29501_MAGNITUDE_REF_MSB 0x2D
  37. #define ISL29501_MAGNITUDE_REF_LSB 0x2E
  38. #define ISL29501_PHASE_OFFSET_MSB 0x2F
  39. #define ISL29501_PHASE_OFFSET_LSB 0x30
  40. /* Analog control registers */
  41. #define ISL29501_DRIVER_RANGE 0x90
  42. #define ISL29501_EMITTER_DAC 0x91
  43. #define ISL29501_COMMAND_REGISTER 0xB0
  44. /* Commands */
  45. #define ISL29501_EMUL_SAMPLE_START_PIN 0x49
  46. #define ISL29501_RESET_ALL_REGISTERS 0xD7
  47. #define ISL29501_RESET_INT_SM 0xD1
  48. /* Ambiant light and temperature corrections */
  49. #define ISL29501_TEMP_REFERENCE 0x31
  50. #define ISL29501_PHASE_EXPONENT 0x33
  51. #define ISL29501_TEMP_COEFF_A 0x34
  52. #define ISL29501_TEMP_COEFF_B 0x39
  53. #define ISL29501_AMBIANT_COEFF_A 0x36
  54. #define ISL29501_AMBIANT_COEFF_B 0x3B
  55. /* Data output registers */
  56. #define ISL29501_DISTANCE_MSB_DATA 0xD1
  57. #define ISL29501_DISTANCE_LSB_DATA 0xD2
  58. #define ISL29501_PRECISION_MSB 0xD3
  59. #define ISL29501_PRECISION_LSB 0xD4
  60. #define ISL29501_MAGNITUDE_EXPONENT 0xD5
  61. #define ISL29501_MAGNITUDE_MSB 0xD6
  62. #define ISL29501_MAGNITUDE_LSB 0xD7
  63. #define ISL29501_PHASE_MSB 0xD8
  64. #define ISL29501_PHASE_LSB 0xD9
  65. #define ISL29501_I_RAW_EXPONENT 0xDA
  66. #define ISL29501_I_RAW_MSB 0xDB
  67. #define ISL29501_I_RAW_LSB 0xDC
  68. #define ISL29501_Q_RAW_EXPONENT 0xDD
  69. #define ISL29501_Q_RAW_MSB 0xDE
  70. #define ISL29501_Q_RAW_LSB 0xDF
  71. #define ISL29501_DIE_TEMPERATURE 0xE2
  72. #define ISL29501_AMBIENT_LIGHT 0xE3
  73. #define ISL29501_GAIN_MSB 0xE6
  74. #define ISL29501_GAIN_LSB 0xE7
  75. #define ISL29501_MAX_EXP_VAL 15
  76. #define ISL29501_INT_TIME_AVAILABLE \
  77. "0.00007 0.00014 0.00028 0.00057 0.00114 " \
  78. "0.00228 0.00455 0.00910 0.01820 0.03640 " \
  79. "0.07281 0.14561"
  80. #define ISL29501_CURRENT_SCALE_AVAILABLE \
  81. "0.0039 0.0078 0.0118 0.0157 0.0196 " \
  82. "0.0235 0.0275 0.0314 0.0352 0.0392 " \
  83. "0.0431 0.0471 0.0510 0.0549 0.0588"
  84. enum isl29501_correction_coeff {
  85. COEFF_TEMP_A,
  86. COEFF_TEMP_B,
  87. COEFF_LIGHT_A,
  88. COEFF_LIGHT_B,
  89. COEFF_MAX,
  90. };
  91. struct isl29501_private {
  92. struct i2c_client *client;
  93. struct mutex lock;
  94. /* Exact representation of correction coefficients. */
  95. unsigned int shadow_coeffs[COEFF_MAX];
  96. };
  97. enum isl29501_register_name {
  98. REG_DISTANCE,
  99. REG_PHASE,
  100. REG_TEMPERATURE,
  101. REG_AMBIENT_LIGHT,
  102. REG_GAIN,
  103. REG_GAIN_BIAS,
  104. REG_PHASE_EXP,
  105. REG_CALIB_PHASE_TEMP_A,
  106. REG_CALIB_PHASE_TEMP_B,
  107. REG_CALIB_PHASE_LIGHT_A,
  108. REG_CALIB_PHASE_LIGHT_B,
  109. REG_DISTANCE_BIAS,
  110. REG_TEMPERATURE_BIAS,
  111. REG_INT_TIME,
  112. REG_SAMPLE_TIME,
  113. REG_DRIVER_RANGE,
  114. REG_EMITTER_DAC,
  115. };
  116. struct isl29501_register_desc {
  117. u8 msb;
  118. u8 lsb;
  119. };
  120. static const struct isl29501_register_desc isl29501_registers[] = {
  121. [REG_DISTANCE] = {
  122. .msb = ISL29501_DISTANCE_MSB_DATA,
  123. .lsb = ISL29501_DISTANCE_LSB_DATA,
  124. },
  125. [REG_PHASE] = {
  126. .msb = ISL29501_PHASE_MSB,
  127. .lsb = ISL29501_PHASE_LSB,
  128. },
  129. [REG_TEMPERATURE] = {
  130. .lsb = ISL29501_DIE_TEMPERATURE,
  131. },
  132. [REG_AMBIENT_LIGHT] = {
  133. .lsb = ISL29501_AMBIENT_LIGHT,
  134. },
  135. [REG_GAIN] = {
  136. .msb = ISL29501_GAIN_MSB,
  137. .lsb = ISL29501_GAIN_LSB,
  138. },
  139. [REG_GAIN_BIAS] = {
  140. .msb = ISL29501_CROSSTALK_GAIN_MSB,
  141. .lsb = ISL29501_CROSSTALK_GAIN_LSB,
  142. },
  143. [REG_PHASE_EXP] = {
  144. .lsb = ISL29501_PHASE_EXPONENT,
  145. },
  146. [REG_CALIB_PHASE_TEMP_A] = {
  147. .lsb = ISL29501_TEMP_COEFF_A,
  148. },
  149. [REG_CALIB_PHASE_TEMP_B] = {
  150. .lsb = ISL29501_TEMP_COEFF_B,
  151. },
  152. [REG_CALIB_PHASE_LIGHT_A] = {
  153. .lsb = ISL29501_AMBIANT_COEFF_A,
  154. },
  155. [REG_CALIB_PHASE_LIGHT_B] = {
  156. .lsb = ISL29501_AMBIANT_COEFF_B,
  157. },
  158. [REG_DISTANCE_BIAS] = {
  159. .msb = ISL29501_PHASE_OFFSET_MSB,
  160. .lsb = ISL29501_PHASE_OFFSET_LSB,
  161. },
  162. [REG_TEMPERATURE_BIAS] = {
  163. .lsb = ISL29501_TEMP_REFERENCE,
  164. },
  165. [REG_INT_TIME] = {
  166. .lsb = ISL29501_INTEGRATION_PERIOD,
  167. },
  168. [REG_SAMPLE_TIME] = {
  169. .lsb = ISL29501_SAMPLE_PERIOD,
  170. },
  171. [REG_DRIVER_RANGE] = {
  172. .lsb = ISL29501_DRIVER_RANGE,
  173. },
  174. [REG_EMITTER_DAC] = {
  175. .lsb = ISL29501_EMITTER_DAC,
  176. },
  177. };
  178. static int isl29501_register_read(struct isl29501_private *isl29501,
  179. enum isl29501_register_name name,
  180. u32 *val)
  181. {
  182. const struct isl29501_register_desc *reg = &isl29501_registers[name];
  183. u8 msb = 0, lsb = 0;
  184. s32 ret;
  185. mutex_lock(&isl29501->lock);
  186. if (reg->msb) {
  187. ret = i2c_smbus_read_byte_data(isl29501->client, reg->msb);
  188. if (ret < 0)
  189. goto err;
  190. msb = ret;
  191. }
  192. if (reg->lsb) {
  193. ret = i2c_smbus_read_byte_data(isl29501->client, reg->lsb);
  194. if (ret < 0)
  195. goto err;
  196. lsb = ret;
  197. }
  198. mutex_unlock(&isl29501->lock);
  199. *val = (msb << 8) + lsb;
  200. return 0;
  201. err:
  202. mutex_unlock(&isl29501->lock);
  203. return ret;
  204. }
  205. static u32 isl29501_register_write(struct isl29501_private *isl29501,
  206. enum isl29501_register_name name,
  207. u32 value)
  208. {
  209. const struct isl29501_register_desc *reg = &isl29501_registers[name];
  210. int ret;
  211. if (!reg->msb && value > U8_MAX)
  212. return -ERANGE;
  213. if (value > U16_MAX)
  214. return -ERANGE;
  215. mutex_lock(&isl29501->lock);
  216. if (reg->msb) {
  217. ret = i2c_smbus_write_byte_data(isl29501->client,
  218. reg->msb, value >> 8);
  219. if (ret < 0)
  220. goto err;
  221. }
  222. ret = i2c_smbus_write_byte_data(isl29501->client, reg->lsb, value);
  223. err:
  224. mutex_unlock(&isl29501->lock);
  225. return ret;
  226. }
  227. static ssize_t isl29501_read_ext(struct iio_dev *indio_dev,
  228. uintptr_t private,
  229. const struct iio_chan_spec *chan,
  230. char *buf)
  231. {
  232. struct isl29501_private *isl29501 = iio_priv(indio_dev);
  233. enum isl29501_register_name reg = private;
  234. int ret;
  235. u32 value, gain, coeff, exp;
  236. switch (reg) {
  237. case REG_GAIN:
  238. case REG_GAIN_BIAS:
  239. ret = isl29501_register_read(isl29501, reg, &gain);
  240. if (ret < 0)
  241. return ret;
  242. value = gain;
  243. break;
  244. case REG_CALIB_PHASE_TEMP_A:
  245. case REG_CALIB_PHASE_TEMP_B:
  246. case REG_CALIB_PHASE_LIGHT_A:
  247. case REG_CALIB_PHASE_LIGHT_B:
  248. ret = isl29501_register_read(isl29501, REG_PHASE_EXP, &exp);
  249. if (ret < 0)
  250. return ret;
  251. ret = isl29501_register_read(isl29501, reg, &coeff);
  252. if (ret < 0)
  253. return ret;
  254. value = coeff << exp;
  255. break;
  256. default:
  257. return -EINVAL;
  258. }
  259. return sprintf(buf, "%u\n", value);
  260. }
  261. static int isl29501_set_shadow_coeff(struct isl29501_private *isl29501,
  262. enum isl29501_register_name reg,
  263. unsigned int val)
  264. {
  265. enum isl29501_correction_coeff coeff;
  266. switch (reg) {
  267. case REG_CALIB_PHASE_TEMP_A:
  268. coeff = COEFF_TEMP_A;
  269. break;
  270. case REG_CALIB_PHASE_TEMP_B:
  271. coeff = COEFF_TEMP_B;
  272. break;
  273. case REG_CALIB_PHASE_LIGHT_A:
  274. coeff = COEFF_LIGHT_A;
  275. break;
  276. case REG_CALIB_PHASE_LIGHT_B:
  277. coeff = COEFF_LIGHT_B;
  278. break;
  279. default:
  280. return -EINVAL;
  281. }
  282. isl29501->shadow_coeffs[coeff] = val;
  283. return 0;
  284. }
  285. static int isl29501_write_coeff(struct isl29501_private *isl29501,
  286. enum isl29501_correction_coeff coeff,
  287. int val)
  288. {
  289. enum isl29501_register_name reg;
  290. switch (coeff) {
  291. case COEFF_TEMP_A:
  292. reg = REG_CALIB_PHASE_TEMP_A;
  293. break;
  294. case COEFF_TEMP_B:
  295. reg = REG_CALIB_PHASE_TEMP_B;
  296. break;
  297. case COEFF_LIGHT_A:
  298. reg = REG_CALIB_PHASE_LIGHT_A;
  299. break;
  300. case COEFF_LIGHT_B:
  301. reg = REG_CALIB_PHASE_LIGHT_B;
  302. break;
  303. default:
  304. return -EINVAL;
  305. }
  306. return isl29501_register_write(isl29501, reg, val);
  307. }
  308. static unsigned int isl29501_find_corr_exp(unsigned int val,
  309. unsigned int max_exp,
  310. unsigned int max_mantissa)
  311. {
  312. unsigned int exp = 1;
  313. /*
  314. * Correction coefficients are represented under
  315. * mantissa * 2^exponent form, where mantissa and exponent
  316. * are stored in two separate registers of the sensor.
  317. *
  318. * Compute and return the lowest exponent such as:
  319. * mantissa = value / 2^exponent
  320. *
  321. * where mantissa < max_mantissa.
  322. */
  323. if (val <= max_mantissa)
  324. return 0;
  325. while ((val >> exp) > max_mantissa) {
  326. exp++;
  327. if (exp > max_exp)
  328. return max_exp;
  329. }
  330. return exp;
  331. }
  332. static ssize_t isl29501_write_ext(struct iio_dev *indio_dev,
  333. uintptr_t private,
  334. const struct iio_chan_spec *chan,
  335. const char *buf, size_t len)
  336. {
  337. struct isl29501_private *isl29501 = iio_priv(indio_dev);
  338. enum isl29501_register_name reg = private;
  339. unsigned int val;
  340. int max_exp = 0;
  341. int ret;
  342. int i;
  343. ret = kstrtouint(buf, 10, &val);
  344. if (ret)
  345. return ret;
  346. switch (reg) {
  347. case REG_GAIN_BIAS:
  348. if (val > U16_MAX)
  349. return -ERANGE;
  350. ret = isl29501_register_write(isl29501, reg, val);
  351. if (ret < 0)
  352. return ret;
  353. break;
  354. case REG_CALIB_PHASE_TEMP_A:
  355. case REG_CALIB_PHASE_TEMP_B:
  356. case REG_CALIB_PHASE_LIGHT_A:
  357. case REG_CALIB_PHASE_LIGHT_B:
  358. if (val > (U8_MAX << ISL29501_MAX_EXP_VAL))
  359. return -ERANGE;
  360. /* Store the correction coefficient under its exact form. */
  361. ret = isl29501_set_shadow_coeff(isl29501, reg, val);
  362. if (ret < 0)
  363. return ret;
  364. /*
  365. * Find the highest exponent needed to represent
  366. * correction coefficients.
  367. */
  368. for (i = 0; i < COEFF_MAX; i++) {
  369. int corr;
  370. int corr_exp;
  371. corr = isl29501->shadow_coeffs[i];
  372. corr_exp = isl29501_find_corr_exp(corr,
  373. ISL29501_MAX_EXP_VAL,
  374. U8_MAX / 2);
  375. dev_dbg(&isl29501->client->dev,
  376. "found exp of corr(%d) = %d\n", corr, corr_exp);
  377. max_exp = max(max_exp, corr_exp);
  378. }
  379. /*
  380. * Represent every correction coefficient under
  381. * mantissa * 2^max_exponent form and force the
  382. * writing of those coefficients on the sensor.
  383. */
  384. for (i = 0; i < COEFF_MAX; i++) {
  385. int corr;
  386. int mantissa;
  387. corr = isl29501->shadow_coeffs[i];
  388. if (!corr)
  389. continue;
  390. mantissa = corr >> max_exp;
  391. ret = isl29501_write_coeff(isl29501, i, mantissa);
  392. if (ret < 0)
  393. return ret;
  394. }
  395. ret = isl29501_register_write(isl29501, REG_PHASE_EXP, max_exp);
  396. if (ret < 0)
  397. return ret;
  398. break;
  399. default:
  400. return -EINVAL;
  401. }
  402. return len;
  403. }
  404. #define _ISL29501_EXT_INFO(_name, _ident) { \
  405. .name = _name, \
  406. .read = isl29501_read_ext, \
  407. .write = isl29501_write_ext, \
  408. .private = _ident, \
  409. .shared = IIO_SEPARATE, \
  410. }
  411. static const struct iio_chan_spec_ext_info isl29501_ext_info[] = {
  412. _ISL29501_EXT_INFO("agc_gain", REG_GAIN),
  413. _ISL29501_EXT_INFO("agc_gain_bias", REG_GAIN_BIAS),
  414. _ISL29501_EXT_INFO("calib_phase_temp_a", REG_CALIB_PHASE_TEMP_A),
  415. _ISL29501_EXT_INFO("calib_phase_temp_b", REG_CALIB_PHASE_TEMP_B),
  416. _ISL29501_EXT_INFO("calib_phase_light_a", REG_CALIB_PHASE_LIGHT_A),
  417. _ISL29501_EXT_INFO("calib_phase_light_b", REG_CALIB_PHASE_LIGHT_B),
  418. { },
  419. };
  420. #define ISL29501_DISTANCE_SCAN_INDEX 0
  421. #define ISL29501_TIMESTAMP_SCAN_INDEX 1
  422. static const struct iio_chan_spec isl29501_channels[] = {
  423. {
  424. .type = IIO_PROXIMITY,
  425. .scan_index = ISL29501_DISTANCE_SCAN_INDEX,
  426. .info_mask_separate =
  427. BIT(IIO_CHAN_INFO_RAW) |
  428. BIT(IIO_CHAN_INFO_SCALE) |
  429. BIT(IIO_CHAN_INFO_CALIBBIAS),
  430. .scan_type = {
  431. .sign = 'u',
  432. .realbits = 16,
  433. .storagebits = 16,
  434. .endianness = IIO_CPU,
  435. },
  436. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
  437. BIT(IIO_CHAN_INFO_SAMP_FREQ),
  438. .ext_info = isl29501_ext_info,
  439. },
  440. {
  441. .type = IIO_PHASE,
  442. .scan_index = -1,
  443. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  444. BIT(IIO_CHAN_INFO_SCALE),
  445. },
  446. {
  447. .type = IIO_CURRENT,
  448. .scan_index = -1,
  449. .output = 1,
  450. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  451. BIT(IIO_CHAN_INFO_SCALE),
  452. },
  453. {
  454. .type = IIO_TEMP,
  455. .scan_index = -1,
  456. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  457. BIT(IIO_CHAN_INFO_SCALE) |
  458. BIT(IIO_CHAN_INFO_CALIBBIAS),
  459. },
  460. {
  461. .type = IIO_INTENSITY,
  462. .scan_index = -1,
  463. .modified = 1,
  464. .channel2 = IIO_MOD_LIGHT_CLEAR,
  465. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  466. BIT(IIO_CHAN_INFO_SCALE),
  467. },
  468. IIO_CHAN_SOFT_TIMESTAMP(ISL29501_TIMESTAMP_SCAN_INDEX),
  469. };
  470. static int isl29501_reset_registers(struct isl29501_private *isl29501)
  471. {
  472. int ret;
  473. ret = i2c_smbus_write_byte_data(isl29501->client,
  474. ISL29501_COMMAND_REGISTER,
  475. ISL29501_RESET_ALL_REGISTERS);
  476. if (ret < 0) {
  477. dev_err(&isl29501->client->dev,
  478. "cannot reset registers %d\n", ret);
  479. return ret;
  480. }
  481. ret = i2c_smbus_write_byte_data(isl29501->client,
  482. ISL29501_COMMAND_REGISTER,
  483. ISL29501_RESET_INT_SM);
  484. if (ret < 0)
  485. dev_err(&isl29501->client->dev,
  486. "cannot reset state machine %d\n", ret);
  487. return ret;
  488. }
  489. static int isl29501_begin_acquisition(struct isl29501_private *isl29501)
  490. {
  491. int ret;
  492. ret = i2c_smbus_write_byte_data(isl29501->client,
  493. ISL29501_COMMAND_REGISTER,
  494. ISL29501_EMUL_SAMPLE_START_PIN);
  495. if (ret < 0)
  496. dev_err(&isl29501->client->dev,
  497. "cannot begin acquisition %d\n", ret);
  498. return ret;
  499. }
  500. static IIO_CONST_ATTR_INT_TIME_AVAIL(ISL29501_INT_TIME_AVAILABLE);
  501. static IIO_CONST_ATTR(out_current_scale_available,
  502. ISL29501_CURRENT_SCALE_AVAILABLE);
  503. static struct attribute *isl29501_attributes[] = {
  504. &iio_const_attr_integration_time_available.dev_attr.attr,
  505. &iio_const_attr_out_current_scale_available.dev_attr.attr,
  506. NULL
  507. };
  508. static const struct attribute_group isl29501_attribute_group = {
  509. .attrs = isl29501_attributes,
  510. };
  511. static const int isl29501_current_scale_table[][2] = {
  512. {0, 3900}, {0, 7800}, {0, 11800}, {0, 15700},
  513. {0, 19600}, {0, 23500}, {0, 27500}, {0, 31400},
  514. {0, 35200}, {0, 39200}, {0, 43100}, {0, 47100},
  515. {0, 51000}, {0, 54900}, {0, 58800},
  516. };
  517. static const int isl29501_int_time[][2] = {
  518. {0, 70}, /* 0.07 ms */
  519. {0, 140}, /* 0.14 ms */
  520. {0, 280}, /* 0.28 ms */
  521. {0, 570}, /* 0.57 ms */
  522. {0, 1140}, /* 1.14 ms */
  523. {0, 2280}, /* 2.28 ms */
  524. {0, 4550}, /* 4.55 ms */
  525. {0, 9100}, /* 9.11 ms */
  526. {0, 18200}, /* 18.2 ms */
  527. {0, 36400}, /* 36.4 ms */
  528. {0, 72810}, /* 72.81 ms */
  529. {0, 145610} /* 145.28 ms */
  530. };
  531. static int isl29501_get_raw(struct isl29501_private *isl29501,
  532. const struct iio_chan_spec *chan,
  533. int *raw)
  534. {
  535. int ret;
  536. switch (chan->type) {
  537. case IIO_PROXIMITY:
  538. ret = isl29501_register_read(isl29501, REG_DISTANCE, raw);
  539. if (ret < 0)
  540. return ret;
  541. return IIO_VAL_INT;
  542. case IIO_INTENSITY:
  543. ret = isl29501_register_read(isl29501,
  544. REG_AMBIENT_LIGHT,
  545. raw);
  546. if (ret < 0)
  547. return ret;
  548. return IIO_VAL_INT;
  549. case IIO_PHASE:
  550. ret = isl29501_register_read(isl29501, REG_PHASE, raw);
  551. if (ret < 0)
  552. return ret;
  553. return IIO_VAL_INT;
  554. case IIO_CURRENT:
  555. ret = isl29501_register_read(isl29501, REG_EMITTER_DAC, raw);
  556. if (ret < 0)
  557. return ret;
  558. return IIO_VAL_INT;
  559. case IIO_TEMP:
  560. ret = isl29501_register_read(isl29501, REG_TEMPERATURE, raw);
  561. if (ret < 0)
  562. return ret;
  563. return IIO_VAL_INT;
  564. default:
  565. return -EINVAL;
  566. }
  567. }
  568. static int isl29501_get_scale(struct isl29501_private *isl29501,
  569. const struct iio_chan_spec *chan,
  570. int *val, int *val2)
  571. {
  572. int ret;
  573. u32 current_scale;
  574. switch (chan->type) {
  575. case IIO_PROXIMITY:
  576. /* distance = raw_distance * 33.31 / 65536 (m) */
  577. *val = 3331;
  578. *val2 = 6553600;
  579. return IIO_VAL_FRACTIONAL;
  580. case IIO_PHASE:
  581. /* phase = raw_phase * 2pi / 65536 (rad) */
  582. *val = 0;
  583. *val2 = 95874;
  584. return IIO_VAL_INT_PLUS_NANO;
  585. case IIO_INTENSITY:
  586. /* light = raw_light * 35 / 10000 (mA) */
  587. *val = 35;
  588. *val2 = 10000;
  589. return IIO_VAL_FRACTIONAL;
  590. case IIO_CURRENT:
  591. ret = isl29501_register_read(isl29501,
  592. REG_DRIVER_RANGE,
  593. &current_scale);
  594. if (ret < 0)
  595. return ret;
  596. if (current_scale > ARRAY_SIZE(isl29501_current_scale_table))
  597. return -EINVAL;
  598. if (!current_scale) {
  599. *val = 0;
  600. *val2 = 0;
  601. return IIO_VAL_INT;
  602. }
  603. *val = isl29501_current_scale_table[current_scale - 1][0];
  604. *val2 = isl29501_current_scale_table[current_scale - 1][1];
  605. return IIO_VAL_INT_PLUS_MICRO;
  606. case IIO_TEMP:
  607. /* temperature = raw_temperature * 125 / 100000 (milli °C) */
  608. *val = 125;
  609. *val2 = 100000;
  610. return IIO_VAL_FRACTIONAL;
  611. default:
  612. return -EINVAL;
  613. }
  614. }
  615. static int isl29501_get_calibbias(struct isl29501_private *isl29501,
  616. const struct iio_chan_spec *chan,
  617. int *bias)
  618. {
  619. switch (chan->type) {
  620. case IIO_PROXIMITY:
  621. return isl29501_register_read(isl29501,
  622. REG_DISTANCE_BIAS,
  623. bias);
  624. case IIO_TEMP:
  625. return isl29501_register_read(isl29501,
  626. REG_TEMPERATURE_BIAS,
  627. bias);
  628. default:
  629. return -EINVAL;
  630. }
  631. }
  632. static int isl29501_get_inttime(struct isl29501_private *isl29501,
  633. int *val, int *val2)
  634. {
  635. int ret;
  636. u32 inttime;
  637. ret = isl29501_register_read(isl29501, REG_INT_TIME, &inttime);
  638. if (ret < 0)
  639. return ret;
  640. if (inttime >= ARRAY_SIZE(isl29501_int_time))
  641. return -EINVAL;
  642. *val = isl29501_int_time[inttime][0];
  643. *val2 = isl29501_int_time[inttime][1];
  644. return IIO_VAL_INT_PLUS_MICRO;
  645. }
  646. static int isl29501_get_freq(struct isl29501_private *isl29501,
  647. int *val, int *val2)
  648. {
  649. int ret;
  650. int sample_time;
  651. unsigned long long freq;
  652. u32 temp;
  653. ret = isl29501_register_read(isl29501, REG_SAMPLE_TIME, &sample_time);
  654. if (ret < 0)
  655. return ret;
  656. /* freq = 1 / (0.000450 * (sample_time + 1) * 10^-6) */
  657. freq = 1000000ULL * 1000000ULL;
  658. do_div(freq, 450 * (sample_time + 1));
  659. temp = do_div(freq, 1000000);
  660. *val = freq;
  661. *val2 = temp;
  662. return IIO_VAL_INT_PLUS_MICRO;
  663. }
  664. static int isl29501_read_raw(struct iio_dev *indio_dev,
  665. struct iio_chan_spec const *chan, int *val,
  666. int *val2, long mask)
  667. {
  668. struct isl29501_private *isl29501 = iio_priv(indio_dev);
  669. switch (mask) {
  670. case IIO_CHAN_INFO_RAW:
  671. return isl29501_get_raw(isl29501, chan, val);
  672. case IIO_CHAN_INFO_SCALE:
  673. return isl29501_get_scale(isl29501, chan, val, val2);
  674. case IIO_CHAN_INFO_INT_TIME:
  675. return isl29501_get_inttime(isl29501, val, val2);
  676. case IIO_CHAN_INFO_SAMP_FREQ:
  677. return isl29501_get_freq(isl29501, val, val2);
  678. case IIO_CHAN_INFO_CALIBBIAS:
  679. return isl29501_get_calibbias(isl29501, chan, val);
  680. default:
  681. return -EINVAL;
  682. }
  683. }
  684. static int isl29501_set_raw(struct isl29501_private *isl29501,
  685. const struct iio_chan_spec *chan,
  686. int raw)
  687. {
  688. switch (chan->type) {
  689. case IIO_CURRENT:
  690. return isl29501_register_write(isl29501, REG_EMITTER_DAC, raw);
  691. default:
  692. return -EINVAL;
  693. }
  694. }
  695. static int isl29501_set_inttime(struct isl29501_private *isl29501,
  696. int val, int val2)
  697. {
  698. int i;
  699. for (i = 0; i < ARRAY_SIZE(isl29501_int_time); i++) {
  700. if (isl29501_int_time[i][0] == val &&
  701. isl29501_int_time[i][1] == val2) {
  702. return isl29501_register_write(isl29501,
  703. REG_INT_TIME,
  704. i);
  705. }
  706. }
  707. return -EINVAL;
  708. }
  709. static int isl29501_set_scale(struct isl29501_private *isl29501,
  710. const struct iio_chan_spec *chan,
  711. int val, int val2)
  712. {
  713. int i;
  714. if (chan->type != IIO_CURRENT)
  715. return -EINVAL;
  716. for (i = 0; i < ARRAY_SIZE(isl29501_current_scale_table); i++) {
  717. if (isl29501_current_scale_table[i][0] == val &&
  718. isl29501_current_scale_table[i][1] == val2) {
  719. return isl29501_register_write(isl29501,
  720. REG_DRIVER_RANGE,
  721. i + 1);
  722. }
  723. }
  724. return -EINVAL;
  725. }
  726. static int isl29501_set_calibbias(struct isl29501_private *isl29501,
  727. const struct iio_chan_spec *chan,
  728. int bias)
  729. {
  730. switch (chan->type) {
  731. case IIO_PROXIMITY:
  732. return isl29501_register_write(isl29501,
  733. REG_DISTANCE_BIAS,
  734. bias);
  735. case IIO_TEMP:
  736. return isl29501_register_write(isl29501,
  737. REG_TEMPERATURE_BIAS,
  738. bias);
  739. default:
  740. return -EINVAL;
  741. }
  742. }
  743. static int isl29501_set_freq(struct isl29501_private *isl29501,
  744. int val, int val2)
  745. {
  746. int freq;
  747. unsigned long long sample_time;
  748. /* sample_freq = 1 / (0.000450 * (sample_time + 1) * 10^-6) */
  749. freq = val * 1000000 + val2 % 1000000;
  750. sample_time = 2222ULL * 1000000ULL;
  751. do_div(sample_time, freq);
  752. sample_time -= 1;
  753. if (sample_time > 255)
  754. return -ERANGE;
  755. return isl29501_register_write(isl29501, REG_SAMPLE_TIME, sample_time);
  756. }
  757. static int isl29501_write_raw(struct iio_dev *indio_dev,
  758. struct iio_chan_spec const *chan,
  759. int val, int val2, long mask)
  760. {
  761. struct isl29501_private *isl29501 = iio_priv(indio_dev);
  762. switch (mask) {
  763. case IIO_CHAN_INFO_RAW:
  764. return isl29501_set_raw(isl29501, chan, val);
  765. case IIO_CHAN_INFO_INT_TIME:
  766. return isl29501_set_inttime(isl29501, val, val2);
  767. case IIO_CHAN_INFO_SAMP_FREQ:
  768. return isl29501_set_freq(isl29501, val, val2);
  769. case IIO_CHAN_INFO_SCALE:
  770. return isl29501_set_scale(isl29501, chan, val, val2);
  771. case IIO_CHAN_INFO_CALIBBIAS:
  772. return isl29501_set_calibbias(isl29501, chan, val);
  773. default:
  774. return -EINVAL;
  775. }
  776. }
  777. static const struct iio_info isl29501_info = {
  778. .read_raw = &isl29501_read_raw,
  779. .write_raw = &isl29501_write_raw,
  780. .attrs = &isl29501_attribute_group,
  781. };
  782. static int isl29501_init_chip(struct isl29501_private *isl29501)
  783. {
  784. int ret;
  785. ret = i2c_smbus_read_byte_data(isl29501->client, ISL29501_DEVICE_ID);
  786. if (ret < 0) {
  787. dev_err(&isl29501->client->dev, "Error reading device id\n");
  788. return ret;
  789. }
  790. if (ret != ISL29501_ID) {
  791. dev_err(&isl29501->client->dev,
  792. "Wrong chip id, got %x expected %x\n",
  793. ret, ISL29501_DEVICE_ID);
  794. return -ENODEV;
  795. }
  796. ret = isl29501_reset_registers(isl29501);
  797. if (ret < 0)
  798. return ret;
  799. return isl29501_begin_acquisition(isl29501);
  800. }
  801. static irqreturn_t isl29501_trigger_handler(int irq, void *p)
  802. {
  803. struct iio_poll_func *pf = p;
  804. struct iio_dev *indio_dev = pf->indio_dev;
  805. struct isl29501_private *isl29501 = iio_priv(indio_dev);
  806. const unsigned long *active_mask = indio_dev->active_scan_mask;
  807. u32 buffer[4] __aligned(8) = {}; /* 1x16-bit + naturally aligned ts */
  808. if (test_bit(ISL29501_DISTANCE_SCAN_INDEX, active_mask))
  809. isl29501_register_read(isl29501, REG_DISTANCE, buffer);
  810. iio_push_to_buffers_with_timestamp(indio_dev, buffer, pf->timestamp);
  811. iio_trigger_notify_done(indio_dev->trig);
  812. return IRQ_HANDLED;
  813. }
  814. static int isl29501_probe(struct i2c_client *client,
  815. const struct i2c_device_id *id)
  816. {
  817. struct iio_dev *indio_dev;
  818. struct isl29501_private *isl29501;
  819. int ret;
  820. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*isl29501));
  821. if (!indio_dev)
  822. return -ENOMEM;
  823. isl29501 = iio_priv(indio_dev);
  824. i2c_set_clientdata(client, indio_dev);
  825. isl29501->client = client;
  826. mutex_init(&isl29501->lock);
  827. ret = isl29501_init_chip(isl29501);
  828. if (ret < 0)
  829. return ret;
  830. indio_dev->modes = INDIO_DIRECT_MODE;
  831. indio_dev->channels = isl29501_channels;
  832. indio_dev->num_channels = ARRAY_SIZE(isl29501_channels);
  833. indio_dev->name = client->name;
  834. indio_dev->info = &isl29501_info;
  835. ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
  836. iio_pollfunc_store_time,
  837. isl29501_trigger_handler,
  838. NULL);
  839. if (ret < 0) {
  840. dev_err(&client->dev, "unable to setup iio triggered buffer\n");
  841. return ret;
  842. }
  843. return devm_iio_device_register(&client->dev, indio_dev);
  844. }
  845. static const struct i2c_device_id isl29501_id[] = {
  846. {"isl29501", 0},
  847. {}
  848. };
  849. MODULE_DEVICE_TABLE(i2c, isl29501_id);
  850. #if defined(CONFIG_OF)
  851. static const struct of_device_id isl29501_i2c_matches[] = {
  852. { .compatible = "renesas,isl29501" },
  853. { }
  854. };
  855. MODULE_DEVICE_TABLE(of, isl29501_i2c_matches);
  856. #endif
  857. static struct i2c_driver isl29501_driver = {
  858. .driver = {
  859. .name = "isl29501",
  860. },
  861. .id_table = isl29501_id,
  862. .probe = isl29501_probe,
  863. };
  864. module_i2c_driver(isl29501_driver);
  865. MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>");
  866. MODULE_DESCRIPTION("ISL29501 Time of Flight sensor driver");
  867. MODULE_LICENSE("GPL v2");