Merge tag 'chrome-platform-v7.1' of git://git.kernel.org/pub/scm/linux/kernel/git/chrome-platform/linux

+18 -23

drivers/platform/chrome/chromeos_privacy_screen.c

··· 12 12 */ 13 13 14 14 #include <linux/acpi.h> 15 + #include <linux/platform_device.h> 15 16 #include <drm/drm_privacy_screen_driver.h> 16 17 17 18 /* ··· 33 32 *drm_privacy_screen) 34 33 { 35 34 union acpi_object *obj; 36 - acpi_handle handle; 37 35 struct device *privacy_screen = 38 36 drm_privacy_screen_get_drvdata(drm_privacy_screen); 37 + acpi_handle handle = ACPI_HANDLE(privacy_screen); 39 38 40 - handle = acpi_device_handle(to_acpi_device(privacy_screen)); 41 39 obj = acpi_evaluate_dsm(handle, &chromeos_privacy_screen_dsm_guid, 42 40 PRIV_SCRN_DSM_REVID, 43 41 PRIV_SCRN_DSM_FN_GET_STATUS, NULL); ··· 65 65 enum drm_privacy_screen_status state) 66 66 { 67 67 union acpi_object *obj = NULL; 68 - acpi_handle handle; 69 68 struct device *privacy_screen = 70 69 drm_privacy_screen_get_drvdata(drm_privacy_screen); 71 - 72 - handle = acpi_device_handle(to_acpi_device(privacy_screen)); 70 + acpi_handle handle = ACPI_HANDLE(privacy_screen); 73 71 74 72 if (state == PRIVACY_SCREEN_DISABLED) { 75 73 obj = acpi_evaluate_dsm(handle, ··· 102 104 .set_sw_state = chromeos_privacy_screen_set_sw_state, 103 105 }; 104 106 105 - static int chromeos_privacy_screen_add(struct acpi_device *adev) 107 + static int chromeos_privacy_screen_probe(struct platform_device *pdev) 106 108 { 107 109 struct drm_privacy_screen *drm_privacy_screen = 108 - drm_privacy_screen_register(&adev->dev, 110 + drm_privacy_screen_register(&pdev->dev, 109 111 &chromeos_privacy_screen_ops, 110 - &adev->dev); 112 + &pdev->dev); 111 113 112 114 if (IS_ERR(drm_privacy_screen)) { 113 - dev_err(&adev->dev, "Error registering privacy-screen\n"); 115 + dev_err(&pdev->dev, "Error registering privacy-screen\n"); 114 116 return PTR_ERR(drm_privacy_screen); 115 117 } 116 118 117 - adev->driver_data = drm_privacy_screen; 118 - dev_info(&adev->dev, "registered privacy-screen '%s'\n", 119 + platform_set_drvdata(pdev, drm_privacy_screen); 120 + dev_info(&pdev->dev, "registered privacy-screen '%s'\n", 119 121 dev_name(&drm_privacy_screen->dev)); 120 122 121 123 return 0; 122 124 } 123 125 124 - static void chromeos_privacy_screen_remove(struct acpi_device *adev) 126 + static void chromeos_privacy_screen_remove(struct platform_device *pdev) 125 127 { 126 - struct drm_privacy_screen *drm_privacy_screen = acpi_driver_data(adev); 127 - 128 - drm_privacy_screen_unregister(drm_privacy_screen); 128 + drm_privacy_screen_unregister(platform_get_drvdata(pdev)); 129 129 } 130 130 131 131 static const struct acpi_device_id chromeos_privacy_screen_device_ids[] = { ··· 132 136 }; 133 137 MODULE_DEVICE_TABLE(acpi, chromeos_privacy_screen_device_ids); 134 138 135 - static struct acpi_driver chromeos_privacy_screen_driver = { 136 - .name = "chromeos_privacy_screen_driver", 137 - .class = "ChromeOS", 138 - .ids = chromeos_privacy_screen_device_ids, 139 - .ops = { 140 - .add = chromeos_privacy_screen_add, 141 - .remove = chromeos_privacy_screen_remove, 139 + static struct platform_driver chromeos_privacy_screen_driver = { 140 + .probe = chromeos_privacy_screen_probe, 141 + .remove = chromeos_privacy_screen_remove, 142 + .driver = { 143 + .name = "chromeos_privacy_screen_driver", 144 + .acpi_match_table = chromeos_privacy_screen_device_ids, 142 145 }, 143 146 }; 144 147 145 - module_acpi_driver(chromeos_privacy_screen_driver); 148 + module_platform_driver(chromeos_privacy_screen_driver); 146 149 MODULE_LICENSE("GPL v2"); 147 150 MODULE_DESCRIPTION("ChromeOS ACPI Privacy Screen driver"); 148 151 MODULE_AUTHOR("Rajat Jain <rajatja@google.com>");

