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 gmux_probe(struct pnp_dev *pnp, const struct pnp_device_id *id) 415 { 416 struct apple_gmux_data *gmux_data; 417 struct resource *res; 418 struct backlight_properties props; 419 struct backlight_device *bdev; 420 u8 ver_major, ver_minor, ver_release; 421 int ret = -ENXIO; 422 acpi_status status; 423 unsigned long long gpe; 424 425 if (apple_gmux_data) 426 return -EBUSY; 427 428 gmux_data = kzalloc(sizeof(*gmux_data), GFP_KERNEL); 429 if (!gmux_data) 430 return -ENOMEM; 431 pnp_set_drvdata(pnp, gmux_data); 432 433 res = pnp_get_resource(pnp, IORESOURCE_IO, 0); 434 if (!res) { 435 pr_err("Failed to find gmux I/O resource\n"); 436 goto err_free; 437 } 438 439 gmux_data->iostart = res->start; 440 gmux_data->iolen = res->end - res->start; 441 442 if (gmux_data->iolen < GMUX_MIN_IO_LEN) { 443 pr_err("gmux I/O region too small (%lu < %u)\n", 444 gmux_data->iolen, GMUX_MIN_IO_LEN); 445 goto err_free; 446 } 447 448 if (!request_region(gmux_data->iostart, gmux_data->iolen, 449 "Apple gmux")) { 450 pr_err("gmux I/O already in use\n"); 451 goto err_free; 452 } 453 454 /* 455 * Invalid version information may indicate either that the gmux 456 * device isn't present or that it's a new one that uses indexed 457 * io 458 */ 459 460 ver_major = gmux_read8(gmux_data, GMUX_PORT_VERSION_MAJOR); 461 ver_minor = gmux_read8(gmux_data, GMUX_PORT_VERSION_MINOR); 462 ver_release = gmux_read8(gmux_data, GMUX_PORT_VERSION_RELEASE); 463 if (ver_major == 0xff && ver_minor == 0xff && ver_release == 0xff) { 464 if (gmux_is_indexed(gmux_data)) { 465 u32 version; 466 mutex_init(&gmux_data->index_lock); 467 gmux_data->indexed = true; 468 version = gmux_read32(gmux_data, 469 GMUX_PORT_VERSION_MAJOR); 470 ver_major = (version >> 24) & 0xff; 471 ver_minor = (version >> 16) & 0xff; 472 ver_release = (version >> 8) & 0xff; 473 } else { 474 pr_info("gmux device not present\n"); 475 ret = -ENODEV; 476 goto err_release; 477 } 478 } 479 pr_info("Found gmux version %d.%d.%d [%s]\n", ver_major, ver_minor, 480 ver_release, (gmux_data->indexed ? "indexed" : "classic")); 481 482 memset(&props, 0, sizeof(props)); 483 props.type = BACKLIGHT_PLATFORM; 484 props.max_brightness = gmux_read32(gmux_data, GMUX_PORT_MAX_BRIGHTNESS); 485 486 /* 487 * Currently it's assumed that the maximum brightness is less than 488 * 2^24 for compatibility with old gmux versions. Cap the max 489 * brightness at this value, but print a warning if the hardware 490 * reports something higher so that it can be fixed. 491 */ 492 if (WARN_ON(props.max_brightness > GMUX_MAX_BRIGHTNESS)) 493 props.max_brightness = GMUX_MAX_BRIGHTNESS; 494 495 bdev = backlight_device_register("gmux_backlight", &pnp->dev, 496 gmux_data, &gmux_bl_ops, &props); 497 if (IS_ERR(bdev)) { 498 ret = PTR_ERR(bdev); 499 goto err_release; 500 } 501 502 gmux_data->bdev = bdev; 503 bdev->props.brightness = gmux_get_brightness(bdev); 504 backlight_update_status(bdev); 505 506 /* 507 * The backlight situation on Macs is complicated. If the gmux is 508 * present it's the best choice, because it always works for 509 * backlight control and supports more levels than other options. 510 * Disable the other backlight choices. 511 */ 512 acpi_video_dmi_promote_vendor(); 513 acpi_video_unregister(); 514 apple_bl_unregister(); 515 516 gmux_data->power_state = VGA_SWITCHEROO_ON; 517 518 gmux_data->dhandle = DEVICE_ACPI_HANDLE(&pnp->dev); 519 if (!gmux_data->dhandle) { 520 pr_err("Cannot find acpi handle for pnp device %s\n", 521 dev_name(&pnp->dev)); 522 ret = -ENODEV; 523 goto err_notify; 524 } 525 526 status = acpi_evaluate_integer(gmux_data->dhandle, "GMGP", NULL, &gpe); 527 if (ACPI_SUCCESS(status)) { 528 gmux_data->gpe = (int)gpe; 529 530 status = acpi_install_notify_handler(gmux_data->dhandle, 531 ACPI_DEVICE_NOTIFY, 532 &gmux_notify_handler, pnp); 533 if (ACPI_FAILURE(status)) { 534 pr_err("Install notify handler failed: %s\n", 535 acpi_format_exception(status)); 536 ret = -ENODEV; 537 goto err_notify; 538 } 539 540 status = acpi_enable_gpe(NULL, gmux_data->gpe); 541 if (ACPI_FAILURE(status)) { 542 pr_err("Cannot enable gpe: %s\n", 543 acpi_format_exception(status)); 544 goto err_enable_gpe; 545 } 546 } else { 547 pr_warn("No GPE found for gmux\n"); 548 gmux_data->gpe = -1; 549 } 550 551 if (vga_switcheroo_register_handler(&gmux_handler)) { 552 ret = -ENODEV; 553 goto err_register_handler; 554 } 555 556 init_completion(&gmux_data->powerchange_done); 557 apple_gmux_data = gmux_data; 558 gmux_enable_interrupts(gmux_data); 559 560 return 0; 561 562 err_register_handler: 563 if (gmux_data->gpe >= 0) 564 acpi_disable_gpe(NULL, gmux_data->gpe); 565 err_enable_gpe: 566 if (gmux_data->gpe >= 0) 567 acpi_remove_notify_handler(gmux_data->dhandle, 568 ACPI_DEVICE_NOTIFY, 569 &gmux_notify_handler); 570 err_notify: 571 backlight_device_unregister(bdev); 572 err_release: 573 release_region(gmux_data->iostart, gmux_data->iolen); 574 err_free: 575 kfree(gmux_data); 576 return ret; 577 } 578 579 static void gmux_remove(struct pnp_dev *pnp) 580 { 581 struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); 582 583 vga_switcheroo_unregister_handler(); 584 gmux_disable_interrupts(gmux_data); 585 if (gmux_data->gpe >= 0) { 586 acpi_disable_gpe(NULL, gmux_data->gpe); 587 acpi_remove_notify_handler(gmux_data->dhandle, 588 ACPI_DEVICE_NOTIFY, 589 &gmux_notify_handler); 590 } 591 592 backlight_device_unregister(gmux_data->bdev); 593 594 release_region(gmux_data->iostart, gmux_data->iolen); 595 apple_gmux_data = NULL; 596 kfree(gmux_data); 597 598 acpi_video_dmi_demote_vendor(); 599 acpi_video_register(); 600 apple_bl_register(); 601 } 602 603 static const struct pnp_device_id gmux_device_ids[] = { 604 {"APP000B", 0}, 605 {"", 0} 606 }; 607 608 static struct pnp_driver gmux_pnp_driver = { 609 .name = "apple-gmux", 610 .probe = gmux_probe, 611 .remove = gmux_remove, 612 .id_table = gmux_device_ids, 613 .suspend = gmux_suspend, 614 .resume = gmux_resume 615 }; 616 617 static int __init apple_gmux_init(void) 618 { 619 return pnp_register_driver(&gmux_pnp_driver); 620 } 621 622 static void __exit apple_gmux_exit(void) 623 { 624 pnp_unregister_driver(&gmux_pnp_driver); 625 } 626 627 module_init(apple_gmux_init); 628 module_exit(apple_gmux_exit); 629 630 MODULE_AUTHOR("Seth Forshee <seth.forshee@canonical.com>"); 631 MODULE_DESCRIPTION("Apple Gmux Driver"); 632 MODULE_LICENSE("GPL"); 633 MODULE_DEVICE_TABLE(pnp, gmux_device_ids); 634