From 6acd075defe8fe86f62a3195b5d5a69a0d89ed0d Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 1 Feb 2010 15:38:10 +1000 Subject: [PATCH 1/2] vga_switcheroo: initial implementation (v6) v2: add power up/down support for both devices on W500 puts i915/radeon into D3 and cuts power to radeon. v3: redo probing methods, no DMI list, drm devices call to register with switcheroo, it tries to find an ATPX method on any device and once there is two devices + ATPX it inits the switcher. v4: ATPX msg handling using buffers - should work on more machines v5: rearchitect after more mjg59 discussion - move ATPX handling to radeon driver. v6: add file headers + initial nouveau bits (to be filled out). mount debugfs /sys/kernel/debug/vgaswitcheroo/switch - should exist if ATPX detected + 2 cards. echo OFF > switch - turn Off whatever card isn't in use echo ON > switch - turn On whatever card isn't in use echo 0000:01:00.0 > switch - switch to that PCI card (ATI) + D3 Intel echo 0000:00:02.0 > switch - switch to that PCI card (Intel) + D3/PWR ATI Tested on W500 (Intel/ATI) and T500 (Intel/ATI) --- drivers/gpu/drm/i915/i915_dma.c | 18 ++ drivers/gpu/drm/i915/i915_drv.c | 4 +- drivers/gpu/drm/i915/i915_drv.h | 2 + drivers/gpu/drm/i915/intel_fb.c | 3 + drivers/gpu/drm/nouveau/nouveau_acpi.c | 31 ++ drivers/gpu/drm/nouveau/nouveau_drv.c | 4 +- drivers/gpu/drm/nouveau/nouveau_drv.h | 3 + drivers/gpu/drm/nouveau/nouveau_fbcon.c | 3 + drivers/gpu/drm/nouveau/nouveau_state.c | 15 + drivers/gpu/drm/radeon/Makefile | 3 +- drivers/gpu/drm/radeon/radeon_atpx_handler.c | 129 +++++++++ drivers/gpu/drm/radeon/radeon_bios.c | 11 +- drivers/gpu/drm/radeon/radeon_device.c | 18 ++ drivers/gpu/drm/radeon/radeon_drv.c | 4 +- drivers/gpu/drm/radeon/radeon_drv.h | 3 + drivers/gpu/drm/radeon/radeon_fb.c | 3 + drivers/gpu/vga/Makefile | 2 +- drivers/gpu/vga/vga_switcheroo.c | 397 ++++++++++++++++++++++++++ drivers/video/console/fbcon.c | 18 ++ include/linux/fb.h | 2 + include/linux/vga_switcheroo.h | 47 +++ 21 files changed, 707 insertions(+), 13 deletions(-) create mode 100644 drivers/gpu/drm/radeon/radeon_atpx_handler.c create mode 100644 drivers/gpu/vga/vga_switcheroo.c create mode 100644 include/linux/vga_switcheroo.h diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c index 02607ed..2e70292 100644 --- a/drivers/gpu/drm/i915/i915_dma.c +++ b/drivers/gpu/drm/i915/i915_dma.c @@ -35,6 +35,7 @@ #include "i915_drv.h" #include "i915_trace.h" #include +#include /* Really want an OS-independent resettable timer. Would like to have * this loop run for (eg) 3 sec, but have the timer reset every time @@ -1188,6 +1189,19 @@ static unsigned int i915_vga_set_decode(void *cookie, bool state) return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM; } +static void i915_switcheroo_set_state(struct pci_dev *pdev, enum vga_switcheroo_state state) +{ + struct drm_device *dev = pci_get_drvdata(pdev); + pm_message_t pmm = { .event = PM_EVENT_SUSPEND }; + if (state == VGA_SWITCHEROO_ON) { + printk(KERN_ERR "VGA switched i915 on\n"); + i915_resume(dev); + } else { + printk(KERN_ERR "VGA switched i915 off\n"); + i915_suspend(dev, pmm); + } +} + static int i915_load_modeset_init(struct drm_device *dev, unsigned long prealloc_start, unsigned long prealloc_size, @@ -1257,6 +1271,10 @@ static int i915_load_modeset_init(struct drm_device *dev, if (ret) goto destroy_ringbuffer; + ret = vga_switcheroo_register_client(dev->pdev, i915_switcheroo_set_state); + if (ret) + goto destroy_ringbuffer; + ret = drm_irq_install(dev); if (ret) goto destroy_ringbuffer; diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 24286ca..2011ecd 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -56,7 +56,7 @@ static struct pci_device_id pciidlist[] = { MODULE_DEVICE_TABLE(pci, pciidlist); #endif -static int i915_suspend(struct drm_device *dev, pm_message_t state) +int i915_suspend(struct drm_device *dev, pm_message_t state) { struct drm_i915_private *dev_priv = dev->dev_private; @@ -95,7 +95,7 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state) return 0; } -static int i915_resume(struct drm_device *dev) +int i915_resume(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; int ret = 0; diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index fbecac7..ddfaffd 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -704,6 +704,8 @@ extern int i915_max_ioctl; extern unsigned int i915_fbpercrtc; extern unsigned int i915_powersave; +extern int i915_suspend(struct drm_device *dev, pm_message_t state); +extern int i915_resume(struct drm_device *dev); extern void i915_save_display(struct drm_device *dev); extern void i915_restore_display(struct drm_device *dev); extern int i915_master_create(struct drm_device *dev, struct drm_master *master); diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c index d4823cc..a24bf75 100644 --- a/drivers/gpu/drm/i915/intel_fb.c +++ b/drivers/gpu/drm/i915/intel_fb.c @@ -35,6 +35,7 @@ #include #include #include +#include #include "drmP.h" #include "drm.h" @@ -234,6 +235,8 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width, intel_fb->base.width, intel_fb->base.height, obj_priv->gtt_offset, fbo); + vga_switcheroo_client_fb_set(dev->pdev, info); + mutex_unlock(&dev->struct_mutex); return 0; diff --git a/drivers/gpu/drm/nouveau/nouveau_acpi.c b/drivers/gpu/drm/nouveau/nouveau_acpi.c index 1cf4882..be8cb90 100644 --- a/drivers/gpu/drm/nouveau/nouveau_acpi.c +++ b/drivers/gpu/drm/nouveau/nouveau_acpi.c @@ -11,6 +11,8 @@ #include "nouveau_drm.h" #include "nv50_display.h" +#include + #define NOUVEAU_DSM_SUPPORTED 0x00 #define NOUVEAU_DSM_SUPPORTED_FUNCTIONS 0x00 @@ -123,3 +125,32 @@ bool nouveau_dsm_probe(struct drm_device *dev) return true; } + +static int nouveau_dsm_switchto(acpi_handle handle, + enum vga_switcheroo_client_id id) +{ + return 0; +} + +static int nouveau_dsm_power_state(acpi_handle handle, + enum vga_switcheroo_client_id id, + enum vga_switcheroo_state state) +{ + return 0; +} + +static struct vga_switcheroo_handler nouveau_dsm_handler = { + .method_id = VGA_SWITCHEROO_DSM, + .switchto = nouveau_dsm_switchto, + .power_state = nouveau_dsm_power_state, +}; + +void nouveau_register_dsm_handler(void) +{ + vga_switcheroo_register_handler(&nouveau_dsm_handler); +} + +void nouveau_unregister_dsm_handler(void) +{ + vga_switcheroo_unregister_handler(); +} diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.c b/drivers/gpu/drm/nouveau/nouveau_drv.c index 343ab7f..eac2162 100644 --- a/drivers/gpu/drm/nouveau/nouveau_drv.c +++ b/drivers/gpu/drm/nouveau/nouveau_drv.c @@ -127,7 +127,7 @@ nouveau_pci_remove(struct pci_dev *pdev) drm_put_dev(dev); } -static int +int nouveau_pci_suspend(struct pci_dev *pdev, pm_message_t pm_state) { struct drm_device *dev = pci_get_drvdata(pdev); @@ -225,7 +225,7 @@ out_abort: return ret; } -static int +int nouveau_pci_resume(struct pci_dev *pdev) { struct drm_device *dev = pci_get_drvdata(pdev); diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.h b/drivers/gpu/drm/nouveau/nouveau_drv.h index 6b96904..0af44d1 100644 --- a/drivers/gpu/drm/nouveau/nouveau_drv.h +++ b/drivers/gpu/drm/nouveau/nouveau_drv.h @@ -679,6 +679,9 @@ extern char *nouveau_vbios; extern int nouveau_ctxfw; extern int nouveau_ignorelid; +extern int nouveau_pci_suspend(struct pci_dev *pdev, pm_message_t pm_state); +extern int nouveau_pci_resume(struct pci_dev *pdev); + /* nouveau_state.c */ extern void nouveau_preclose(struct drm_device *dev, struct drm_file *); extern int nouveau_load(struct drm_device *, unsigned long flags); diff --git a/drivers/gpu/drm/nouveau/nouveau_fbcon.c b/drivers/gpu/drm/nouveau/nouveau_fbcon.c index 0b05c86..3b41c1e 100644 --- a/drivers/gpu/drm/nouveau/nouveau_fbcon.c +++ b/drivers/gpu/drm/nouveau/nouveau_fbcon.c @@ -36,6 +36,7 @@ #include #include #include +#include #include "drmP.h" #include "drm.h" @@ -335,6 +336,8 @@ nouveau_fbcon_create(struct drm_device *dev, uint32_t fb_width, nouveau_fb->base.height, nvbo->bo.offset, nvbo); + vga_switcheroo_client_fb_set(dev->pdev, info); + mutex_unlock(&dev->struct_mutex); return 0; diff --git a/drivers/gpu/drm/nouveau/nouveau_state.c b/drivers/gpu/drm/nouveau/nouveau_state.c index f2d0187..940fdd3 100644 --- a/drivers/gpu/drm/nouveau/nouveau_state.c +++ b/drivers/gpu/drm/nouveau/nouveau_state.c @@ -29,6 +29,7 @@ #include "drm_sarea.h" #include "drm_crtc_helper.h" #include +#include #include "nouveau_drv.h" #include "nouveau_drm.h" @@ -363,6 +364,19 @@ out_err: return ret; } +static void nouveau_switcheroo_set_state (struct pci_dev *pdev, + enum vga_switcheroo_state state) +{ + pm_message_t pmm = { .event = PM_EVENT_SUSPEND }; + if (state == VGA_SWITCHEROO_ON) { + printk(KERN_ERR "VGA switcheroo: switched nouveau on\n"); + nouveau_pci_resume(pdev); + } else { + printk(KERN_ERR "VGA switcheroo: switched nouveau off\n"); + nouveau_pci_suspend(pdev, pmm); + } +} + int nouveau_card_init(struct drm_device *dev) { @@ -376,6 +390,7 @@ nouveau_card_init(struct drm_device *dev) return 0; vga_client_register(dev->pdev, dev, NULL, nouveau_vga_set_decode); + vga_switcheroo_register_client(dev->pdev, nouveau_switcheroo_set_state); /* Initialise internal driver API hooks */ ret = nouveau_init_engine_ptrs(dev); diff --git a/drivers/gpu/drm/radeon/Makefile b/drivers/gpu/drm/radeon/Makefile index 1cc7b93..8e62fe1 100644 --- a/drivers/gpu/drm/radeon/Makefile +++ b/drivers/gpu/drm/radeon/Makefile @@ -54,7 +54,8 @@ radeon-y += radeon_device.o radeon_kms.o \ radeon_cs.o radeon_bios.o radeon_benchmark.o r100.o r300.o r420.o \ rs400.o rs600.o rs690.o rv515.o r520.o r600.o rv770.o radeon_test.o \ r200.o radeon_legacy_tv.o r600_cs.o r600_blit.o r600_blit_shaders.o \ - r600_blit_kms.o radeon_pm.o atombios_dp.o r600_audio.o r600_hdmi.o + r600_blit_kms.o radeon_pm.o atombios_dp.o r600_audio.o r600_hdmi.o \ + radeon_atpx_handler.o radeon-$(CONFIG_COMPAT) += radeon_ioc32.o diff --git a/drivers/gpu/drm/radeon/radeon_atpx_handler.c b/drivers/gpu/drm/radeon/radeon_atpx_handler.c new file mode 100644 index 0000000..808d980 --- /dev/null +++ b/drivers/gpu/drm/radeon/radeon_atpx_handler.c @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2010 Red Hat Inc. + * Author : Dave Airlie + * + * Licensed under GPLv2 + */ + +#include + +#define ATPX_VERSION 0 +#define ATPX_GPU_PWR 2 +#define ATPX_MUX_SELECT 3 + +#define ATPX_INTEGRATED 0 +#define ATPX_DISCRETE 1 + +#define ATPX_MUX_IGD 0 +#define ATPX_MUX_DISCRETE 1 + +static int radeon_atpx_get_version(acpi_handle handle) +{ + acpi_status status; + union acpi_object atpx_arg_elements[2], *obj; + struct acpi_object_list atpx_arg; + struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; + + atpx_arg.count = 2; + atpx_arg.pointer = &atpx_arg_elements[0]; + + atpx_arg_elements[0].type = ACPI_TYPE_INTEGER; + atpx_arg_elements[0].integer.value = ATPX_VERSION; + + atpx_arg_elements[1].type = ACPI_TYPE_INTEGER; + atpx_arg_elements[1].integer.value = ATPX_VERSION; + + status = acpi_evaluate_object(handle, NULL, &atpx_arg, &buffer); + if (ACPI_FAILURE(status)) { + printk("%s: failed to call ATPX: %s\n", __func__, acpi_format_exception(status)); + return -ENOSYS; + } + obj = (union acpi_object *)buffer.pointer; + if (obj && (obj->type == ACPI_TYPE_BUFFER)) { + printk("VERN is %d\n", *((u8 *)(obj->buffer.pointer) + 2)); + } + kfree(buffer.pointer); + return 0; +} + +static int radeon_atpx_execute(acpi_handle handle, int cmd_id, u16 value) +{ + acpi_status status; + union acpi_object atpx_arg_elements[2]; + struct acpi_object_list atpx_arg; + struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; + uint8_t buf[4] = {0}; + + if (!handle) + return -EINVAL; + + atpx_arg.count = 2; + atpx_arg.pointer = &atpx_arg_elements[0]; + + atpx_arg_elements[0].type = ACPI_TYPE_INTEGER; + atpx_arg_elements[0].integer.value = cmd_id; + + buf[2] = value & 0xff; + buf[3] = (value >> 8) & 0xff; + + atpx_arg_elements[1].type = ACPI_TYPE_BUFFER; + atpx_arg_elements[1].buffer.length = 4; + atpx_arg_elements[1].buffer.pointer = buf; + + status = acpi_evaluate_object(handle, NULL, &atpx_arg, &buffer); + if (ACPI_FAILURE(status)) { + printk("%s: failed to call ATPX: %s\n", __func__, acpi_format_exception(status)); + return -ENOSYS; + } + kfree(buffer.pointer); + + return 0; +} + +static int radeon_atpx_set_discrete_state(acpi_handle handle, int state) +{ + return radeon_atpx_execute(handle, ATPX_GPU_PWR, state); +} + +static int radeon_atpx_switch_mux(acpi_handle handle, int mux_id) +{ + return radeon_atpx_execute(handle, ATPX_MUX_SELECT, mux_id); +} + + +static int radeon_atpx_switchto(acpi_handle handle, enum vga_switcheroo_client_id id) +{ + if (id == VGA_SWITCHEROO_IGD) + radeon_atpx_switch_mux(handle, 0); + else + radeon_atpx_switch_mux(handle, 1); + return 0; +} + +static int radeon_atpx_power_state(acpi_handle handle, + enum vga_switcheroo_client_id id, + enum vga_switcheroo_state state) +{ + /* on w500 ACPI can't change intel gpu state */ + if (id == VGA_SWITCHEROO_IGD) + return 0; + + radeon_atpx_set_discrete_state(handle, state); + return 0; +} + +static struct vga_switcheroo_handler radeon_atpx_handler = { + .method_id = VGA_SWITCHEROO_ATPX, + .switchto = radeon_atpx_switchto, + .power_state = radeon_atpx_power_state, +}; + +void radeon_register_atpx_handler(void) +{ + vga_switcheroo_register_handler(&radeon_atpx_handler); +} + +void radeon_unregister_atpx_handler(void) +{ + vga_switcheroo_unregister_handler(); +} diff --git a/drivers/gpu/drm/radeon/radeon_bios.c b/drivers/gpu/drm/radeon/radeon_bios.c index 9069217..a406af0 100644 --- a/drivers/gpu/drm/radeon/radeon_bios.c +++ b/drivers/gpu/drm/radeon/radeon_bios.c @@ -50,8 +50,10 @@ static bool igp_read_bios_from_vram(struct radeon_device *rdev) vram_base = drm_get_resource_start(rdev->ddev, 0); bios = ioremap(vram_base, size); if (!bios) { + DRM_ERROR("unable to ioremap %x %d\n", (unsigned int)vram_base, (unsigned int)size); return false; } + DRM_ERROR("ioremapped %d %d \n", bios[0], bios[1]); if (size == 0 || bios[0] != 0x55 || bios[1] != 0xaa) { iounmap(bios); @@ -62,7 +64,7 @@ static bool igp_read_bios_from_vram(struct radeon_device *rdev) iounmap(bios); return false; } - memcpy(rdev->bios, bios, size); + memcpy_fromio(rdev->bios, bios, size); iounmap(bios); return true; } @@ -393,11 +395,8 @@ bool radeon_get_bios(struct radeon_device *rdev) bool r; uint16_t tmp; - if (rdev->flags & RADEON_IS_IGP) { - r = igp_read_bios_from_vram(rdev); - if (r == false) - r = radeon_read_bios(rdev); - } else + r = igp_read_bios_from_vram(rdev); + if (r == false) r = radeon_read_bios(rdev); if (r == false) { r = radeon_read_disabled_bios(rdev); diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c index 768b150..3ad4aba 100644 --- a/drivers/gpu/drm/radeon/radeon_device.c +++ b/drivers/gpu/drm/radeon/radeon_device.c @@ -30,11 +30,15 @@ #include #include #include +#include #include "radeon_reg.h" #include "radeon.h" #include "radeon_asic.h" #include "atom.h" +int radeon_suspend_kms(struct drm_device *dev, pm_message_t state); +int radeon_resume_kms(struct drm_device *dev); + /* * Clear GPU surface registers. */ @@ -613,6 +617,19 @@ void radeon_check_arguments(struct radeon_device *rdev) } } +static void radeon_switcheroo_set_state(struct pci_dev *pdev, enum vga_switcheroo_state state) +{ + struct drm_device *dev = pci_get_drvdata(pdev); + pm_message_t pmm = { .event = PM_EVENT_SUSPEND }; + if (state == VGA_SWITCHEROO_ON) { + printk(KERN_ERR "VGA switched radeon on\n"); + radeon_resume_kms(dev); + } else { + printk(KERN_ERR "VGA switched radeon off\n"); + radeon_suspend_kms(dev, pmm); + } +} + int radeon_device_init(struct radeon_device *rdev, struct drm_device *ddev, struct pci_dev *pdev, @@ -692,6 +709,7 @@ int radeon_device_init(struct radeon_device *rdev, /* this will fail for cards that aren't VGA class devices, just * ignore it */ vga_client_register(rdev->pdev, rdev, NULL, radeon_vga_set_decode); + vga_switcheroo_register_client(rdev->pdev, radeon_switcheroo_set_state); r = radeon_init(rdev); if (r) diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c index 8ba3de7..69017f2 100644 --- a/drivers/gpu/drm/radeon/radeon_drv.c +++ b/drivers/gpu/drm/radeon/radeon_drv.c @@ -87,7 +87,7 @@ int radeon_testing = 0; int radeon_connector_table = 0; int radeon_tv = 1; int radeon_new_pll = 1; -int radeon_audio = 1; +int radeon_audio = 0; MODULE_PARM_DESC(no_wb, "Disable AGP writeback for scratch registers"); module_param_named(no_wb, radeon_no_wb, int, 0444); @@ -339,6 +339,7 @@ static int __init radeon_init(void) driver = &kms_driver; driver->driver_features |= DRIVER_MODESET; driver->num_ioctls = radeon_max_kms_ioctl; + radeon_register_atpx_handler(); } /* if the vga console setting is enabled still * let modprobe override it */ @@ -348,6 +349,7 @@ static int __init radeon_init(void) static void __exit radeon_exit(void) { drm_exit(driver); + radeon_unregister_atpx_handler(); } module_init(radeon_init); diff --git a/drivers/gpu/drm/radeon/radeon_drv.h b/drivers/gpu/drm/radeon/radeon_drv.h index e137852..e4e0781 100644 --- a/drivers/gpu/drm/radeon/radeon_drv.h +++ b/drivers/gpu/drm/radeon/radeon_drv.h @@ -454,6 +454,9 @@ extern void r600_blit_swap(struct drm_device *dev, int sx, int sy, int dx, int dy, int w, int h, int src_pitch, int dst_pitch, int cpp); +/* atpx handler */ +void radeon_register_atpx_handler(void); +void radeon_unregister_atpx_handler(void); /* Flags for stats.boxes */ #define RADEON_BOX_DMA_IDLE 0x1 diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c index 66055b3..cbf4dbb 100644 --- a/drivers/gpu/drm/radeon/radeon_fb.c +++ b/drivers/gpu/drm/radeon/radeon_fb.c @@ -39,6 +39,8 @@ #include "drm_fb_helper.h" +#include + struct radeon_fb_device { struct drm_fb_helper helper; struct radeon_framebuffer *rfb; @@ -290,6 +292,7 @@ int radeonfb_create(struct drm_device *dev, rfbdev->rfb = rfb; rfbdev->rdev = rdev; + vga_switcheroo_client_fb_set(rdev->ddev->pdev, info); mutex_unlock(&rdev->ddev->struct_mutex); return 0; diff --git a/drivers/gpu/vga/Makefile b/drivers/gpu/vga/Makefile index 7cc8c1e..6592546 100644 --- a/drivers/gpu/vga/Makefile +++ b/drivers/gpu/vga/Makefile @@ -1 +1 @@ -obj-$(CONFIG_VGA_ARB) += vgaarb.o +obj-$(CONFIG_VGA_ARB) += vgaarb.o vga_switcheroo.o diff --git a/drivers/gpu/vga/vga_switcheroo.c b/drivers/gpu/vga/vga_switcheroo.c new file mode 100644 index 0000000..c4779ab --- /dev/null +++ b/drivers/gpu/vga/vga_switcheroo.c @@ -0,0 +1,397 @@ +/* + * Copyright (c) 2010 Red Hat Inc. + * Author : Dave Airlie + * + * + * Licensed under GPLv2 + * + * vga_switcheroo.c - Support for laptop with dual GPU using one set of outputs + + Switcher interface - methods require for ATPX and DCM + - switchto - this throws the output MUX switch + - discrete_set_power - sets the power state for the discrete card + + GPU driver interface + - set_gpu_state - this should do the equiv of s/r for the card + - this should *not* set the discrete power state + - switch_check - check if the device is in a position to switch now + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + + +struct vga_switcheroo_client { + struct pci_dev *pdev; + struct fb_info *fb_info; + int pwr_state; + /* TODO callbacks */ + void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state); + /* TODO callbacks */ + void (*switch_check)(struct pci_dev *pdev); +}; + +struct vgasr_priv { + + bool active; + + struct dentry *debugfs_root; + struct dentry *switch_file; + + enum vga_switcheroo_method method; + int active_client; + + int registered_clients; + struct vga_switcheroo_client clients[VGA_SWITCHEROO_MAX_CLIENTS]; + + struct vga_switcheroo_handler *handler; + acpi_handle handle; +}; + +static int vga_switcheroo_debugfs_init(struct vgasr_priv *priv); +static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv); + +/* only one switcheroo per system */ +static struct vgasr_priv vgasr_priv; + +/* + * it would be nice to have these in the drivers - but it gets messy + * since Intel can load before radeon, and we'd have to reprobe on + * both client and handler registration + * though with Intel I suppose we always know its going to be the IGD + */ +static bool vga_switcheroo_detect_atpx(struct pci_dev *pdev, acpi_handle *handle, + enum vga_switcheroo_client_id *client_id) +{ + acpi_handle dhandle, atpx_handle; + acpi_status status; + + *client_id = VGA_SWITCHEROO_DIS; + dhandle = DEVICE_ACPI_HANDLE(&pdev->dev); + if (dhandle) { + status = acpi_get_handle(dhandle, "ATPX", &atpx_handle); + if (ACPI_SUCCESS(status)) { + WARN((vgasr_priv.method != VGA_SWITCHEROO_NONE && + vgasr_priv.method != VGA_SWITCHEROO_ATPX), + "Inconsistent VGA switcher state detected\n"); + /* ATPX defines IGD to have this method */ + *client_id = VGA_SWITCHEROO_IGD; + *handle = atpx_handle; + return true; + } + } + return false; +} + +static bool vga_switcheroo_detect_dsm(struct pci_dev *pdev, acpi_handle *handle, + enum vga_switcheroo_client_id *client_id) +{ + acpi_handle dhandle, dsm_handle; + acpi_status status; + + /* TODO client ID for DSM when both are nvidia */ + if (pdev->vendor == PCI_VENDOR_ID_INTEL) + *client_id = VGA_SWITCHEROO_IGD; + else + *client_id = VGA_SWITCHEROO_DIS; + dhandle = DEVICE_ACPI_HANDLE(&pdev->dev); + if (dhandle) { + status = acpi_get_handle(dhandle, "_DSM", &dsm_handle); + if (ACPI_SUCCESS(status)) { + WARN((vgasr_priv.method != VGA_SWITCHEROO_NONE && + vgasr_priv.method != VGA_SWITCHEROO_DSM), + "Inconsistent VGA switcher state detected\n"); + *handle = dsm_handle; + return true; + } + } + return false; +} + +static bool vga_switcheroo_detect_acpi_method(struct pci_dev *pdev, acpi_handle *handle, + enum vga_switcheroo_client_id *client_id) +{ + bool ret; + char acpi_method_name[255] = { 0 }; + struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name}; + + ret = vga_switcheroo_detect_atpx(pdev, handle, client_id); + if (ret == true) + goto out_print; + + ret = vga_switcheroo_detect_dsm(pdev, handle, client_id); + if (ret == true) + goto out_print; + + return false; + +out_print: + acpi_get_name(*handle, ACPI_FULL_PATHNAME, &buffer); + printk(KERN_INFO "VGA switcheroo: detected switching method %s handle on PCI device %s\n", + acpi_method_name, + pci_name(pdev)); + return true; +} + + +int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler) +{ + if (vgasr_priv.handler) + return -EINVAL; + + vgasr_priv.method = handler->method_id; + vgasr_priv.handler = handler; + return 0; +} +EXPORT_SYMBOL(vga_switcheroo_register_handler); + +void vga_switcheroo_unregister_handler(void) +{ + vgasr_priv.method = VGA_SWITCHEROO_NONE; + vgasr_priv.handler = NULL; +} +EXPORT_SYMBOL(vga_switcheroo_unregister_handler); + +int vga_switcheroo_register_client(struct pci_dev *pdev, + void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state)) +{ + enum vga_switcheroo_client_id client_id; + + vga_switcheroo_detect_acpi_method(pdev, &vgasr_priv.handle, &client_id); + if (vgasr_priv.registered_clients & (1 << client_id)) { + WARN(1, "VGA switcheroo: Double registration for %s client\n", + client_id == VGA_SWITCHEROO_IGD ? "Integrated" : "Discrete"); + return -EINVAL; + } + + vgasr_priv.clients[client_id].pwr_state = VGA_SWITCHEROO_ON; + vgasr_priv.clients[client_id].pdev = pdev; + vgasr_priv.clients[client_id].set_gpu_state = set_gpu_state; + if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) + vgasr_priv.active_client = client_id; + + vgasr_priv.registered_clients |= (1 << client_id); + + if (vgasr_priv.registered_clients == 0x3 && vgasr_priv.handle) { + printk(KERN_INFO "VGA switcheroo enabled\n"); + vga_switcheroo_debugfs_init(&vgasr_priv); + vgasr_priv.active = true; + } + return 0; +} +EXPORT_SYMBOL(vga_switcheroo_register_client); + +void vga_switcheroo_unregister_client(struct pci_dev *pdev) +{ + int i; + + for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { + if (vgasr_priv.clients[i].pdev == pdev) { + vgasr_priv.registered_clients &= ~(1 << i); + break; + } + } + + printk(KERN_INFO "VGA switcheroo disabled\n"); + vga_switcheroo_debugfs_fini(&vgasr_priv); + vgasr_priv.active = false; +} +EXPORT_SYMBOL(vga_switcheroo_unregister_client); + +void vga_switcheroo_client_fb_set(struct pci_dev *pdev, + struct fb_info *info) +{ + int i; + + for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { + if (vgasr_priv.clients[i].pdev == pdev) { + vgasr_priv.clients[i].fb_info = info; + break; + } + } +} +EXPORT_SYMBOL(vga_switcheroo_client_fb_set); + +static int vga_switcheroo_show(struct seq_file *m, void *v) +{ + int i; + for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { + seq_printf(m, "%d:%c:%s:%s\n", i, + (i == vgasr_priv.active_client ? '+': ' '), + vgasr_priv.clients[i].pwr_state ? "Pwr" : "Off", + pci_name(vgasr_priv.clients[i].pdev)); + } + return 0; +} + +static int vga_switcheroo_debugfs_open(struct inode *inode, struct file *file) +{ + return single_open(file, vga_switcheroo_show, NULL); +} + +static int vga_switchon(int index) +{ + int ret; + + ret = vgasr_priv.handler->power_state(vgasr_priv.handle, index, VGA_SWITCHEROO_ON); + /* call the driver callback to turn on device */ + vgasr_priv.clients[index].set_gpu_state(vgasr_priv.clients[index].pdev, VGA_SWITCHEROO_ON); + vgasr_priv.clients[index].pwr_state = VGA_SWITCHEROO_ON; + return 0; +} + +static int vga_switchoff(int index) +{ + /* call the driver callback to turn off device */ + vgasr_priv.clients[index].set_gpu_state(vgasr_priv.clients[index].pdev, VGA_SWITCHEROO_OFF); + vgasr_priv.handler->power_state(vgasr_priv.handle, index, VGA_SWITCHEROO_OFF); + vgasr_priv.clients[index].pwr_state = VGA_SWITCHEROO_OFF; + return 0; +} + +static int vga_switchto(int index) +{ + int cur = vgasr_priv.active_client; + int ret; + + if (cur == index) + return 0; + + /* power up the first device */ + if (vgasr_priv.clients[index].pwr_state == VGA_SWITCHEROO_OFF) { + vga_switchon(index); + } + + + ret = pci_enable_device(vgasr_priv.clients[index].pdev); + if (ret) + return ret; + + /* swap shadow resource to denote boot VGA device has changed so X starts on new device */ + vgasr_priv.clients[cur].pdev->resource[PCI_ROM_RESOURCE].flags &= ~IORESOURCE_ROM_SHADOW; + vgasr_priv.clients[index].pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW; + + if (vgasr_priv.clients[index].fb_info) { + struct fb_event event; + event.info = vgasr_priv.clients[index].fb_info; + fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event); + } + + ret = vgasr_priv.handler->switchto(vgasr_priv.handle, index); + if (ret) + return ret; + + if (vgasr_priv.clients[cur].pwr_state == VGA_SWITCHEROO_ON) { + vga_switchoff(cur); + } + + vgasr_priv.active_client = index; + return 0; +} + +static ssize_t +vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf, + size_t cnt, loff_t *ppos) +{ + char pci_id[64]; + char *pdev_name; + int i, ret; + + if (cnt > 63) + cnt = 63; + + if (copy_from_user(pci_id, ubuf, cnt)) + return -EFAULT; + + /* pwr off the device not in use */ + if (strncmp(pci_id, "OFF", 3) == 0) { + for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { + if (vgasr_priv.active_client == i) + continue; + if (vgasr_priv.clients[i].pwr_state == VGA_SWITCHEROO_ON) { + vga_switchoff(i); + } + } + goto out; + } + /* pwr on the device not in use */ + if (strncmp(pci_id, "ON", 2) == 0) { + for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { + if (vgasr_priv.active_client == i) + continue; + if (vgasr_priv.clients[i].pwr_state == VGA_SWITCHEROO_OFF) { + vga_switchon(i); + } + } + goto out; + } + /* switch devices */ + for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { + pdev_name = pci_name(vgasr_priv.clients[i].pdev); + if (strncmp(pci_id, pdev_name, strlen(pdev_name)) == 0) { + printk("switching to %d %s\n", i, pdev_name); + ret = vga_switchto(i); + if (ret) + printk("switching failed %d\n", ret); + break; + } + } +out: + return cnt; +} + +static const struct file_operations vga_switcheroo_debugfs_fops = { + .owner = THIS_MODULE, + .open = vga_switcheroo_debugfs_open, + .write = vga_switcheroo_debugfs_write, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv) +{ + if (priv->switch_file) { + debugfs_remove(priv->switch_file); + priv->switch_file = NULL; + } + if (priv->debugfs_root) { + debugfs_remove(priv->debugfs_root); + priv->debugfs_root = NULL; + } +} + +static int vga_switcheroo_debugfs_init(struct vgasr_priv *priv) +{ + /* already initialised */ + if (priv->debugfs_root) + return 0; + priv->debugfs_root = debugfs_create_dir("vgaswitcheroo", NULL); + + if (!priv->debugfs_root) { + printk(KERN_ERR "Cannot create /sys/kernel/debug/vgaswitcheroo\n"); + goto fail; + } + + priv->switch_file = debugfs_create_file("switch", 0644, + priv->debugfs_root, NULL, &vga_switcheroo_debugfs_fops); + if (!priv->switch_file) { + printk(KERN_ERR "cannot create /sys/kernel/debug/vgaswitcheroo/switch\n"); + goto fail; + } + return 0; +fail: + vga_switcheroo_debugfs_fini(priv); + return -1; +} diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c index 3681c6a..4fadd99 100644 --- a/drivers/video/console/fbcon.c +++ b/drivers/video/console/fbcon.c @@ -3025,6 +3025,20 @@ static int fbcon_fb_unregistered(struct fb_info *info) return 0; } +static void fbcon_remap_all(int idx) +{ + int i; + for (i = first_fb_vc; i <= last_fb_vc; i++) { + set_con2fb_map(i, idx, 0); + } + if (con_is_bound(&fb_con)) { + printk(KERN_INFO "fbcon: Remapping primary device, " + "fb%i, to tty %i-%i\n", idx, + first_fb_vc + 1, last_fb_vc + 1); + info_idx = idx; + } +} + #ifdef CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY static void fbcon_select_primary(struct fb_info *info) { @@ -3225,6 +3239,10 @@ static int fbcon_event_notify(struct notifier_block *self, caps = event->data; fbcon_get_requirement(info, caps); break; + case FB_EVENT_REMAP_ALL_CONSOLE: + idx = info->node; + fbcon_remap_all(idx); + break; } done: return ret; diff --git a/include/linux/fb.h b/include/linux/fb.h index de9c722..cb3ff5c 100644 --- a/include/linux/fb.h +++ b/include/linux/fb.h @@ -543,6 +543,8 @@ struct fb_cursor_user { #define FB_EVENT_GET_REQ 0x0D /* Unbind from the console if possible */ #define FB_EVENT_FB_UNBIND 0x0E +/* CONSOLE-SPECIFIC: remap all consoles to new fb - for vga switcheroo */ +#define FB_EVENT_REMAP_ALL_CONSOLE 0x0F struct fb_event { struct fb_info *info; diff --git a/include/linux/vga_switcheroo.h b/include/linux/vga_switcheroo.h new file mode 100644 index 0000000..694cfc5 --- /dev/null +++ b/include/linux/vga_switcheroo.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 Red Hat Inc. + * Author : Dave Airlie + * + * Licensed under GPLv2 + * + * vga_switcheroo.h - Support for laptop with dual GPU using one set of outputs + */ + +#include +#include + +enum vga_switcheroo_state { + VGA_SWITCHEROO_OFF, + VGA_SWITCHEROO_ON, +}; + +enum vga_switcheroo_method { + VGA_SWITCHEROO_NONE, + VGA_SWITCHEROO_ATPX, + VGA_SWITCHEROO_DSM, +}; + +enum vga_switcheroo_client_id { + VGA_SWITCHEROO_IGD, + VGA_SWITCHEROO_DIS, + VGA_SWITCHEROO_MAX_CLIENTS, +}; + +void vga_switcheroo_unregister_client(struct pci_dev *dev); +int vga_switcheroo_register_client(struct pci_dev *dev, + void (*set_gpu_state)(struct pci_dev *dev, enum vga_switcheroo_state)); + +void vga_switcheroo_client_fb_set(struct pci_dev *dev, + struct fb_info *info); + +struct vga_switcheroo_handler { + enum vga_switcheroo_method method_id; + int (*switchto)(acpi_handle handle, + enum vga_switcheroo_client_id id); + int (*power_state)(acpi_handle handle, + enum vga_switcheroo_client_id id, + enum vga_switcheroo_state state); +}; + +int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler); +void vga_switcheroo_unregister_handler(void); -- 1.6.5.2