+36 -19

drivers/platform/chrome/chromeos_tbmc.c

··· 16 16 #include <linux/input.h> 17 17 #include <linux/io.h> 18 18 #include <linux/module.h> 19 + #include <linux/platform_device.h> 19 20 #include <linux/printk.h> 20 21 21 22 #define DRV_NAME "chromeos_tbmc" ··· 41 40 42 41 static __maybe_unused int chromeos_tbmc_resume(struct device *dev) 43 42 { 44 - struct acpi_device *adev = to_acpi_device(dev); 45 - 46 - return chromeos_tbmc_query_switch(adev, adev->driver_data); 43 + return chromeos_tbmc_query_switch(ACPI_COMPANION(dev), dev_get_drvdata(dev)); 47 44 } 48 45 49 - static void chromeos_tbmc_notify(struct acpi_device *adev, u32 event) 46 + static void chromeos_tbmc_notify(acpi_handle handle, u32 event, void *data) 50 47 { 51 - acpi_pm_wakeup_event(&adev->dev); 48 + struct device *dev = data; 49 + 50 + acpi_pm_wakeup_event(dev); 52 51 switch (event) { 53 52 case 0x80: 54 - chromeos_tbmc_query_switch(adev, adev->driver_data); 53 + chromeos_tbmc_query_switch(ACPI_COMPANION(dev), dev_get_drvdata(dev)); 55 54 break; 56 55 default: 57 - dev_err(&adev->dev, "Unexpected event: 0x%08X\n", event); 56 + dev_err(dev, "Unexpected event: 0x%08X\n", event); 58 57 } 59 58 } 60 59 ··· 65 64 return chromeos_tbmc_query_switch(adev, idev); 66 65 } 67 66 68 - static int chromeos_tbmc_add(struct acpi_device *adev) 67 + static int chromeos_tbmc_probe(struct platform_device *pdev) 69 68 { 70 69 struct input_dev *idev; 71 - struct device *dev = &adev->dev; 70 + struct device *dev = &pdev->dev; 71 + struct acpi_device *adev = ACPI_COMPANION(dev); 72 72 int ret; 73 73 74 74 idev = devm_input_allocate_device(dev); ··· 85 83 idev->open = chromeos_tbmc_open; 86 84 87 85 input_set_drvdata(idev, adev); 88 - adev->driver_data = idev; 86 + platform_set_drvdata(pdev, idev); 89 87 90 88 input_set_capability(idev, EV_SW, SW_TABLET_MODE); 91 89 ret = input_register_device(idev); ··· 94 92 return ret; 95 93 } 96 94 device_init_wakeup(dev, true); 95 + 96 + ret = acpi_dev_install_notify_handler(adev, ACPI_DEVICE_NOTIFY, 97 + chromeos_tbmc_notify, dev); 98 + if (ret) { 99 + dev_err(dev, "cannot install ACPI notify handler\n"); 100 + device_init_wakeup(dev, false); 101 + return ret; 102 + } 103 + 97 104 return 0; 105 + } 106 + 107 + static void chromeos_tbmc_remove(struct platform_device *pdev) 108 + { 109 + acpi_dev_remove_notify_handler(ACPI_COMPANION(&pdev->dev), 110 + ACPI_DEVICE_NOTIFY, chromeos_tbmc_notify); 111 + device_init_wakeup(&pdev->dev, false); 98 112 } 99 113 100 114 static const struct acpi_device_id chromeos_tbmc_acpi_device_ids[] = { ··· 122 104 static SIMPLE_DEV_PM_OPS(chromeos_tbmc_pm_ops, NULL, 123 105 chromeos_tbmc_resume); 124 106 125 - static struct acpi_driver chromeos_tbmc_driver = { 126 - .name = DRV_NAME, 127 - .class = DRV_NAME, 128 - .ids = chromeos_tbmc_acpi_device_ids, 129 - .ops = { 130 - .add = chromeos_tbmc_add, 131 - .notify = chromeos_tbmc_notify, 107 + static struct platform_driver chromeos_tbmc_driver = { 108 + .probe = chromeos_tbmc_probe, 109 + .remove = chromeos_tbmc_remove, 110 + .driver = { 111 + .name = DRV_NAME, 112 + .acpi_match_table = chromeos_tbmc_acpi_device_ids, 113 + .pm = &chromeos_tbmc_pm_ops, 132 114 }, 133 - .drv.pm = &chromeos_tbmc_pm_ops, 134 115 }; 135 116 136 - module_acpi_driver(chromeos_tbmc_driver); 117 + module_platform_driver(chromeos_tbmc_driver); 137 118 138 119 MODULE_LICENSE("GPL v2"); 139 120 MODULE_DESCRIPTION("ChromeOS ACPI tablet switch driver");

