tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'tee-bus-callback-for-6.20' of git://git.kernel.org/pub/scm/linux/kernel/git/jenswi/linux-tee into soc/drivers

TEE bus callback for 6.20

- Move from generic device_driver to TEE bus-specific callbacks
- Add module_tee_client_driver() and registration helpers to reduce
boilerplate
- Convert several client drivers (TPM, KEYS, firmware, EFI, hwrng,
and RTC)
- Update documentation and fix kernel-doc warnings

* tag 'tee-bus-callback-for-6.20' of git://git.kernel.org/pub/scm/linux/kernel/git/jenswi/linux-tee:
tpm/tpm_ftpm_tee: Fix kdoc after function renames
tpm/tpm_ftpm_tee: Make use of tee bus methods
tpm/tpm_ftpm_tee: Make use of tee specific driver registration
KEYS: trusted: Make use of tee bus methods
KEYS: trusted: Migrate to use tee specific driver registration function
firmware: tee_bnxt: Make use of tee bus methods
firmware: tee_bnxt: Make use of module_tee_client_driver()
firmware: arm_scmi: Make use of tee bus methods
firmware: arm_scmi: optee: Make use of module_tee_client_driver()
efi: stmm: Make use of tee bus methods
efi: stmm: Make use of module_tee_client_driver()
hwrng: optee - Make use of tee bus methods
hwrng: optee - Make use of module_tee_client_driver()
rtc: optee: Make use of tee bus methods
rtc: optee: Migrate to use tee specific driver registration function
tee: Adapt documentation to cover recent additions
tee: Add probe, remove and shutdown bus callbacks to tee_client_driver
tee: Add some helpers to reduce boilerplate for tee client drivers

Signed-off-by: Arnd Bergmann <arnd@arndb.de>

Arnd Bergmann e6bea2f5 08b67ff2

