ntxec.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * The Netronix embedded controller is a microcontroller found in some
  4. * e-book readers designed by the original design manufacturer Netronix, Inc.
  5. * It contains RTC, battery monitoring, system power management, and PWM
  6. * functionality.
  7. *
  8. * This driver implements register access, version detection, and system
  9. * power-off/reset.
  10. *
  11. * Copyright 2020 Jonathan Neuschäfer <[email protected]>
  12. */
  13. #include <linux/delay.h>
  14. #include <linux/errno.h>
  15. #include <linux/i2c.h>
  16. #include <linux/mfd/core.h>
  17. #include <linux/mfd/ntxec.h>
  18. #include <linux/module.h>
  19. #include <linux/pm.h>
  20. #include <linux/reboot.h>
  21. #include <linux/regmap.h>
  22. #include <linux/types.h>
  23. #include <asm/unaligned.h>
  24. #define NTXEC_REG_VERSION 0x00
  25. #define NTXEC_REG_POWEROFF 0x50
  26. #define NTXEC_REG_POWERKEEP 0x70
  27. #define NTXEC_REG_RESET 0x90
  28. #define NTXEC_POWEROFF_VALUE 0x0100
  29. #define NTXEC_POWERKEEP_VALUE 0x0800
  30. #define NTXEC_RESET_VALUE 0xff00
  31. static struct i2c_client *poweroff_restart_client;
  32. static void ntxec_poweroff(void)
  33. {
  34. int res;
  35. u8 buf[3] = { NTXEC_REG_POWEROFF };
  36. struct i2c_msg msgs[] = {
  37. {
  38. .addr = poweroff_restart_client->addr,
  39. .flags = 0,
  40. .len = sizeof(buf),
  41. .buf = buf,
  42. },
  43. };
  44. put_unaligned_be16(NTXEC_POWEROFF_VALUE, buf + 1);
  45. res = i2c_transfer(poweroff_restart_client->adapter, msgs, ARRAY_SIZE(msgs));
  46. if (res < 0)
  47. dev_warn(&poweroff_restart_client->dev,
  48. "Failed to power off (err = %d)\n", res);
  49. /*
  50. * The time from the register write until the host CPU is powered off
  51. * has been observed to be about 2.5 to 3 seconds. Sleep long enough to
  52. * safely avoid returning from the poweroff handler.
  53. */
  54. msleep(5000);
  55. }
  56. static int ntxec_restart(struct notifier_block *nb,
  57. unsigned long action, void *data)
  58. {
  59. int res;
  60. u8 buf[3] = { NTXEC_REG_RESET };
  61. /*
  62. * NOTE: The lower half of the reset value is not sent, because sending
  63. * it causes an I2C error. (The reset handler in the downstream driver
  64. * does send the full two-byte value, but doesn't check the result).
  65. */
  66. struct i2c_msg msgs[] = {
  67. {
  68. .addr = poweroff_restart_client->addr,
  69. .flags = 0,
  70. .len = sizeof(buf) - 1,
  71. .buf = buf,
  72. },
  73. };
  74. put_unaligned_be16(NTXEC_RESET_VALUE, buf + 1);
  75. res = i2c_transfer(poweroff_restart_client->adapter, msgs, ARRAY_SIZE(msgs));
  76. if (res < 0)
  77. dev_warn(&poweroff_restart_client->dev,
  78. "Failed to restart (err = %d)\n", res);
  79. return NOTIFY_DONE;
  80. }
  81. static struct notifier_block ntxec_restart_handler = {
  82. .notifier_call = ntxec_restart,
  83. .priority = 128,
  84. };
  85. static int regmap_ignore_write(void *context,
  86. unsigned int reg, unsigned int val)
  87. {
  88. struct regmap *regmap = context;
  89. regmap_write(regmap, reg, val);
  90. return 0;
  91. }
  92. static int regmap_wrap_read(void *context, unsigned int reg,
  93. unsigned int *val)
  94. {
  95. struct regmap *regmap = context;
  96. return regmap_read(regmap, reg, val);
  97. }
  98. /*
  99. * Some firmware versions do not ack written data, add a wrapper. It
  100. * is used to stack another regmap on top.
  101. */
  102. static const struct regmap_config regmap_config_noack = {
  103. .name = "ntxec_noack",
  104. .reg_bits = 8,
  105. .val_bits = 16,
  106. .cache_type = REGCACHE_NONE,
  107. .reg_write = regmap_ignore_write,
  108. .reg_read = regmap_wrap_read
  109. };
  110. static const struct regmap_config regmap_config = {
  111. .name = "ntxec",
  112. .reg_bits = 8,
  113. .val_bits = 16,
  114. .cache_type = REGCACHE_NONE,
  115. .val_format_endian = REGMAP_ENDIAN_BIG,
  116. };
  117. static const struct mfd_cell ntxec_subdev[] = {
  118. { .name = "ntxec-rtc" },
  119. { .name = "ntxec-pwm" },
  120. };
  121. static const struct mfd_cell ntxec_subdev_pwm[] = {
  122. { .name = "ntxec-pwm" },
  123. };
  124. static int ntxec_probe(struct i2c_client *client)
  125. {
  126. struct ntxec *ec;
  127. unsigned int version;
  128. int res;
  129. const struct mfd_cell *subdevs;
  130. size_t n_subdevs;
  131. ec = devm_kmalloc(&client->dev, sizeof(*ec), GFP_KERNEL);
  132. if (!ec)
  133. return -ENOMEM;
  134. ec->dev = &client->dev;
  135. ec->regmap = devm_regmap_init_i2c(client, &regmap_config);
  136. if (IS_ERR(ec->regmap)) {
  137. dev_err(ec->dev, "Failed to set up regmap for device\n");
  138. return PTR_ERR(ec->regmap);
  139. }
  140. /* Determine the firmware version */
  141. res = regmap_read(ec->regmap, NTXEC_REG_VERSION, &version);
  142. if (res < 0) {
  143. dev_err(ec->dev, "Failed to read firmware version number\n");
  144. return res;
  145. }
  146. /* Bail out if we encounter an unknown firmware version */
  147. switch (version) {
  148. case NTXEC_VERSION_KOBO_AURA:
  149. subdevs = ntxec_subdev;
  150. n_subdevs = ARRAY_SIZE(ntxec_subdev);
  151. break;
  152. case NTXEC_VERSION_TOLINO_SHINE2:
  153. subdevs = ntxec_subdev_pwm;
  154. n_subdevs = ARRAY_SIZE(ntxec_subdev_pwm);
  155. /* Another regmap stacked on top of the other */
  156. ec->regmap = devm_regmap_init(ec->dev, NULL,
  157. ec->regmap,
  158. &regmap_config_noack);
  159. if (IS_ERR(ec->regmap))
  160. return PTR_ERR(ec->regmap);
  161. break;
  162. default:
  163. dev_err(ec->dev,
  164. "Netronix embedded controller version %04x is not supported.\n",
  165. version);
  166. return -ENODEV;
  167. }
  168. dev_info(ec->dev,
  169. "Netronix embedded controller version %04x detected.\n", version);
  170. if (of_device_is_system_power_controller(ec->dev->of_node)) {
  171. /*
  172. * Set the 'powerkeep' bit. This is necessary on some boards
  173. * in order to keep the system running.
  174. */
  175. res = regmap_write(ec->regmap, NTXEC_REG_POWERKEEP,
  176. NTXEC_POWERKEEP_VALUE);
  177. if (res < 0)
  178. return res;
  179. if (poweroff_restart_client)
  180. /*
  181. * Another instance of the driver already took
  182. * poweroff/restart duties.
  183. */
  184. dev_err(ec->dev, "poweroff_restart_client already assigned\n");
  185. else
  186. poweroff_restart_client = client;
  187. if (pm_power_off)
  188. /* Another driver already registered a poweroff handler. */
  189. dev_err(ec->dev, "pm_power_off already assigned\n");
  190. else
  191. pm_power_off = ntxec_poweroff;
  192. res = register_restart_handler(&ntxec_restart_handler);
  193. if (res)
  194. dev_err(ec->dev,
  195. "Failed to register restart handler: %d\n", res);
  196. }
  197. i2c_set_clientdata(client, ec);
  198. res = devm_mfd_add_devices(ec->dev, PLATFORM_DEVID_NONE,
  199. subdevs, n_subdevs, NULL, 0, NULL);
  200. if (res)
  201. dev_err(ec->dev, "Failed to add subdevices: %d\n", res);
  202. return res;
  203. }
  204. static void ntxec_remove(struct i2c_client *client)
  205. {
  206. if (client == poweroff_restart_client) {
  207. poweroff_restart_client = NULL;
  208. pm_power_off = NULL;
  209. unregister_restart_handler(&ntxec_restart_handler);
  210. }
  211. }
  212. static const struct of_device_id of_ntxec_match_table[] = {
  213. { .compatible = "netronix,ntxec", },
  214. {}
  215. };
  216. MODULE_DEVICE_TABLE(of, of_ntxec_match_table);
  217. static struct i2c_driver ntxec_driver = {
  218. .driver = {
  219. .name = "ntxec",
  220. .of_match_table = of_ntxec_match_table,
  221. },
  222. .probe_new = ntxec_probe,
  223. .remove = ntxec_remove,
  224. };
  225. module_i2c_driver(ntxec_driver);
  226. MODULE_AUTHOR("Jonathan Neuschäfer <[email protected]>");
  227. MODULE_DESCRIPTION("Core driver for Netronix EC");
  228. MODULE_LICENSE("GPL");