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