drivers/platform/chrome/chromeos_laptop.c

   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");