1 /* 2 * chromeos_laptop.c - Driver to instantiate Chromebook i2c/smbus devices. 3 * 4 * Author : Benson Leung <bleung@chromium.org> 5 * 6 * Copyright (C) 2012 Google, Inc. 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include <linux/dmi.h> 25 #include <linux/i2c.h> 26 #include <linux/i2c/atmel_mxt_ts.h> 27 #include <linux/input.h> 28 #include <linux/interrupt.h> 29 #include <linux/module.h> 30 #include <linux/platform_device.h> 31 32 #define ATMEL_TP_I2C_ADDR 0x4b 33 #define ATMEL_TP_I2C_BL_ADDR 0x25 34 #define ATMEL_TS_I2C_ADDR 0x4a 35 #define ATMEL_TS_I2C_BL_ADDR 0x26 36 #define CYAPA_TP_I2C_ADDR 0x67 37 #define ISL_ALS_I2C_ADDR 0x44 38 #define TAOS_ALS_I2C_ADDR 0x29 39 40 #define MAX_I2C_DEVICE_DEFERRALS 5 41 42 static struct i2c_client *als; 43 static struct i2c_client *tp; 44 static struct i2c_client *ts; 45 46 static const char *i2c_adapter_names[] = { 47 "SMBus I801 adapter", 48 "i915 gmbus vga", 49 "i915 gmbus panel", 50 "i2c-designware-pci", 51 "i2c-designware-pci", 52 }; 53 54 /* Keep this enum consistent with i2c_adapter_names */ 55 enum i2c_adapter_type { 56 I2C_ADAPTER_SMBUS = 0, 57 I2C_ADAPTER_VGADDC, 58 I2C_ADAPTER_PANEL, 59 I2C_ADAPTER_DESIGNWARE_0, 60 I2C_ADAPTER_DESIGNWARE_1, 61 }; 62 63 enum i2c_peripheral_state { 64 UNPROBED = 0, 65 PROBED, 66 TIMEDOUT, 67 }; 68 69 struct i2c_peripheral { 70 int (*add)(enum i2c_adapter_type type); 71 enum i2c_adapter_type type; 72 enum i2c_peripheral_state state; 73 int tries; 74 }; 75 76 #define MAX_I2C_PERIPHERALS 3 77 78 struct chromeos_laptop { 79 struct i2c_peripheral i2c_peripherals[MAX_I2C_PERIPHERALS]; 80 }; 81 82 static struct chromeos_laptop *cros_laptop; 83 84 static struct i2c_board_info cyapa_device = { 85 I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR), 86 .flags = I2C_CLIENT_WAKE, 87 }; 88 89 static struct i2c_board_info isl_als_device = { 90 I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR), 91 }; 92 93 static struct i2c_board_info tsl2583_als_device = { 94 I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR), 95 }; 96 97 static struct i2c_board_info tsl2563_als_device = { 98 I2C_BOARD_INFO("tsl2563", TAOS_ALS_I2C_ADDR), 99 }; 100 101 static int mxt_t19_keys[] = { 102 KEY_RESERVED, 103 KEY_RESERVED, 104 KEY_RESERVED, 105 KEY_RESERVED, 106 KEY_RESERVED, 107 BTN_LEFT 108 }; 109 110 static struct mxt_platform_data atmel_224s_tp_platform_data = { 111 .irqflags = IRQF_TRIGGER_FALLING, 112 .t19_num_keys = ARRAY_SIZE(mxt_t19_keys), 113 .t19_keymap = mxt_t19_keys, 114 }; 115 116 static struct i2c_board_info atmel_224s_tp_device = { 117 I2C_BOARD_INFO("atmel_mxt_tp", ATMEL_TP_I2C_ADDR), 118 .platform_data = &atmel_224s_tp_platform_data, 119 .flags = I2C_CLIENT_WAKE, 120 }; 121 122 static struct mxt_platform_data atmel_1664s_platform_data = { 123 .irqflags = IRQF_TRIGGER_FALLING, 124 }; 125 126 static struct i2c_board_info atmel_1664s_device = { 127 I2C_BOARD_INFO("atmel_mxt_ts", ATMEL_TS_I2C_ADDR), 128 .platform_data = &atmel_1664s_platform_data, 129 .flags = I2C_CLIENT_WAKE, 130 }; 131 132 static struct i2c_client *__add_probed_i2c_device( 133 const char *name, 134 int bus, 135 struct i2c_board_info *info, 136 const unsigned short *addrs) 137 { 138 const struct dmi_device *dmi_dev; 139 const struct dmi_dev_onboard *dev_data; 140 struct i2c_adapter *adapter; 141 struct i2c_client *client; 142 143 if (bus < 0) 144 return NULL; 145 /* 146 * If a name is specified, look for irq platform information stashed 147 * in DMI_DEV_TYPE_DEV_ONBOARD by the Chrome OS custom system firmware. 148 */ 149 if (name) { 150 dmi_dev = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, name, NULL); 151 if (!dmi_dev) { 152 pr_err("%s failed to dmi find device %s.\n", 153 __func__, 154 name); 155 return NULL; 156 } 157 dev_data = (struct dmi_dev_onboard *)dmi_dev->device_data; 158 if (!dev_data) { 159 pr_err("%s failed to get data from dmi for %s.\n", 160 __func__, name); 161 return NULL; 162 } 163 info->irq = dev_data->instance; 164 } 165 166 adapter = i2c_get_adapter(bus); 167 if (!adapter) { 168 pr_err("%s failed to get i2c adapter %d.\n", __func__, bus); 169 return NULL; 170 } 171 172 /* add the i2c device */ 173 client = i2c_new_probed_device(adapter, info, addrs, NULL); 174 if (!client) 175 pr_notice("%s failed to register device %d-%02x\n", 176 __func__, bus, info->addr); 177 else 178 pr_debug("%s added i2c device %d-%02x\n", 179 __func__, bus, info->addr); 180 181 i2c_put_adapter(adapter); 182 return client; 183 } 184 185 struct i2c_lookup { 186 const char *name; 187 int instance; 188 int n; 189 }; 190 191 static int __find_i2c_adap(struct device *dev, void *data) 192 { 193 struct i2c_lookup *lookup = data; 194 static const char *prefix = "i2c-"; 195 struct i2c_adapter *adapter; 196 197 if (strncmp(dev_name(dev), prefix, strlen(prefix)) != 0) 198 return 0; 199 adapter = to_i2c_adapter(dev); 200 if (strncmp(adapter->name, lookup->name, strlen(lookup->name)) == 0 && 201 lookup->n++ == lookup->instance) 202 return 1; 203 return 0; 204 } 205 206 static int find_i2c_adapter_num(enum i2c_adapter_type type) 207 { 208 struct device *dev = NULL; 209 struct i2c_adapter *adapter; 210 struct i2c_lookup lookup; 211 212 memset(&lookup, 0, sizeof(lookup)); 213 lookup.name = i2c_adapter_names[type]; 214 lookup.instance = (type == I2C_ADAPTER_DESIGNWARE_1) ? 1 : 0; 215 216 /* find the adapter by name */ 217 dev = bus_find_device(&i2c_bus_type, NULL, &lookup, __find_i2c_adap); 218 if (!dev) { 219 /* Adapters may appear later. Deferred probing will retry */ 220 pr_notice("%s: i2c adapter %s not found on system.\n", __func__, 221 lookup.name); 222 return -ENODEV; 223 } 224 adapter = to_i2c_adapter(dev); 225 return adapter->nr; 226 } 227 228 /* 229 * Takes a list of addresses in addrs as such : 230 * { addr1, ... , addrn, I2C_CLIENT_END }; 231 * add_probed_i2c_device will use i2c_new_probed_device 232 * and probe for devices at all of the addresses listed. 233 * Returns NULL if no devices found. 234 * See Documentation/i2c/instantiating-devices for more information. 235 */ 236 static struct i2c_client *add_probed_i2c_device( 237 const char *name, 238 enum i2c_adapter_type type, 239 struct i2c_board_info *info, 240 const unsigned short *addrs) 241 { 242 return __add_probed_i2c_device(name, 243 find_i2c_adapter_num(type), 244 info, 245 addrs); 246 } 247 248 /* 249 * Probes for a device at a single address, the one provided by 250 * info->addr. 251 * Returns NULL if no device found. 252 */ 253 static struct i2c_client *add_i2c_device(const char *name, 254 enum i2c_adapter_type type, 255 struct i2c_board_info *info) 256 { 257 const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END }; 258 259 return __add_probed_i2c_device(name, 260 find_i2c_adapter_num(type), 261 info, 262 addr_list); 263 } 264 265 static int setup_cyapa_tp(enum i2c_adapter_type type) 266 { 267 if (tp) 268 return 0; 269 270 /* add cyapa touchpad */ 271 tp = add_i2c_device("trackpad", type, &cyapa_device); 272 return (!tp) ? -EAGAIN : 0; 273 } 274 275 static int setup_atmel_224s_tp(enum i2c_adapter_type type) 276 { 277 const unsigned short addr_list[] = { ATMEL_TP_I2C_BL_ADDR, 278 ATMEL_TP_I2C_ADDR, 279 I2C_CLIENT_END }; 280 if (tp) 281 return 0; 282 283 /* add atmel mxt touchpad */ 284 tp = add_probed_i2c_device("trackpad", type, 285 &atmel_224s_tp_device, addr_list); 286 return (!tp) ? -EAGAIN : 0; 287 } 288 289 static int setup_atmel_1664s_ts(enum i2c_adapter_type type) 290 { 291 const unsigned short addr_list[] = { ATMEL_TS_I2C_BL_ADDR, 292 ATMEL_TS_I2C_ADDR, 293 I2C_CLIENT_END }; 294 if (ts) 295 return 0; 296 297 /* add atmel mxt touch device */ 298 ts = add_probed_i2c_device("touchscreen", type, 299 &atmel_1664s_device, addr_list); 300 return (!ts) ? -EAGAIN : 0; 301 } 302 303 static int setup_isl29018_als(enum i2c_adapter_type type) 304 { 305 if (als) 306 return 0; 307 308 /* add isl29018 light sensor */ 309 als = add_i2c_device("lightsensor", type, &isl_als_device); 310 return (!als) ? -EAGAIN : 0; 311 } 312 313 static int setup_tsl2583_als(enum i2c_adapter_type type) 314 { 315 if (als) 316 return 0; 317 318 /* add tsl2583 light sensor */ 319 als = add_i2c_device(NULL, type, &tsl2583_als_device); 320 return (!als) ? -EAGAIN : 0; 321 } 322 323 static int setup_tsl2563_als(enum i2c_adapter_type type) 324 { 325 if (als) 326 return 0; 327 328 /* add tsl2563 light sensor */ 329 als = add_i2c_device(NULL, type, &tsl2563_als_device); 330 return (!als) ? -EAGAIN : 0; 331 } 332 333 static int __init chromeos_laptop_dmi_matched(const struct dmi_system_id *id) 334 { 335 cros_laptop = (void *)id->driver_data; 336 pr_debug("DMI Matched %s.\n", id->ident); 337 338 /* Indicate to dmi_scan that processing is done. */ 339 return 1; 340 } 341 342 static int chromeos_laptop_probe(struct platform_device *pdev) 343 { 344 int i; 345 int ret = 0; 346 347 for (i = 0; i < MAX_I2C_PERIPHERALS; i++) { 348 struct i2c_peripheral *i2c_dev; 349 350 i2c_dev = &cros_laptop->i2c_peripherals[i]; 351 352 /* No more peripherals. */ 353 if (i2c_dev->add == NULL) 354 break; 355 356 if (i2c_dev->state == TIMEDOUT || i2c_dev->state == PROBED) 357 continue; 358 359 /* 360 * Check that the i2c adapter is present. 361 * -EPROBE_DEFER if missing as the adapter may appear much 362 * later. 363 */ 364 if (find_i2c_adapter_num(i2c_dev->type) == -ENODEV) { 365 ret = -EPROBE_DEFER; 366 continue; 367 } 368 369 /* Add the device. */ 370 if (i2c_dev->add(i2c_dev->type) == -EAGAIN) { 371 /* 372 * Set -EPROBE_DEFER a limited num of times 373 * if device is not successfully added. 374 */ 375 if (++i2c_dev->tries < MAX_I2C_DEVICE_DEFERRALS) { 376 ret = -EPROBE_DEFER; 377 } else { 378 /* Ran out of tries. */ 379 pr_notice("%s: Ran out of tries for device.\n", 380 __func__); 381 i2c_dev->state = TIMEDOUT; 382 } 383 } else { 384 i2c_dev->state = PROBED; 385 } 386 } 387 388 return ret; 389 } 390 391 static struct chromeos_laptop samsung_series_5_550 = { 392 .i2c_peripherals = { 393 /* Touchpad. */ 394 { .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS }, 395 /* Light Sensor. */ 396 { .add = setup_isl29018_als, I2C_ADAPTER_SMBUS }, 397 }, 398 }; 399 400 static struct chromeos_laptop samsung_series_5 = { 401 .i2c_peripherals = { 402 /* Light Sensor. */ 403 { .add = setup_tsl2583_als, I2C_ADAPTER_SMBUS }, 404 }, 405 }; 406 407 static struct chromeos_laptop chromebook_pixel = { 408 .i2c_peripherals = { 409 /* Touch Screen. */ 410 { .add = setup_atmel_1664s_ts, I2C_ADAPTER_PANEL }, 411 /* Touchpad. */ 412 { .add = setup_atmel_224s_tp, I2C_ADAPTER_VGADDC }, 413 /* Light Sensor. */ 414 { .add = setup_isl29018_als, I2C_ADAPTER_PANEL }, 415 }, 416 }; 417 418 static struct chromeos_laptop hp_chromebook_14 = { 419 .i2c_peripherals = { 420 /* Touchpad. */ 421 { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 }, 422 }, 423 }; 424 425 static struct chromeos_laptop dell_chromebook_11 = { 426 .i2c_peripherals = { 427 /* Touchpad. */ 428 { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 }, 429 }, 430 }; 431 432 static struct chromeos_laptop toshiba_cb35 = { 433 .i2c_peripherals = { 434 /* Touchpad. */ 435 { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 }, 436 }, 437 }; 438 439 static struct chromeos_laptop acer_c7_chromebook = { 440 .i2c_peripherals = { 441 /* Touchpad. */ 442 { .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS }, 443 }, 444 }; 445 446 static struct chromeos_laptop acer_ac700 = { 447 .i2c_peripherals = { 448 /* Light Sensor. */ 449 { .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS }, 450 }, 451 }; 452 453 static struct chromeos_laptop acer_c720 = { 454 .i2c_peripherals = { 455 /* Touchscreen. */ 456 { .add = setup_atmel_1664s_ts, I2C_ADAPTER_DESIGNWARE_1 }, 457 /* Touchpad. */ 458 { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 }, 459 /* Light Sensor. */ 460 { .add = setup_isl29018_als, I2C_ADAPTER_DESIGNWARE_1 }, 461 }, 462 }; 463 464 static struct chromeos_laptop hp_pavilion_14_chromebook = { 465 .i2c_peripherals = { 466 /* Touchpad. */ 467 { .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS }, 468 }, 469 }; 470 471 static struct chromeos_laptop cr48 = { 472 .i2c_peripherals = { 473 /* Light Sensor. */ 474 { .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS }, 475 }, 476 }; 477 478 #define _CBDD(board_) \ 479 .callback = chromeos_laptop_dmi_matched, \ 480 .driver_data = (void *)&board_ 481 482 static struct dmi_system_id chromeos_laptop_dmi_table[] __initdata = { 483 { 484 .ident = "Samsung Series 5 550", 485 .matches = { 486 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"), 487 DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"), 488 }, 489 _CBDD(samsung_series_5_550), 490 }, 491 { 492 .ident = "Samsung Series 5", 493 .matches = { 494 DMI_MATCH(DMI_PRODUCT_NAME, "Alex"), 495 }, 496 _CBDD(samsung_series_5), 497 }, 498 { 499 .ident = "Chromebook Pixel", 500 .matches = { 501 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 502 DMI_MATCH(DMI_PRODUCT_NAME, "Link"), 503 }, 504 _CBDD(chromebook_pixel), 505 }, 506 { 507 .ident = "Wolf", 508 .matches = { 509 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 510 DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"), 511 }, 512 _CBDD(dell_chromebook_11), 513 }, 514 { 515 .ident = "HP Chromebook 14", 516 .matches = { 517 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 518 DMI_MATCH(DMI_PRODUCT_NAME, "Falco"), 519 }, 520 _CBDD(hp_chromebook_14), 521 }, 522 { 523 .ident = "Toshiba CB35", 524 .matches = { 525 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 526 DMI_MATCH(DMI_PRODUCT_NAME, "Leon"), 527 }, 528 _CBDD(toshiba_cb35), 529 }, 530 { 531 .ident = "Acer C7 Chromebook", 532 .matches = { 533 DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"), 534 }, 535 _CBDD(acer_c7_chromebook), 536 }, 537 { 538 .ident = "Acer AC700", 539 .matches = { 540 DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"), 541 }, 542 _CBDD(acer_ac700), 543 }, 544 { 545 .ident = "Acer C720", 546 .matches = { 547 DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"), 548 }, 549 _CBDD(acer_c720), 550 }, 551 { 552 .ident = "HP Pavilion 14 Chromebook", 553 .matches = { 554 DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"), 555 }, 556 _CBDD(hp_pavilion_14_chromebook), 557 }, 558 { 559 .ident = "Cr-48", 560 .matches = { 561 DMI_MATCH(DMI_PRODUCT_NAME, "Mario"), 562 }, 563 _CBDD(cr48), 564 }, 565 { } 566 }; 567 MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table); 568 569 static struct platform_device *cros_platform_device; 570 571 static struct platform_driver cros_platform_driver = { 572 .driver = { 573 .name = "chromeos_laptop", 574 .owner = THIS_MODULE, 575 }, 576 .probe = chromeos_laptop_probe, 577 }; 578 579 static int __init chromeos_laptop_init(void) 580 { 581 int ret; 582 583 if (!dmi_check_system(chromeos_laptop_dmi_table)) { 584 pr_debug("%s unsupported system.\n", __func__); 585 return -ENODEV; 586 } 587 588 ret = platform_driver_register(&cros_platform_driver); 589 if (ret) 590 return ret; 591 592 cros_platform_device = platform_device_alloc("chromeos_laptop", -1); 593 if (!cros_platform_device) { 594 ret = -ENOMEM; 595 goto fail_platform_device1; 596 } 597 598 ret = platform_device_add(cros_platform_device); 599 if (ret) 600 goto fail_platform_device2; 601 602 return 0; 603 604 fail_platform_device2: 605 platform_device_put(cros_platform_device); 606 fail_platform_device1: 607 platform_driver_unregister(&cros_platform_driver); 608 return ret; 609 } 610 611 static void __exit chromeos_laptop_exit(void) 612 { 613 if (als) 614 i2c_unregister_device(als); 615 if (tp) 616 i2c_unregister_device(tp); 617 if (ts) 618 i2c_unregister_device(ts); 619 620 platform_device_unregister(cros_platform_device); 621 platform_driver_unregister(&cros_platform_driver); 622 } 623 624 module_init(chromeos_laptop_init); 625 module_exit(chromeos_laptop_exit); 626 627 MODULE_DESCRIPTION("Chrome OS Laptop driver"); 628 MODULE_AUTHOR("Benson Leung <bleung@chromium.org>"); 629 MODULE_LICENSE("GPL"); 630