drivers/platform/x86/apple-gmux.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  Gmux driver for Apple laptops
   4  *
   5  *  Copyright (C) Canonical Ltd. <[email protected]>
   6  *  Copyright (C) 2010-2012 Andreas Heider <[email protected]>
   7  *  Copyright (C) 2015 Lukas Wunner <[email protected]>
   8  *  Copyright (C) 2023 Orlando Chamberlain <[email protected]>
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/backlight.h>
  17 #include <linux/acpi.h>
  18 #include <linux/pnp.h>
  19 #include <linux/apple-gmux.h>
  20 #include <linux/slab.h>
  21 #include <linux/delay.h>
  22 #include <linux/pci.h>
  23 #include <linux/vga_switcheroo.h>
  24 #include <linux/debugfs.h>
  25 #include <acpi/video.h>
  26 #include <asm/io.h>
  27
  28 /**
  29  * DOC: Overview
  30  *
  31  * gmux is a microcontroller built into the MacBook Pro to support dual GPUs:
  32  * A `Lattice XP2`_ on pre-retinas, a `Renesas R4F2113`_ on pre-T2 retinas.
  33  *
  34  * On T2 Macbooks, the gmux is part of the T2 Coprocessor's SMC. The SMC has
  35  * an I2C connection to a `NXP PCAL6524` GPIO expander, which enables/disables
  36  * the voltage regulators of the discrete GPU, drives the display panel power,
  37  * and has a GPIO to switch the eDP mux. The Intel CPU can interact with
  38  * gmux through MMIO, similar to how the main SMC interface is controlled.
  39  *
  40  * (The MacPro6,1 2013 also has a gmux, however it is unclear why since it has
  41  * dual GPUs but no built-in display.)
  42  *
  43  * gmux is connected to the LPC bus of the southbridge. Its I/O ports are
  44  * accessed differently depending on the microcontroller: Driver functions
  45  * to access a pre-retina gmux are infixed ``_pio_``, those for a pre-T2
  46  * retina gmux are infixed ``_index_``, and those on T2 Macs are infixed
  47  * with ``_mmio_``.
  48  *
  49  * .. _Lattice XP2:
  50  *     http://www.latticesemi.com/en/Products/FPGAandCPLD/LatticeXP2.aspx
  51  * .. _Renesas R4F2113:
  52  *     http://www.renesas.com/products/mpumcu/h8s/h8s2100/h8s2113/index.jsp
  53  * .. _NXP PCAL6524:
  54  *     https://www.nxp.com/docs/en/data-sheet/PCAL6524.pdf
  55  */
  56
  57 struct apple_gmux_config;
  58
  59 struct apple_gmux_data {
  60         u8 __iomem *iomem_base;
  61         unsigned long iostart;
  62         unsigned long iolen;
  63         const struct apple_gmux_config *config;
  64         struct mutex index_lock;
  65
  66         struct backlight_device *bdev;
  67
  68         /* switcheroo data */
  69         acpi_handle dhandle;
  70         int gpe;
  71         bool external_switchable;
  72         enum vga_switcheroo_client_id switch_state_display;
  73         enum vga_switcheroo_client_id switch_state_ddc;
  74         enum vga_switcheroo_client_id switch_state_external;
  75         enum vga_switcheroo_state power_state;
  76         struct completion powerchange_done;
  77
  78         /* debugfs data */
  79         u8 selected_port;
  80         struct dentry *debug_dentry;
  81 };
  82
  83 static struct apple_gmux_data *apple_gmux_data;
  84
  85 struct apple_gmux_config {
  86         u8 (*read8)(struct apple_gmux_data *gmux_data, int port);
  87         void (*write8)(struct apple_gmux_data *gmux_data, int port, u8 val);
  88         u32 (*read32)(struct apple_gmux_data *gmux_data, int port);
  89         void (*write32)(struct apple_gmux_data *gmux_data, int port, u32 val);
  90         const struct vga_switcheroo_handler *gmux_handler;
  91         enum vga_switcheroo_handler_flags_t handler_flags;
  92         unsigned long resource_type;
  93         bool read_version_as_u32;
  94         char *name;
  95 };
  96
  97 #define GMUX_INTERRUPT_ENABLE           0xff
  98 #define GMUX_INTERRUPT_DISABLE          0x00
  99
 100 #define GMUX_INTERRUPT_STATUS_ACTIVE    0
 101 #define GMUX_INTERRUPT_STATUS_DISPLAY   (1 << 0)
 102 #define GMUX_INTERRUPT_STATUS_POWER     (1 << 2)
 103 #define GMUX_INTERRUPT_STATUS_HOTPLUG   (1 << 3)
 104
 105 #define GMUX_BRIGHTNESS_MASK            0x00ffffff
 106 #define GMUX_MAX_BRIGHTNESS             GMUX_BRIGHTNESS_MASK
 107
 108 # define MMIO_GMUX_MAX_BRIGHTNESS       0xffff
 109
 110 static u8 gmux_pio_read8(struct apple_gmux_data *gmux_data, int port)
 111 {
 112         return inb(gmux_data->iostart + port);
 113 }
 114
 115 static void gmux_pio_write8(struct apple_gmux_data *gmux_data, int port,
 116                                u8 val)
 117 {
 118         outb(val, gmux_data->iostart + port);
 119 }
 120
 121 static u32 gmux_pio_read32(struct apple_gmux_data *gmux_data, int port)
 122 {
 123         return inl(gmux_data->iostart + port);
 124 }
 125
 126 static void gmux_pio_write32(struct apple_gmux_data *gmux_data, int port,
 127                              u32 val)
 128 {
 129         int i;
 130         u8 tmpval;
 131
 132         for (i = 0; i < 4; i++) {
 133                 tmpval = (val >> (i * 8)) & 0xff;
 134                 outb(tmpval, gmux_data->iostart + port + i);
 135         }
 136 }
 137
 138 static int gmux_index_wait_ready(struct apple_gmux_data *gmux_data)
 139 {
 140         int i = 200;
 141         u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
 142
 143         while (i && (gwr & 0x01)) {
 144                 inb(gmux_data->iostart + GMUX_PORT_READ);
 145                 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
 146                 udelay(100);
 147                 i--;
 148         }
 149
 150         return !!i;
 151 }
 152
 153 static int gmux_index_wait_complete(struct apple_gmux_data *gmux_data)
 154 {
 155         int i = 200;
 156         u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
 157
 158         while (i && !(gwr & 0x01)) {
 159                 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE);
 160                 udelay(100);
 161                 i--;
 162         }
 163
 164         if (gwr & 0x01)
 165                 inb(gmux_data->iostart + GMUX_PORT_READ);
 166
 167         return !!i;
 168 }
 169
 170 static u8 gmux_index_read8(struct apple_gmux_data *gmux_data, int port)
 171 {
 172         u8 val;
 173
 174         mutex_lock(&gmux_data->index_lock);
 175         gmux_index_wait_ready(gmux_data);
 176         outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ);
 177         gmux_index_wait_complete(gmux_data);
 178         val = inb(gmux_data->iostart + GMUX_PORT_VALUE);
 179         mutex_unlock(&gmux_data->index_lock);
 180
 181         return val;
 182 }
 183
 184 static void gmux_index_write8(struct apple_gmux_data *gmux_data, int port,
 185                               u8 val)
 186 {
 187         mutex_lock(&gmux_data->index_lock);
 188         outb(val, gmux_data->iostart + GMUX_PORT_VALUE);
 189         gmux_index_wait_ready(gmux_data);
 190         outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE);
 191         gmux_index_wait_complete(gmux_data);
 192         mutex_unlock(&gmux_data->index_lock);
 193 }
 194
 195 static u32 gmux_index_read32(struct apple_gmux_data *gmux_data, int port)
 196 {
 197         u32 val;
 198
 199         mutex_lock(&gmux_data->index_lock);
 200         gmux_index_wait_ready(gmux_data);
 201         outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ);
 202         gmux_index_wait_complete(gmux_data);
 203         val = inl(gmux_data->iostart + GMUX_PORT_VALUE);
 204         mutex_unlock(&gmux_data->index_lock);
 205
 206         return val;
 207 }
 208
 209 static void gmux_index_write32(struct apple_gmux_data *gmux_data, int port,
 210                                u32 val)
 211 {
 212         int i;
 213         u8 tmpval;
 214
 215         mutex_lock(&gmux_data->index_lock);
 216
 217         for (i = 0; i < 4; i++) {
 218                 tmpval = (val >> (i * 8)) & 0xff;
 219                 outb(tmpval, gmux_data->iostart + GMUX_PORT_VALUE + i);
 220         }
 221
 222         gmux_index_wait_ready(gmux_data);
 223         outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE);
 224         gmux_index_wait_complete(gmux_data);
 225         mutex_unlock(&gmux_data->index_lock);
 226 }
 227
 228 static int gmux_mmio_wait(struct apple_gmux_data *gmux_data)
 229 {
 230         int i = 200;
 231         u8 gwr = ioread8(gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);
 232
 233         while (i && gwr) {
 234                 gwr = ioread8(gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);
 235                 udelay(100);
 236                 i--;
 237         }
 238
 239         return !!i;
 240 }
 241
 242 static u8 gmux_mmio_read8(struct apple_gmux_data *gmux_data, int port)
 243 {
 244         u8 val;
 245
 246         mutex_lock(&gmux_data->index_lock);
 247         gmux_mmio_wait(gmux_data);
 248         iowrite8((port & 0xff), gmux_data->iomem_base + GMUX_MMIO_PORT_SELECT);
 249         iowrite8(GMUX_MMIO_READ | sizeof(val),
 250                 gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);
 251         gmux_mmio_wait(gmux_data);
 252         val = ioread8(gmux_data->iomem_base);
 253         mutex_unlock(&gmux_data->index_lock);
 254
 255         return val;
 256 }
 257
 258 static void gmux_mmio_write8(struct apple_gmux_data *gmux_data, int port,
 259                               u8 val)
 260 {
 261         mutex_lock(&gmux_data->index_lock);
 262         gmux_mmio_wait(gmux_data);
 263         iowrite8(val, gmux_data->iomem_base);
 264
 265         iowrite8(port & 0xff, gmux_data->iomem_base + GMUX_MMIO_PORT_SELECT);
 266         iowrite8(GMUX_MMIO_WRITE | sizeof(val),
 267                 gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);
 268
 269         gmux_mmio_wait(gmux_data);
 270         mutex_unlock(&gmux_data->index_lock);
 271 }
 272
 273 static u32 gmux_mmio_read32(struct apple_gmux_data *gmux_data, int port)
 274 {
 275         u32 val;
 276
 277         mutex_lock(&gmux_data->index_lock);
 278         gmux_mmio_wait(gmux_data);
 279         iowrite8((port & 0xff), gmux_data->iomem_base + GMUX_MMIO_PORT_SELECT);
 280         iowrite8(GMUX_MMIO_READ | sizeof(val),
 281                 gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);
 282         gmux_mmio_wait(gmux_data);
 283         val = ioread32be(gmux_data->iomem_base);
 284         mutex_unlock(&gmux_data->index_lock);
 285
 286         return val;
 287 }
 288
 289 static void gmux_mmio_write32(struct apple_gmux_data *gmux_data, int port,
 290                                u32 val)
 291 {
 292         mutex_lock(&gmux_data->index_lock);
 293         iowrite32be(val, gmux_data->iomem_base);
 294         iowrite8(port & 0xff, gmux_data->iomem_base + GMUX_MMIO_PORT_SELECT);
 295         iowrite8(GMUX_MMIO_WRITE | sizeof(val),
 296                 gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);
 297         gmux_mmio_wait(gmux_data);
 298         mutex_unlock(&gmux_data->index_lock);
 299 }
 300
 301 static u8 gmux_read8(struct apple_gmux_data *gmux_data, int port)
 302 {
 303         return gmux_data->config->read8(gmux_data, port);
 304 }
 305
 306 static void gmux_write8(struct apple_gmux_data *gmux_data, int port, u8 val)
 307 {
 308         return gmux_data->config->write8(gmux_data, port, val);
 309 }
 310
 311 static u32 gmux_read32(struct apple_gmux_data *gmux_data, int port)
 312 {
 313         return gmux_data->config->read32(gmux_data, port);
 314 }
 315
 316 static void gmux_write32(struct apple_gmux_data *gmux_data, int port,
 317                              u32 val)
 318 {
 319         return gmux_data->config->write32(gmux_data, port, val);
 320 }
 321
 322 /**
 323  * DOC: Backlight control
 324  *
 325  * On single GPU MacBooks, the PWM signal for the backlight is generated by
 326  * the GPU. On dual GPU MacBook Pros by contrast, either GPU may be suspended
 327  * to conserve energy. Hence the PWM signal needs to be generated by a separate
 328  * backlight driver which is controlled by gmux. The earliest generation
 329  * MBP5 2008/09 uses a `TI LP8543`_ backlight driver. Newer models
 330  * use a `TI LP8545`_ or a TI LP8548.
 331  *
 332  * .. _TI LP8543: https://www.ti.com/lit/ds/symlink/lp8543.pdf
 333  * .. _TI LP8545: https://www.ti.com/lit/ds/symlink/lp8545.pdf
 334  */
 335
 336 static int gmux_get_brightness(struct backlight_device *bd)
 337 {
 338         struct apple_gmux_data *gmux_data = bl_get_data(bd);
 339         return gmux_read32(gmux_data, GMUX_PORT_BRIGHTNESS) &
 340                GMUX_BRIGHTNESS_MASK;
 341 }
 342
 343 static int gmux_update_status(struct backlight_device *bd)
 344 {
 345         struct apple_gmux_data *gmux_data = bl_get_data(bd);
 346         u32 brightness = backlight_get_brightness(bd);
 347
 348         gmux_write32(gmux_data, GMUX_PORT_BRIGHTNESS, brightness);
 349
 350         return 0;
 351 }
 352
 353 static const struct backlight_ops gmux_bl_ops = {
 354         .options = BL_CORE_SUSPENDRESUME,
 355         .get_brightness = gmux_get_brightness,
 356         .update_status = gmux_update_status,
 357 };
 358
 359 /**
 360  * DOC: Graphics mux
 361  *
 362  * On pre-retinas, the LVDS outputs of both GPUs feed into gmux which muxes
 363  * either of them to the panel. One of the tricks gmux has up its sleeve is
 364  * to lengthen the blanking interval of its output during a switch to
 365  * synchronize it with the GPU switched to. This allows for a flicker-free
 366  * switch that is imperceptible by the user (`US 8,687,007 B2`_).
 367  *
 368  * On retinas, muxing is no longer done by gmux itself, but by a separate
 369  * chip which is controlled by gmux. The chip is triple sourced, it is
 370  * either an `NXP CBTL06142`_, `TI HD3SS212`_ or `Pericom PI3VDP12412`_.
 371  * The panel is driven with eDP instead of LVDS since the pixel clock
 372  * required for retina resolution exceeds LVDS' limits.
 373  *
 374  * Pre-retinas are able to switch the panel's DDC pins separately.
 375  * This is handled by a `TI SN74LV4066A`_ which is controlled by gmux.
 376  * The inactive GPU can thus probe the panel's EDID without switching over
 377  * the entire panel. Retinas lack this functionality as the chips used for
 378  * eDP muxing are incapable of switching the AUX channel separately (see
 379  * the linked data sheets, Pericom would be capable but this is unused).
 380  * However the retina panel has the NO_AUX_HANDSHAKE_LINK_TRAINING bit set
 381  * in its DPCD, allowing the inactive GPU to skip the AUX handshake and
 382  * set up the output with link parameters pre-calibrated by the active GPU.
 383  *
 384  * The external DP port is only fully switchable on the first two unibody
 385  * MacBook Pro generations, MBP5 2008/09 and MBP6 2010. This is done by an
 386  * `NXP CBTL06141`_ which is controlled by gmux. It's the predecessor of the
 387  * eDP mux on retinas, the difference being support for 2.7 versus 5.4 Gbit/s.
 388  *
 389  * The following MacBook Pro generations replaced the external DP port with a
 390  * combined DP/Thunderbolt port and lost the ability to switch it between GPUs,
 391  * connecting it either to the discrete GPU or the Thunderbolt controller.
 392  * Oddly enough, while the full port is no longer switchable, AUX and HPD
 393  * are still switchable by way of an `NXP CBTL03062`_ (on pre-retinas
 394  * MBP8 2011 and MBP9 2012) or two `TI TS3DS10224`_ (on pre-t2 retinas) under
 395  * the control of gmux. Since the integrated GPU is missing the main link,
 396  * external displays appear to it as phantoms which fail to link-train.
 397  *
 398  * gmux receives the HPD signal of all display connectors and sends an
 399  * interrupt on hotplug. On generations which cannot switch external ports,
 400  * the discrete GPU can then be woken to drive the newly connected display.
 401  * The ability to switch AUX on these generations could be used to improve
 402  * reliability of hotplug detection by having the integrated GPU poll the
 403  * ports while the discrete GPU is asleep, but currently we do not make use
 404  * of this feature.
 405  *
 406  * Our switching policy for the external port is that on those generations
 407  * which are able to switch it fully, the port is switched together with the
 408  * panel when IGD / DIS commands are issued to vga_switcheroo. It is thus
 409  * possible to drive e.g. a beamer on battery power with the integrated GPU.
 410  * The user may manually switch to the discrete GPU if more performance is
 411  * needed.
 412  *
 413  * On all newer generations, the external port can only be driven by the
 414  * discrete GPU. If a display is plugged in while the panel is switched to
 415  * the integrated GPU, *both* GPUs will be in use for maximum performance.
 416  * To decrease power consumption, the user may manually switch to the
 417  * discrete GPU, thereby suspending the integrated GPU.
 418  *
 419  * gmux' initial switch state on bootup is user configurable via the EFI
 420  * variable ``gpu-power-prefs-fa4ce28d-b62f-4c99-9cc3-6815686e30f9`` (5th byte,
 421  * 1 = IGD, 0 = DIS). Based on this setting, the EFI firmware tells gmux to
 422  * switch the panel and the external DP connector and allocates a framebuffer
 423  * for the selected GPU.
 424  *
 425  * .. _US 8,687,007 B2: https://pimg-fpiw.uspto.gov/fdd/07/870/086/0.pdf
 426  * .. _NXP CBTL06141:   https://www.nxp.com/documents/data_sheet/CBTL06141.pdf
 427  * .. _NXP CBTL06142:   https://www.nxp.com/documents/data_sheet/CBTL06141.pdf
 428  * .. _TI HD3SS212:     https://www.ti.com/lit/ds/symlink/hd3ss212.pdf
 429  * .. _Pericom PI3VDP12412: https://www.pericom.com/assets/Datasheets/PI3VDP12412.pdf
 430  * .. _TI SN74LV4066A:  https://www.ti.com/lit/ds/symlink/sn74lv4066a.pdf
 431  * .. _NXP CBTL03062:   http://pdf.datasheetarchive.com/indexerfiles/Datasheets-SW16/DSASW00308511.pdf
 432  * .. _TI TS3DS10224:   https://www.ti.com/lit/ds/symlink/ts3ds10224.pdf
 433  */
 434
 435 static void gmux_read_switch_state(struct apple_gmux_data *gmux_data)
 436 {
 437         if (gmux_read8(gmux_data, GMUX_PORT_SWITCH_DDC) == 1)
 438                 gmux_data->switch_state_ddc = VGA_SWITCHEROO_IGD;
 439         else
 440                 gmux_data->switch_state_ddc = VGA_SWITCHEROO_DIS;
 441
 442         if (gmux_read8(gmux_data, GMUX_PORT_SWITCH_DISPLAY) & 1)
 443                 gmux_data->switch_state_display = VGA_SWITCHEROO_DIS;
 444         else
 445                 gmux_data->switch_state_display = VGA_SWITCHEROO_IGD;
 446
 447         if (gmux_read8(gmux_data, GMUX_PORT_SWITCH_EXTERNAL) == 2)
 448                 gmux_data->switch_state_external = VGA_SWITCHEROO_IGD;
 449         else
 450                 gmux_data->switch_state_external = VGA_SWITCHEROO_DIS;
 451 }
 452
 453 static void gmux_write_switch_state(struct apple_gmux_data *gmux_data)
 454 {
 455         if (gmux_data->switch_state_ddc == VGA_SWITCHEROO_IGD)
 456                 gmux_write8(gmux_data, GMUX_PORT_SWITCH_DDC, 1);
 457         else
 458                 gmux_write8(gmux_data, GMUX_PORT_SWITCH_DDC, 2);
 459
 460         if (gmux_data->switch_state_display == VGA_SWITCHEROO_IGD)
 461                 gmux_write8(gmux_data, GMUX_PORT_SWITCH_DISPLAY, 2);
 462         else
 463                 gmux_write8(gmux_data, GMUX_PORT_SWITCH_DISPLAY, 3);
 464
 465         if (gmux_data->switch_state_external == VGA_SWITCHEROO_IGD)
 466                 gmux_write8(gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 2);
 467         else
 468                 gmux_write8(gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 3);
 469 }
 470
 471 static int gmux_switchto(enum vga_switcheroo_client_id id)
 472 {
 473         apple_gmux_data->switch_state_ddc = id;
 474         apple_gmux_data->switch_state_display = id;
 475         if (apple_gmux_data->external_switchable)
 476                 apple_gmux_data->switch_state_external = id;
 477
 478         gmux_write_switch_state(apple_gmux_data);
 479
 480         return 0;
 481 }
 482
 483 static int gmux_switch_ddc(enum vga_switcheroo_client_id id)
 484 {
 485         enum vga_switcheroo_client_id old_ddc_owner =
 486                 apple_gmux_data->switch_state_ddc;
 487
 488         if (id == old_ddc_owner)
 489                 return id;
 490
 491         pr_debug("Switching DDC from %d to %d\n", old_ddc_owner, id);
 492         apple_gmux_data->switch_state_ddc = id;
 493
 494         if (id == VGA_SWITCHEROO_IGD)
 495                 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 1);
 496         else
 497                 gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 2);
 498
 499         return old_ddc_owner;
 500 }
 501
 502 /**
 503  * DOC: Power control
 504  *
 505  * gmux is able to cut power to the discrete GPU. It automatically takes care
 506  * of the correct sequence to tear down and bring up the power rails for
 507  * core voltage, VRAM and PCIe.
 508  */
 509
 510 static int gmux_set_discrete_state(struct apple_gmux_data *gmux_data,
 511                                    enum vga_switcheroo_state state)
 512 {
 513         reinit_completion(&gmux_data->powerchange_done);
 514
 515         if (state == VGA_SWITCHEROO_ON) {
 516                 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1);
 517                 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 3);
 518                 pr_debug("Discrete card powered up\n");
 519         } else {
 520                 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1);
 521                 gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 0);
 522                 pr_debug("Discrete card powered down\n");
 523         }
 524
 525         gmux_data->power_state = state;
 526
 527         if (gmux_data->gpe >= 0 &&
 528             !wait_for_completion_interruptible_timeout(&gmux_data->powerchange_done,
 529                                                        msecs_to_jiffies(200)))
 530                 pr_warn("Timeout waiting for gmux switch to complete\n");
 531
 532         return 0;
 533 }
 534
 535 static int gmux_set_power_state(enum vga_switcheroo_client_id id,
 536                                 enum vga_switcheroo_state state)
 537 {
 538         if (id == VGA_SWITCHEROO_IGD)
 539                 return 0;
 540
 541         return gmux_set_discrete_state(apple_gmux_data, state);
 542 }
 543
 544 static enum vga_switcheroo_client_id gmux_get_client_id(struct pci_dev *pdev)
 545 {
 546         /*
 547          * Early Macbook Pros with switchable graphics use nvidia
 548          * integrated graphics. Hardcode that the 9400M is integrated.
 549          */
 550         if (pdev->vendor == PCI_VENDOR_ID_INTEL)
 551                 return VGA_SWITCHEROO_IGD;
 552         else if (pdev->vendor == PCI_VENDOR_ID_NVIDIA &&
 553                  pdev->device == 0x0863)
 554                 return VGA_SWITCHEROO_IGD;
 555         else
 556                 return VGA_SWITCHEROO_DIS;
 557 }
 558
 559 static const struct vga_switcheroo_handler gmux_handler_no_ddc = {
 560         .switchto = gmux_switchto,
 561         .power_state = gmux_set_power_state,
 562         .get_client_id = gmux_get_client_id,
 563 };
 564
 565 static const struct vga_switcheroo_handler gmux_handler_ddc = {
 566         .switchto = gmux_switchto,
 567         .switch_ddc = gmux_switch_ddc,
 568         .power_state = gmux_set_power_state,
 569         .get_client_id = gmux_get_client_id,
 570 };
 571
 572 static const struct apple_gmux_config apple_gmux_pio = {
 573         .read8 = &gmux_pio_read8,
 574         .write8 = &gmux_pio_write8,
 575         .read32 = &gmux_pio_read32,
 576         .write32 = &gmux_pio_write32,
 577         .gmux_handler = &gmux_handler_ddc,
 578         .handler_flags = VGA_SWITCHEROO_CAN_SWITCH_DDC,
 579         .resource_type = IORESOURCE_IO,
 580         .read_version_as_u32 = false,
 581         .name = "classic"
 582 };
 583
 584 static const struct apple_gmux_config apple_gmux_index = {
 585         .read8 = &gmux_index_read8,
 586         .write8 = &gmux_index_write8,
 587         .read32 = &gmux_index_read32,
 588         .write32 = &gmux_index_write32,
 589         .gmux_handler = &gmux_handler_no_ddc,
 590         .handler_flags = VGA_SWITCHEROO_NEEDS_EDP_CONFIG,
 591         .resource_type = IORESOURCE_IO,
 592         .read_version_as_u32 = true,
 593         .name = "indexed"
 594 };
 595
 596 static const struct apple_gmux_config apple_gmux_mmio = {
 597         .read8 = &gmux_mmio_read8,
 598         .write8 = &gmux_mmio_write8,
 599         .read32 = &gmux_mmio_read32,
 600         .write32 = &gmux_mmio_write32,
 601         .gmux_handler = &gmux_handler_no_ddc,
 602         .handler_flags = VGA_SWITCHEROO_NEEDS_EDP_CONFIG,
 603         .resource_type = IORESOURCE_MEM,
 604         .read_version_as_u32 = true,
 605         .name = "T2"
 606 };
 607
 608
 609 /**
 610  * DOC: Interrupt
 611  *
 612  * gmux is also connected to a GPIO pin of the southbridge and thereby is able
 613  * to trigger an ACPI GPE. ACPI name GMGP holds this GPIO pin's number. On the
 614  * MBP5 2008/09 it's GPIO pin 22 of the Nvidia MCP79, on following generations
 615  * it's GPIO pin 6 of the Intel PCH, on MMIO gmux's it's pin 21.
 616  *
 617  * The GPE merely signals that an interrupt occurred, the actual type of event
 618  * is identified by reading a gmux register.
 619  *
 620  * In addition to the GMGP name, gmux's ACPI device also has two methods GMSP
 621  * and GMLV. GMLV likely means "GMUX Level", and reads the value of the GPIO,
 622  * while GMSP likely means "GMUX Set Polarity", and seems to write to the GPIO's
 623  * value. On newer Macbooks (This was introduced with or sometime before the
 624  * MacBookPro14,3), the ACPI GPE method differentiates between the OS type: On
 625  * Darwin, only a notification is signaled, whereas on other OSes, the GPIO's
 626  * value is read and then inverted.
 627  *
 628  * Because Linux masquerades as Darwin, it ends up in the notification-only code
 629  * path. On MMIO gmux's, this seems to lead to us being unable to clear interrupts,
 630  * unless we call GMSP(0). Without this, there is a flood of status=0 interrupts
 631  * that can't be cleared. This issue seems to be unique to MMIO gmux's.
 632  */
 633
 634 static inline void gmux_disable_interrupts(struct apple_gmux_data *gmux_data)
 635 {
 636         gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE,
 637                     GMUX_INTERRUPT_DISABLE);
 638 }
 639
 640 static inline void gmux_enable_interrupts(struct apple_gmux_data *gmux_data)
 641 {
 642         gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE,
 643                     GMUX_INTERRUPT_ENABLE);
 644 }
 645
 646 static inline u8 gmux_interrupt_get_status(struct apple_gmux_data *gmux_data)
 647 {
 648         return gmux_read8(gmux_data, GMUX_PORT_INTERRUPT_STATUS);
 649 }
 650
 651 static void gmux_clear_interrupts(struct apple_gmux_data *gmux_data)
 652 {
 653         u8 status;
 654
 655         /* to clear interrupts write back current status */
 656         status = gmux_interrupt_get_status(gmux_data);
 657         gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_STATUS, status);
 658         /* Prevent flood of status=0 interrupts */
 659         if (gmux_data->config == &apple_gmux_mmio)
 660                 acpi_execute_simple_method(gmux_data->dhandle, "GMSP", 0);
 661 }
 662
 663 static void gmux_notify_handler(acpi_handle device, u32 value, void *context)
 664 {
 665         u8 status;
 666         struct pnp_dev *pnp = (struct pnp_dev *)context;
 667         struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
 668
 669         status = gmux_interrupt_get_status(gmux_data);
 670         gmux_disable_interrupts(gmux_data);
 671         pr_debug("Notify handler called: status %d\n", status);
 672
 673         gmux_clear_interrupts(gmux_data);
 674         gmux_enable_interrupts(gmux_data);
 675
 676         if (status & GMUX_INTERRUPT_STATUS_POWER)
 677                 complete(&gmux_data->powerchange_done);
 678 }
 679
 680 /**
 681  * DOC: Debugfs Interface
 682  *
 683  * gmux ports can be accessed from userspace as a debugfs interface. For example:
 684  *
 685  * # echo 4 > /sys/kernel/debug/apple_gmux/selected_port
 686  * # cat /sys/kernel/debug/apple_gmux/selected_port_data | xxd -p
 687  * 00000005
 688  *
 689  * Reads 4 bytes from port 4 (GMUX_PORT_VERSION_MAJOR).
 690  *
 691  * 1 and 4 byte writes are also allowed.
 692  */
 693
 694 static ssize_t gmux_selected_port_data_write(struct file *file,
 695                 const char __user *userbuf, size_t count, loff_t *ppos)
 696 {
 697         struct apple_gmux_data *gmux_data = file->private_data;
 698
 699         if (*ppos)
 700                 return -EINVAL;
 701
 702         if (count == 1) {
 703                 u8 data;
 704
 705                 if (copy_from_user(&data, userbuf, 1))
 706                         return -EFAULT;
 707
 708                 gmux_write8(gmux_data, gmux_data->selected_port, data);
 709         } else if (count == 4) {
 710                 u32 data;
 711
 712                 if (copy_from_user(&data, userbuf, 4))
 713                         return -EFAULT;
 714
 715                 gmux_write32(gmux_data, gmux_data->selected_port, data);
 716         } else
 717                 return -EINVAL;
 718
 719         return count;
 720 }
 721
 722 static ssize_t gmux_selected_port_data_read(struct file *file,
 723                 char __user *userbuf, size_t count, loff_t *ppos)
 724 {
 725         struct apple_gmux_data *gmux_data = file->private_data;
 726         u32 data;
 727
 728         data = gmux_read32(gmux_data, gmux_data->selected_port);
 729
 730         return simple_read_from_buffer(userbuf, count, ppos, &data, sizeof(data));
 731 }
 732
 733 static const struct file_operations gmux_port_data_ops = {
 734         .open = simple_open,
 735         .write = gmux_selected_port_data_write,
 736         .read = gmux_selected_port_data_read
 737 };
 738
 739 static void gmux_init_debugfs(struct apple_gmux_data *gmux_data)
 740 {
 741         gmux_data->debug_dentry = debugfs_create_dir(KBUILD_MODNAME, NULL);
 742
 743         debugfs_create_u8("selected_port", 0644, gmux_data->debug_dentry,
 744                         &gmux_data->selected_port);
 745         debugfs_create_file("selected_port_data", 0644, gmux_data->debug_dentry,
 746                         gmux_data, &gmux_port_data_ops);
 747 }
 748
 749 static void gmux_fini_debugfs(struct apple_gmux_data *gmux_data)
 750 {
 751         debugfs_remove_recursive(gmux_data->debug_dentry);
 752 }
 753
 754 static int gmux_suspend(struct device *dev)
 755 {
 756         struct pnp_dev *pnp = to_pnp_dev(dev);
 757         struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
 758
 759         gmux_disable_interrupts(gmux_data);
 760         return 0;
 761 }
 762
 763 static int gmux_resume(struct device *dev)
 764 {
 765         struct pnp_dev *pnp = to_pnp_dev(dev);
 766         struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
 767
 768         gmux_enable_interrupts(gmux_data);
 769         gmux_write_switch_state(gmux_data);
 770         if (gmux_data->power_state == VGA_SWITCHEROO_OFF)
 771                 gmux_set_discrete_state(gmux_data, gmux_data->power_state);
 772         return 0;
 773 }
 774
 775 static int is_thunderbolt(struct device *dev, void *data)
 776 {
 777         return to_pci_dev(dev)->is_thunderbolt;
 778 }
 779
 780 static int gmux_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
 781 {
 782         struct apple_gmux_data *gmux_data;
 783         struct resource *res;
 784         struct backlight_properties props;
 785         struct backlight_device *bdev = NULL;
 786         u8 ver_major, ver_minor, ver_release;
 787         bool register_bdev = true;
 788         int ret = -ENXIO;
 789         acpi_status status;
 790         unsigned long long gpe;
 791         enum apple_gmux_type type;
 792         u32 version;
 793
 794         if (apple_gmux_data)
 795                 return -EBUSY;
 796
 797         if (!apple_gmux_detect(pnp, &type)) {
 798                 pr_info("gmux device not present\n");
 799                 return -ENODEV;
 800         }
 801
 802         gmux_data = kzalloc(sizeof(*gmux_data), GFP_KERNEL);
 803         if (!gmux_data)
 804                 return -ENOMEM;
 805         pnp_set_drvdata(pnp, gmux_data);
 806
 807         switch (type) {
 808         case APPLE_GMUX_TYPE_MMIO:
 809                 gmux_data->config = &apple_gmux_mmio;
 810                 mutex_init(&gmux_data->index_lock);
 811
 812                 res = pnp_get_resource(pnp, IORESOURCE_MEM, 0);
 813                 gmux_data->iostart = res->start;
 814                 /* Although the ACPI table only allocates 8 bytes, we need 16. */
 815                 gmux_data->iolen = 16;
 816                 if (!request_mem_region(gmux_data->iostart, gmux_data->iolen,
 817                                         "Apple gmux")) {
 818                         pr_err("gmux I/O already in use\n");
 819                         goto err_free;
 820                 }
 821                 gmux_data->iomem_base = ioremap(gmux_data->iostart, gmux_data->iolen);
 822                 if (!gmux_data->iomem_base) {
 823                         pr_err("couldn't remap gmux mmio region");
 824                         goto err_release;
 825                 }
 826                 goto get_version;
 827         case APPLE_GMUX_TYPE_INDEXED:
 828                 gmux_data->config = &apple_gmux_index;
 829                 mutex_init(&gmux_data->index_lock);
 830                 break;
 831         case APPLE_GMUX_TYPE_PIO:
 832                 gmux_data->config = &apple_gmux_pio;
 833                 break;
 834         }
 835
 836         res = pnp_get_resource(pnp, IORESOURCE_IO, 0);
 837         gmux_data->iostart = res->start;
 838         gmux_data->iolen = resource_size(res);
 839
 840         if (!request_region(gmux_data->iostart, gmux_data->iolen,
 841                             "Apple gmux")) {
 842                 pr_err("gmux I/O already in use\n");
 843                 goto err_free;
 844         }
 845
 846 get_version:
 847         if (gmux_data->config->read_version_as_u32) {
 848                 version = gmux_read32(gmux_data, GMUX_PORT_VERSION_MAJOR);
 849                 ver_major = (version >> 24) & 0xff;
 850                 ver_minor = (version >> 16) & 0xff;
 851                 ver_release = (version >> 8) & 0xff;
 852         } else {
 853                 ver_major = gmux_read8(gmux_data, GMUX_PORT_VERSION_MAJOR);
 854                 ver_minor = gmux_read8(gmux_data, GMUX_PORT_VERSION_MINOR);
 855                 ver_release = gmux_read8(gmux_data, GMUX_PORT_VERSION_RELEASE);
 856         }
 857         pr_info("Found gmux version %d.%d.%d [%s]\n", ver_major, ver_minor,
 858                 ver_release, gmux_data->config->name);
 859
 860         memset(&props, 0, sizeof(props));
 861         props.type = BACKLIGHT_PLATFORM;
 862
 863         /*
 864          * All MMIO gmux's have 0xffff as max brightness, but some iMacs incorrectly
 865          * report 0x03ff, despite the firmware being happy to set 0xffff as the brightness
 866          * at boot. Force 0xffff for all MMIO gmux's so they all have the correct brightness
 867          * range.
 868          */
 869         if (type == APPLE_GMUX_TYPE_MMIO)
 870                 props.max_brightness = MMIO_GMUX_MAX_BRIGHTNESS;
 871         else
 872                 props.max_brightness = gmux_read32(gmux_data, GMUX_PORT_MAX_BRIGHTNESS);
 873
 874 #if IS_REACHABLE(CONFIG_ACPI_VIDEO)
 875         register_bdev = acpi_video_get_backlight_type() == acpi_backlight_apple_gmux;
 876 #endif
 877         if (register_bdev) {
 878                 /*
 879                  * Currently it's assumed that the maximum brightness is less than
 880                  * 2^24 for compatibility with old gmux versions. Cap the max
 881                  * brightness at this value, but print a warning if the hardware
 882                  * reports something higher so that it can be fixed.
 883                  */
 884                 if (WARN_ON(props.max_brightness > GMUX_MAX_BRIGHTNESS))
 885                         props.max_brightness = GMUX_MAX_BRIGHTNESS;
 886
 887                 bdev = backlight_device_register("gmux_backlight", &pnp->dev,
 888                                                  gmux_data, &gmux_bl_ops, &props);
 889                 if (IS_ERR(bdev)) {
 890                         ret = PTR_ERR(bdev);
 891                         goto err_unmap;
 892                 }
 893
 894                 gmux_data->bdev = bdev;
 895                 bdev->props.brightness = gmux_get_brightness(bdev);
 896                 backlight_update_status(bdev);
 897         }
 898
 899         gmux_data->power_state = VGA_SWITCHEROO_ON;
 900
 901         gmux_data->dhandle = ACPI_HANDLE(&pnp->dev);
 902         if (!gmux_data->dhandle) {
 903                 pr_err("Cannot find acpi handle for pnp device %s\n",
 904                        dev_name(&pnp->dev));
 905                 ret = -ENODEV;
 906                 goto err_notify;
 907         }
 908
 909         status = acpi_evaluate_integer(gmux_data->dhandle, "GMGP", NULL, &gpe);
 910         if (ACPI_SUCCESS(status)) {
 911                 gmux_data->gpe = (int)gpe;
 912
 913                 status = acpi_install_notify_handler(gmux_data->dhandle,
 914                                                      ACPI_DEVICE_NOTIFY,
 915                                                      &gmux_notify_handler, pnp);
 916                 if (ACPI_FAILURE(status)) {
 917                         pr_err("Install notify handler failed: %s\n",
 918                                acpi_format_exception(status));
 919                         ret = -ENODEV;
 920                         goto err_notify;
 921                 }
 922
 923                 status = acpi_enable_gpe(NULL, gmux_data->gpe);
 924                 if (ACPI_FAILURE(status)) {
 925                         pr_err("Cannot enable gpe: %s\n",
 926                                acpi_format_exception(status));
 927                         goto err_enable_gpe;
 928                 }
 929         } else {
 930                 pr_warn("No GPE found for gmux\n");
 931                 gmux_data->gpe = -1;
 932         }
 933
 934         /*
 935          * If Thunderbolt is present, the external DP port is not fully
 936          * switchable. Force its AUX channel to the discrete GPU.
 937          */
 938         gmux_data->external_switchable =
 939                 !bus_for_each_dev(&pci_bus_type, NULL, NULL, is_thunderbolt);
 940         if (!gmux_data->external_switchable)
 941                 gmux_write8(gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 3);
 942
 943         apple_gmux_data = gmux_data;
 944         init_completion(&gmux_data->powerchange_done);
 945         gmux_enable_interrupts(gmux_data);
 946         gmux_read_switch_state(gmux_data);
 947
 948         /*
 949          * Retina MacBook Pros cannot switch the panel's AUX separately
 950          * and need eDP pre-calibration. They are distinguishable from
 951          * pre-retinas by having an "indexed" or "T2" gmux.
 952          *
 953          * Pre-retina MacBook Pros can switch the panel's DDC separately.
 954          */
 955         ret = vga_switcheroo_register_handler(gmux_data->config->gmux_handler,
 956                         gmux_data->config->handler_flags);
 957         if (ret) {
 958                 pr_err("Failed to register vga_switcheroo handler\n");
 959                 goto err_register_handler;
 960         }
 961
 962         gmux_init_debugfs(gmux_data);
 963         return 0;
 964
 965 err_register_handler:
 966         gmux_disable_interrupts(gmux_data);
 967         apple_gmux_data = NULL;
 968         if (gmux_data->gpe >= 0)
 969                 acpi_disable_gpe(NULL, gmux_data->gpe);
 970 err_enable_gpe:
 971         if (gmux_data->gpe >= 0)
 972                 acpi_remove_notify_handler(gmux_data->dhandle,
 973                                            ACPI_DEVICE_NOTIFY,
 974                                            &gmux_notify_handler);
 975 err_notify:
 976         backlight_device_unregister(bdev);
 977 err_unmap:
 978         if (gmux_data->iomem_base)
 979                 iounmap(gmux_data->iomem_base);
 980 err_release:
 981         if (gmux_data->config->resource_type == IORESOURCE_MEM)
 982                 release_mem_region(gmux_data->iostart, gmux_data->iolen);
 983         else
 984                 release_region(gmux_data->iostart, gmux_data->iolen);
 985 err_free:
 986         kfree(gmux_data);
 987         return ret;
 988 }
 989
 990 static void gmux_remove(struct pnp_dev *pnp)
 991 {
 992         struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp);
 993
 994         gmux_fini_debugfs(gmux_data);
 995         vga_switcheroo_unregister_handler();
 996         gmux_disable_interrupts(gmux_data);
 997         if (gmux_data->gpe >= 0) {
 998                 acpi_disable_gpe(NULL, gmux_data->gpe);
 999                 acpi_remove_notify_handler(gmux_data->dhandle,
1000                                            ACPI_DEVICE_NOTIFY,
1001                                            &gmux_notify_handler);
1002         }
1003
1004         backlight_device_unregister(gmux_data->bdev);
1005
1006         if (gmux_data->iomem_base) {
1007                 iounmap(gmux_data->iomem_base);
1008                 release_mem_region(gmux_data->iostart, gmux_data->iolen);
1009         } else
1010                 release_region(gmux_data->iostart, gmux_data->iolen);
1011         apple_gmux_data = NULL;
1012         kfree(gmux_data);
1013 }
1014
1015 static const struct pnp_device_id gmux_device_ids[] = {
1016         {GMUX_ACPI_HID, 0},
1017         {"", 0}
1018 };
1019
1020 static const struct dev_pm_ops gmux_dev_pm_ops = {
1021         .suspend = gmux_suspend,
1022         .resume = gmux_resume,
1023 };
1024
1025 static struct pnp_driver gmux_pnp_driver = {
1026         .name           = "apple-gmux",
1027         .probe          = gmux_probe,
1028         .remove         = gmux_remove,
1029         .id_table       = gmux_device_ids,
1030         .driver         = {
1031                         .pm = &gmux_dev_pm_ops,
1032         },
1033 };
1034
1035 module_pnp_driver(gmux_pnp_driver);
1036 MODULE_AUTHOR("Seth Forshee <[email protected]>");
1037 MODULE_DESCRIPTION("Apple Gmux Driver");
1038 MODULE_LICENSE("GPL");
1039 MODULE_DEVICE_TABLE(pnp, gmux_device_ids);