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