core.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <robh@kernel.org>
  4. *
  5. * Based on drivers/spmi/spmi.c:
  6. * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
  7. */
  8. #include <linux/acpi.h>
  9. #include <linux/errno.h>
  10. #include <linux/idr.h>
  11. #include <linux/kernel.h>
  12. #include <linux/module.h>
  13. #include <linux/of.h>
  14. #include <linux/of_device.h>
  15. #include <linux/pm_domain.h>
  16. #include <linux/pm_runtime.h>
  17. #include <linux/serdev.h>
  18. #include <linux/slab.h>
  19. static bool is_registered;
  20. static DEFINE_IDA(ctrl_ida);
  21. static ssize_t modalias_show(struct device *dev,
  22. struct device_attribute *attr, char *buf)
  23. {
  24. int len;
  25. len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);
  26. if (len != -ENODEV)
  27. return len;
  28. return of_device_modalias(dev, buf, PAGE_SIZE);
  29. }
  30. static DEVICE_ATTR_RO(modalias);
  31. static struct attribute *serdev_device_attrs[] = {
  32. &dev_attr_modalias.attr,
  33. NULL,
  34. };
  35. ATTRIBUTE_GROUPS(serdev_device);
  36. static int serdev_device_uevent(struct device *dev, struct kobj_uevent_env *env)
  37. {
  38. int rc;
  39. /* TODO: platform modalias */
  40. rc = acpi_device_uevent_modalias(dev, env);
  41. if (rc != -ENODEV)
  42. return rc;
  43. return of_device_uevent_modalias(dev, env);
  44. }
  45. static void serdev_device_release(struct device *dev)
  46. {
  47. struct serdev_device *serdev = to_serdev_device(dev);
  48. kfree(serdev);
  49. }
  50. static const struct device_type serdev_device_type = {
  51. .groups = serdev_device_groups,
  52. .uevent = serdev_device_uevent,
  53. .release = serdev_device_release,
  54. };
  55. static bool is_serdev_device(const struct device *dev)
  56. {
  57. return dev->type == &serdev_device_type;
  58. }
  59. static void serdev_ctrl_release(struct device *dev)
  60. {
  61. struct serdev_controller *ctrl = to_serdev_controller(dev);
  62. ida_simple_remove(&ctrl_ida, ctrl->nr);
  63. kfree(ctrl);
  64. }
  65. static const struct device_type serdev_ctrl_type = {
  66. .release = serdev_ctrl_release,
  67. };
  68. static int serdev_device_match(struct device *dev, struct device_driver *drv)
  69. {
  70. if (!is_serdev_device(dev))
  71. return 0;
  72. /* TODO: platform matching */
  73. if (acpi_driver_match_device(dev, drv))
  74. return 1;
  75. return of_driver_match_device(dev, drv);
  76. }
  77. /**
  78. * serdev_device_add() - add a device previously constructed via serdev_device_alloc()
  79. * @serdev: serdev_device to be added
  80. */
  81. int serdev_device_add(struct serdev_device *serdev)
  82. {
  83. struct serdev_controller *ctrl = serdev->ctrl;
  84. struct device *parent = serdev->dev.parent;
  85. int err;
  86. dev_set_name(&serdev->dev, "%s-%d", dev_name(parent), serdev->nr);
  87. /* Only a single slave device is currently supported. */
  88. if (ctrl->serdev) {
  89. dev_err(&serdev->dev, "controller busy\n");
  90. return -EBUSY;
  91. }
  92. ctrl->serdev = serdev;
  93. err = device_add(&serdev->dev);
  94. if (err < 0) {
  95. dev_err(&serdev->dev, "Can't add %s, status %d\n",
  96. dev_name(&serdev->dev), err);
  97. goto err_clear_serdev;
  98. }
  99. dev_dbg(&serdev->dev, "device %s registered\n", dev_name(&serdev->dev));
  100. return 0;
  101. err_clear_serdev:
  102. ctrl->serdev = NULL;
  103. return err;
  104. }
  105. EXPORT_SYMBOL_GPL(serdev_device_add);
  106. /**
  107. * serdev_device_remove(): remove an serdev device
  108. * @serdev: serdev_device to be removed
  109. */
  110. void serdev_device_remove(struct serdev_device *serdev)
  111. {
  112. struct serdev_controller *ctrl = serdev->ctrl;
  113. device_unregister(&serdev->dev);
  114. ctrl->serdev = NULL;
  115. }
  116. EXPORT_SYMBOL_GPL(serdev_device_remove);
  117. int serdev_device_open(struct serdev_device *serdev)
  118. {
  119. struct serdev_controller *ctrl = serdev->ctrl;
  120. int ret;
  121. if (!ctrl || !ctrl->ops->open)
  122. return -EINVAL;
  123. ret = ctrl->ops->open(ctrl);
  124. if (ret)
  125. return ret;
  126. ret = pm_runtime_get_sync(&ctrl->dev);
  127. if (ret < 0) {
  128. pm_runtime_put_noidle(&ctrl->dev);
  129. goto err_close;
  130. }
  131. return 0;
  132. err_close:
  133. if (ctrl->ops->close)
  134. ctrl->ops->close(ctrl);
  135. return ret;
  136. }
  137. EXPORT_SYMBOL_GPL(serdev_device_open);
  138. void serdev_device_close(struct serdev_device *serdev)
  139. {
  140. struct serdev_controller *ctrl = serdev->ctrl;
  141. if (!ctrl || !ctrl->ops->close)
  142. return;
  143. pm_runtime_put(&ctrl->dev);
  144. ctrl->ops->close(ctrl);
  145. }
  146. EXPORT_SYMBOL_GPL(serdev_device_close);
  147. static void devm_serdev_device_release(struct device *dev, void *dr)
  148. {
  149. serdev_device_close(*(struct serdev_device **)dr);
  150. }
  151. int devm_serdev_device_open(struct device *dev, struct serdev_device *serdev)
  152. {
  153. struct serdev_device **dr;
  154. int ret;
  155. dr = devres_alloc(devm_serdev_device_release, sizeof(*dr), GFP_KERNEL);
  156. if (!dr)
  157. return -ENOMEM;
  158. ret = serdev_device_open(serdev);
  159. if (ret) {
  160. devres_free(dr);
  161. return ret;
  162. }
  163. *dr = serdev;
  164. devres_add(dev, dr);
  165. return 0;
  166. }
  167. EXPORT_SYMBOL_GPL(devm_serdev_device_open);
  168. void serdev_device_write_wakeup(struct serdev_device *serdev)
  169. {
  170. complete(&serdev->write_comp);
  171. }
  172. EXPORT_SYMBOL_GPL(serdev_device_write_wakeup);
  173. int serdev_device_write_buf(struct serdev_device *serdev,
  174. const unsigned char *buf, size_t count)
  175. {
  176. struct serdev_controller *ctrl = serdev->ctrl;
  177. if (!ctrl || !ctrl->ops->write_buf)
  178. return -EINVAL;
  179. return ctrl->ops->write_buf(ctrl, buf, count);
  180. }
  181. EXPORT_SYMBOL_GPL(serdev_device_write_buf);
  182. int serdev_device_write(struct serdev_device *serdev,
  183. const unsigned char *buf, size_t count,
  184. unsigned long timeout)
  185. {
  186. struct serdev_controller *ctrl = serdev->ctrl;
  187. int ret;
  188. if (!ctrl || !ctrl->ops->write_buf ||
  189. (timeout && !serdev->ops->write_wakeup))
  190. return -EINVAL;
  191. mutex_lock(&serdev->write_lock);
  192. do {
  193. reinit_completion(&serdev->write_comp);
  194. ret = ctrl->ops->write_buf(ctrl, buf, count);
  195. if (ret < 0)
  196. break;
  197. buf += ret;
  198. count -= ret;
  199. } while (count &&
  200. (timeout = wait_for_completion_timeout(&serdev->write_comp,
  201. timeout)));
  202. mutex_unlock(&serdev->write_lock);
  203. return ret < 0 ? ret : (count ? -ETIMEDOUT : 0);
  204. }
  205. EXPORT_SYMBOL_GPL(serdev_device_write);
  206. void serdev_device_write_flush(struct serdev_device *serdev)
  207. {
  208. struct serdev_controller *ctrl = serdev->ctrl;
  209. if (!ctrl || !ctrl->ops->write_flush)
  210. return;
  211. ctrl->ops->write_flush(ctrl);
  212. }
  213. EXPORT_SYMBOL_GPL(serdev_device_write_flush);
  214. int serdev_device_write_room(struct serdev_device *serdev)
  215. {
  216. struct serdev_controller *ctrl = serdev->ctrl;
  217. if (!ctrl || !ctrl->ops->write_room)
  218. return 0;
  219. return serdev->ctrl->ops->write_room(ctrl);
  220. }
  221. EXPORT_SYMBOL_GPL(serdev_device_write_room);
  222. unsigned int serdev_device_set_baudrate(struct serdev_device *serdev, unsigned int speed)
  223. {
  224. struct serdev_controller *ctrl = serdev->ctrl;
  225. if (!ctrl || !ctrl->ops->set_baudrate)
  226. return 0;
  227. return ctrl->ops->set_baudrate(ctrl, speed);
  228. }
  229. EXPORT_SYMBOL_GPL(serdev_device_set_baudrate);
  230. void serdev_device_set_flow_control(struct serdev_device *serdev, bool enable)
  231. {
  232. struct serdev_controller *ctrl = serdev->ctrl;
  233. if (!ctrl || !ctrl->ops->set_flow_control)
  234. return;
  235. ctrl->ops->set_flow_control(ctrl, enable);
  236. }
  237. EXPORT_SYMBOL_GPL(serdev_device_set_flow_control);
  238. int serdev_device_set_parity(struct serdev_device *serdev,
  239. enum serdev_parity parity)
  240. {
  241. struct serdev_controller *ctrl = serdev->ctrl;
  242. if (!ctrl || !ctrl->ops->set_parity)
  243. return -ENOTSUPP;
  244. return ctrl->ops->set_parity(ctrl, parity);
  245. }
  246. EXPORT_SYMBOL_GPL(serdev_device_set_parity);
  247. void serdev_device_wait_until_sent(struct serdev_device *serdev, long timeout)
  248. {
  249. struct serdev_controller *ctrl = serdev->ctrl;
  250. if (!ctrl || !ctrl->ops->wait_until_sent)
  251. return;
  252. ctrl->ops->wait_until_sent(ctrl, timeout);
  253. }
  254. EXPORT_SYMBOL_GPL(serdev_device_wait_until_sent);
  255. int serdev_device_get_tiocm(struct serdev_device *serdev)
  256. {
  257. struct serdev_controller *ctrl = serdev->ctrl;
  258. if (!ctrl || !ctrl->ops->get_tiocm)
  259. return -ENOTSUPP;
  260. return ctrl->ops->get_tiocm(ctrl);
  261. }
  262. EXPORT_SYMBOL_GPL(serdev_device_get_tiocm);
  263. int serdev_device_set_tiocm(struct serdev_device *serdev, int set, int clear)
  264. {
  265. struct serdev_controller *ctrl = serdev->ctrl;
  266. if (!ctrl || !ctrl->ops->set_tiocm)
  267. return -ENOTSUPP;
  268. return ctrl->ops->set_tiocm(ctrl, set, clear);
  269. }
  270. EXPORT_SYMBOL_GPL(serdev_device_set_tiocm);
  271. static int serdev_drv_probe(struct device *dev)
  272. {
  273. const struct serdev_device_driver *sdrv = to_serdev_device_driver(dev->driver);
  274. int ret;
  275. ret = dev_pm_domain_attach(dev, true);
  276. if (ret)
  277. return ret;
  278. ret = sdrv->probe(to_serdev_device(dev));
  279. if (ret)
  280. dev_pm_domain_detach(dev, true);
  281. return ret;
  282. }
  283. static int serdev_drv_remove(struct device *dev)
  284. {
  285. const struct serdev_device_driver *sdrv = to_serdev_device_driver(dev->driver);
  286. if (sdrv->remove)
  287. sdrv->remove(to_serdev_device(dev));
  288. dev_pm_domain_detach(dev, true);
  289. return 0;
  290. }
  291. static struct bus_type serdev_bus_type = {
  292. .name = "serial",
  293. .match = serdev_device_match,
  294. .probe = serdev_drv_probe,
  295. .remove = serdev_drv_remove,
  296. };
  297. /**
  298. * serdev_device_alloc() - Allocate a new serdev device
  299. * @ctrl: associated controller
  300. *
  301. * Caller is responsible for either calling serdev_device_add() to add the
  302. * newly allocated controller, or calling serdev_device_put() to discard it.
  303. */
  304. struct serdev_device *serdev_device_alloc(struct serdev_controller *ctrl)
  305. {
  306. struct serdev_device *serdev;
  307. serdev = kzalloc(sizeof(*serdev), GFP_KERNEL);
  308. if (!serdev)
  309. return NULL;
  310. serdev->ctrl = ctrl;
  311. device_initialize(&serdev->dev);
  312. serdev->dev.parent = &ctrl->dev;
  313. serdev->dev.bus = &serdev_bus_type;
  314. serdev->dev.type = &serdev_device_type;
  315. init_completion(&serdev->write_comp);
  316. mutex_init(&serdev->write_lock);
  317. return serdev;
  318. }
  319. EXPORT_SYMBOL_GPL(serdev_device_alloc);
  320. /**
  321. * serdev_controller_alloc() - Allocate a new serdev controller
  322. * @parent: parent device
  323. * @size: size of private data
  324. *
  325. * Caller is responsible for either calling serdev_controller_add() to add the
  326. * newly allocated controller, or calling serdev_controller_put() to discard it.
  327. * The allocated private data region may be accessed via
  328. * serdev_controller_get_drvdata()
  329. */
  330. struct serdev_controller *serdev_controller_alloc(struct device *parent,
  331. size_t size)
  332. {
  333. struct serdev_controller *ctrl;
  334. int id;
  335. if (WARN_ON(!parent))
  336. return NULL;
  337. ctrl = kzalloc(sizeof(*ctrl) + size, GFP_KERNEL);
  338. if (!ctrl)
  339. return NULL;
  340. id = ida_simple_get(&ctrl_ida, 0, 0, GFP_KERNEL);
  341. if (id < 0) {
  342. dev_err(parent,
  343. "unable to allocate serdev controller identifier.\n");
  344. goto err_free;
  345. }
  346. ctrl->nr = id;
  347. device_initialize(&ctrl->dev);
  348. ctrl->dev.type = &serdev_ctrl_type;
  349. ctrl->dev.bus = &serdev_bus_type;
  350. ctrl->dev.parent = parent;
  351. ctrl->dev.of_node = parent->of_node;
  352. serdev_controller_set_drvdata(ctrl, &ctrl[1]);
  353. dev_set_name(&ctrl->dev, "serial%d", id);
  354. pm_runtime_no_callbacks(&ctrl->dev);
  355. pm_suspend_ignore_children(&ctrl->dev, true);
  356. dev_dbg(&ctrl->dev, "allocated controller 0x%p id %d\n", ctrl, id);
  357. return ctrl;
  358. err_free:
  359. kfree(ctrl);
  360. return NULL;
  361. }
  362. EXPORT_SYMBOL_GPL(serdev_controller_alloc);
  363. static int of_serdev_register_devices(struct serdev_controller *ctrl)
  364. {
  365. struct device_node *node;
  366. struct serdev_device *serdev = NULL;
  367. int err;
  368. bool found = false;
  369. for_each_available_child_of_node(ctrl->dev.of_node, node) {
  370. if (!of_get_property(node, "compatible", NULL))
  371. continue;
  372. dev_dbg(&ctrl->dev, "adding child %pOF\n", node);
  373. serdev = serdev_device_alloc(ctrl);
  374. if (!serdev)
  375. continue;
  376. serdev->dev.of_node = node;
  377. err = serdev_device_add(serdev);
  378. if (err) {
  379. dev_err(&serdev->dev,
  380. "failure adding device. status %d\n", err);
  381. serdev_device_put(serdev);
  382. } else
  383. found = true;
  384. }
  385. if (!found)
  386. return -ENODEV;
  387. return 0;
  388. }
  389. #ifdef CONFIG_ACPI
  390. static acpi_status acpi_serdev_register_device(struct serdev_controller *ctrl,
  391. struct acpi_device *adev)
  392. {
  393. struct serdev_device *serdev = NULL;
  394. int err;
  395. if (acpi_bus_get_status(adev) || !adev->status.present ||
  396. acpi_device_enumerated(adev))
  397. return AE_OK;
  398. serdev = serdev_device_alloc(ctrl);
  399. if (!serdev) {
  400. dev_err(&ctrl->dev, "failed to allocate serdev device for %s\n",
  401. dev_name(&adev->dev));
  402. return AE_NO_MEMORY;
  403. }
  404. ACPI_COMPANION_SET(&serdev->dev, adev);
  405. acpi_device_set_enumerated(adev);
  406. err = serdev_device_add(serdev);
  407. if (err) {
  408. dev_err(&serdev->dev,
  409. "failure adding ACPI serdev device. status %d\n", err);
  410. serdev_device_put(serdev);
  411. }
  412. return AE_OK;
  413. }
  414. static const struct acpi_device_id serdev_acpi_devices_blacklist[] = {
  415. { "INT3511", 0 },
  416. { "INT3512", 0 },
  417. { },
  418. };
  419. static acpi_status acpi_serdev_add_device(acpi_handle handle, u32 level,
  420. void *data, void **return_value)
  421. {
  422. struct serdev_controller *ctrl = data;
  423. struct acpi_device *adev;
  424. if (acpi_bus_get_device(handle, &adev))
  425. return AE_OK;
  426. /* Skip if black listed */
  427. if (!acpi_match_device_ids(adev, serdev_acpi_devices_blacklist))
  428. return AE_OK;
  429. return acpi_serdev_register_device(ctrl, adev);
  430. }
  431. static int acpi_serdev_register_devices(struct serdev_controller *ctrl)
  432. {
  433. acpi_status status;
  434. acpi_handle handle;
  435. handle = ACPI_HANDLE(ctrl->dev.parent);
  436. if (!handle)
  437. return -ENODEV;
  438. status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
  439. acpi_serdev_add_device, NULL, ctrl, NULL);
  440. if (ACPI_FAILURE(status))
  441. dev_dbg(&ctrl->dev, "failed to enumerate serdev slaves\n");
  442. if (!ctrl->serdev)
  443. return -ENODEV;
  444. return 0;
  445. }
  446. #else
  447. static inline int acpi_serdev_register_devices(struct serdev_controller *ctrl)
  448. {
  449. return -ENODEV;
  450. }
  451. #endif /* CONFIG_ACPI */
  452. /**
  453. * serdev_controller_add() - Add an serdev controller
  454. * @ctrl: controller to be registered.
  455. *
  456. * Register a controller previously allocated via serdev_controller_alloc() with
  457. * the serdev core.
  458. */
  459. int serdev_controller_add(struct serdev_controller *ctrl)
  460. {
  461. int ret_of, ret_acpi, ret;
  462. /* Can't register until after driver model init */
  463. if (WARN_ON(!is_registered))
  464. return -EAGAIN;
  465. ret = device_add(&ctrl->dev);
  466. if (ret)
  467. return ret;
  468. pm_runtime_enable(&ctrl->dev);
  469. ret_of = of_serdev_register_devices(ctrl);
  470. ret_acpi = acpi_serdev_register_devices(ctrl);
  471. if (ret_of && ret_acpi) {
  472. dev_dbg(&ctrl->dev, "no devices registered: of:%d acpi:%d\n",
  473. ret_of, ret_acpi);
  474. ret = -ENODEV;
  475. goto err_rpm_disable;
  476. }
  477. dev_dbg(&ctrl->dev, "serdev%d registered: dev:%p\n",
  478. ctrl->nr, &ctrl->dev);
  479. return 0;
  480. err_rpm_disable:
  481. pm_runtime_disable(&ctrl->dev);
  482. device_del(&ctrl->dev);
  483. return ret;
  484. };
  485. EXPORT_SYMBOL_GPL(serdev_controller_add);
  486. /* Remove a device associated with a controller */
  487. static int serdev_remove_device(struct device *dev, void *data)
  488. {
  489. struct serdev_device *serdev = to_serdev_device(dev);
  490. if (dev->type == &serdev_device_type)
  491. serdev_device_remove(serdev);
  492. return 0;
  493. }
  494. /**
  495. * serdev_controller_remove(): remove an serdev controller
  496. * @ctrl: controller to remove
  497. *
  498. * Remove a serdev controller. Caller is responsible for calling
  499. * serdev_controller_put() to discard the allocated controller.
  500. */
  501. void serdev_controller_remove(struct serdev_controller *ctrl)
  502. {
  503. int dummy;
  504. if (!ctrl)
  505. return;
  506. dummy = device_for_each_child(&ctrl->dev, NULL,
  507. serdev_remove_device);
  508. pm_runtime_disable(&ctrl->dev);
  509. device_del(&ctrl->dev);
  510. }
  511. EXPORT_SYMBOL_GPL(serdev_controller_remove);
  512. /**
  513. * serdev_driver_register() - Register client driver with serdev core
  514. * @sdrv: client driver to be associated with client-device.
  515. *
  516. * This API will register the client driver with the serdev framework.
  517. * It is typically called from the driver's module-init function.
  518. */
  519. int __serdev_device_driver_register(struct serdev_device_driver *sdrv, struct module *owner)
  520. {
  521. sdrv->driver.bus = &serdev_bus_type;
  522. sdrv->driver.owner = owner;
  523. /* force drivers to async probe so I/O is possible in probe */
  524. sdrv->driver.probe_type = PROBE_PREFER_ASYNCHRONOUS;
  525. return driver_register(&sdrv->driver);
  526. }
  527. EXPORT_SYMBOL_GPL(__serdev_device_driver_register);
  528. static void __exit serdev_exit(void)
  529. {
  530. bus_unregister(&serdev_bus_type);
  531. ida_destroy(&ctrl_ida);
  532. }
  533. module_exit(serdev_exit);
  534. static int __init serdev_init(void)
  535. {
  536. int ret;
  537. ret = bus_register(&serdev_bus_type);
  538. if (ret)
  539. return ret;
  540. is_registered = true;
  541. return 0;
  542. }
  543. /* Must be before serial drivers register */
  544. postcore_initcall(serdev_init);
  545. MODULE_AUTHOR("Rob Herring <robh@kernel.org>");
  546. MODULE_LICENSE("GPL v2");
  547. MODULE_DESCRIPTION("Serial attached device bus");