1 /* 2 * Gmux driver for Apple laptops 3 * 4 * Copyright (C) Canonical Ltd. <seth.forshee@canonical.com> 5 * Copyright (C) 2010-2012 Andreas Heider <andreas@meetr.de> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/module.h> 15 #include <linux/kernel.h> 16 #include <linux/init.h> 17 #include <linux/backlight.h> 18 #include <linux/acpi.h> 19 #include <linux/pnp.h> 20 #include <linux/apple_bl.h> 21 #include <linux/slab.h> 22 #include <linux/delay.h> 23 #include <linux/pci.h> 24 #include <linux/vga_switcheroo.h> 25 #include <acpi/video.h> 26 #include <asm/io.h> 27 28 struct apple_gmux_data { 29 unsigned long iostart; 30 unsigned long iolen; 31 bool indexed; 32 struct mutex index_lock; 33 34 struct backlight_device *bdev; 35 36 /* switcheroo data */ 37 acpi_handle dhandle; 38 int gpe; 39 enum vga_switcheroo_client_id resume_client_id; 40 enum vga_switcheroo_state power_state; 41 struct completion powerchange_done; 42 }; 43 44 static struct apple_gmux_data *apple_gmux_data; 45 46 /* 47 * gmux port offsets. Many of these are not yet used, but may be in the 48 * future, and it's useful to have them documented here anyhow. 49 */ 50 #define GMUX_PORT_VERSION_MAJOR 0x04 51 #define GMUX_PORT_VERSION_MINOR 0x05 52 #define GMUX_PORT_VERSION_RELEASE 0x06 53 #define GMUX_PORT_SWITCH_DISPLAY 0x10 54 #define GMUX_PORT_SWITCH_GET_DISPLAY 0x11 55 #define GMUX_PORT_INTERRUPT_ENABLE 0x14 56 #define GMUX_PORT_INTERRUPT_STATUS 0x16 57 #define GMUX_PORT_SWITCH_DDC 0x28 58 #define GMUX_PORT_SWITCH_EXTERNAL 0x40 59 #define GMUX_PORT_SWITCH_GET_EXTERNAL 0x41 60 #define GMUX_PORT_DISCRETE_POWER 0x50 61 #define GMUX_PORT_MAX_BRIGHTNESS 0x70 62 #define GMUX_PORT_BRIGHTNESS 0x74 63 #define GMUX_PORT_VALUE 0xc2 64 #define GMUX_PORT_READ 0xd0 65 #define GMUX_PORT_WRITE 0xd4 66 67 #define GMUX_MIN_IO_LEN (GMUX_PORT_BRIGHTNESS + 4) 68 69 #define GMUX_INTERRUPT_ENABLE 0xff 70 #define GMUX_INTERRUPT_DISABLE 0x00 71 72 #define GMUX_INTERRUPT_STATUS_ACTIVE 0 73 #define GMUX_INTERRUPT_STATUS_DISPLAY (1 << 0) 74 #define GMUX_INTERRUPT_STATUS_POWER (1 << 2) 75 #define GMUX_INTERRUPT_STATUS_HOTPLUG (1 << 3) 76 77 #define GMUX_BRIGHTNESS_MASK 0x00ffffff 78 #define GMUX_MAX_BRIGHTNESS GMUX_BRIGHTNESS_MASK 79 80 static u8 gmux_pio_read8(struct apple_gmux_data *gmux_data, int port) 81 { 82 return inb(gmux_data->iostart + port); 83 } 84 85 static void gmux_pio_write8(struct apple_gmux_data *gmux_data, int port, 86 u8 val) 87 { 88 outb(val, gmux_data->iostart + port); 89 } 90 91 static u32 gmux_pio_read32(struct apple_gmux_data *gmux_data, int port) 92 { 93 return inl(gmux_data->iostart + port); 94 } 95 96 static void gmux_pio_write32(struct apple_gmux_data *gmux_data, int port, 97 u32 val) 98 { 99 int i; 100 u8 tmpval; 101 102 for (i = 0; i < 4; i++) { 103 tmpval = (val >> (i * 8)) & 0xff; 104 outb(tmpval, gmux_data->iostart + port + i); 105 } 106 } 107 108 static int gmux_index_wait_ready(struct apple_gmux_data *gmux_data) 109 { 110 int i = 200; 111 u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); 112 113 while (i && (gwr & 0x01)) { 114 inb(gmux_data->iostart + GMUX_PORT_READ); 115 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); 116 udelay(100); 117 i--; 118 } 119 120 return !!i; 121 } 122 123 static int gmux_index_wait_complete(struct apple_gmux_data *gmux_data) 124 { 125 int i = 200; 126 u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); 127 128 while (i && !(gwr & 0x01)) { 129 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); 130 udelay(100); 131 i--; 132 } 133 134 if (gwr & 0x01) 135 inb(gmux_data->iostart + GMUX_PORT_READ); 136 137 return !!i; 138 } 139 140 static u8 gmux_index_read8(struct apple_gmux_data *gmux_data, int port) 141 { 142 u8 val; 143 144 mutex_lock(&gmux_data->index_lock); 145 gmux_index_wait_ready(gmux_data); 146 outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ); 147 gmux_index_wait_complete(gmux_data); 148 val = inb(gmux_data->iostart + GMUX_PORT_VALUE); 149 mutex_unlock(&gmux_data->index_lock); 150 151 return val; 152 } 153 154 static void gmux_index_write8(struct apple_gmux_data *gmux_data, int port, 155 u8 val) 156 { 157 mutex_lock(&gmux_data->index_lock); 158 outb(val, gmux_data->iostart + GMUX_PORT_VALUE); 159 gmux_index_wait_ready(gmux_data); 160 outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE); 161 gmux_index_wait_complete(gmux_data); 162 mutex_unlock(&gmux_data->index_lock); 163 } 164 165 static u32 gmux_index_read32(struct apple_gmux_data *gmux_data, int port) 166 { 167 u32 val; 168 169 mutex_lock(&gmux_data->index_lock); 170 gmux_index_wait_ready(gmux_data); 171 outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ); 172 gmux_index_wait_complete(gmux_data); 173 val = inl(gmux_data->iostart + GMUX_PORT_VALUE); 174 mutex_unlock(&gmux_data->index_lock); 175 176 return val; 177 } 178 179 static void gmux_index_write32(struct apple_gmux_data *gmux_data, int port, 180 u32 val) 181 { 182 int i; 183 u8 tmpval; 184 185 mutex_lock(&gmux_data->index_lock); 186 187 for (i = 0; i < 4; i++) { 188 tmpval = (val >> (i * 8)) & 0xff; 189 outb(tmpval, gmux_data->iostart + GMUX_PORT_VALUE + i); 190 } 191 192 gmux_index_wait_ready(gmux_data); 193 outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE); 194 gmux_index_wait_complete(gmux_data); 195 mutex_unlock(&gmux_data->index_lock); 196 } 197 198 static u8 gmux_read8(struct apple_gmux_data *gmux_data, int port) 199 { 200 if (gmux_data->indexed) 201 return gmux_index_read8(gmux_data, port); 202 else 203 return gmux_pio_read8(gmux_data, port); 204 } 205 206 static void gmux_write8(struct apple_gmux_data *gmux_data, int port, u8 val) 207 { 208 if (gmux_data->indexed) 209 gmux_index_write8(gmux_data, port, val); 210 else 211 gmux_pio_write8(gmux_data, port, val); 212 } 213 214 static u32 gmux_read32(struct apple_gmux_data *gmux_data, int port) 215 { 216 if (gmux_data->indexed) 217 return gmux_index_read32(gmux_data, port); 218 else 219 return gmux_pio_read32(gmux_data, port); 220 } 221 222 static void gmux_write32(struct apple_gmux_data *gmux_data, int port, 223 u32 val) 224 { 225 if (gmux_data->indexed) 226 gmux_index_write32(gmux_data, port, val); 227 else 228 gmux_pio_write32(gmux_data, port, val); 229 } 230 231 static bool gmux_is_indexed(struct apple_gmux_data *gmux_data) 232 { 233 u16 val; 234 235 outb(0xaa, gmux_data->iostart + 0xcc); 236 outb(0x55, gmux_data->iostart + 0xcd); 237 outb(0x00, gmux_data->iostart + 0xce); 238 239 val = inb(gmux_data->iostart + 0xcc) | 240 (inb(gmux_data->iostart + 0xcd) << 8); 241 242 if (val == 0x55aa) 243 return true; 244 245 return false; 246 } 247 248 static int gmux_get_brightness(struct backlight_device *bd) 249 { 250 struct apple_gmux_data *gmux_data = bl_get_data(bd); 251 return gmux_read32(gmux_data, GMUX_PORT_BRIGHTNESS) & 252 GMUX_BRIGHTNESS_MASK; 253 } 254 255 static int gmux_update_status(struct backlight_device *bd) 256 { 257 struct apple_gmux_data *gmux_data = bl_get_data(bd); 258 u32 brightness = bd->props.brightness; 259 260 if (bd->props.state & BL_CORE_SUSPENDED) 261 return 0; 262 263 gmux_write32(gmux_data, GMUX_PORT_BRIGHTNESS, brightness); 264 265 return 0; 266 } 267 268 static const struct backlight_ops gmux_bl_ops = { 269 .options = BL_CORE_SUSPENDRESUME, 270 .get_brightness = gmux_get_brightness, 271 .update_status = gmux_update_status, 272 }; 273 274 static int gmux_switchto(enum vga_switcheroo_client_id id) 275 { 276 if (id == VGA_SWITCHEROO_IGD) { 277 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 1); 278 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DISPLAY, 2); 279 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 2); 280 } else { 281 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 2); 282 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DISPLAY, 3); 283 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 3); 284 } 285 286 return 0; 287 } 288 289 static int gmux_set_discrete_state(struct apple_gmux_data *gmux_data, 290 enum vga_switcheroo_state state) 291 { 292 INIT_COMPLETION(gmux_data->powerchange_done); 293 294 if (state == VGA_SWITCHEROO_ON) { 295 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1); 296 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 3); 297 pr_debug("Discrete card powered up\n"); 298 } else { 299 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1); 300 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 0); 301 pr_debug("Discrete card powered down\n"); 302 } 303 304 gmux_data->power_state = state; 305 306 if (gmux_data->gpe >= 0 && 307 !wait_for_completion_interruptible_timeout(&gmux_data->powerchange_done, 308 msecs_to_jiffies(200))) 309 pr_warn("Timeout waiting for gmux switch to complete\n"); 310 311 return 0; 312 } 313 314 static int gmux_set_power_state(enum vga_switcheroo_client_id id, 315 enum vga_switcheroo_state state) 316 { 317 if (id == VGA_SWITCHEROO_IGD) 318 return 0; 319 320 return gmux_set_discrete_state(apple_gmux_data, state); 321 } 322 323 static int gmux_get_client_id(struct pci_dev *pdev) 324 { 325 /* 326 * Early Macbook Pros with switchable graphics use nvidia 327 * integrated graphics. Hardcode that the 9400M is integrated. 328 */ 329 if (pdev->vendor == PCI_VENDOR_ID_INTEL) 330 return VGA_SWITCHEROO_IGD; 331 else if (pdev->vendor == PCI_VENDOR_ID_NVIDIA && 332 pdev->device == 0x0863) 333 return VGA_SWITCHEROO_IGD; 334 else 335 return VGA_SWITCHEROO_DIS; 336 } 337 338 static enum vga_switcheroo_client_id 339 gmux_active_client(struct apple_gmux_data *gmux_data) 340 { 341 if (gmux_read8(gmux_data, GMUX_PORT_SWITCH_DISPLAY) == 2) 342 return VGA_SWITCHEROO_IGD; 343 344 return VGA_SWITCHEROO_DIS; 345 } 346 347 static struct vga_switcheroo_handler gmux_handler = { 348 .switchto = gmux_switchto, 349 .power_state = gmux_set_power_state, 350 .get_client_id = gmux_get_client_id, 351 }; 352 353 static inline void gmux_disable_interrupts(struct apple_gmux_data *gmux_data) 354 { 355 gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE, 356 GMUX_INTERRUPT_DISABLE); 357 } 358 359 static inline void gmux_enable_interrupts(struct apple_gmux_data *gmux_data) 360 { 361 gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE, 362 GMUX_INTERRUPT_ENABLE); 363 } 364 365 static inline u8 gmux_interrupt_get_status(struct apple_gmux_data *gmux_data) 366 { 367 return gmux_read8(gmux_data, GMUX_PORT_INTERRUPT_STATUS); 368 } 369 370 static void gmux_clear_interrupts(struct apple_gmux_data *gmux_data) 371 { 372 u8 status; 373 374 /* to clear interrupts write back current status */ 375 status = gmux_interrupt_get_status(gmux_data); 376 gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_STATUS, status); 377 } 378 379 static void gmux_notify_handler(acpi_handle device, u32 value, void *context) 380 { 381 u8 status; 382 struct pnp_dev *pnp = (struct pnp_dev *)context; 383 struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); 384 385 status = gmux_interrupt_get_status(gmux_data); 386 gmux_disable_interrupts(gmux_data); 387 pr_debug("Notify handler called: status %d\n", status); 388 389 gmux_clear_interrupts(gmux_data); 390 gmux_enable_interrupts(gmux_data); 391 392 if (status & GMUX_INTERRUPT_STATUS_POWER) 393 complete(&gmux_data->powerchange_done); 394 } 395 396 static int gmux_suspend(struct pnp_dev *pnp, pm_message_t state) 397 { 398 struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); 399 gmux_data->resume_client_id = gmux_active_client(gmux_data); 400 gmux_disable_interrupts(gmux_data); 401 return 0; 402 } 403 404 static int gmux_resume(struct pnp_dev *pnp) 405 { 406 struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); 407 gmux_enable_interrupts(gmux_data); 408 gmux_switchto(gmux_data->resume_client_id); 409 if (gmux_data->power_state == VGA_SWITCHEROO_OFF) 410 gmux_set_discrete_state(gmux_data, gmux_data->power_state); 411 return 0; 412 } 413 414 static int __devinit gmux_probe(struct pnp_dev *pnp, 415 const struct pnp_device_id *id) 416 { 417 struct apple_gmux_data *gmux_data; 418 struct resource *res; 419 struct backlight_properties props; 420 struct backlight_device *bdev; 421 u8 ver_major, ver_minor, ver_release; 422 int ret = -ENXIO; 423 acpi_status status; 424 unsigned long long gpe; 425 426 if (apple_gmux_data) 427 return -EBUSY; 428 429 gmux_data = kzalloc(sizeof(*gmux_data), GFP_KERNEL); 430 if (!gmux_data) 431 return -ENOMEM; 432 pnp_set_drvdata(pnp, gmux_data); 433 434 res = pnp_get_resource(pnp, IORESOURCE_IO, 0); 435 if (!res) { 436 pr_err("Failed to find gmux I/O resource\n"); 437 goto err_free; 438 } 439 440 gmux_data->iostart = res->start; 441 gmux_data->iolen = res->end - res->start; 442 443 if (gmux_data->iolen < GMUX_MIN_IO_LEN) { 444 pr_err("gmux I/O region too small (%lu < %u)\n", 445 gmux_data->iolen, GMUX_MIN_IO_LEN); 446 goto err_free; 447 } 448 449 if (!request_region(gmux_data->iostart, gmux_data->iolen, 450 "Apple gmux")) { 451 pr_err("gmux I/O already in use\n"); 452 goto err_free; 453 } 454 455 /* 456 * Invalid version information may indicate either that the gmux 457 * device isn't present or that it's a new one that uses indexed 458 * io 459 */ 460 461 ver_major = gmux_read8(gmux_data, GMUX_PORT_VERSION_MAJOR); 462 ver_minor = gmux_read8(gmux_data, GMUX_PORT_VERSION_MINOR); 463 ver_release = gmux_read8(gmux_data, GMUX_PORT_VERSION_RELEASE); 464 if (ver_major == 0xff && ver_minor == 0xff && ver_release == 0xff) { 465 if (gmux_is_indexed(gmux_data)) { 466 u32 version; 467 mutex_init(&gmux_data->index_lock); 468 gmux_data->indexed = true; 469 version = gmux_read32(gmux_data, 470 GMUX_PORT_VERSION_MAJOR); 471 ver_major = (version >> 24) & 0xff; 472 ver_minor = (version >> 16) & 0xff; 473 ver_release = (version >> 8) & 0xff; 474 } else { 475 pr_info("gmux device not present\n"); 476 ret = -ENODEV; 477 goto err_release; 478 } 479 } 480 pr_info("Found gmux version %d.%d.%d [%s]\n", ver_major, ver_minor, 481 ver_release, (gmux_data->indexed ? "indexed" : "classic")); 482 483 memset(&props, 0, sizeof(props)); 484 props.type = BACKLIGHT_PLATFORM; 485 props.max_brightness = gmux_read32(gmux_data, GMUX_PORT_MAX_BRIGHTNESS); 486 487 /* 488 * Currently it's assumed that the maximum brightness is less than 489 * 2^24 for compatibility with old gmux versions. Cap the max 490 * brightness at this value, but print a warning if the hardware 491 * reports something higher so that it can be fixed. 492 */ 493 if (WARN_ON(props.max_brightness > GMUX_MAX_BRIGHTNESS)) 494 props.max_brightness = GMUX_MAX_BRIGHTNESS; 495 496 bdev = backlight_device_register("gmux_backlight", &pnp->dev, 497 gmux_data, &gmux_bl_ops, &props); 498 if (IS_ERR(bdev)) { 499 ret = PTR_ERR(bdev); 500 goto err_release; 501 } 502 503 gmux_data->bdev = bdev; 504 bdev->props.brightness = gmux_get_brightness(bdev); 505 backlight_update_status(bdev); 506 507 /* 508 * The backlight situation on Macs is complicated. If the gmux is 509 * present it's the best choice, because it always works for 510 * backlight control and supports more levels than other options. 511 * Disable the other backlight choices. 512 */ 513 acpi_video_dmi_promote_vendor(); 514 acpi_video_unregister(); 515 apple_bl_unregister(); 516 517 gmux_data->power_state = VGA_SWITCHEROO_ON; 518 519 gmux_data->dhandle = DEVICE_ACPI_HANDLE(&pnp->dev); 520 if (!gmux_data->dhandle) { 521 pr_err("Cannot find acpi handle for pnp device %s\n", 522 dev_name(&pnp->dev)); 523 ret = -ENODEV; 524 goto err_notify; 525 } 526 527 status = acpi_evaluate_integer(gmux_data->dhandle, "GMGP", NULL, &gpe); 528 if (ACPI_SUCCESS(status)) { 529 gmux_data->gpe = (int)gpe; 530 531 status = acpi_install_notify_handler(gmux_data->dhandle, 532 ACPI_DEVICE_NOTIFY, 533 &gmux_notify_handler, pnp); 534 if (ACPI_FAILURE(status)) { 535 pr_err("Install notify handler failed: %s\n", 536 acpi_format_exception(status)); 537 ret = -ENODEV; 538 goto err_notify; 539 } 540 541 status = acpi_enable_gpe(NULL, gmux_data->gpe); 542 if (ACPI_FAILURE(status)) { 543 pr_err("Cannot enable gpe: %s\n", 544 acpi_format_exception(status)); 545 goto err_enable_gpe; 546 } 547 } else { 548 pr_warn("No GPE found for gmux\n"); 549 gmux_data->gpe = -1; 550 } 551 552 if (vga_switcheroo_register_handler(&gmux_handler)) { 553 ret = -ENODEV; 554 goto err_register_handler; 555 } 556 557 init_completion(&gmux_data->powerchange_done); 558 apple_gmux_data = gmux_data; 559 gmux_enable_interrupts(gmux_data); 560 561 return 0; 562 563 err_register_handler: 564 if (gmux_data->gpe >= 0) 565 acpi_disable_gpe(NULL, gmux_data->gpe); 566 err_enable_gpe: 567 if (gmux_data->gpe >= 0) 568 acpi_remove_notify_handler(gmux_data->dhandle, 569 ACPI_DEVICE_NOTIFY, 570 &gmux_notify_handler); 571 err_notify: 572 backlight_device_unregister(bdev); 573 err_release: 574 release_region(gmux_data->iostart, gmux_data->iolen); 575 err_free: 576 kfree(gmux_data); 577 return ret; 578 } 579 580 static void __devexit gmux_remove(struct pnp_dev *pnp) 581 { 582 struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); 583 584 vga_switcheroo_unregister_handler(); 585 gmux_disable_interrupts(gmux_data); 586 if (gmux_data->gpe >= 0) { 587 acpi_disable_gpe(NULL, gmux_data->gpe); 588 acpi_remove_notify_handler(gmux_data->dhandle, 589 ACPI_DEVICE_NOTIFY, 590 &gmux_notify_handler); 591 } 592 593 backlight_device_unregister(gmux_data->bdev); 594 595 release_region(gmux_data->iostart, gmux_data->iolen); 596 apple_gmux_data = NULL; 597 kfree(gmux_data); 598 599 acpi_video_dmi_demote_vendor(); 600 acpi_video_register(); 601 apple_bl_register(); 602 } 603 604 static const struct pnp_device_id gmux_device_ids[] = { 605 {"APP000B", 0}, 606 {"", 0} 607 }; 608 609 static struct pnp_driver gmux_pnp_driver = { 610 .name = "apple-gmux", 611 .probe = gmux_probe, 612 .remove = __devexit_p(gmux_remove), 613 .id_table = gmux_device_ids, 614 .suspend = gmux_suspend, 615 .resume = gmux_resume 616 }; 617 618 static int __init apple_gmux_init(void) 619 { 620 return pnp_register_driver(&gmux_pnp_driver); 621 } 622 623 static void __exit apple_gmux_exit(void) 624 { 625 pnp_unregister_driver(&gmux_pnp_driver); 626 } 627 628 module_init(apple_gmux_init); 629 module_exit(apple_gmux_exit); 630 631 MODULE_AUTHOR("Seth Forshee <seth.forshee@canonical.com>"); 632 MODULE_DESCRIPTION("Apple Gmux Driver"); 633 MODULE_LICENSE("GPL"); 634 MODULE_DEVICE_TABLE(pnp, gmux_device_ids); 635