+166 -140
+3 -15
Documentation/driver-api/tee.rst
··· 43 43 MODULE_DEVICE_TABLE(tee, client_id_table); 44 44 45 45 static struct tee_client_driver client_driver = { 46 + .probe = client_probe, 47 + .remove = client_remove, 46 48 .id_table = client_id_table, 47 49 .driver = { 48 50 .name = DRIVER_NAME, 49 - .bus = &tee_bus_type, 50 - .probe = client_probe, 51 - .remove = client_remove, 52 51 }, 53 52 }; 54 53 55 - static int __init client_init(void) 56 - { 57 - return driver_register(&client_driver.driver); 58 - } 59 - 60 - static void __exit client_exit(void) 61 - { 62 - driver_unregister(&client_driver.driver); 63 - } 64 - 65 - module_init(client_init); 66 - module_exit(client_exit); 54 + module_tee_client_driver(client_driver);
+6 -20
drivers/char/hw_random/optee-rng.c
··· 211 211 return 0; 212 212 } 213 213 214 - static int optee_rng_probe(struct device *dev) 214 + static int optee_rng_probe(struct tee_client_device *rng_device) 215 215 { 216 - struct tee_client_device *rng_device = to_tee_client_device(dev); 216 + struct device *dev = &rng_device->dev; 217 217 int ret = 0, err = -ENODEV; 218 218 struct tee_ioctl_open_session_arg sess_arg; 219 219 ··· 261 261 return err; 262 262 } 263 263 264 - static int optee_rng_remove(struct device *dev) 264 + static void optee_rng_remove(struct tee_client_device *tee_dev) 265 265 { 266 266 tee_client_close_session(pvt_data.ctx, pvt_data.session_id); 267 267 tee_client_close_context(pvt_data.ctx); 268 - 269 - return 0; 270 268 } 271 269 272 270 static const struct tee_client_device_id optee_rng_id_table[] = { ··· 276 278 MODULE_DEVICE_TABLE(tee, optee_rng_id_table); 277 279 278 280 static struct tee_client_driver optee_rng_driver = { 281 + .probe = optee_rng_probe, 282 + .remove = optee_rng_remove, 279 283 .id_table = optee_rng_id_table, 280 284 .driver = { 281 285 .name = DRIVER_NAME, 282 - .bus = &tee_bus_type, 283 - .probe = optee_rng_probe, 284 - .remove = optee_rng_remove, 285 286 }, 286 287 }; 287 288 288 - static int __init optee_rng_mod_init(void) 289 - { 290 - return driver_register(&optee_rng_driver.driver); 291 - } 292 - 293 - static void __exit optee_rng_mod_exit(void) 294 - { 295 - driver_unregister(&optee_rng_driver.driver); 296 - } 297 - 298 - module_init(optee_rng_mod_init); 299 - module_exit(optee_rng_mod_exit); 289 + module_tee_client_driver(optee_rng_driver); 300 290 301 291 MODULE_LICENSE("GPL v2"); 302 292 MODULE_AUTHOR("Sumit Garg <sumit.garg@linaro.org>");
+23 -12
drivers/char/tpm/tpm_ftpm_tee.c
··· 163 163 } 164 164 165 165 /** 166 - * ftpm_tee_probe() - initialize the fTPM 166 + * ftpm_tee_probe_generic() - initialize the fTPM 167 167 * @dev: the device description. 168 168 * 169 169 * Return: 170 170 * On success, 0. On failure, -errno. 171 171 */ 172 - static int ftpm_tee_probe(struct device *dev) 172 + static int ftpm_tee_probe_generic(struct device *dev) 173 173 { 174 174 int rc; 175 175 struct tpm_chip *chip; ··· 251 251 return rc; 252 252 } 253 253 254 + static int ftpm_tee_probe(struct tee_client_device *tcdev) 255 + { 256 + struct device *dev = &tcdev->dev; 257 + 258 + return ftpm_tee_probe_generic(dev); 259 + } 260 + 254 261 static int ftpm_plat_tee_probe(struct platform_device *pdev) 255 262 { 256 263 struct device *dev = &pdev->dev; 257 264 258 - return ftpm_tee_probe(dev); 265 + return ftpm_tee_probe_generic(dev); 259 266 } 260 267 261 268 /** 262 - * ftpm_tee_remove() - remove the TPM device 269 + * ftpm_tee_remove_generic() - remove the TPM device 263 270 * @dev: the device description. 264 271 * 265 272 * Return: 266 273 * 0 always. 267 274 */ 268 - static int ftpm_tee_remove(struct device *dev) 275 + static void ftpm_tee_remove_generic(struct device *dev) 269 276 { 270 277 struct ftpm_tee_private *pvt_data = dev_get_drvdata(dev); 271 278 ··· 292 285 tee_client_close_context(pvt_data->ctx); 293 286 294 287 /* memory allocated with devm_kzalloc() is freed automatically */ 288 + } 295 289 296 - return 0; 290 + static void ftpm_tee_remove(struct tee_client_device *tcdev) 291 + { 292 + struct device *dev = &tcdev->dev; 293 + 294 + ftpm_tee_remove_generic(dev); 297 295 } 298 296 299 297 static void ftpm_plat_tee_remove(struct platform_device *pdev) 300 298 { 301 299 struct device *dev = &pdev->dev; 302 300 303 - ftpm_tee_remove(dev); 301 + ftpm_tee_remove_generic(dev); 304 302 } 305 303 306 304 /** ··· 347 335 MODULE_DEVICE_TABLE(tee, optee_ftpm_id_table); 348 336 349 337 static struct tee_client_driver ftpm_tee_driver = { 338 + .probe = ftpm_tee_probe, 339 + .remove = ftpm_tee_remove, 350 340 .id_table = optee_ftpm_id_table, 351 341 .driver = { 352 342 .name = "optee-ftpm", 353 - .bus = &tee_bus_type, 354 - .probe = ftpm_tee_probe, 355 - .remove = ftpm_tee_remove, 356 343 }, 357 344 }; 358 345 ··· 363 352 if (rc) 364 353 return rc; 365 354 366 - rc = driver_register(&ftpm_tee_driver.driver); 355 + rc = tee_client_driver_register(&ftpm_tee_driver); 367 356 if (rc) { 368 357 platform_driver_unregister(&ftpm_tee_plat_driver); 369 358 return rc; ··· 375 364 static void __exit ftpm_mod_exit(void) 376 365 { 377 366 platform_driver_unregister(&ftpm_tee_plat_driver); 378 - driver_unregister(&ftpm_tee_driver.driver); 367 + tee_client_driver_unregister(&ftpm_tee_driver); 379 368 } 380 369 381 370 module_init(ftpm_mod_init);
+10 -22
drivers/firmware/arm_scmi/transports/optee.c
··· 529 529 DEFINE_SCMI_TRANSPORT_DRIVER(scmi_optee, scmi_optee_driver, scmi_optee_desc, 530 530 scmi_of_match, core); 531 531 532 - static int scmi_optee_service_probe(struct device *dev) 532 + static int scmi_optee_service_probe(struct tee_client_device *scmi_pta) 533 533 { 534 + struct device *dev = &scmi_pta->dev; 534 535 struct scmi_optee_agent *agent; 535 536 struct tee_context *tee_ctx; 536 537 int ret; ··· 579 578 return ret; 580 579 } 581 580 582 - static int scmi_optee_service_remove(struct device *dev) 581 + static void scmi_optee_service_remove(struct tee_client_device *scmi_pta) 583 582 { 584 583 struct scmi_optee_agent *agent = scmi_optee_private; 585 584 586 585 if (!scmi_optee_private) 587 - return -EINVAL; 586 + return; 588 587 589 588 platform_driver_unregister(&scmi_optee_driver); 590 589 591 590 if (!list_empty(&scmi_optee_private->channel_list)) 592 - return -EBUSY; 591 + return; 593 592 594 593 /* Ensure cleared reference is visible before resources are released */ 595 594 smp_store_mb(scmi_optee_private, NULL); 596 595 597 596 tee_client_close_context(agent->tee_ctx); 598 - 599 - return 0; 600 597 } 601 598 602 599 static const struct tee_client_device_id scmi_optee_service_id[] = { ··· 608 609 MODULE_DEVICE_TABLE(tee, scmi_optee_service_id); 609 610 610 611 static struct tee_client_driver scmi_optee_service_driver = { 611 - .id_table = scmi_optee_service_id, 612 - .driver = { 612 + .probe = scmi_optee_service_probe, 613 + .remove = scmi_optee_service_remove, 614 + .id_table = scmi_optee_service_id, 615 + .driver = { 613 616 .name = "scmi-optee", 614 - .bus = &tee_bus_type, 615 - .probe = scmi_optee_service_probe, 616 - .remove = scmi_optee_service_remove, 617 617 }, 618 618 }; 619 619 620 - static int __init scmi_transport_optee_init(void) 621 - { 622 - return driver_register(&scmi_optee_service_driver.driver); 623 - } 624 - module_init(scmi_transport_optee_init); 625 - 626 - static void __exit scmi_transport_optee_exit(void) 627 - { 628 - driver_unregister(&scmi_optee_service_driver.driver); 629 - } 630 - module_exit(scmi_transport_optee_exit); 620 + module_tee_client_driver(scmi_optee_service_driver); 631 621 632 622 MODULE_AUTHOR("Etienne Carriere <etienne.carriere@foss.st.com>"); 633 623 MODULE_DESCRIPTION("SCMI OPTEE Transport driver");
+8 -22
drivers/firmware/broadcom/tee_bnxt_fw.c
··· 181 181 return (ver->impl_id == TEE_IMPL_ID_OPTEE); 182 182 } 183 183 184 - static int tee_bnxt_fw_probe(struct device *dev) 184 + static int tee_bnxt_fw_probe(struct tee_client_device *bnxt_device) 185 185 { 186 - struct tee_client_device *bnxt_device = to_tee_client_device(dev); 186 + struct device *dev = &bnxt_device->dev; 187 187 int ret, err = -ENODEV; 188 188 struct tee_ioctl_open_session_arg sess_arg; 189 189 struct tee_shm *fw_shm_pool; ··· 231 231 return err; 232 232 } 233 233 234 - static int tee_bnxt_fw_remove(struct device *dev) 234 + static void tee_bnxt_fw_remove(struct tee_client_device *bnxt_device) 235 235 { 236 236 tee_shm_free(pvt_data.fw_shm_pool); 237 237 tee_client_close_session(pvt_data.ctx, pvt_data.session_id); 238 238 tee_client_close_context(pvt_data.ctx); 239 239 pvt_data.ctx = NULL; 240 - 241 - return 0; 242 240 } 243 241 244 - static void tee_bnxt_fw_shutdown(struct device *dev) 242 + static void tee_bnxt_fw_shutdown(struct tee_client_device *bnxt_device) 245 243 { 246 244 tee_shm_free(pvt_data.fw_shm_pool); 247 245 tee_client_close_session(pvt_data.ctx, pvt_data.session_id); ··· 256 258 MODULE_DEVICE_TABLE(tee, tee_bnxt_fw_id_table); 257 259 258 260 static struct tee_client_driver tee_bnxt_fw_driver = { 261 + .probe = tee_bnxt_fw_probe, 262 + .remove = tee_bnxt_fw_remove, 263 + .shutdown = tee_bnxt_fw_shutdown, 259 264 .id_table = tee_bnxt_fw_id_table, 260 265 .driver = { 261 266 .name = KBUILD_MODNAME, 262 - .bus = &tee_bus_type, 263 - .probe = tee_bnxt_fw_probe, 264 - .remove = tee_bnxt_fw_remove, 265 - .shutdown = tee_bnxt_fw_shutdown, 266 267 }, 267 268 }; 268 269 269 - static int __init tee_bnxt_fw_mod_init(void) 270 - { 271 - return driver_register(&tee_bnxt_fw_driver.driver); 272 - } 273 - 274 - static void __exit tee_bnxt_fw_mod_exit(void) 275 - { 276 - driver_unregister(&tee_bnxt_fw_driver.driver); 277 - } 278 - 279 - module_init(tee_bnxt_fw_mod_init); 280 - module_exit(tee_bnxt_fw_mod_exit); 270 + module_tee_client_driver(tee_bnxt_fw_driver); 281 271 282 272 MODULE_AUTHOR("Vikas Gupta <vikas.gupta@broadcom.com>"); 283 273 MODULE_DESCRIPTION("Broadcom bnxt firmware manager");
+6 -19
drivers/firmware/efi/stmm/tee_stmm_efi.c
··· 520 520 efivars_generic_ops_register(); 521 521 } 522 522 523 - static int tee_stmm_efi_probe(struct device *dev) 523 + static int tee_stmm_efi_probe(struct tee_client_device *tee_dev) 524 524 { 525 + struct device *dev = &tee_dev->dev; 525 526 struct tee_ioctl_open_session_arg sess_arg; 526 527 efi_status_t ret; 527 528 int rc; ··· 572 571 return 0; 573 572 } 574 573 575 - static int tee_stmm_efi_remove(struct device *dev) 574 + static void tee_stmm_efi_remove(struct tee_client_device *dev) 576 575 { 577 576 tee_stmm_restore_efivars_generic_ops(); 578 - 579 - return 0; 580 577 } 581 578 582 579 MODULE_DEVICE_TABLE(tee, tee_stmm_efi_id_table); 583 580 584 581 static struct tee_client_driver tee_stmm_efi_driver = { 585 582 .id_table = tee_stmm_efi_id_table, 583 + .probe = tee_stmm_efi_probe, 584 + .remove = tee_stmm_efi_remove, 586 585 .driver = { 587 586 .name = "tee-stmm-efi", 588 - .bus = &tee_bus_type, 589 - .probe = tee_stmm_efi_probe, 590 - .remove = tee_stmm_efi_remove, 591 587 }, 592 588 }; 593 589 594 - static int __init tee_stmm_efi_mod_init(void) 595 - { 596 - return driver_register(&tee_stmm_efi_driver.driver); 597 - } 598 - 599 - static void __exit tee_stmm_efi_mod_exit(void) 600 - { 601 - driver_unregister(&tee_stmm_efi_driver.driver); 602 - } 603 - 604 - module_init(tee_stmm_efi_mod_init); 605 - module_exit(tee_stmm_efi_mod_exit); 590 + module_tee_client_driver(tee_stmm_efi_driver); 606 591 607 592 MODULE_LICENSE("GPL"); 608 593 MODULE_AUTHOR("Ilias Apalodimas <ilias.apalodimas@linaro.org>");
+7 -20
drivers/rtc/rtc-optee.c
··· 547 547 return 0; 548 548 } 549 549 550 - static int optee_rtc_probe(struct device *dev) 550 + static int optee_rtc_probe(struct tee_client_device *rtc_device) 551 551 { 552 - struct tee_client_device *rtc_device = to_tee_client_device(dev); 552 + struct device *dev = &rtc_device->dev; 553 553 struct tee_ioctl_open_session_arg sess2_arg = {0}; 554 554 struct tee_ioctl_open_session_arg sess_arg = {0}; 555 555 struct optee_rtc *priv; ··· 682 682 return err; 683 683 } 684 684 685 - static int optee_rtc_remove(struct device *dev) 685 + static void optee_rtc_remove(struct tee_client_device *rtc_device) 686 686 { 687 + struct device *dev = &rtc_device->dev; 687 688 struct optee_rtc *priv = dev_get_drvdata(dev); 688 689 689 690 if (priv->features & TA_RTC_FEATURE_ALARM) { ··· 697 696 tee_shm_free(priv->shm); 698 697 tee_client_close_session(priv->ctx, priv->session_id); 699 698 tee_client_close_context(priv->ctx); 700 - 701 - return 0; 702 699 } 703 700 704 701 static int optee_rtc_suspend(struct device *dev) ··· 723 724 724 725 static struct tee_client_driver optee_rtc_driver = { 725 726 .id_table = optee_rtc_id_table, 727 + .probe = optee_rtc_probe, 728 + .remove = optee_rtc_remove, 726 729 .driver = { 727 730 .name = "optee_rtc", 728 - .bus = &tee_bus_type, 729 - .probe = optee_rtc_probe, 730 - .remove = optee_rtc_remove, 731 731 .pm = pm_sleep_ptr(&optee_rtc_pm_ops), 732 732 }, 733 733 }; 734 734 735 - static int __init optee_rtc_mod_init(void) 736 - { 737 - return driver_register(&optee_rtc_driver.driver); 738 - } 739 - 740 - static void __exit optee_rtc_mod_exit(void) 741 - { 742 - driver_unregister(&optee_rtc_driver.driver); 743 - } 744 - 745 - module_init(optee_rtc_mod_init); 746 - module_exit(optee_rtc_mod_exit); 735 + module_tee_client_driver(optee_rtc_driver); 747 736 748 737 MODULE_LICENSE("GPL v2"); 749 738 MODULE_AUTHOR("Clément Léger <clement.leger@bootlin.com>");
+84
drivers/tee/tee_core.c
··· 1398 1398 return add_uevent_var(env, "MODALIAS=tee:%pUb", dev_id); 1399 1399 } 1400 1400 1401 + static int tee_client_device_probe(struct device *dev) 1402 + { 1403 + struct tee_client_device *tcdev = to_tee_client_device(dev); 1404 + struct tee_client_driver *drv = to_tee_client_driver(dev->driver); 1405 + 1406 + if (drv->probe) 1407 + return drv->probe(tcdev); 1408 + else 1409 + return 0; 1410 + } 1411 + 1412 + static void tee_client_device_remove(struct device *dev) 1413 + { 1414 + struct tee_client_device *tcdev = to_tee_client_device(dev); 1415 + struct tee_client_driver *drv = to_tee_client_driver(dev->driver); 1416 + 1417 + if (drv->remove) 1418 + drv->remove(tcdev); 1419 + } 1420 + 1421 + static void tee_client_device_shutdown(struct device *dev) 1422 + { 1423 + struct tee_client_device *tcdev = to_tee_client_device(dev); 1424 + struct tee_client_driver *drv = to_tee_client_driver(dev->driver); 1425 + 1426 + if (dev->driver && drv->shutdown) 1427 + drv->shutdown(tcdev); 1428 + } 1429 + 1401 1430 const struct bus_type tee_bus_type = { 1402 1431 .name = "tee", 1403 1432 .match = tee_client_device_match, 1404 1433 .uevent = tee_client_device_uevent, 1434 + .probe = tee_client_device_probe, 1435 + .remove = tee_client_device_remove, 1436 + .shutdown = tee_client_device_shutdown, 1405 1437 }; 1406 1438 EXPORT_SYMBOL_GPL(tee_bus_type); 1439 + 1440 + static int tee_client_device_probe_legacy(struct tee_client_device *tcdev) 1441 + { 1442 + struct device *dev = &tcdev->dev; 1443 + struct device_driver *driver = dev->driver; 1444 + 1445 + return driver->probe(dev); 1446 + } 1447 + 1448 + static void tee_client_device_remove_legacy(struct tee_client_device *tcdev) 1449 + { 1450 + struct device *dev = &tcdev->dev; 1451 + struct device_driver *driver = dev->driver; 1452 + 1453 + driver->remove(dev); 1454 + } 1455 + 1456 + static void tee_client_device_shutdown_legacy(struct tee_client_device *tcdev) 1457 + { 1458 + struct device *dev = &tcdev->dev; 1459 + struct device_driver *driver = dev->driver; 1460 + 1461 + driver->shutdown(dev); 1462 + } 1463 + 1464 + int __tee_client_driver_register(struct tee_client_driver *tee_driver, 1465 + struct module *owner) 1466 + { 1467 + tee_driver->driver.owner = owner; 1468 + tee_driver->driver.bus = &tee_bus_type; 1469 + 1470 + /* 1471 + * Drivers that have callbacks set for tee_driver->driver need updating 1472 + * to use the callbacks in tee_driver instead. driver_register() warns 1473 + * about that, so no need to warn here, too. 1474 + */ 1475 + if (!tee_driver->probe && tee_driver->driver.probe) 1476 + tee_driver->probe = tee_client_device_probe_legacy; 1477 + if (!tee_driver->remove && tee_driver->driver.remove) 1478 + tee_driver->remove = tee_client_device_remove_legacy; 1479 + if (!tee_driver->shutdown && tee_driver->driver.probe) 1480 + tee_driver->shutdown = tee_client_device_shutdown_legacy; 1481 + 1482 + return driver_register(&tee_driver->driver); 1483 + } 1484 + EXPORT_SYMBOL_GPL(__tee_client_driver_register); 1485 + 1486 + void tee_client_driver_unregister(struct tee_client_driver *tee_driver) 1487 + { 1488 + driver_unregister(&tee_driver->driver); 1489 + } 1490 + EXPORT_SYMBOL_GPL(tee_client_driver_unregister); 1407 1491 1408 1492 static int __init tee_init(void) 1409 1493 {
+12
include/linux/tee_drv.h
··· 315 315 * @driver: driver structure 316 316 */ 317 317 struct tee_client_driver { 318 + int (*probe)(struct tee_client_device *); 319 + void (*remove)(struct tee_client_device *); 320 + void (*shutdown)(struct tee_client_device *); 318 321 const struct tee_client_device_id *id_table; 319 322 struct device_driver driver; 320 323 }; 321 324 322 325 #define to_tee_client_driver(d) \ 323 326 container_of_const(d, struct tee_client_driver, driver) 327 + 328 + #define tee_client_driver_register(drv) \ 329 + __tee_client_driver_register(drv, THIS_MODULE) 330 + int __tee_client_driver_register(struct tee_client_driver *, struct module *); 331 + void tee_client_driver_unregister(struct tee_client_driver *); 332 + 333 + #define module_tee_client_driver(__tee_client_driver) \ 334 + module_driver(__tee_client_driver, tee_client_driver_register, \ 335 + tee_client_driver_unregister) 324 336 325 337 #endif /*__TEE_DRV_H*/
+7 -10
security/keys/trusted-keys/trusted_tee.c
··· 202 202 return 0; 203 203 } 204 204 205 - static int trusted_key_probe(struct device *dev) 205 + static int trusted_key_probe(struct tee_client_device *rng_device) 206 206 { 207 - struct tee_client_device *rng_device = to_tee_client_device(dev); 207 + struct device *dev = &rng_device->dev; 208 208 int ret; 209 209 struct tee_ioctl_open_session_arg sess_arg; 210 210 ··· 244 244 return ret; 245 245 } 246 246 247 - static int trusted_key_remove(struct device *dev) 247 + static void trusted_key_remove(struct tee_client_device *dev) 248 248 { 249 249 unregister_key_type(&key_type_trusted); 250 250 tee_client_close_session(pvt_data.ctx, pvt_data.session_id); 251 251 tee_client_close_context(pvt_data.ctx); 252 - 253 - return 0; 254 252 } 255 253 256 254 static const struct tee_client_device_id trusted_key_id_table[] = { ··· 259 261 MODULE_DEVICE_TABLE(tee, trusted_key_id_table); 260 262 261 263 static struct tee_client_driver trusted_key_driver = { 264 + .probe = trusted_key_probe, 265 + .remove = trusted_key_remove, 262 266 .id_table = trusted_key_id_table, 263 267 .driver = { 264 268 .name = DRIVER_NAME, 265 - .bus = &tee_bus_type, 266 - .probe = trusted_key_probe, 267 - .remove = trusted_key_remove, 268 269 }, 269 270 }; 270 271 271 272 static int trusted_tee_init(void) 272 273 { 273 - return driver_register(&trusted_key_driver.driver); 274 + return tee_client_driver_register(&trusted_key_driver); 274 275 } 275 276 276 277 static void trusted_tee_exit(void) 277 278 { 278 - driver_unregister(&trusted_key_driver.driver); 279 + tee_client_driver_unregister(&trusted_key_driver); 279 280 } 280 281 281 282 struct trusted_key_ops trusted_key_tee_ops = {