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