1 /* 2 * apple_gmux - Gmux driver for DragonFly 3 * 4 * Adapted from linux v4.8: drivers/platform/x86/apple-gmux.c 5 * 6 */ 7 8 /* 9 * Gmux driver for Apple laptops 10 * 11 * Copyright (C) Canonical Ltd. <seth.forshee@canonical.com> 12 * Copyright (C) 2010-2012 Andreas Heider <andreas@meetr.de> 13 * Copyright (C) 2015 Lukas Wunner <lukas@wunner.de> 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License version 2 as 17 * published by the Free Software Foundation. 18 */ 19 20 #include <sys/param.h> 21 #include <sys/kernel.h> 22 #include <sys/bio.h> 23 #include <sys/bus.h> 24 #include <sys/malloc.h> 25 #include <sys/module.h> 26 #include <sys/proc.h> 27 #include <sys/types.h> 28 #include <sys/systm.h> 29 #include <sys/device.h> 30 #include <sys/conf.h> 31 #include <sys/rman.h> 32 33 #define pr_fmt(fmt) "apple_gmux: " fmt 34 35 #include <linux/types.h> 36 #include <linux/pci.h> 37 #include <linux/pci_ids.h> 38 #include <linux/backlight.h> 39 #include <linux/apple-gmux.h> 40 #include <linux/delay.h> 41 #include <linux/completion.h> 42 43 #include <drm/drmP.h> 44 #ifndef VGA_SWITCHEROO 45 #define VGA_SWITCHEROO 1 /* Must be always defined */ 46 #endif 47 #include <linux/vga_switcheroo.h> 48 49 #include <bus/pci/pcireg.h> 50 #include <bus/pci/pcivar.h> 51 #include "opt_acpi.h" 52 #include <contrib/dev/acpica/source/include/acpi.h> 53 #include <contrib/dev/acpica/source/include/accommon.h> 54 #include <dev/acpica/acpivar.h> 55 56 /* 57 * gmux port offsets. Many of these are not yet used, but may be in the 58 * future, and it's useful to have them documented here anyhow. 59 */ 60 #define GMUX_PORT_VERSION_MAJOR 0x04 61 #define GMUX_PORT_VERSION_MINOR 0x05 62 #define GMUX_PORT_VERSION_RELEASE 0x06 63 #define GMUX_PORT_SWITCH_DISPLAY 0x10 64 #define GMUX_PORT_SWITCH_GET_DISPLAY 0x11 65 #define GMUX_PORT_INTERRUPT_ENABLE 0x14 66 #define GMUX_PORT_INTERRUPT_STATUS 0x16 67 #define GMUX_PORT_SWITCH_DDC 0x28 68 #define GMUX_PORT_SWITCH_EXTERNAL 0x40 69 #define GMUX_PORT_SWITCH_GET_EXTERNAL 0x41 70 #define GMUX_PORT_DISCRETE_POWER 0x50 71 #define GMUX_PORT_MAX_BRIGHTNESS 0x70 72 #define GMUX_PORT_BRIGHTNESS 0x74 73 #define GMUX_PORT_VALUE 0xc2 74 #define GMUX_PORT_READ 0xd0 75 #define GMUX_PORT_WRITE 0xd4 76 77 #define GMUX_MIN_IO_LEN (GMUX_PORT_BRIGHTNESS + 4) 78 79 #define GMUX_INTERRUPT_ENABLE 0xff 80 #define GMUX_INTERRUPT_DISABLE 0x00 81 82 #define GMUX_INTERRUPT_STATUS_ACTIVE 0 83 #define GMUX_INTERRUPT_STATUS_DISPLAY (1 << 0) 84 #define GMUX_INTERRUPT_STATUS_POWER (1 << 2) 85 #define GMUX_INTERRUPT_STATUS_HOTPLUG (1 << 3) 86 87 #define GMUX_BRIGHTNESS_MASK 0x00ffffff 88 #define GMUX_MAX_BRIGHTNESS GMUX_BRIGHTNESS_MASK 89 90 /** 91 * DOC: Overview 92 * 93 * :1: http://www.latticesemi.com/en/Products/FPGAandCPLD/LatticeXP2.aspx 94 * :2: http://www.renesas.com/products/mpumcu/h8s/h8s2100/h8s2113/index.jsp 95 * 96 * gmux is a microcontroller built into the MacBook Pro to support dual GPUs: 97 * A {1}[Lattice XP2] on pre-retinas, a {2}[Renesas R4F2113] on retinas. 98 * 99 * (The MacPro6,1 2013 also has a gmux, however it is unclear why since it has 100 * dual GPUs but no built-in display.) 101 * 102 * gmux is connected to the LPC bus of the southbridge. Its I/O ports are 103 * accessed differently depending on the microcontroller: Driver functions 104 * to access a pre-retina gmux are infixed `_pio_`, those for a retina gmux 105 * are infixed `_index_`. 106 */ 107 108 struct apple_gmux_softc { 109 device_t gmux_dev; 110 int io_rid; 111 struct resource *io_res; 112 bool indexed; 113 struct lock lk; 114 115 int unit; 116 117 struct pci_dev *pdev; 118 /* struct backlight_device *bdev; */ 119 120 /* switcheroo data */ 121 ACPI_HANDLE dhandle; 122 int gpe; 123 enum vga_switcheroo_client_id switch_state_display; 124 enum vga_switcheroo_client_id switch_state_ddc; 125 enum vga_switcheroo_client_id switch_state_external; 126 enum vga_switcheroo_state power_state; 127 struct completion powerchange_done; 128 }; 129 130 static struct apple_gmux_softc *apple_gmux_softc_data; 131 132 static void apple_gmux_lock(struct apple_gmux_softc *sc); 133 static void apple_gmux_unlock(struct apple_gmux_softc *sc); 134 static u8 gmux_pio_read8(struct apple_gmux_softc *sc, uint8_t offset); 135 static void gmux_pio_write8(struct apple_gmux_softc *sc, int offset, uint8_t value); 136 static u32 gmux_pio_read32(struct apple_gmux_softc *sc, uint8_t offset); 137 //static void gmux_pio_write32(struct apple_gmux_softc *sc, uint8_t offset, uint32_t value); 138 static int gmux_index_wait_ready(struct apple_gmux_softc *sc); 139 static int gmux_index_wait_complete(struct apple_gmux_softc *sc); 140 static u8 gmux_index_read8(struct apple_gmux_softc *sc, uint8_t offset); 141 static void gmux_index_write8(struct apple_gmux_softc *sc, int offset, uint8_t value); 142 static u32 gmux_index_read32(struct apple_gmux_softc *sc, uint8_t offset); 143 //static void gmux_index_write32(struct apple_gmux_softc *sc, int offset, uint32_t value); 144 static u8 gmux_read8(struct apple_gmux_softc *sc, int offset); 145 static void gmux_write8(struct apple_gmux_softc *sc, int offset, uint8_t value); 146 static u32 gmux_read32(struct apple_gmux_softc *sc, int offset); 147 //static void gmux_write32(struct apple_gmux_softc *sc, int offset, uint32_t value); 148 static bool gmux_is_indexed(struct apple_gmux_softc *sc); 149 static void gmux_read_switch_state(struct apple_gmux_softc *sc); 150 static void gmux_write_switch_state(struct apple_gmux_softc *sc); 151 static int gmux_switchto(enum vga_switcheroo_client_id id); 152 static int gmux_switch_ddc(enum vga_switcheroo_client_id id); 153 static int gmux_set_discrete_state(struct apple_gmux_softc *sc, enum vga_switcheroo_state state); 154 static int gmux_set_power_state(enum vga_switcheroo_client_id id, enum vga_switcheroo_state state); 155 static inline void gmux_disable_interrupts(struct apple_gmux_softc *sc); 156 static inline void gmux_enable_interrupts(struct apple_gmux_softc *sc); 157 static inline u8 gmux_interrupt_get_status(struct apple_gmux_softc *sc); 158 static void gmux_clear_interrupts(struct apple_gmux_softc *sc); 159 static void gmux_notify_handler(ACPI_HANDLE device, UINT32 value, void *context); 160 static int apple_gmux_suspend(device_t dev); 161 static int apple_gmux_resume(device_t dev); 162 device_t gmux_get_io_pdev(void); 163 static int apple_gmux_probe(device_t dev); 164 static int apple_gmux_attach(device_t dev); 165 static int apple_gmux_detach(device_t dev); 166 167 static void 168 apple_gmux_lock(struct apple_gmux_softc *sc) 169 { 170 lockmgr(&sc->lk, LK_EXCLUSIVE); 171 } 172 173 static void 174 apple_gmux_unlock(struct apple_gmux_softc *sc) 175 { 176 lockmgr(&sc->lk, LK_RELEASE); 177 } 178 179 static u8 180 gmux_pio_read8(struct apple_gmux_softc *sc, uint8_t offset) 181 { 182 return(bus_read_1(sc->io_res, offset)); 183 } 184 185 static void 186 gmux_pio_write8(struct apple_gmux_softc *sc, int offset, uint8_t value) 187 { 188 bus_write_1(sc->io_res, offset, value); 189 } 190 191 static u32 192 gmux_pio_read32(struct apple_gmux_softc *sc, uint8_t offset) 193 { 194 return(bus_read_4(sc->io_res, offset)); 195 } 196 197 #if 0 /* Defined but not used */ 198 static void 199 gmux_pio_write32(struct apple_gmux_softc *sc, uint8_t offset, 200 uint32_t value) 201 { 202 int i; 203 u8 tmpval; 204 205 for (i = 0; i < 4; i++) { 206 tmpval = (value >> (i * 8)) & 0xff; 207 bus_write_1(sc->io_res, offset + i, tmpval); 208 } 209 } 210 #endif /* Defined but not used */ 211 212 static int 213 gmux_index_wait_ready(struct apple_gmux_softc *sc) 214 { 215 int i = 200; 216 u8 gwr = bus_read_1(sc->io_res, GMUX_PORT_WRITE); 217 218 while (i && (gwr & 0x01)) { 219 bus_read_1(sc->io_res, GMUX_PORT_READ); 220 gwr = bus_read_1(sc->io_res, GMUX_PORT_WRITE); 221 udelay(100); 222 i--; 223 } 224 225 return !!i; 226 } 227 228 static int 229 gmux_index_wait_complete(struct apple_gmux_softc *sc) 230 { 231 int i = 200; 232 u8 gwr = bus_read_1(sc->io_res, GMUX_PORT_WRITE); 233 234 while (i && !(gwr & 0x01)) { 235 gwr = bus_read_1(sc->io_res, GMUX_PORT_WRITE); 236 udelay(100); 237 i--; 238 } 239 240 if (gwr & 0x01) 241 bus_read_1(sc->io_res, GMUX_PORT_READ); 242 243 return !!i; 244 } 245 246 static u8 247 gmux_index_read8(struct apple_gmux_softc *sc, uint8_t offset) 248 { 249 u8 val; 250 251 apple_gmux_lock(sc); 252 gmux_index_wait_ready(sc); 253 bus_write_1(sc->io_res, GMUX_PORT_READ, (offset & 0xff)); 254 gmux_index_wait_complete(sc); 255 val = bus_read_1(sc->io_res, GMUX_PORT_VALUE); 256 apple_gmux_unlock(sc); 257 258 return val; 259 } 260 261 static void 262 gmux_index_write8(struct apple_gmux_softc *sc, int offset, uint8_t value) 263 { 264 apple_gmux_lock(sc); 265 bus_write_1(sc->io_res, GMUX_PORT_VALUE, value); 266 gmux_index_wait_ready(sc); 267 bus_write_1(sc->io_res, GMUX_PORT_WRITE, (offset & 0xff)); 268 gmux_index_wait_complete(sc); 269 apple_gmux_unlock(sc); 270 } 271 272 static u32 273 gmux_index_read32(struct apple_gmux_softc *sc, uint8_t offset) 274 { 275 u32 val; 276 277 apple_gmux_lock(sc); 278 gmux_index_wait_ready(sc); 279 bus_write_1(sc->io_res, GMUX_PORT_READ, (offset & 0xff)); 280 gmux_index_wait_complete(sc); 281 val = bus_read_4(sc->io_res, GMUX_PORT_VALUE); 282 apple_gmux_unlock(sc); 283 284 return val; 285 } 286 287 #if 0 /* Defined but not used */ 288 static void 289 gmux_index_write32(struct apple_gmux_softc *sc, int offset, uint32_t value) 290 { 291 int i; 292 u8 tmpval; 293 294 apple_gmux_lock(sc); 295 296 for (i = 0; i < 4; i++) { 297 tmpval = (value >> (i * 8)) & 0xff; 298 bus_write_1(sc->io_res, GMUX_PORT_VALUE + i, tmpval); 299 } 300 301 gmux_index_wait_ready(sc); 302 bus_write_1(sc->io_res, GMUX_PORT_WRITE, (offset & 0xff)); 303 gmux_index_wait_complete(sc); 304 apple_gmux_unlock(sc); 305 } 306 #endif /* Defined but not used */ 307 308 static u8 309 gmux_read8(struct apple_gmux_softc *sc, int offset) 310 { 311 if (sc->indexed) 312 return gmux_index_read8(sc, offset); 313 else 314 return gmux_pio_read8(sc, offset); 315 } 316 317 static void 318 gmux_write8(struct apple_gmux_softc *sc, int offset, uint8_t value) 319 { 320 if (sc->indexed) 321 gmux_index_write8(sc, offset, value); 322 else 323 gmux_pio_write8(sc, offset, value); 324 } 325 326 static u32 327 gmux_read32(struct apple_gmux_softc *sc, int offset) 328 { 329 if (sc->indexed) 330 return gmux_index_read32(sc, offset); 331 else 332 return gmux_pio_read32(sc, offset); 333 } 334 335 #if 0 /* Defined but not used */ 336 static void 337 gmux_write32(struct apple_gmux_softc *sc, int offset, uint32_t value) 338 { 339 if (sc->indexed) 340 gmux_index_write32(sc, offset, value); 341 else 342 gmux_pio_write32(sc, offset, value); 343 } 344 #endif /* Defined but not used */ 345 346 static bool 347 gmux_is_indexed(struct apple_gmux_softc *sc) 348 { 349 u16 val; 350 351 bus_write_1(sc->io_res, 0xcc, 0xaa); 352 bus_write_1(sc->io_res, 0xcd, 0x55); 353 bus_write_1(sc->io_res, 0xce, 0x00); 354 355 val = bus_read_1(sc->io_res, 0xcc) | 356 (bus_read_1(sc->io_res, 0xcd) << 8); 357 358 if (val == 0x55aa) 359 return true; 360 361 return(false); 362 } 363 364 /** 365 * DOC: Backlight control 366 * 367 * :3: http://www.ti.com/lit/ds/symlink/lp8543.pdf 368 * :4: http://www.ti.com/lit/ds/symlink/lp8545.pdf 369 * 370 * On single GPU MacBooks, the PWM signal for the backlight is generated by 371 * the GPU. On dual GPU MacBook Pros by contrast, either GPU may be suspended 372 * to conserve energy. Hence the PWM signal needs to be generated by a separate 373 * backlight driver which is controlled by gmux. The earliest generation 374 * MBP5 2008/09 uses a {3}[TI LP8543] backlight driver. All newer models 375 * use a {4}[TI LP8545]. 376 */ 377 378 #if 0 /* no backlight */ 379 static int 380 gmux_get_brightness(struct backlight_device *bd) 381 { 382 struct apple_gmux_softc *sc = bl_get_data(bd); 383 return gmux_read32(sc, GMUX_PORT_BRIGHTNESS) & 384 GMUX_BRIGHTNESS_MASK; 385 } 386 387 static int 388 gmux_update_status(struct backlight_device *bd) 389 { 390 struct apple_gmux_softc *sc = bl_get_data(bd); 391 u32 brightness = bd->props.brightness; 392 393 if (bd->props.state & BL_CORE_SUSPENDED) 394 return 0; 395 396 gmux_write32(sc, GMUX_PORT_BRIGHTNESS, brightness); 397 398 return 0; 399 } 400 401 static const struct backlight_ops gmux_bl_ops = { 402 .options = BL_CORE_SUSPENDRESUME, 403 .get_brightness = gmux_get_brightness, 404 .update_status = gmux_update_status, 405 }; 406 #endif /* no backlight */ 407 408 /** 409 * DOC: Graphics mux 410 * 411 * :5: http://pimg-fpiw.uspto.gov/fdd/07/870/086/0.pdf 412 * :6: http://www.nxp.com/documents/data_sheet/CBTL06141.pdf 413 * :7: http://www.ti.com/lit/ds/symlink/hd3ss212.pdf 414 * :8: https://www.pericom.com/assets/Datasheets/PI3VDP12412.pdf 415 * :9: http://www.ti.com/lit/ds/symlink/sn74lv4066a.pdf 416 * :10: http://pdf.datasheetarchive.com/indexerfiles/Datasheets-SW16/DSASW00308511.pdf 417 * :11: http://www.ti.com/lit/ds/symlink/ts3ds10224.pdf 418 * 419 * On pre-retinas, the LVDS outputs of both GPUs feed into gmux which muxes 420 * either of them to the panel. One of the tricks gmux has up its sleeve is 421 * to lengthen the blanking interval of its output during a switch to 422 * synchronize it with the GPU switched to. This allows for a flicker-free 423 * switch that is imperceptible by the user ({5}[US 8,687,007 B2]). 424 * 425 * On retinas, muxing is no longer done by gmux itself, but by a separate 426 * chip which is controlled by gmux. The chip is triple sourced, it is 427 * either an {6}[NXP CBTL06142], {7}[TI HD3SS212] or {8}[Pericom PI3VDP12412]. 428 * The panel is driven with eDP instead of LVDS since the pixel clock 429 * required for retina resolution exceeds LVDS' limits. 430 * 431 * Pre-retinas are able to switch the panel's DDC pins separately. 432 * This is handled by a {9}[TI SN74LV4066A] which is controlled by gmux. 433 * The inactive GPU can thus probe the panel's EDID without switching over 434 * the entire panel. Retinas lack this functionality as the chips used for 435 * eDP muxing are incapable of switching the AUX channel separately (see 436 * the linked data sheets, Pericom would be capable but this is unused). 437 * However the retina panel has the NO_AUX_HANDSHAKE_LINK_TRAINING bit set 438 * in its DPCD, allowing the inactive GPU to skip the AUX handshake and 439 * set up the output with link parameters pre-calibrated by the active GPU. 440 * 441 * The external DP port is only fully switchable on the first two unibody 442 * MacBook Pro generations, MBP5 2008/09 and MBP6 2010. This is done by an 443 * {6}[NXP CBTL06141] which is controlled by gmux. It's the predecessor of the 444 * eDP mux on retinas, the difference being support for 2.7 versus 5.4 Gbit/s. 445 * 446 * The following MacBook Pro generations replaced the external DP port with a 447 * combined DP/Thunderbolt port and lost the ability to switch it between GPUs, 448 * connecting it either to the discrete GPU or the Thunderbolt controller. 449 * Oddly enough, while the full port is no longer switchable, AUX and HPD 450 * are still switchable by way of an {10}[NXP CBTL03062] (on pre-retinas 451 * MBP8 2011 and MBP9 2012) or two {11}[TI TS3DS10224] (on retinas) under the 452 * control of gmux. Since the integrated GPU is missing the main link, 453 * external displays appear to it as phantoms which fail to link-train. 454 * 455 * gmux receives the HPD signal of all display connectors and sends an 456 * interrupt on hotplug. On generations which cannot switch external ports, 457 * the discrete GPU can then be woken to drive the newly connected display. 458 * The ability to switch AUX on these generations could be used to improve 459 * reliability of hotplug detection by having the integrated GPU poll the 460 * ports while the discrete GPU is asleep, but currently we do not make use 461 * of this feature. 462 * 463 * gmux' initial switch state on bootup is user configurable via the EFI 464 * variable `gpu-power-prefs-fa4ce28d-b62f-4c99-9cc3-6815686e30f9` (5th byte, 465 * 1 = IGD, 0 = DIS). Based on this setting, the EFI firmware tells gmux to 466 * switch the panel and the external DP connector and allocates a framebuffer 467 * for the selected GPU. 468 */ 469 470 static void 471 gmux_read_switch_state(struct apple_gmux_softc *sc) 472 { 473 if (gmux_read8(sc, GMUX_PORT_SWITCH_DDC) == 1) 474 sc->switch_state_ddc = VGA_SWITCHEROO_IGD; 475 else 476 sc->switch_state_ddc = VGA_SWITCHEROO_DIS; 477 478 if (gmux_read8(sc, GMUX_PORT_SWITCH_DISPLAY) == 2) 479 sc->switch_state_display = VGA_SWITCHEROO_IGD; 480 else 481 sc->switch_state_display = VGA_SWITCHEROO_DIS; 482 483 if (gmux_read8(sc, GMUX_PORT_SWITCH_EXTERNAL) == 2) 484 sc->switch_state_external = VGA_SWITCHEROO_IGD; 485 else 486 sc->switch_state_external = VGA_SWITCHEROO_DIS; 487 } 488 489 static void 490 gmux_write_switch_state(struct apple_gmux_softc *sc) 491 { 492 if (sc->switch_state_ddc == VGA_SWITCHEROO_IGD) 493 gmux_write8(sc, GMUX_PORT_SWITCH_DDC, 1); 494 else 495 gmux_write8(sc, GMUX_PORT_SWITCH_DDC, 2); 496 497 if (sc->switch_state_display == VGA_SWITCHEROO_IGD) 498 gmux_write8(sc, GMUX_PORT_SWITCH_DISPLAY, 2); 499 else 500 gmux_write8(sc, GMUX_PORT_SWITCH_DISPLAY, 3); 501 502 if (sc->switch_state_external == VGA_SWITCHEROO_IGD) 503 gmux_write8(sc, GMUX_PORT_SWITCH_EXTERNAL, 2); 504 else 505 gmux_write8(sc, GMUX_PORT_SWITCH_EXTERNAL, 3); 506 } 507 508 static int 509 gmux_switchto(enum vga_switcheroo_client_id id) 510 { 511 apple_gmux_softc_data->switch_state_ddc = id; 512 apple_gmux_softc_data->switch_state_display = id; 513 apple_gmux_softc_data->switch_state_external = id; 514 515 gmux_write_switch_state(apple_gmux_softc_data); 516 517 return 0; 518 } 519 520 static int 521 gmux_switch_ddc(enum vga_switcheroo_client_id id) 522 { 523 enum vga_switcheroo_client_id old_ddc_owner = 524 apple_gmux_softc_data->switch_state_ddc; 525 526 if (id == old_ddc_owner) 527 return id; 528 529 pr_debug("Switching DDC from %d to %d\n", old_ddc_owner, id); 530 apple_gmux_softc_data->switch_state_ddc = id; 531 532 if (id == VGA_SWITCHEROO_IGD) 533 gmux_write8(apple_gmux_softc_data, GMUX_PORT_SWITCH_DDC, 1); 534 else 535 gmux_write8(apple_gmux_softc_data, GMUX_PORT_SWITCH_DDC, 2); 536 537 return old_ddc_owner; 538 } 539 540 /** 541 * DOC: Power control 542 * 543 * gmux is able to cut power to the discrete GPU. It automatically takes care 544 * of the correct sequence to tear down and bring up the power rails for 545 * core voltage, VRAM and PCIe. 546 */ 547 548 static int 549 gmux_set_discrete_state(struct apple_gmux_softc *sc, 550 enum vga_switcheroo_state state) 551 { 552 reinit_completion(&sc->powerchange_done); 553 554 if (state == VGA_SWITCHEROO_ON) { 555 gmux_write8(sc, GMUX_PORT_DISCRETE_POWER, 1); 556 gmux_write8(sc, GMUX_PORT_DISCRETE_POWER, 3); 557 pr_debug("Discrete card powered up\n"); 558 } else { 559 gmux_write8(sc, GMUX_PORT_DISCRETE_POWER, 1); 560 gmux_write8(sc, GMUX_PORT_DISCRETE_POWER, 0); 561 pr_debug("Discrete card powered down\n"); 562 } 563 564 sc->power_state = state; 565 566 if (sc->gpe >= 0 && 567 !wait_for_completion_interruptible_timeout(&sc->powerchange_done, 568 msecs_to_jiffies(200))) 569 pr_warn("Timeout waiting for gmux switch to complete\n"); 570 571 return 0; 572 } 573 574 static int 575 gmux_set_power_state(enum vga_switcheroo_client_id id, 576 enum vga_switcheroo_state state) 577 { 578 if (id == VGA_SWITCHEROO_IGD) 579 return 0; 580 581 return gmux_set_discrete_state(apple_gmux_softc_data, state); 582 } 583 584 static int 585 gmux_get_client_id(struct pci_dev *pdev) 586 { 587 /* 588 * Early Macbook Pros with switchable graphics use nvidia 589 * integrated graphics. Hardcode that the 9400M is integrated. 590 */ 591 if (pdev->vendor == PCI_VENDOR_ID_INTEL) 592 return VGA_SWITCHEROO_IGD; 593 else if (pdev->vendor == PCI_VENDOR_ID_NVIDIA && 594 pdev->device == 0x0863) 595 return VGA_SWITCHEROO_IGD; 596 else 597 return VGA_SWITCHEROO_DIS; 598 } 599 600 static const struct vga_switcheroo_handler gmux_handler_indexed = { 601 .switchto = gmux_switchto, 602 .power_state = gmux_set_power_state, 603 .get_client_id = gmux_get_client_id, 604 }; 605 606 static const struct vga_switcheroo_handler gmux_handler_classic = { 607 .switchto = gmux_switchto, 608 .switch_ddc = gmux_switch_ddc, 609 .power_state = gmux_set_power_state, 610 .get_client_id = gmux_get_client_id, 611 }; 612 613 /** 614 * DOC: Interrupt 615 * 616 * gmux is also connected to a GPIO pin of the southbridge and thereby is able 617 * to trigger an ACPI GPE. On the MBP5 2008/09 it's GPIO pin 22 of the Nvidia 618 * MCP79, on all following generations it's GPIO pin 6 of the Intel PCH. 619 * The GPE merely signals that an interrupt occurred, the actual type of event 620 * is identified by reading a gmux register. 621 */ 622 623 static inline void 624 gmux_disable_interrupts(struct apple_gmux_softc *sc) 625 { 626 gmux_write8(sc, GMUX_PORT_INTERRUPT_ENABLE, GMUX_INTERRUPT_DISABLE); 627 } 628 629 static inline void 630 gmux_enable_interrupts(struct apple_gmux_softc *sc) 631 { 632 gmux_write8(sc, GMUX_PORT_INTERRUPT_ENABLE, GMUX_INTERRUPT_ENABLE); 633 } 634 635 static inline u8 636 gmux_interrupt_get_status(struct apple_gmux_softc *sc) 637 { 638 return gmux_read8(sc, GMUX_PORT_INTERRUPT_STATUS); 639 } 640 641 static void 642 gmux_clear_interrupts(struct apple_gmux_softc *sc) 643 { 644 u8 status; 645 646 /* to clear interrupts write back current status */ 647 status = gmux_interrupt_get_status(sc); 648 gmux_write8(sc, GMUX_PORT_INTERRUPT_STATUS, status); 649 } 650 651 static void 652 gmux_notify_handler(ACPI_HANDLE device, UINT32 value, void *context) 653 { 654 u8 status; 655 device_t dev = context; 656 struct apple_gmux_softc *sc = device_get_softc(dev); 657 658 status = gmux_interrupt_get_status(sc); 659 gmux_disable_interrupts(sc); 660 pr_debug("Notify handler called: status %d\n", status); 661 662 gmux_clear_interrupts(sc); 663 gmux_enable_interrupts(sc); 664 665 if (status & GMUX_INTERRUPT_STATUS_POWER) 666 complete(&sc->powerchange_done); 667 } 668 669 static int 670 apple_gmux_suspend(device_t dev) 671 { 672 /* XXX: TODO */ 673 674 return 0; 675 } 676 677 static int 678 apple_gmux_resume(device_t dev) 679 { 680 /* XXX: TODO */ 681 682 return 0; 683 } 684 685 device_t 686 gmux_get_io_pdev(void) 687 { 688 device_t pch = NULL; 689 struct pci_devinfo *di = NULL; 690 691 while ((pch = pci_iterate_class(&di, PCIC_DISPLAY, PCIS_DISPLAY_VGA))) { 692 u16 cmd; 693 694 cmd = (u16)pci_read_config(pch, PCIR_COMMAND, 2); 695 if (!(cmd & PCIM_CMD_PORTEN)) 696 continue; 697 698 return(pch); 699 } 700 701 return(NULL); 702 } 703 704 static int 705 apple_gmux_probe(device_t dev) 706 { 707 device_t bus; 708 static char *gmux_ids[] = { GMUX_ACPI_HID, NULL }; 709 710 bus = device_get_parent(dev); 711 712 if (ACPI_ID_PROBE(bus, dev, gmux_ids) == NULL) 713 return(ENXIO); 714 715 device_set_desc(dev, "apple gmux controller"); 716 717 return(BUS_PROBE_DEFAULT); 718 } 719 720 static int 721 apple_gmux_attach(device_t dev) 722 { 723 struct apple_gmux_softc *sc; 724 int unit; 725 uint8_t ver_major, ver_minor, ver_release; 726 int ret = -ENXIO; 727 ACPI_STATUS status; 728 UINT32 gpe; 729 device_t pch_dev = NULL; 730 731 sc = device_get_softc(dev); 732 unit = device_get_unit(dev); 733 734 sc->gmux_dev = dev; 735 sc->unit = unit; 736 737 sc->io_rid = 0; 738 sc->io_res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &sc->io_rid, 739 RF_ACTIVE); 740 741 if (sc->io_res == NULL) { 742 pr_err("Failed to find gmux I/O resource\n"); 743 return(ENXIO); 744 } 745 746 /* 747 * Explicitly initialize sc->indexed, to be clear we assume 748 * gmux is classic by default. 749 */ 750 sc->indexed = false; 751 752 /* 753 * Invalid version information may indicate either that the gmux 754 * device isn't present or that it's a new one that uses indexed 755 * io 756 */ 757 758 ver_major = gmux_read8(sc, GMUX_PORT_VERSION_MAJOR); 759 ver_minor = gmux_read8(sc, GMUX_PORT_VERSION_MINOR); 760 ver_release = gmux_read8(sc, GMUX_PORT_VERSION_RELEASE); 761 if (ver_major == 0xff && ver_minor == 0xff && ver_release == 0xff) { 762 if (gmux_is_indexed(sc)) { 763 u32 version; 764 lockinit(&sc->lk, "apple_gmux", 0, 0); 765 sc->indexed = true; 766 version = gmux_read32(sc, GMUX_PORT_VERSION_MAJOR); 767 ver_major = (version >> 24) & 0xff; 768 ver_minor = (version >> 16) & 0xff; 769 ver_release = (version >> 8) & 0xff; 770 } else { 771 pr_info("gmux device not present or IO disabled\n"); 772 ret = -ENODEV; 773 goto err_release; 774 } 775 } 776 pr_info("Found gmux version %d.%d.%d [%s]\n", ver_major, ver_minor, 777 ver_release, (sc->indexed ? "indexed" : "classic")); 778 779 /* 780 * Apple systems with gmux are EFI based and normally don't use 781 * VGA. In addition changing IO+MEM ownership between IGP and dGPU 782 * disables IO/MEM used for backlight control on some systems. 783 * Lock IO+MEM to GPU with active IO to prevent switch. 784 */ 785 pch_dev = gmux_get_io_pdev(); 786 if (pch_dev == NULL) { 787 ret = -ENODEV; 788 pr_err("Cannot find PCI device\n"); 789 goto err_release; 790 } 791 drm_init_pdev(pch_dev, &sc->pdev); 792 793 #if 0 /* no backlight infrastructure */ 794 memset(&props, 0, sizeof(props)); 795 props.type = BACKLIGHT_PLATFORM; 796 props.max_brightness = gmux_read32(gmux_data, GMUX_PORT_MAX_BRIGHTNESS); 797 798 /* 799 * Currently it's assumed that the maximum brightness is less than 800 * 2^24 for compatibility with old gmux versions. Cap the max 801 * brightness at this value, but print a warning if the hardware 802 * reports something higher so that it can be fixed. 803 */ 804 if (WARN_ON(props.max_brightness > GMUX_MAX_BRIGHTNESS)) 805 props.max_brightness = GMUX_MAX_BRIGHTNESS; 806 807 bdev = backlight_device_register("gmux_backlight", &pnp->dev, 808 gmux_data, &gmux_bl_ops, &props); 809 if (IS_ERR(bdev)) { 810 ret = PTR_ERR(bdev); 811 goto err_release; 812 } 813 814 gmux_data->bdev = bdev; 815 bdev->props.brightness = gmux_get_brightness(bdev); 816 backlight_update_status(bdev); 817 818 /* 819 * The backlight situation on Macs is complicated. If the gmux is 820 * present it's the best choice, because it always works for 821 * backlight control and supports more levels than other options. 822 * Disable the other backlight choices. 823 */ 824 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 825 apple_bl_unregister(); 826 #endif /* no backlight infrastructure */ 827 828 sc->power_state = VGA_SWITCHEROO_ON; 829 830 sc->dhandle = acpi_get_handle(dev); 831 if (!sc->dhandle) { 832 pr_err("Cannot find acpi handle for pnp device %s\n", 833 device_get_name(dev)); 834 ret = -ENODEV; 835 goto err_notify; 836 } 837 838 status = acpi_GetInteger(sc->dhandle, "GMGP", &gpe); 839 if (ACPI_SUCCESS(status)) { 840 sc->gpe = (int)gpe; 841 842 status = AcpiInstallNotifyHandler(sc->dhandle, 843 ACPI_DEVICE_NOTIFY, 844 gmux_notify_handler, dev); 845 846 if (ACPI_FAILURE(status)) { 847 pr_err("AcpiInstallNotifyHandler failed: %s\n", 848 AcpiFormatException(status)); 849 ret = -ENODEV; 850 goto err_notify; 851 } 852 853 status = AcpiEnableGpe(NULL, sc->gpe); 854 if (ACPI_FAILURE(status)) { 855 pr_err("AcpiEnableGpe failed: %s\n", 856 AcpiFormatException(status)); 857 goto err_enable_gpe; 858 } 859 } else { 860 pr_warn("No GPE found for gmux\n"); 861 sc->gpe = -1; 862 } 863 864 apple_gmux_softc_data = sc; 865 init_completion(&sc->powerchange_done); 866 gmux_enable_interrupts(sc); 867 gmux_read_switch_state(sc); 868 869 /* 870 * Retina MacBook Pros cannot switch the panel's AUX separately 871 * and need eDP pre-calibration. They are distinguishable from 872 * pre-retinas by having an "indexed" gmux. 873 * 874 * Pre-retina MacBook Pros can switch the panel's DDC separately. 875 */ 876 if (sc->indexed) 877 ret = vga_switcheroo_register_handler(&gmux_handler_indexed, 878 VGA_SWITCHEROO_NEEDS_EDP_CONFIG); 879 else 880 ret = vga_switcheroo_register_handler(&gmux_handler_classic, 881 VGA_SWITCHEROO_CAN_SWITCH_DDC); 882 if (ret) { 883 pr_err("Failed to register vga_switcheroo handler\n"); 884 goto err_register_handler; 885 } 886 887 return 0; 888 889 err_register_handler: 890 gmux_disable_interrupts(sc); 891 apple_gmux_softc_data = NULL; 892 if (sc->gpe >= 0) 893 AcpiDisableGpe(NULL, sc->gpe); 894 err_enable_gpe: 895 if (sc->gpe >= 0) 896 AcpiRemoveNotifyHandler(sc->dhandle, ACPI_DEVICE_NOTIFY, 897 gmux_notify_handler); 898 err_notify: 899 /* backlight_device_unregister(bdev); */ 900 err_release: 901 drm_fini_pdev(&sc->pdev); 902 bus_release_resource(dev, SYS_RES_IOPORT, sc->io_rid, sc->io_res); 903 904 return(ret); 905 } 906 907 static int 908 apple_gmux_detach(device_t dev) 909 { 910 struct apple_gmux_softc *sc = device_get_softc(dev); 911 912 vga_switcheroo_unregister_handler(); 913 gmux_disable_interrupts(sc); 914 if (sc->gpe >= 0) { 915 AcpiDisableGpe(NULL, sc->gpe); 916 AcpiRemoveNotifyHandler(sc->dhandle, ACPI_DEVICE_NOTIFY, 917 gmux_notify_handler); 918 } 919 920 apple_gmux_softc_data = NULL; 921 drm_fini_pdev(&sc->pdev); 922 return(bus_release_resource(dev, SYS_RES_IOPORT, 923 sc->io_rid, sc->io_res)); 924 } 925 926 static device_method_t apple_gmux_methods[] = { 927 DEVMETHOD(device_probe, apple_gmux_probe), 928 DEVMETHOD(device_attach, apple_gmux_attach), 929 DEVMETHOD(device_detach, apple_gmux_detach), 930 DEVMETHOD(device_resume, apple_gmux_resume), 931 DEVMETHOD(device_suspend, apple_gmux_suspend), 932 933 DEVMETHOD_END 934 }; 935 936 devclass_t gmux_devclass; 937 938 static driver_t apple_gmux_driver = { 939 "apple_gmux", 940 apple_gmux_methods, 941 sizeof(struct apple_gmux_softc) 942 }; 943 944 DRIVER_MODULE(gmux, acpi, apple_gmux_driver, gmux_devclass, 0, 0); 945 MODULE_VERSION(apple_gmux, 1); 946 MODULE_DEPEND(apple_gmux, drm, 1, 1, 2); 947 MODULE_DEPEND(apple_gmux, vga_switcheroo, 1, 1, 2); 948