1 // SPDX-License-Identifier: GPL-2.0+ 2 // Driver to instantiate Chromebook i2c/smbus devices. 3 // 4 // Copyright (C) 2012 Google, Inc. 5 // Author: Benson Leung <bleung@chromium.org> 6 7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9 #include <linux/acpi.h> 10 #include <linux/dmi.h> 11 #include <linux/i2c.h> 12 #include <linux/input.h> 13 #include <linux/interrupt.h> 14 #include <linux/ioport.h> 15 #include <linux/module.h> 16 #include <linux/pci.h> 17 #include <linux/platform_device.h> 18 #include <linux/property.h> 19 20 #define ATMEL_TP_I2C_ADDR 0x4b 21 #define ATMEL_TP_I2C_BL_ADDR 0x25 22 #define ATMEL_TS_I2C_ADDR 0x4a 23 #define ATMEL_TS_I2C_BL_ADDR 0x26 24 #define CYAPA_TP_I2C_ADDR 0x67 25 #define ELAN_TP_I2C_ADDR 0x15 26 #define ISL_ALS_I2C_ADDR 0x44 27 #define TAOS_ALS_I2C_ADDR 0x29 28 29 static const char *i2c_adapter_names[] = { 30 "SMBus I801 adapter", 31 "i915 gmbus vga", 32 "i915 gmbus panel", 33 "Synopsys DesignWare I2C adapter", 34 }; 35 36 /* Keep this enum consistent with i2c_adapter_names */ 37 enum i2c_adapter_type { 38 I2C_ADAPTER_SMBUS = 0, 39 I2C_ADAPTER_VGADDC, 40 I2C_ADAPTER_PANEL, 41 I2C_ADAPTER_DESIGNWARE, 42 }; 43 44 struct i2c_peripheral { 45 struct i2c_board_info board_info; 46 unsigned short alt_addr; 47 48 const char *dmi_name; 49 unsigned long irqflags; 50 struct resource irq_resource; 51 52 enum i2c_adapter_type type; 53 u32 pci_devid; 54 55 struct i2c_client *client; 56 }; 57 58 struct acpi_peripheral { 59 char hid[ACPI_ID_LEN]; 60 const struct property_entry *properties; 61 }; 62 63 struct chromeos_laptop { 64 /* 65 * Note that we can't mark this pointer as const because 66 * i2c_new_probed_device() changes passed in I2C board info, so. 67 */ 68 struct i2c_peripheral *i2c_peripherals; 69 unsigned int num_i2c_peripherals; 70 71 const struct acpi_peripheral *acpi_peripherals; 72 unsigned int num_acpi_peripherals; 73 }; 74 75 static const struct chromeos_laptop *cros_laptop; 76 77 static struct i2c_client * 78 chromes_laptop_instantiate_i2c_device(struct i2c_adapter *adapter, 79 struct i2c_board_info *info, 80 unsigned short alt_addr) 81 { 82 const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END }; 83 struct i2c_client *client; 84 85 /* 86 * Add the i2c device. If we can't detect it at the primary 87 * address we scan secondary addresses. In any case the client 88 * structure gets assigned primary address. 89 */ 90 client = i2c_new_probed_device(adapter, info, addr_list, NULL); 91 if (!client && alt_addr) { 92 struct i2c_board_info dummy_info = { 93 I2C_BOARD_INFO("dummy", info->addr), 94 }; 95 const unsigned short alt_addr_list[] = { 96 alt_addr, I2C_CLIENT_END 97 }; 98 struct i2c_client *dummy; 99 100 dummy = i2c_new_probed_device(adapter, &dummy_info, 101 alt_addr_list, NULL); 102 if (dummy) { 103 pr_debug("%d-%02x is probed at %02x\n", 104 adapter->nr, info->addr, dummy->addr); 105 i2c_unregister_device(dummy); 106 client = i2c_new_device(adapter, info); 107 } 108 } 109 110 if (!client) 111 pr_debug("failed to register device %d-%02x\n", 112 adapter->nr, info->addr); 113 else 114 pr_debug("added i2c device %d-%02x\n", 115 adapter->nr, info->addr); 116 117 return client; 118 } 119 120 static bool chromeos_laptop_match_adapter_devid(struct device *dev, u32 devid) 121 { 122 struct pci_dev *pdev; 123 124 if (!dev_is_pci(dev)) 125 return false; 126 127 pdev = to_pci_dev(dev); 128 return devid == PCI_DEVID(pdev->bus->number, pdev->devfn); 129 } 130 131 static void chromeos_laptop_check_adapter(struct i2c_adapter *adapter) 132 { 133 struct i2c_peripheral *i2c_dev; 134 int i; 135 136 for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) { 137 i2c_dev = &cros_laptop->i2c_peripherals[i]; 138 139 /* Skip devices already created */ 140 if (i2c_dev->client) 141 continue; 142 143 if (strncmp(adapter->name, i2c_adapter_names[i2c_dev->type], 144 strlen(i2c_adapter_names[i2c_dev->type]))) 145 continue; 146 147 if (i2c_dev->pci_devid && 148 !chromeos_laptop_match_adapter_devid(adapter->dev.parent, 149 i2c_dev->pci_devid)) { 150 continue; 151 } 152 153 i2c_dev->client = 154 chromes_laptop_instantiate_i2c_device(adapter, 155 &i2c_dev->board_info, 156 i2c_dev->alt_addr); 157 } 158 } 159 160 static bool chromeos_laptop_adjust_client(struct i2c_client *client) 161 { 162 const struct acpi_peripheral *acpi_dev; 163 struct acpi_device_id acpi_ids[2] = { }; 164 int i; 165 int error; 166 167 if (!has_acpi_companion(&client->dev)) 168 return false; 169 170 for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) { 171 acpi_dev = &cros_laptop->acpi_peripherals[i]; 172 173 memcpy(acpi_ids[0].id, acpi_dev->hid, ACPI_ID_LEN); 174 175 if (acpi_match_device(acpi_ids, &client->dev)) { 176 error = device_add_properties(&client->dev, 177 acpi_dev->properties); 178 if (error) { 179 dev_err(&client->dev, 180 "failed to add properties: %d\n", 181 error); 182 break; 183 } 184 185 return true; 186 } 187 } 188 189 return false; 190 } 191 192 static void chromeos_laptop_detach_i2c_client(struct i2c_client *client) 193 { 194 struct i2c_peripheral *i2c_dev; 195 int i; 196 197 for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) { 198 i2c_dev = &cros_laptop->i2c_peripherals[i]; 199 200 if (i2c_dev->client == client) 201 i2c_dev->client = NULL; 202 } 203 } 204 205 static int chromeos_laptop_i2c_notifier_call(struct notifier_block *nb, 206 unsigned long action, void *data) 207 { 208 struct device *dev = data; 209 210 switch (action) { 211 case BUS_NOTIFY_ADD_DEVICE: 212 if (dev->type == &i2c_adapter_type) 213 chromeos_laptop_check_adapter(to_i2c_adapter(dev)); 214 else if (dev->type == &i2c_client_type) 215 chromeos_laptop_adjust_client(to_i2c_client(dev)); 216 break; 217 218 case BUS_NOTIFY_REMOVED_DEVICE: 219 if (dev->type == &i2c_client_type) 220 chromeos_laptop_detach_i2c_client(to_i2c_client(dev)); 221 break; 222 } 223 224 return 0; 225 } 226 227 static struct notifier_block chromeos_laptop_i2c_notifier = { 228 .notifier_call = chromeos_laptop_i2c_notifier_call, 229 }; 230 231 #define DECLARE_CROS_LAPTOP(_name) \ 232 static const struct chromeos_laptop _name __initconst = { \ 233 .i2c_peripherals = _name##_peripherals, \ 234 .num_i2c_peripherals = ARRAY_SIZE(_name##_peripherals), \ 235 } 236 237 #define DECLARE_ACPI_CROS_LAPTOP(_name) \ 238 static const struct chromeos_laptop _name __initconst = { \ 239 .acpi_peripherals = _name##_peripherals, \ 240 .num_acpi_peripherals = ARRAY_SIZE(_name##_peripherals), \ 241 } 242 243 static struct i2c_peripheral samsung_series_5_550_peripherals[] __initdata = { 244 /* Touchpad. */ 245 { 246 .board_info = { 247 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 248 .flags = I2C_CLIENT_WAKE, 249 }, 250 .dmi_name = "trackpad", 251 .type = I2C_ADAPTER_SMBUS, 252 }, 253 /* Light Sensor. */ 254 { 255 .board_info = { 256 I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR), 257 }, 258 .dmi_name = "lightsensor", 259 .type = I2C_ADAPTER_SMBUS, 260 }, 261 }; 262 DECLARE_CROS_LAPTOP(samsung_series_5_550); 263 264 static struct i2c_peripheral samsung_series_5_peripherals[] __initdata = { 265 /* Light Sensor. */ 266 { 267 .board_info = { 268 I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR), 269 }, 270 .type = I2C_ADAPTER_SMBUS, 271 }, 272 }; 273 DECLARE_CROS_LAPTOP(samsung_series_5); 274 275 static const int chromebook_pixel_tp_keys[] __initconst = { 276 KEY_RESERVED, 277 KEY_RESERVED, 278 KEY_RESERVED, 279 KEY_RESERVED, 280 KEY_RESERVED, 281 BTN_LEFT 282 }; 283 284 static const struct property_entry 285 chromebook_pixel_trackpad_props[] __initconst = { 286 PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"), 287 PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", chromebook_pixel_tp_keys), 288 { } 289 }; 290 291 static const struct property_entry 292 chromebook_atmel_touchscreen_props[] __initconst = { 293 PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"), 294 { } 295 }; 296 297 static struct i2c_peripheral chromebook_pixel_peripherals[] __initdata = { 298 /* Touch Screen. */ 299 { 300 .board_info = { 301 I2C_BOARD_INFO("atmel_mxt_ts", 302 ATMEL_TS_I2C_ADDR), 303 .properties = 304 chromebook_atmel_touchscreen_props, 305 .flags = I2C_CLIENT_WAKE, 306 }, 307 .dmi_name = "touchscreen", 308 .irqflags = IRQF_TRIGGER_FALLING, 309 .type = I2C_ADAPTER_PANEL, 310 .alt_addr = ATMEL_TS_I2C_BL_ADDR, 311 }, 312 /* Touchpad. */ 313 { 314 .board_info = { 315 I2C_BOARD_INFO("atmel_mxt_tp", 316 ATMEL_TP_I2C_ADDR), 317 .properties = 318 chromebook_pixel_trackpad_props, 319 .flags = I2C_CLIENT_WAKE, 320 }, 321 .dmi_name = "trackpad", 322 .irqflags = IRQF_TRIGGER_FALLING, 323 .type = I2C_ADAPTER_VGADDC, 324 .alt_addr = ATMEL_TP_I2C_BL_ADDR, 325 }, 326 /* Light Sensor. */ 327 { 328 .board_info = { 329 I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR), 330 }, 331 .dmi_name = "lightsensor", 332 .type = I2C_ADAPTER_PANEL, 333 }, 334 }; 335 DECLARE_CROS_LAPTOP(chromebook_pixel); 336 337 static struct i2c_peripheral hp_chromebook_14_peripherals[] __initdata = { 338 /* Touchpad. */ 339 { 340 .board_info = { 341 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 342 .flags = I2C_CLIENT_WAKE, 343 }, 344 .dmi_name = "trackpad", 345 .type = I2C_ADAPTER_DESIGNWARE, 346 }, 347 }; 348 DECLARE_CROS_LAPTOP(hp_chromebook_14); 349 350 static struct i2c_peripheral dell_chromebook_11_peripherals[] __initdata = { 351 /* Touchpad. */ 352 { 353 .board_info = { 354 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 355 .flags = I2C_CLIENT_WAKE, 356 }, 357 .dmi_name = "trackpad", 358 .type = I2C_ADAPTER_DESIGNWARE, 359 }, 360 /* Elan Touchpad option. */ 361 { 362 .board_info = { 363 I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR), 364 .flags = I2C_CLIENT_WAKE, 365 }, 366 .dmi_name = "trackpad", 367 .type = I2C_ADAPTER_DESIGNWARE, 368 }, 369 }; 370 DECLARE_CROS_LAPTOP(dell_chromebook_11); 371 372 static struct i2c_peripheral toshiba_cb35_peripherals[] __initdata = { 373 /* Touchpad. */ 374 { 375 .board_info = { 376 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 377 .flags = I2C_CLIENT_WAKE, 378 }, 379 .dmi_name = "trackpad", 380 .type = I2C_ADAPTER_DESIGNWARE, 381 }, 382 }; 383 DECLARE_CROS_LAPTOP(toshiba_cb35); 384 385 static struct i2c_peripheral acer_c7_chromebook_peripherals[] __initdata = { 386 /* Touchpad. */ 387 { 388 .board_info = { 389 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 390 .flags = I2C_CLIENT_WAKE, 391 }, 392 .dmi_name = "trackpad", 393 .type = I2C_ADAPTER_SMBUS, 394 }, 395 }; 396 DECLARE_CROS_LAPTOP(acer_c7_chromebook); 397 398 static struct i2c_peripheral acer_ac700_peripherals[] __initdata = { 399 /* Light Sensor. */ 400 { 401 .board_info = { 402 I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR), 403 }, 404 .type = I2C_ADAPTER_SMBUS, 405 }, 406 }; 407 DECLARE_CROS_LAPTOP(acer_ac700); 408 409 static struct i2c_peripheral acer_c720_peripherals[] __initdata = { 410 /* Touchscreen. */ 411 { 412 .board_info = { 413 I2C_BOARD_INFO("atmel_mxt_ts", 414 ATMEL_TS_I2C_ADDR), 415 .properties = 416 chromebook_atmel_touchscreen_props, 417 .flags = I2C_CLIENT_WAKE, 418 }, 419 .dmi_name = "touchscreen", 420 .irqflags = IRQF_TRIGGER_FALLING, 421 .type = I2C_ADAPTER_DESIGNWARE, 422 .pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)), 423 .alt_addr = ATMEL_TS_I2C_BL_ADDR, 424 }, 425 /* Touchpad. */ 426 { 427 .board_info = { 428 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 429 .flags = I2C_CLIENT_WAKE, 430 }, 431 .dmi_name = "trackpad", 432 .type = I2C_ADAPTER_DESIGNWARE, 433 .pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)), 434 }, 435 /* Elan Touchpad option. */ 436 { 437 .board_info = { 438 I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR), 439 .flags = I2C_CLIENT_WAKE, 440 }, 441 .dmi_name = "trackpad", 442 .type = I2C_ADAPTER_DESIGNWARE, 443 .pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)), 444 }, 445 /* Light Sensor. */ 446 { 447 .board_info = { 448 I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR), 449 }, 450 .dmi_name = "lightsensor", 451 .type = I2C_ADAPTER_DESIGNWARE, 452 .pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)), 453 }, 454 }; 455 DECLARE_CROS_LAPTOP(acer_c720); 456 457 static struct i2c_peripheral 458 hp_pavilion_14_chromebook_peripherals[] __initdata = { 459 /* Touchpad. */ 460 { 461 .board_info = { 462 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 463 .flags = I2C_CLIENT_WAKE, 464 }, 465 .dmi_name = "trackpad", 466 .type = I2C_ADAPTER_SMBUS, 467 }, 468 }; 469 DECLARE_CROS_LAPTOP(hp_pavilion_14_chromebook); 470 471 static struct i2c_peripheral cr48_peripherals[] __initdata = { 472 /* Light Sensor. */ 473 { 474 .board_info = { 475 I2C_BOARD_INFO("tsl2563", TAOS_ALS_I2C_ADDR), 476 }, 477 .type = I2C_ADAPTER_SMBUS, 478 }, 479 }; 480 DECLARE_CROS_LAPTOP(cr48); 481 482 static const u32 samus_touchpad_buttons[] __initconst = { 483 KEY_RESERVED, 484 KEY_RESERVED, 485 KEY_RESERVED, 486 BTN_LEFT 487 }; 488 489 static const struct property_entry samus_trackpad_props[] __initconst = { 490 PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"), 491 PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", samus_touchpad_buttons), 492 { } 493 }; 494 495 static struct acpi_peripheral samus_peripherals[] __initdata = { 496 /* Touchpad */ 497 { 498 .hid = "ATML0000", 499 .properties = samus_trackpad_props, 500 }, 501 /* Touchsceen */ 502 { 503 .hid = "ATML0001", 504 .properties = chromebook_atmel_touchscreen_props, 505 }, 506 }; 507 DECLARE_ACPI_CROS_LAPTOP(samus); 508 509 static struct acpi_peripheral generic_atmel_peripherals[] __initdata = { 510 /* Touchpad */ 511 { 512 .hid = "ATML0000", 513 .properties = chromebook_pixel_trackpad_props, 514 }, 515 /* Touchsceen */ 516 { 517 .hid = "ATML0001", 518 .properties = chromebook_atmel_touchscreen_props, 519 }, 520 }; 521 DECLARE_ACPI_CROS_LAPTOP(generic_atmel); 522 523 static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = { 524 { 525 .ident = "Samsung Series 5 550", 526 .matches = { 527 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"), 528 DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"), 529 }, 530 .driver_data = (void *)&samsung_series_5_550, 531 }, 532 { 533 .ident = "Samsung Series 5", 534 .matches = { 535 DMI_MATCH(DMI_PRODUCT_NAME, "Alex"), 536 }, 537 .driver_data = (void *)&samsung_series_5, 538 }, 539 { 540 .ident = "Chromebook Pixel", 541 .matches = { 542 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 543 DMI_MATCH(DMI_PRODUCT_NAME, "Link"), 544 }, 545 .driver_data = (void *)&chromebook_pixel, 546 }, 547 { 548 .ident = "Wolf", 549 .matches = { 550 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 551 DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"), 552 }, 553 .driver_data = (void *)&dell_chromebook_11, 554 }, 555 { 556 .ident = "HP Chromebook 14", 557 .matches = { 558 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 559 DMI_MATCH(DMI_PRODUCT_NAME, "Falco"), 560 }, 561 .driver_data = (void *)&hp_chromebook_14, 562 }, 563 { 564 .ident = "Toshiba CB35", 565 .matches = { 566 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 567 DMI_MATCH(DMI_PRODUCT_NAME, "Leon"), 568 }, 569 .driver_data = (void *)&toshiba_cb35, 570 }, 571 { 572 .ident = "Acer C7 Chromebook", 573 .matches = { 574 DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"), 575 }, 576 .driver_data = (void *)&acer_c7_chromebook, 577 }, 578 { 579 .ident = "Acer AC700", 580 .matches = { 581 DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"), 582 }, 583 .driver_data = (void *)&acer_ac700, 584 }, 585 { 586 .ident = "Acer C720", 587 .matches = { 588 DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"), 589 }, 590 .driver_data = (void *)&acer_c720, 591 }, 592 { 593 .ident = "HP Pavilion 14 Chromebook", 594 .matches = { 595 DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"), 596 }, 597 .driver_data = (void *)&hp_pavilion_14_chromebook, 598 }, 599 { 600 .ident = "Cr-48", 601 .matches = { 602 DMI_MATCH(DMI_PRODUCT_NAME, "Mario"), 603 }, 604 .driver_data = (void *)&cr48, 605 }, 606 /* Devices with peripherals incompletely described in ACPI */ 607 { 608 .ident = "Chromebook Pro", 609 .matches = { 610 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 611 DMI_MATCH(DMI_PRODUCT_NAME, "Caroline"), 612 }, 613 .driver_data = (void *)&samus, 614 }, 615 { 616 .ident = "Google Pixel 2 (2015)", 617 .matches = { 618 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 619 DMI_MATCH(DMI_PRODUCT_NAME, "Samus"), 620 }, 621 .driver_data = (void *)&samus, 622 }, 623 { 624 .ident = "Samsung Chromebook 3", 625 .matches = { 626 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 627 DMI_MATCH(DMI_PRODUCT_NAME, "Celes"), 628 }, 629 .driver_data = (void *)&samus, 630 }, 631 { 632 /* 633 * Other Chromebooks with Atmel touch controllers: 634 * - Winky (touchpad) 635 * - Clapper, Expresso, Rambi, Glimmer (touchscreen) 636 */ 637 .ident = "Other Chromebook", 638 .matches = { 639 /* 640 * This will match all Google devices, not only devices 641 * with Atmel, but we will validate that the device 642 * actually has matching peripherals. 643 */ 644 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 645 }, 646 .driver_data = (void *)&generic_atmel, 647 }, 648 { } 649 }; 650 MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table); 651 652 static int __init chromeos_laptop_scan_peripherals(struct device *dev, void *data) 653 { 654 int error; 655 656 if (dev->type == &i2c_adapter_type) { 657 chromeos_laptop_check_adapter(to_i2c_adapter(dev)); 658 } else if (dev->type == &i2c_client_type) { 659 if (chromeos_laptop_adjust_client(to_i2c_client(dev))) { 660 /* 661 * Now that we have needed properties re-trigger 662 * driver probe in case driver was initialized 663 * earlier and probe failed. 664 */ 665 error = device_attach(dev); 666 if (error < 0) 667 dev_warn(dev, 668 "%s: device_attach() failed: %d\n", 669 __func__, error); 670 } 671 } 672 673 return 0; 674 } 675 676 static int __init chromeos_laptop_get_irq_from_dmi(const char *dmi_name) 677 { 678 const struct dmi_device *dmi_dev; 679 const struct dmi_dev_onboard *dev_data; 680 681 dmi_dev = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, dmi_name, NULL); 682 if (!dmi_dev) { 683 pr_err("failed to find DMI device '%s'\n", dmi_name); 684 return -ENOENT; 685 } 686 687 dev_data = dmi_dev->device_data; 688 if (!dev_data) { 689 pr_err("failed to get data from DMI for '%s'\n", dmi_name); 690 return -EINVAL; 691 } 692 693 return dev_data->instance; 694 } 695 696 static int __init chromeos_laptop_setup_irq(struct i2c_peripheral *i2c_dev) 697 { 698 int irq; 699 700 if (i2c_dev->dmi_name) { 701 irq = chromeos_laptop_get_irq_from_dmi(i2c_dev->dmi_name); 702 if (irq < 0) 703 return irq; 704 705 i2c_dev->irq_resource = (struct resource) 706 DEFINE_RES_NAMED(irq, 1, NULL, 707 IORESOURCE_IRQ | i2c_dev->irqflags); 708 i2c_dev->board_info.resources = &i2c_dev->irq_resource; 709 i2c_dev->board_info.num_resources = 1; 710 } 711 712 return 0; 713 } 714 715 static int __init 716 chromeos_laptop_prepare_i2c_peripherals(struct chromeos_laptop *cros_laptop, 717 const struct chromeos_laptop *src) 718 { 719 struct i2c_peripheral *i2c_dev; 720 struct i2c_board_info *info; 721 int i; 722 int error; 723 724 if (!src->num_i2c_peripherals) 725 return 0; 726 727 cros_laptop->i2c_peripherals = kmemdup(src->i2c_peripherals, 728 src->num_i2c_peripherals * 729 sizeof(*src->i2c_peripherals), 730 GFP_KERNEL); 731 if (!cros_laptop->i2c_peripherals) 732 return -ENOMEM; 733 734 cros_laptop->num_i2c_peripherals = src->num_i2c_peripherals; 735 736 for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) { 737 i2c_dev = &cros_laptop->i2c_peripherals[i]; 738 info = &i2c_dev->board_info; 739 740 error = chromeos_laptop_setup_irq(i2c_dev); 741 if (error) 742 goto err_out; 743 744 /* We need to deep-copy properties */ 745 if (info->properties) { 746 info->properties = 747 property_entries_dup(info->properties); 748 if (IS_ERR(info->properties)) { 749 error = PTR_ERR(info->properties); 750 goto err_out; 751 } 752 } 753 } 754 755 return 0; 756 757 err_out: 758 while (--i >= 0) { 759 i2c_dev = &cros_laptop->i2c_peripherals[i]; 760 info = &i2c_dev->board_info; 761 if (info->properties) 762 property_entries_free(info->properties); 763 } 764 kfree(cros_laptop->i2c_peripherals); 765 return error; 766 } 767 768 static int __init 769 chromeos_laptop_prepare_acpi_peripherals(struct chromeos_laptop *cros_laptop, 770 const struct chromeos_laptop *src) 771 { 772 struct acpi_peripheral *acpi_peripherals; 773 struct acpi_peripheral *acpi_dev; 774 const struct acpi_peripheral *src_dev; 775 int n_peripherals = 0; 776 int i; 777 int error; 778 779 for (i = 0; i < src->num_acpi_peripherals; i++) { 780 if (acpi_dev_present(src->acpi_peripherals[i].hid, NULL, -1)) 781 n_peripherals++; 782 } 783 784 if (!n_peripherals) 785 return 0; 786 787 acpi_peripherals = kcalloc(n_peripherals, 788 sizeof(*src->acpi_peripherals), 789 GFP_KERNEL); 790 if (!acpi_peripherals) 791 return -ENOMEM; 792 793 acpi_dev = acpi_peripherals; 794 for (i = 0; i < src->num_acpi_peripherals; i++) { 795 src_dev = &src->acpi_peripherals[i]; 796 if (!acpi_dev_present(src_dev->hid, NULL, -1)) 797 continue; 798 799 *acpi_dev = *src_dev; 800 801 /* We need to deep-copy properties */ 802 if (src_dev->properties) { 803 acpi_dev->properties = 804 property_entries_dup(src_dev->properties); 805 if (IS_ERR(acpi_dev->properties)) { 806 error = PTR_ERR(acpi_dev->properties); 807 goto err_out; 808 } 809 } 810 811 acpi_dev++; 812 } 813 814 cros_laptop->acpi_peripherals = acpi_peripherals; 815 cros_laptop->num_acpi_peripherals = n_peripherals; 816 817 return 0; 818 819 err_out: 820 while (--i >= 0) { 821 acpi_dev = &acpi_peripherals[i]; 822 if (acpi_dev->properties) 823 property_entries_free(acpi_dev->properties); 824 } 825 826 kfree(acpi_peripherals); 827 return error; 828 } 829 830 static void chromeos_laptop_destroy(const struct chromeos_laptop *cros_laptop) 831 { 832 const struct acpi_peripheral *acpi_dev; 833 struct i2c_peripheral *i2c_dev; 834 struct i2c_board_info *info; 835 int i; 836 837 for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) { 838 i2c_dev = &cros_laptop->i2c_peripherals[i]; 839 info = &i2c_dev->board_info; 840 841 if (i2c_dev->client) 842 i2c_unregister_device(i2c_dev->client); 843 844 if (info->properties) 845 property_entries_free(info->properties); 846 } 847 848 for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) { 849 acpi_dev = &cros_laptop->acpi_peripherals[i]; 850 851 if (acpi_dev->properties) 852 property_entries_free(acpi_dev->properties); 853 } 854 855 kfree(cros_laptop->i2c_peripherals); 856 kfree(cros_laptop->acpi_peripherals); 857 kfree(cros_laptop); 858 } 859 860 static struct chromeos_laptop * __init 861 chromeos_laptop_prepare(const struct chromeos_laptop *src) 862 { 863 struct chromeos_laptop *cros_laptop; 864 int error; 865 866 cros_laptop = kzalloc(sizeof(*cros_laptop), GFP_KERNEL); 867 if (!cros_laptop) 868 return ERR_PTR(-ENOMEM); 869 870 error = chromeos_laptop_prepare_i2c_peripherals(cros_laptop, src); 871 if (!error) 872 error = chromeos_laptop_prepare_acpi_peripherals(cros_laptop, 873 src); 874 875 if (error) { 876 chromeos_laptop_destroy(cros_laptop); 877 return ERR_PTR(error); 878 } 879 880 return cros_laptop; 881 } 882 883 static int __init chromeos_laptop_init(void) 884 { 885 const struct dmi_system_id *dmi_id; 886 int error; 887 888 dmi_id = dmi_first_match(chromeos_laptop_dmi_table); 889 if (!dmi_id) { 890 pr_debug("unsupported system\n"); 891 return -ENODEV; 892 } 893 894 pr_debug("DMI Matched %s\n", dmi_id->ident); 895 896 cros_laptop = chromeos_laptop_prepare((void *)dmi_id->driver_data); 897 if (IS_ERR(cros_laptop)) 898 return PTR_ERR(cros_laptop); 899 900 if (!cros_laptop->num_i2c_peripherals && 901 !cros_laptop->num_acpi_peripherals) { 902 pr_debug("no relevant devices detected\n"); 903 error = -ENODEV; 904 goto err_destroy_cros_laptop; 905 } 906 907 error = bus_register_notifier(&i2c_bus_type, 908 &chromeos_laptop_i2c_notifier); 909 if (error) { 910 pr_err("failed to register i2c bus notifier: %d\n", 911 error); 912 goto err_destroy_cros_laptop; 913 } 914 915 /* 916 * Scan adapters that have been registered and clients that have 917 * been created before we installed the notifier to make sure 918 * we do not miss any devices. 919 */ 920 i2c_for_each_dev(NULL, chromeos_laptop_scan_peripherals); 921 922 return 0; 923 924 err_destroy_cros_laptop: 925 chromeos_laptop_destroy(cros_laptop); 926 return error; 927 } 928 929 static void __exit chromeos_laptop_exit(void) 930 { 931 bus_unregister_notifier(&i2c_bus_type, &chromeos_laptop_i2c_notifier); 932 chromeos_laptop_destroy(cros_laptop); 933 } 934 935 module_init(chromeos_laptop_init); 936 module_exit(chromeos_laptop_exit); 937 938 MODULE_DESCRIPTION("Chrome OS Laptop driver"); 939 MODULE_AUTHOR("Benson Leung <bleung@chromium.org>"); 940 MODULE_LICENSE("GPL"); 941