+3

drivers/platform/chrome/cros_ec_lightbar.c

··· 461 461 param = (struct ec_params_lightbar *)msg->data; 462 462 param->cmd = LIGHTBAR_CMD_SEQ; 463 463 param->seq.num = num; 464 + msg->outsize = offsetof(typeof(*param), seq) + sizeof(param->seq); 465 + msg->insize = 0; 464 466 ret = lb_throttle(); 465 467 if (ret) 466 468 goto exit; ··· 518 516 if (ret) 519 517 goto exit; 520 518 param = (struct ec_params_lightbar *)msg->data; 519 + msg->insize = 0; 521 520 522 521 if (lb_version < 3) { 523 522 dev_info(dev, "Copying %zu byte program to EC", count);

+7 -11

drivers/platform/chrome/cros_usbpd_logger.c

··· 5 5 * Copyright 2018 Google LLC. 6 6 */ 7 7 8 + #include <linux/devm-helpers.h> 8 9 #include <linux/ktime.h> 9 10 #include <linux/math64.h> 10 11 #include <linux/mod_devicetable.h> ··· 200 199 struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent); 201 200 struct device *dev = &pd->dev; 202 201 struct logger_data *logger; 202 + int ret; 203 203 204 204 logger = devm_kzalloc(dev, sizeof(*logger), GFP_KERNEL); 205 205 if (!logger) ··· 212 210 platform_set_drvdata(pd, logger); 213 211 214 212 /* Retrieve PD event logs periodically */ 215 - INIT_DELAYED_WORK(&logger->log_work, cros_usbpd_log_check); 216 - logger->log_workqueue = create_singlethread_workqueue("cros_usbpd_log"); 213 + logger->log_workqueue = devm_alloc_ordered_workqueue(dev, "cros_usbpd_log", 0); 217 214 if (!logger->log_workqueue) 218 215 return -ENOMEM; 216 + 217 + ret = devm_delayed_work_autocancel(dev, &logger->log_work, cros_usbpd_log_check); 218 + if (ret) 219 + return ret; 219 220 220 221 queue_delayed_work(logger->log_workqueue, &logger->log_work, 221 222 CROS_USBPD_LOG_UPDATE_DELAY); 222 223 223 224 return 0; 224 - } 225 - 226 - static void cros_usbpd_logger_remove(struct platform_device *pd) 227 - { 228 - struct logger_data *logger = platform_get_drvdata(pd); 229 - 230 - cancel_delayed_work_sync(&logger->log_work); 231 - destroy_workqueue(logger->log_workqueue); 232 225 } 233 226 234 227 static int __maybe_unused cros_usbpd_logger_resume(struct device *dev) ··· 260 263 .pm = &cros_usbpd_logger_pm_ops, 261 264 }, 262 265 .probe = cros_usbpd_logger_probe, 263 - .remove = cros_usbpd_logger_remove, 264 266 .id_table = cros_usbpd_logger_id, 265 267 }; 266 268

+43 -30

drivers/platform/chrome/wilco_ec/event.c

··· 38 38 #include <linux/io.h> 39 39 #include <linux/list.h> 40 40 #include <linux/module.h> 41 + #include <linux/platform_device.h> 41 42 #include <linux/poll.h> 42 43 #include <linux/spinlock.h> 43 44 #include <linux/uaccess.h> ··· 199 198 200 199 /** 201 200 * enqueue_events() - Place EC events in queue to be read by userspace. 202 - * @adev: Device the events came from. 201 + * @dev: Device the events came from. 203 202 * @buf: Buffer of event data. 204 203 * @length: Length of event data buffer. 205 204 * ··· 210 209 * 211 210 * Return: 0 on success or negative error code on failure. 212 211 */ 213 - static int enqueue_events(struct acpi_device *adev, const u8 *buf, u32 length) 212 + static int enqueue_events(struct device *dev, const u8 *buf, u32 length) 214 213 { 215 - struct event_device_data *dev_data = adev->driver_data; 214 + struct event_device_data *dev_data = dev_get_drvdata(dev); 216 215 struct ec_event *event, *queue_event, *old_event; 217 216 size_t num_words, event_size; 218 217 u32 offset = 0; ··· 223 222 num_words = ec_event_num_words(event); 224 223 event_size = ec_event_size(event); 225 224 if (num_words > EC_ACPI_MAX_EVENT_WORDS) { 226 - dev_err(&adev->dev, "Too many event words: %zu > %d\n", 225 + dev_err(dev, "Too many event words: %zu > %d\n", 227 226 num_words, EC_ACPI_MAX_EVENT_WORDS); 228 227 return -EOVERFLOW; 229 228 } 230 229 231 230 /* Ensure event does not overflow the available buffer */ 232 231 if ((offset + event_size) > length) { 233 - dev_err(&adev->dev, "Event exceeds buffer: %zu > %d\n", 232 + dev_err(dev, "Event exceeds buffer: %zu > %d\n", 234 233 offset + event_size, length); 235 234 return -EOVERFLOW; 236 235 } ··· 254 253 255 254 /** 256 255 * event_device_notify() - Callback when EC generates an event over ACPI. 257 - * @adev: The device that the event is coming from. 256 + * @handle: ACPI handle of the device that the event is coming from. 258 257 * @value: Value passed to Notify() in ACPI. 258 + * @data: Notify handler data. 259 259 * 260 260 * This function will read the events from the device and enqueue them. 261 261 */ 262 - static void event_device_notify(struct acpi_device *adev, u32 value) 262 + static void event_device_notify(acpi_handle handle, u32 value, void *data) 263 263 { 264 264 struct acpi_buffer event_buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 265 + struct device *dev = data; 266 + struct acpi_device *adev = ACPI_COMPANION(dev); 265 267 union acpi_object *obj; 266 268 acpi_status status; 267 269 268 270 if (value != EC_ACPI_NOTIFY_EVENT) { 269 - dev_err(&adev->dev, "Invalid event: 0x%08x\n", value); 271 + dev_err(dev, "Invalid event: 0x%08x\n", value); 270 272 return; 271 273 } 272 274 ··· 277 273 status = acpi_evaluate_object(adev->handle, EC_ACPI_GET_EVENT, 278 274 NULL, &event_buffer); 279 275 if (ACPI_FAILURE(status)) { 280 - dev_err(&adev->dev, "Error executing ACPI method %s()\n", 276 + dev_err(dev, "Error executing ACPI method %s()\n", 281 277 EC_ACPI_GET_EVENT); 282 278 return; 283 279 } 284 280 285 281 obj = (union acpi_object *)event_buffer.pointer; 286 282 if (!obj) { 287 - dev_err(&adev->dev, "Nothing returned from %s()\n", 283 + dev_err(dev, "Nothing returned from %s()\n", 288 284 EC_ACPI_GET_EVENT); 289 285 return; 290 286 } 291 287 if (obj->type != ACPI_TYPE_BUFFER) { 292 - dev_err(&adev->dev, "Invalid object returned from %s()\n", 288 + dev_err(dev, "Invalid object returned from %s()\n", 293 289 EC_ACPI_GET_EVENT); 294 290 kfree(obj); 295 291 return; 296 292 } 297 293 if (obj->buffer.length < sizeof(struct ec_event)) { 298 - dev_err(&adev->dev, "Invalid buffer length %d from %s()\n", 294 + dev_err(dev, "Invalid buffer length %d from %s()\n", 299 295 obj->buffer.length, EC_ACPI_GET_EVENT); 300 296 kfree(obj); 301 297 return; 302 298 } 303 299 304 - enqueue_events(adev, obj->buffer.pointer, obj->buffer.length); 300 + enqueue_events(dev, obj->buffer.pointer, obj->buffer.length); 305 301 kfree(obj); 306 302 } 307 303 ··· 436 432 } 437 433 438 434 /** 439 - * event_device_add() - Callback when creating a new device. 440 - * @adev: ACPI device that we will be receiving events from. 435 + * event_device_probe() - Callback when creating a new device. 436 + * @pdev: Platform device that we will be receiving events from. 441 437 * 442 438 * This finds a free minor number for the device, allocates and initializes 443 439 * some device data, and creates a new device and char dev node. ··· 449 445 * 450 446 * Return: 0 on success, negative error code on failure. 451 447 */ 452 - static int event_device_add(struct acpi_device *adev) 448 + static int event_device_probe(struct platform_device *pdev) 453 449 { 454 450 struct event_device_data *dev_data; 455 451 int error, minor; ··· 457 453 minor = ida_alloc_max(&event_ida, EVENT_MAX_DEV-1, GFP_KERNEL); 458 454 if (minor < 0) { 459 455 error = minor; 460 - dev_err(&adev->dev, "Failed to find minor number: %d\n", error); 456 + dev_err(&pdev->dev, "Failed to find minor number: %d\n", error); 461 457 return error; 462 458 } 463 459 ··· 468 464 } 469 465 470 466 /* Initialize the device data. */ 471 - adev->driver_data = dev_data; 467 + platform_set_drvdata(pdev, dev_data); 472 468 dev_data->events = event_queue_new(queue_size); 473 469 if (!dev_data->events) { 474 470 kfree(dev_data); ··· 493 489 if (error) 494 490 goto free_dev_data; 495 491 492 + /* Install an ACPI notify handler. */ 493 + error = acpi_dev_install_notify_handler(ACPI_COMPANION(&pdev->dev), 494 + ACPI_DEVICE_NOTIFY, 495 + event_device_notify, &pdev->dev); 496 + if (error) 497 + goto free_cdev; 498 + 496 499 return 0; 497 500 501 + free_cdev: 502 + cdev_device_del(&dev_data->cdev, &dev_data->dev); 498 503 free_dev_data: 499 504 hangup_device(dev_data); 500 505 free_minor: ··· 511 498 return error; 512 499 } 513 500 514 - static void event_device_remove(struct acpi_device *adev) 501 + static void event_device_remove(struct platform_device *pdev) 515 502 { 516 - struct event_device_data *dev_data = adev->driver_data; 503 + struct event_device_data *dev_data = platform_get_drvdata(pdev); 517 504 505 + acpi_dev_remove_notify_handler(ACPI_COMPANION(&pdev->dev), 506 + ACPI_DEVICE_NOTIFY, event_device_notify); 518 507 cdev_device_del(&dev_data->cdev, &dev_data->dev); 519 508 ida_free(&event_ida, MINOR(dev_data->dev.devt)); 520 509 hangup_device(dev_data); ··· 528 513 }; 529 514 MODULE_DEVICE_TABLE(acpi, event_acpi_ids); 530 515 531 - static struct acpi_driver event_driver = { 532 - .name = DRV_NAME, 533 - .class = DRV_NAME, 534 - .ids = event_acpi_ids, 535 - .ops = { 536 - .add = event_device_add, 537 - .notify = event_device_notify, 538 - .remove = event_device_remove, 516 + static struct platform_driver event_driver = { 517 + .probe = event_device_probe, 518 + .remove = event_device_remove, 519 + .driver = { 520 + .name = DRV_NAME, 521 + .acpi_match_table = event_acpi_ids, 539 522 }, 540 523 }; 541 524 ··· 556 543 } 557 544 event_major = MAJOR(dev_num); 558 545 559 - ret = acpi_bus_register_driver(&event_driver); 546 + ret = platform_driver_register(&event_driver); 560 547 if (ret < 0) { 561 548 pr_err(DRV_NAME ": Failed registering driver: %d\n", ret); 562 549 goto unregister_region; ··· 574 561 575 562 static void __exit event_module_exit(void) 576 563 { 577 - acpi_bus_unregister_driver(&event_driver); 564 + platform_driver_unregister(&event_driver); 578 565 unregister_chrdev_region(MKDEV(event_major, 0), EVENT_MAX_DEV); 579 566 class_unregister(&event_class); 580 567 ida_destroy(&event_ida);

Configure Feed

Configure Feed