Merge branch 'gpu-switcher' of /ssd/git//linux-2.6 into drm-next-stage
* 'gpu-switcher' of /ssd/git//linux-2.6: vga_switcheroo: initial implementation (v15) fb: for framebuffer handover don't exit the loop early. Conflicts: drivers/gpu/drm/i915/i915_dma.c drivers/gpu/drm/radeon/Makefile drivers/gpu/drm/radeon/radeon.h
This commit is contained in:
Dave Airlie
commit
1c62233508
|
|
@ -37,6 +37,7 @@
|
|||
#include <linux/vgaarb.h>
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/pnp.h>
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
/* 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
|
||||
|
|
@ -1381,6 +1382,32 @@ 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_INFO "i915: switched off\n");
|
||||
/* i915 resume handler doesn't set to D0 */
|
||||
pci_set_power_state(dev->pdev, PCI_D0);
|
||||
i915_resume(dev);
|
||||
} else {
|
||||
printk(KERN_ERR "i915: switched off\n");
|
||||
i915_suspend(dev, pmm);
|
||||
}
|
||||
}
|
||||
|
||||
static bool i915_switcheroo_can_switch(struct pci_dev *pdev)
|
||||
{
|
||||
struct drm_device *dev = pci_get_drvdata(pdev);
|
||||
bool can_switch;
|
||||
|
||||
spin_lock(&dev->count_lock);
|
||||
can_switch = (dev->open_count == 0);
|
||||
spin_unlock(&dev->count_lock);
|
||||
return can_switch;
|
||||
}
|
||||
|
||||
static int i915_load_modeset_init(struct drm_device *dev,
|
||||
unsigned long prealloc_start,
|
||||
unsigned long prealloc_size,
|
||||
|
|
@ -1442,6 +1469,12 @@ 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,
|
||||
i915_switcheroo_can_switch);
|
||||
if (ret)
|
||||
goto destroy_ringbuffer;
|
||||
|
||||
intel_modeset_init(dev);
|
||||
|
||||
ret = drm_irq_install(dev);
|
||||
|
|
@ -1733,6 +1766,7 @@ int i915_driver_unload(struct drm_device *dev)
|
|||
dev_priv->child_dev_num = 0;
|
||||
}
|
||||
drm_irq_uninstall(dev);
|
||||
vga_switcheroo_unregister_client(dev->pdev);
|
||||
vga_client_register(dev->pdev, NULL, NULL, NULL);
|
||||
}
|
||||
|
||||
|
|
@ -1802,6 +1836,7 @@ void i915_driver_lastclose(struct drm_device * dev)
|
|||
|
||||
if (!dev_priv || drm_core_check_feature(dev, DRIVER_MODESET)) {
|
||||
drm_fb_helper_restore();
|
||||
vga_switcheroo_process_delayed_switch();
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ static int i915_drm_freeze(struct drm_device *dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i915_suspend(struct drm_device *dev, pm_message_t state)
|
||||
int i915_suspend(struct drm_device *dev, pm_message_t state)
|
||||
{
|
||||
int error;
|
||||
|
||||
|
|
@ -268,7 +268,7 @@ static int i915_drm_thaw(struct drm_device *dev)
|
|||
return error;
|
||||
}
|
||||
|
||||
static int i915_resume(struct drm_device *dev)
|
||||
int i915_resume(struct drm_device *dev)
|
||||
{
|
||||
if (pci_enable_device(dev->pdev))
|
||||
return -EIO;
|
||||
|
|
|
|||
|
|
@ -773,6 +773,8 @@ extern unsigned int i915_fbpercrtc;
|
|||
extern unsigned int i915_powersave;
|
||||
extern unsigned int i915_lvds_downclock;
|
||||
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@
|
|||
#include <linux/delay.h>
|
||||
#include <linux/fb.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
|
|
@ -235,6 +236,7 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width,
|
|||
obj_priv->gtt_offset, fbo);
|
||||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
vga_switcheroo_client_fb_set(dev->pdev, info);
|
||||
return 0;
|
||||
|
||||
out_unpin:
|
||||
|
|
|
|||
|
|
@ -11,6 +11,8 @@
|
|||
#include "nouveau_drm.h"
|
||||
#include "nv50_display.h"
|
||||
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
#define NOUVEAU_DSM_SUPPORTED 0x00
|
||||
#define NOUVEAU_DSM_SUPPORTED_FUNCTIONS 0x00
|
||||
|
||||
|
|
@ -28,31 +30,30 @@
|
|||
#define NOUVEAU_DSM_POWER_SPEED 0x01
|
||||
#define NOUVEAU_DSM_POWER_STAMINA 0x02
|
||||
|
||||
static int nouveau_dsm(struct drm_device *dev, int func, int arg, int *result)
|
||||
{
|
||||
static char muid[] = {
|
||||
0xA0, 0xA0, 0x95, 0x9D, 0x60, 0x00, 0x48, 0x4D,
|
||||
0xB3, 0x4D, 0x7E, 0x5F, 0xEA, 0x12, 0x9F, 0xD4,
|
||||
};
|
||||
static struct nouveau_dsm_priv {
|
||||
bool dsm_detected;
|
||||
acpi_handle dhandle;
|
||||
acpi_handle dsm_handle;
|
||||
} nouveau_dsm_priv;
|
||||
|
||||
struct pci_dev *pdev = dev->pdev;
|
||||
struct acpi_handle *handle;
|
||||
static const char nouveau_dsm_muid[] = {
|
||||
0xA0, 0xA0, 0x95, 0x9D, 0x60, 0x00, 0x48, 0x4D,
|
||||
0xB3, 0x4D, 0x7E, 0x5F, 0xEA, 0x12, 0x9F, 0xD4,
|
||||
};
|
||||
|
||||
static int nouveau_dsm(acpi_handle handle, int func, int arg, int *result)
|
||||
{
|
||||
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
|
||||
struct acpi_object_list input;
|
||||
union acpi_object params[4];
|
||||
union acpi_object *obj;
|
||||
int err;
|
||||
|
||||
handle = DEVICE_ACPI_HANDLE(&pdev->dev);
|
||||
|
||||
if (!handle)
|
||||
return -ENODEV;
|
||||
|
||||
input.count = 4;
|
||||
input.pointer = params;
|
||||
params[0].type = ACPI_TYPE_BUFFER;
|
||||
params[0].buffer.length = sizeof(muid);
|
||||
params[0].buffer.pointer = (char *)muid;
|
||||
params[0].buffer.length = sizeof(nouveau_dsm_muid);
|
||||
params[0].buffer.pointer = (char *)nouveau_dsm_muid;
|
||||
params[1].type = ACPI_TYPE_INTEGER;
|
||||
params[1].integer.value = 0x00000102;
|
||||
params[2].type = ACPI_TYPE_INTEGER;
|
||||
|
|
@ -62,7 +63,7 @@ static int nouveau_dsm(struct drm_device *dev, int func, int arg, int *result)
|
|||
|
||||
err = acpi_evaluate_object(handle, "_DSM", &input, &output);
|
||||
if (err) {
|
||||
NV_INFO(dev, "failed to evaluate _DSM: %d\n", err);
|
||||
printk(KERN_INFO "failed to evaluate _DSM: %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -86,40 +87,119 @@ static int nouveau_dsm(struct drm_device *dev, int func, int arg, int *result)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int nouveau_hybrid_setup(struct drm_device *dev)
|
||||
static int nouveau_dsm_switch_mux(acpi_handle handle, int mux_id)
|
||||
{
|
||||
int result;
|
||||
|
||||
if (nouveau_dsm(dev, NOUVEAU_DSM_POWER, NOUVEAU_DSM_POWER_STATE,
|
||||
&result))
|
||||
return -ENODEV;
|
||||
|
||||
NV_INFO(dev, "_DSM hardware status gave 0x%x\n", result);
|
||||
|
||||
if (result) { /* Ensure that the external GPU is enabled */
|
||||
nouveau_dsm(dev, NOUVEAU_DSM_LED, NOUVEAU_DSM_LED_SPEED, NULL);
|
||||
nouveau_dsm(dev, NOUVEAU_DSM_POWER, NOUVEAU_DSM_POWER_SPEED,
|
||||
NULL);
|
||||
} else { /* Stamina mode - disable the external GPU */
|
||||
nouveau_dsm(dev, NOUVEAU_DSM_LED, NOUVEAU_DSM_LED_STAMINA,
|
||||
NULL);
|
||||
nouveau_dsm(dev, NOUVEAU_DSM_POWER, NOUVEAU_DSM_POWER_STAMINA,
|
||||
NULL);
|
||||
}
|
||||
return nouveau_dsm(handle, NOUVEAU_DSM_LED, mux_id, NULL);
|
||||
}
|
||||
|
||||
static int nouveau_dsm_set_discrete_state(acpi_handle handle, enum vga_switcheroo_state state)
|
||||
{
|
||||
int arg;
|
||||
if (state == VGA_SWITCHEROO_ON)
|
||||
arg = NOUVEAU_DSM_POWER_SPEED;
|
||||
else
|
||||
arg = NOUVEAU_DSM_POWER_STAMINA;
|
||||
nouveau_dsm(handle, NOUVEAU_DSM_POWER, arg, NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool nouveau_dsm_probe(struct drm_device *dev)
|
||||
static int nouveau_dsm_switchto(enum vga_switcheroo_client_id id)
|
||||
{
|
||||
int support = 0;
|
||||
if (id == VGA_SWITCHEROO_IGD)
|
||||
return nouveau_dsm_switch_mux(nouveau_dsm_priv.dsm_handle, NOUVEAU_DSM_LED_STAMINA);
|
||||
else
|
||||
return nouveau_dsm_switch_mux(nouveau_dsm_priv.dsm_handle, NOUVEAU_DSM_LED_SPEED);
|
||||
}
|
||||
|
||||
if (nouveau_dsm(dev, NOUVEAU_DSM_SUPPORTED,
|
||||
NOUVEAU_DSM_SUPPORTED_FUNCTIONS, &support))
|
||||
return false;
|
||||
|
||||
if (!support)
|
||||
static int nouveau_dsm_power_state(enum vga_switcheroo_client_id id,
|
||||
enum vga_switcheroo_state state)
|
||||
{
|
||||
if (id == VGA_SWITCHEROO_IGD)
|
||||
return 0;
|
||||
|
||||
return nouveau_dsm_set_discrete_state(nouveau_dsm_priv.dsm_handle, state);
|
||||
}
|
||||
|
||||
static int nouveau_dsm_init(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int nouveau_dsm_get_client_id(struct pci_dev *pdev)
|
||||
{
|
||||
if (nouveau_dsm_priv.dhandle == DEVICE_ACPI_HANDLE(&pdev->dev))
|
||||
return VGA_SWITCHEROO_IGD;
|
||||
else
|
||||
return VGA_SWITCHEROO_DIS;
|
||||
}
|
||||
|
||||
static struct vga_switcheroo_handler nouveau_dsm_handler = {
|
||||
.switchto = nouveau_dsm_switchto,
|
||||
.power_state = nouveau_dsm_power_state,
|
||||
.init = nouveau_dsm_init,
|
||||
.get_client_id = nouveau_dsm_get_client_id,
|
||||
};
|
||||
|
||||
static bool nouveau_dsm_pci_probe(struct pci_dev *pdev)
|
||||
{
|
||||
acpi_handle dhandle, nvidia_handle;
|
||||
acpi_status status;
|
||||
int ret;
|
||||
uint32_t result;
|
||||
|
||||
dhandle = DEVICE_ACPI_HANDLE(&pdev->dev);
|
||||
if (!dhandle)
|
||||
return false;
|
||||
status = acpi_get_handle(dhandle, "_DSM", &nvidia_handle);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ret= nouveau_dsm(nvidia_handle, NOUVEAU_DSM_SUPPORTED,
|
||||
NOUVEAU_DSM_SUPPORTED_FUNCTIONS, &result);
|
||||
if (ret < 0)
|
||||
return false;
|
||||
|
||||
nouveau_dsm_priv.dhandle = dhandle;
|
||||
nouveau_dsm_priv.dsm_handle = nvidia_handle;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool nouveau_dsm_detect(void)
|
||||
{
|
||||
char acpi_method_name[255] = { 0 };
|
||||
struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
|
||||
struct pci_dev *pdev = NULL;
|
||||
int has_dsm = 0;
|
||||
int vga_count = 0;
|
||||
while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
|
||||
vga_count++;
|
||||
|
||||
has_dsm |= (nouveau_dsm_pci_probe(pdev) == true);
|
||||
}
|
||||
|
||||
if (vga_count == 2 && has_dsm) {
|
||||
acpi_get_name(nouveau_dsm_priv.dsm_handle, ACPI_FULL_PATHNAME, &buffer);
|
||||
printk(KERN_INFO "VGA switcheroo: detected DSM switching method %s handle\n",
|
||||
acpi_method_name);
|
||||
nouveau_dsm_priv.dsm_detected = true;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void nouveau_register_dsm_handler(void)
|
||||
{
|
||||
bool r;
|
||||
|
||||
r = nouveau_dsm_detect();
|
||||
if (!r)
|
||||
return;
|
||||
|
||||
vga_switcheroo_register_handler(&nouveau_dsm_handler);
|
||||
}
|
||||
|
||||
void nouveau_unregister_dsm_handler(void)
|
||||
{
|
||||
vga_switcheroo_unregister_handler();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -135,7 +135,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);
|
||||
|
|
@ -233,7 +233,7 @@ out_abort:
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
int
|
||||
nouveau_pci_resume(struct pci_dev *pdev)
|
||||
{
|
||||
struct drm_device *dev = pci_get_drvdata(pdev);
|
||||
|
|
@ -402,8 +402,10 @@ static int __init nouveau_init(void)
|
|||
nouveau_modeset = 1;
|
||||
}
|
||||
|
||||
if (nouveau_modeset == 1)
|
||||
if (nouveau_modeset == 1) {
|
||||
driver.driver_features |= DRIVER_MODESET;
|
||||
nouveau_register_dsm_handler();
|
||||
}
|
||||
|
||||
return drm_init(&driver);
|
||||
}
|
||||
|
|
@ -411,6 +413,7 @@ static int __init nouveau_init(void)
|
|||
static void __exit nouveau_exit(void)
|
||||
{
|
||||
drm_exit(&driver);
|
||||
nouveau_unregister_dsm_handler();
|
||||
}
|
||||
|
||||
module_init(nouveau_init);
|
||||
|
|
|
|||
|
|
@ -622,7 +622,6 @@ struct drm_nouveau_private {
|
|||
} susres;
|
||||
|
||||
struct backlight_device *backlight;
|
||||
bool acpi_dsm;
|
||||
|
||||
struct nouveau_channel *evo;
|
||||
|
||||
|
|
@ -690,6 +689,9 @@ extern int nouveau_ignorelid;
|
|||
extern int nouveau_nofbaccel;
|
||||
extern int nouveau_noaccel;
|
||||
|
||||
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);
|
||||
|
|
@ -850,19 +852,8 @@ extern int nouveau_dma_init(struct nouveau_channel *);
|
|||
extern int nouveau_dma_wait(struct nouveau_channel *, int slots, int size);
|
||||
|
||||
/* nouveau_acpi.c */
|
||||
#ifdef CONFIG_ACPI
|
||||
extern int nouveau_hybrid_setup(struct drm_device *dev);
|
||||
extern bool nouveau_dsm_probe(struct drm_device *dev);
|
||||
#else
|
||||
static inline int nouveau_hybrid_setup(struct drm_device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
static inline bool nouveau_dsm_probe(struct drm_device *dev)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
void nouveau_register_dsm_handler(void);
|
||||
void nouveau_unregister_dsm_handler(void);
|
||||
|
||||
/* nouveau_backlight.c */
|
||||
#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@
|
|||
#include <linux/fb.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/screen_info.h>
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
|
|
@ -370,6 +371,7 @@ nouveau_fbcon_create(struct drm_device *dev, uint32_t fb_width,
|
|||
nvbo->bo.offset, nvbo);
|
||||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
vga_switcheroo_client_fb_set(dev->pdev, info);
|
||||
return 0;
|
||||
|
||||
out_unref:
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@
|
|||
#include "drm_sarea.h"
|
||||
#include "drm_crtc_helper.h"
|
||||
#include <linux/vgaarb.h>
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
#include "nouveau_drv.h"
|
||||
#include "nouveau_drm.h"
|
||||
|
|
@ -371,6 +372,30 @@ 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);
|
||||
}
|
||||
}
|
||||
|
||||
static bool nouveau_switcheroo_can_switch(struct pci_dev *pdev)
|
||||
{
|
||||
struct drm_device *dev = pci_get_drvdata(pdev);
|
||||
bool can_switch;
|
||||
|
||||
spin_lock(&dev->count_lock);
|
||||
can_switch = (dev->open_count == 0);
|
||||
spin_unlock(&dev->count_lock);
|
||||
return can_switch;
|
||||
}
|
||||
|
||||
int
|
||||
nouveau_card_init(struct drm_device *dev)
|
||||
{
|
||||
|
|
@ -384,6 +409,8 @@ 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,
|
||||
nouveau_switcheroo_can_switch);
|
||||
|
||||
/* Initialise internal driver API hooks */
|
||||
ret = nouveau_init_engine_ptrs(dev);
|
||||
|
|
@ -618,11 +645,6 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
|
|||
NV_DEBUG(dev, "vendor: 0x%X device: 0x%X class: 0x%X\n",
|
||||
dev->pci_vendor, dev->pci_device, dev->pdev->class);
|
||||
|
||||
dev_priv->acpi_dsm = nouveau_dsm_probe(dev);
|
||||
|
||||
if (dev_priv->acpi_dsm)
|
||||
nouveau_hybrid_setup(dev);
|
||||
|
||||
dev_priv->wq = create_workqueue("nouveau");
|
||||
if (!dev_priv->wq)
|
||||
return -EINVAL;
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ radeon-y += radeon_device.o radeon_kms.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 \
|
||||
evergreen.o
|
||||
evergreen.o radeon_atpx_handler.o
|
||||
|
||||
radeon-$(CONFIG_COMPAT) += radeon_ioc32.o
|
||||
|
||||
|
|
|
|||
|
|
@ -119,6 +119,10 @@ struct radeon_device;
|
|||
/*
|
||||
* BIOS.
|
||||
*/
|
||||
#define ATRM_BIOS_PAGE 4096
|
||||
|
||||
bool radeon_atrm_supported(struct pci_dev *pdev);
|
||||
int radeon_atrm_get_bios_chunk(uint8_t *bios, int offset, int len);
|
||||
bool radeon_get_bios(struct radeon_device *rdev);
|
||||
|
||||
|
||||
|
|
@ -957,6 +961,8 @@ struct radeon_device {
|
|||
int audio_bits_per_sample;
|
||||
uint8_t audio_status_bits;
|
||||
uint8_t audio_category_code;
|
||||
|
||||
bool powered_down;
|
||||
};
|
||||
|
||||
int radeon_device_init(struct radeon_device *rdev,
|
||||
|
|
@ -1167,6 +1173,8 @@ extern void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain);
|
|||
extern bool radeon_ttm_bo_is_radeon_bo(struct ttm_buffer_object *bo);
|
||||
extern void radeon_vram_location(struct radeon_device *rdev, struct radeon_mc *mc, u64 base);
|
||||
extern void radeon_gtt_location(struct radeon_device *rdev, struct radeon_mc *mc);
|
||||
extern int radeon_resume_kms(struct drm_device *dev);
|
||||
extern int radeon_suspend_kms(struct drm_device *dev, pm_message_t state);
|
||||
|
||||
/* r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 */
|
||||
struct r100_mc_save {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,258 @@
|
|||
/*
|
||||
* Copyright (c) 2010 Red Hat Inc.
|
||||
* Author : Dave Airlie <airlied@redhat.com>
|
||||
*
|
||||
* Licensed under GPLv2
|
||||
*
|
||||
* ATPX support for both Intel/ATI
|
||||
*/
|
||||
|
||||
#include <linux/vga_switcheroo.h>
|
||||
#include <acpi/acpi.h>
|
||||
#include <acpi/acpi_bus.h>
|
||||
#include <linux/pci.h>
|
||||
|
||||
#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 struct radeon_atpx_priv {
|
||||
bool atpx_detected;
|
||||
/* handle for device - and atpx */
|
||||
acpi_handle dhandle;
|
||||
acpi_handle atpx_handle;
|
||||
acpi_handle atrm_handle;
|
||||
} radeon_atpx_priv;
|
||||
|
||||
/* retrieve the ROM in 4k blocks */
|
||||
static int radeon_atrm_call(acpi_handle atrm_handle, uint8_t *bios,
|
||||
int offset, int len)
|
||||
{
|
||||
acpi_status status;
|
||||
union acpi_object atrm_arg_elements[2], *obj;
|
||||
struct acpi_object_list atrm_arg;
|
||||
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL};
|
||||
|
||||
atrm_arg.count = 2;
|
||||
atrm_arg.pointer = &atrm_arg_elements[0];
|
||||
|
||||
atrm_arg_elements[0].type = ACPI_TYPE_INTEGER;
|
||||
atrm_arg_elements[0].integer.value = offset;
|
||||
|
||||
atrm_arg_elements[1].type = ACPI_TYPE_INTEGER;
|
||||
atrm_arg_elements[1].integer.value = len;
|
||||
|
||||
status = acpi_evaluate_object(atrm_handle, NULL, &atrm_arg, &buffer);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
printk("failed to evaluate ATRM got %s\n", acpi_format_exception(status));
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
obj = (union acpi_object *)buffer.pointer;
|
||||
memcpy(bios+offset, obj->buffer.pointer, len);
|
||||
kfree(buffer.pointer);
|
||||
return len;
|
||||
}
|
||||
|
||||
bool radeon_atrm_supported(struct pci_dev *pdev)
|
||||
{
|
||||
/* get the discrete ROM only via ATRM */
|
||||
if (!radeon_atpx_priv.atpx_detected)
|
||||
return false;
|
||||
|
||||
if (radeon_atpx_priv.dhandle == DEVICE_ACPI_HANDLE(&pdev->dev))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
int radeon_atrm_get_bios_chunk(uint8_t *bios, int offset, int len)
|
||||
{
|
||||
return radeon_atrm_call(radeon_atpx_priv.atrm_handle, bios, offset, len);
|
||||
}
|
||||
|
||||
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(KERN_INFO "radeon atpx: version 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(enum vga_switcheroo_client_id id)
|
||||
{
|
||||
if (id == VGA_SWITCHEROO_IGD)
|
||||
radeon_atpx_switch_mux(radeon_atpx_priv.atpx_handle, 0);
|
||||
else
|
||||
radeon_atpx_switch_mux(radeon_atpx_priv.atpx_handle, 1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int radeon_atpx_power_state(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(radeon_atpx_priv.atpx_handle, state);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
|
||||
{
|
||||
acpi_handle dhandle, atpx_handle, atrm_handle;
|
||||
acpi_status status;
|
||||
|
||||
dhandle = DEVICE_ACPI_HANDLE(&pdev->dev);
|
||||
if (!dhandle)
|
||||
return false;
|
||||
|
||||
status = acpi_get_handle(dhandle, "ATPX", &atpx_handle);
|
||||
if (ACPI_FAILURE(status))
|
||||
return false;
|
||||
|
||||
status = acpi_get_handle(dhandle, "ATRM", &atrm_handle);
|
||||
if (ACPI_FAILURE(status))
|
||||
return false;
|
||||
|
||||
radeon_atpx_priv.dhandle = dhandle;
|
||||
radeon_atpx_priv.atpx_handle = atpx_handle;
|
||||
radeon_atpx_priv.atrm_handle = atrm_handle;
|
||||
return true;
|
||||
}
|
||||
|
||||
static int radeon_atpx_init(void)
|
||||
{
|
||||
/* set up the ATPX handle */
|
||||
|
||||
radeon_atpx_get_version(radeon_atpx_priv.atpx_handle);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int radeon_atpx_get_client_id(struct pci_dev *pdev)
|
||||
{
|
||||
if (radeon_atpx_priv.dhandle == DEVICE_ACPI_HANDLE(&pdev->dev))
|
||||
return VGA_SWITCHEROO_IGD;
|
||||
else
|
||||
return VGA_SWITCHEROO_DIS;
|
||||
}
|
||||
|
||||
static struct vga_switcheroo_handler radeon_atpx_handler = {
|
||||
.switchto = radeon_atpx_switchto,
|
||||
.power_state = radeon_atpx_power_state,
|
||||
.init = radeon_atpx_init,
|
||||
.get_client_id = radeon_atpx_get_client_id,
|
||||
};
|
||||
|
||||
static bool radeon_atpx_detect(void)
|
||||
{
|
||||
char acpi_method_name[255] = { 0 };
|
||||
struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
|
||||
struct pci_dev *pdev = NULL;
|
||||
bool has_atpx = false;
|
||||
int vga_count = 0;
|
||||
|
||||
while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
|
||||
vga_count++;
|
||||
|
||||
has_atpx |= (radeon_atpx_pci_probe_handle(pdev) == true);
|
||||
}
|
||||
|
||||
if (has_atpx && vga_count == 2) {
|
||||
acpi_get_name(radeon_atpx_priv.atpx_handle, ACPI_FULL_PATHNAME, &buffer);
|
||||
printk(KERN_INFO "VGA switcheroo: detected switching method %s handle\n",
|
||||
acpi_method_name);
|
||||
radeon_atpx_priv.atpx_detected = true;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void radeon_register_atpx_handler(void)
|
||||
{
|
||||
bool r;
|
||||
|
||||
/* detect if we have any ATPX + 2 VGA in the system */
|
||||
r = radeon_atpx_detect();
|
||||
if (!r)
|
||||
return;
|
||||
|
||||
vga_switcheroo_register_handler(&radeon_atpx_handler);
|
||||
}
|
||||
|
||||
void radeon_unregister_atpx_handler(void)
|
||||
{
|
||||
vga_switcheroo_unregister_handler();
|
||||
}
|
||||
|
|
@ -30,6 +30,7 @@
|
|||
#include "radeon.h"
|
||||
#include "atom.h"
|
||||
|
||||
#include <linux/vga_switcheroo.h>
|
||||
/*
|
||||
* BIOS.
|
||||
*/
|
||||
|
|
@ -62,7 +63,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;
|
||||
}
|
||||
|
|
@ -93,6 +94,38 @@ static bool radeon_read_bios(struct radeon_device *rdev)
|
|||
return true;
|
||||
}
|
||||
|
||||
/* ATRM is used to get the BIOS on the discrete cards in
|
||||
* dual-gpu systems.
|
||||
*/
|
||||
static bool radeon_atrm_get_bios(struct radeon_device *rdev)
|
||||
{
|
||||
int ret;
|
||||
int size = 64 * 1024;
|
||||
int i;
|
||||
|
||||
if (!radeon_atrm_supported(rdev->pdev))
|
||||
return false;
|
||||
|
||||
rdev->bios = kmalloc(size, GFP_KERNEL);
|
||||
if (!rdev->bios) {
|
||||
DRM_ERROR("Unable to allocate bios\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
for (i = 0; i < size / ATRM_BIOS_PAGE; i++) {
|
||||
ret = radeon_atrm_get_bios_chunk(rdev->bios,
|
||||
(i * ATRM_BIOS_PAGE),
|
||||
ATRM_BIOS_PAGE);
|
||||
if (ret <= 0)
|
||||
break;
|
||||
}
|
||||
|
||||
if (i == 0 || rdev->bios[0] != 0x55 || rdev->bios[1] != 0xaa) {
|
||||
kfree(rdev->bios);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
static bool r700_read_disabled_bios(struct radeon_device *rdev)
|
||||
{
|
||||
uint32_t viph_control;
|
||||
|
|
@ -388,16 +421,16 @@ static bool radeon_read_disabled_bios(struct radeon_device *rdev)
|
|||
return legacy_read_disabled_bios(rdev);
|
||||
}
|
||||
|
||||
|
||||
bool radeon_get_bios(struct radeon_device *rdev)
|
||||
{
|
||||
bool r;
|
||||
uint16_t tmp;
|
||||
|
||||
if (rdev->flags & RADEON_IS_IGP) {
|
||||
r = radeon_atrm_get_bios(rdev);
|
||||
if (r == false)
|
||||
r = igp_read_bios_from_vram(rdev);
|
||||
if (r == false)
|
||||
r = radeon_read_bios(rdev);
|
||||
} else
|
||||
if (r == false)
|
||||
r = radeon_read_bios(rdev);
|
||||
if (r == false) {
|
||||
r = radeon_read_disabled_bios(rdev);
|
||||
|
|
@ -408,6 +441,7 @@ bool radeon_get_bios(struct radeon_device *rdev)
|
|||
return false;
|
||||
}
|
||||
if (rdev->bios[0] != 0x55 || rdev->bios[1] != 0xaa) {
|
||||
printk("BIOS signature incorrect %x %x\n", rdev->bios[0], rdev->bios[1]);
|
||||
goto free_bios;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
#include <drm/drm_crtc_helper.h>
|
||||
#include <drm/radeon_drm.h>
|
||||
#include <linux/vgaarb.h>
|
||||
#include <linux/vga_switcheroo.h>
|
||||
#include "radeon_reg.h"
|
||||
#include "radeon.h"
|
||||
#include "radeon_asic.h"
|
||||
|
|
@ -655,6 +656,36 @@ 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);
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
pm_message_t pmm = { .event = PM_EVENT_SUSPEND };
|
||||
if (state == VGA_SWITCHEROO_ON) {
|
||||
printk(KERN_INFO "radeon: switched on\n");
|
||||
/* don't suspend or resume card normally */
|
||||
rdev->powered_down = false;
|
||||
radeon_resume_kms(dev);
|
||||
} else {
|
||||
printk(KERN_INFO "radeon: switched off\n");
|
||||
radeon_suspend_kms(dev, pmm);
|
||||
/* don't suspend or resume card normally */
|
||||
rdev->powered_down = true;
|
||||
}
|
||||
}
|
||||
|
||||
static bool radeon_switcheroo_can_switch(struct pci_dev *pdev)
|
||||
{
|
||||
struct drm_device *dev = pci_get_drvdata(pdev);
|
||||
bool can_switch;
|
||||
|
||||
spin_lock(&dev->count_lock);
|
||||
can_switch = (dev->open_count == 0);
|
||||
spin_unlock(&dev->count_lock);
|
||||
return can_switch;
|
||||
}
|
||||
|
||||
|
||||
int radeon_device_init(struct radeon_device *rdev,
|
||||
struct drm_device *ddev,
|
||||
struct pci_dev *pdev,
|
||||
|
|
@ -737,6 +768,9 @@ 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,
|
||||
radeon_switcheroo_can_switch);
|
||||
|
||||
r = radeon_init(rdev);
|
||||
if (r)
|
||||
|
|
@ -768,6 +802,7 @@ void radeon_device_fini(struct radeon_device *rdev)
|
|||
rdev->shutdown = true;
|
||||
radeon_fini(rdev);
|
||||
destroy_workqueue(rdev->wq);
|
||||
vga_switcheroo_unregister_client(rdev->pdev);
|
||||
vga_client_register(rdev->pdev, NULL, NULL, NULL);
|
||||
iounmap(rdev->rmmio);
|
||||
rdev->rmmio = NULL;
|
||||
|
|
@ -791,6 +826,8 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state)
|
|||
}
|
||||
rdev = dev->dev_private;
|
||||
|
||||
if (rdev->powered_down)
|
||||
return 0;
|
||||
/* unpin the front buffers */
|
||||
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
||||
struct radeon_framebuffer *rfb = to_radeon_framebuffer(crtc->fb);
|
||||
|
|
@ -836,6 +873,9 @@ int radeon_resume_kms(struct drm_device *dev)
|
|||
{
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
|
||||
if (rdev->powered_down)
|
||||
return 0;
|
||||
|
||||
acquire_console_sem();
|
||||
pci_set_power_state(dev->pdev, PCI_D0);
|
||||
pci_restore_state(dev->pdev);
|
||||
|
|
|
|||
|
|
@ -343,6 +343,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 */
|
||||
|
|
@ -352,6 +353,7 @@ static int __init radeon_init(void)
|
|||
static void __exit radeon_exit(void)
|
||||
{
|
||||
drm_exit(driver);
|
||||
radeon_unregister_atpx_handler();
|
||||
}
|
||||
|
||||
module_init(radeon_init);
|
||||
|
|
|
|||
|
|
@ -462,6 +462,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
|
||||
|
|
|
|||
|
|
@ -39,6 +39,8 @@
|
|||
|
||||
#include "drm_fb_helper.h"
|
||||
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
struct radeon_fb_device {
|
||||
struct drm_fb_helper helper;
|
||||
struct radeon_framebuffer *rfb;
|
||||
|
|
@ -286,6 +288,7 @@ int radeonfb_create(struct drm_device *dev,
|
|||
rfbdev->rdev = rdev;
|
||||
|
||||
mutex_unlock(&rdev->ddev->struct_mutex);
|
||||
vga_switcheroo_client_fb_set(rdev->ddev->pdev, info);
|
||||
return 0;
|
||||
|
||||
out_unref:
|
||||
|
|
|
|||
|
|
@ -30,6 +30,8 @@
|
|||
#include "radeon.h"
|
||||
#include "radeon_drm.h"
|
||||
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
int radeon_driver_unload_kms(struct drm_device *dev)
|
||||
{
|
||||
struct radeon_device *rdev = dev->dev_private;
|
||||
|
|
@ -136,6 +138,7 @@ int radeon_driver_firstopen_kms(struct drm_device *dev)
|
|||
|
||||
void radeon_driver_lastclose_kms(struct drm_device *dev)
|
||||
{
|
||||
vga_switcheroo_process_delayed_switch();
|
||||
}
|
||||
|
||||
int radeon_driver_open_kms(struct drm_device *dev, struct drm_file *file_priv)
|
||||
|
|
|
|||
|
|
@ -8,3 +8,16 @@ config VGA_ARB
|
|||
are accessed at same time they need some kind of coordination. Please
|
||||
see Documentation/vgaarbiter.txt for more details. Select this to
|
||||
enable VGA arbiter.
|
||||
|
||||
config VGA_SWITCHEROO
|
||||
bool "Laptop Hybrid Grapics - GPU switching support"
|
||||
default y
|
||||
depends on X86
|
||||
depends on ACPI
|
||||
help
|
||||
Many laptops released in 2008/9/10 have two gpus with a multiplxer
|
||||
to switch between them. This adds support for dynamic switching when
|
||||
X isn't running and delayed switching until the next logoff. This
|
||||
features is called hybrid graphics, ATI PowerXpress, and Nvidia
|
||||
HybridPower.
|
||||
|
||||
|
|
|
|||
|
|
@ -1 +1,2 @@
|
|||
obj-$(CONFIG_VGA_ARB) += vgaarb.o
|
||||
obj-$(CONFIG_VGA_SWITCHEROO) += vga_switcheroo.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,453 @@
|
|||
/*
|
||||
* Copyright (c) 2010 Red Hat Inc.
|
||||
* Author : Dave Airlie <airlied@redhat.com>
|
||||
*
|
||||
*
|
||||
* 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 <linux/module.h>
|
||||
#include <linux/dmi.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/uaccess.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/debugfs.h>
|
||||
#include <linux/fb.h>
|
||||
|
||||
#include <acpi/acpi.h>
|
||||
#include <acpi/acpi_bus.h>
|
||||
|
||||
#include <linux/pci.h>
|
||||
#include <linux/vga_switcheroo.h>
|
||||
|
||||
struct vga_switcheroo_client {
|
||||
struct pci_dev *pdev;
|
||||
struct fb_info *fb_info;
|
||||
int pwr_state;
|
||||
void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state);
|
||||
bool (*can_switch)(struct pci_dev *pdev);
|
||||
int id;
|
||||
bool active;
|
||||
};
|
||||
|
||||
static DEFINE_MUTEX(vgasr_mutex);
|
||||
|
||||
struct vgasr_priv {
|
||||
|
||||
bool active;
|
||||
bool delayed_switch_active;
|
||||
enum vga_switcheroo_client_id delayed_client_id;
|
||||
|
||||
struct dentry *debugfs_root;
|
||||
struct dentry *switch_file;
|
||||
|
||||
int registered_clients;
|
||||
struct vga_switcheroo_client clients[VGA_SWITCHEROO_MAX_CLIENTS];
|
||||
|
||||
struct vga_switcheroo_handler *handler;
|
||||
};
|
||||
|
||||
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;
|
||||
|
||||
int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler)
|
||||
{
|
||||
mutex_lock(&vgasr_mutex);
|
||||
if (vgasr_priv.handler) {
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
vgasr_priv.handler = handler;
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_register_handler);
|
||||
|
||||
void vga_switcheroo_unregister_handler(void)
|
||||
{
|
||||
mutex_lock(&vgasr_mutex);
|
||||
vgasr_priv.handler = NULL;
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_unregister_handler);
|
||||
|
||||
static void vga_switcheroo_enable(void)
|
||||
{
|
||||
int i;
|
||||
int ret;
|
||||
/* call the handler to init */
|
||||
vgasr_priv.handler->init();
|
||||
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
ret = vgasr_priv.handler->get_client_id(vgasr_priv.clients[i].pdev);
|
||||
if (ret < 0)
|
||||
return;
|
||||
|
||||
vgasr_priv.clients[i].id = ret;
|
||||
}
|
||||
vga_switcheroo_debugfs_init(&vgasr_priv);
|
||||
vgasr_priv.active = true;
|
||||
}
|
||||
|
||||
int vga_switcheroo_register_client(struct pci_dev *pdev,
|
||||
void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state),
|
||||
bool (*can_switch)(struct pci_dev *pdev))
|
||||
{
|
||||
int index;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
/* don't do IGD vs DIS here */
|
||||
if (vgasr_priv.registered_clients & 1)
|
||||
index = 1;
|
||||
else
|
||||
index = 0;
|
||||
|
||||
vgasr_priv.clients[index].pwr_state = VGA_SWITCHEROO_ON;
|
||||
vgasr_priv.clients[index].pdev = pdev;
|
||||
vgasr_priv.clients[index].set_gpu_state = set_gpu_state;
|
||||
vgasr_priv.clients[index].can_switch = can_switch;
|
||||
vgasr_priv.clients[index].id = -1;
|
||||
if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
|
||||
vgasr_priv.clients[index].active = true;
|
||||
|
||||
vgasr_priv.registered_clients |= (1 << index);
|
||||
|
||||
/* if we get two clients + handler */
|
||||
if (vgasr_priv.registered_clients == 0x3 && vgasr_priv.handler) {
|
||||
printk(KERN_INFO "vga_switcheroo: enabled\n");
|
||||
vga_switcheroo_enable();
|
||||
}
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_register_client);
|
||||
|
||||
void vga_switcheroo_unregister_client(struct pci_dev *pdev)
|
||||
{
|
||||
int i;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
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;
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_unregister_client);
|
||||
|
||||
void vga_switcheroo_client_fb_set(struct pci_dev *pdev,
|
||||
struct fb_info *info)
|
||||
{
|
||||
int i;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
if (vgasr_priv.clients[i].pdev == pdev) {
|
||||
vgasr_priv.clients[i].fb_info = info;
|
||||
break;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_client_fb_set);
|
||||
|
||||
static int vga_switcheroo_show(struct seq_file *m, void *v)
|
||||
{
|
||||
int i;
|
||||
mutex_lock(&vgasr_mutex);
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
seq_printf(m, "%d:%c:%s:%s\n", i,
|
||||
vgasr_priv.clients[i].active ? '+' : ' ',
|
||||
vgasr_priv.clients[i].pwr_state ? "Pwr" : "Off",
|
||||
pci_name(vgasr_priv.clients[i].pdev));
|
||||
}
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
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(struct vga_switcheroo_client *client)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_ON);
|
||||
/* call the driver callback to turn on device */
|
||||
client->set_gpu_state(client->pdev, VGA_SWITCHEROO_ON);
|
||||
client->pwr_state = VGA_SWITCHEROO_ON;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int vga_switchoff(struct vga_switcheroo_client *client)
|
||||
{
|
||||
/* call the driver callback to turn off device */
|
||||
client->set_gpu_state(client->pdev, VGA_SWITCHEROO_OFF);
|
||||
vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_OFF);
|
||||
client->pwr_state = VGA_SWITCHEROO_OFF;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int vga_switchto(struct vga_switcheroo_client *new_client)
|
||||
{
|
||||
int ret;
|
||||
int i;
|
||||
struct vga_switcheroo_client *active = NULL;
|
||||
|
||||
if (new_client->active == true)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
if (vgasr_priv.clients[i].active == true) {
|
||||
active = &vgasr_priv.clients[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!active)
|
||||
return 0;
|
||||
|
||||
/* power up the first device */
|
||||
ret = pci_enable_device(new_client->pdev);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (new_client->pwr_state == VGA_SWITCHEROO_OFF)
|
||||
vga_switchon(new_client);
|
||||
|
||||
/* swap shadow resource to denote boot VGA device has changed so X starts on new device */
|
||||
active->active = false;
|
||||
|
||||
active->pdev->resource[PCI_ROM_RESOURCE].flags &= ~IORESOURCE_ROM_SHADOW;
|
||||
new_client->pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW;
|
||||
|
||||
if (new_client->fb_info) {
|
||||
struct fb_event event;
|
||||
event.info = new_client->fb_info;
|
||||
fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event);
|
||||
}
|
||||
|
||||
ret = vgasr_priv.handler->switchto(new_client->id);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (active->pwr_state == VGA_SWITCHEROO_ON)
|
||||
vga_switchoff(active);
|
||||
|
||||
new_client->active = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf,
|
||||
size_t cnt, loff_t *ppos)
|
||||
{
|
||||
char usercmd[64];
|
||||
const char *pdev_name;
|
||||
int i, ret;
|
||||
bool delay = false, can_switch;
|
||||
int client_id = -1;
|
||||
struct vga_switcheroo_client *client = NULL;
|
||||
|
||||
if (cnt > 63)
|
||||
cnt = 63;
|
||||
|
||||
if (copy_from_user(usercmd, ubuf, cnt))
|
||||
return -EFAULT;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
|
||||
if (!vgasr_priv.active)
|
||||
return -EINVAL;
|
||||
|
||||
/* pwr off the device not in use */
|
||||
if (strncmp(usercmd, "OFF", 3) == 0) {
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
if (vgasr_priv.clients[i].active)
|
||||
continue;
|
||||
if (vgasr_priv.clients[i].pwr_state == VGA_SWITCHEROO_ON)
|
||||
vga_switchoff(&vgasr_priv.clients[i]);
|
||||
}
|
||||
goto out;
|
||||
}
|
||||
/* pwr on the device not in use */
|
||||
if (strncmp(usercmd, "ON", 2) == 0) {
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
if (vgasr_priv.clients[i].active)
|
||||
continue;
|
||||
if (vgasr_priv.clients[i].pwr_state == VGA_SWITCHEROO_OFF)
|
||||
vga_switchon(&vgasr_priv.clients[i]);
|
||||
}
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* request a delayed switch - test can we switch now */
|
||||
if (strncmp(usercmd, "DIGD", 4) == 0) {
|
||||
client_id = VGA_SWITCHEROO_IGD;
|
||||
delay = true;
|
||||
}
|
||||
|
||||
if (strncmp(usercmd, "DDIS", 4) == 0) {
|
||||
client_id = VGA_SWITCHEROO_DIS;
|
||||
delay = true;
|
||||
}
|
||||
|
||||
if (strncmp(usercmd, "IGD", 3) == 0)
|
||||
client_id = VGA_SWITCHEROO_IGD;
|
||||
|
||||
if (strncmp(usercmd, "DIS", 3) == 0)
|
||||
client_id = VGA_SWITCHEROO_DIS;
|
||||
|
||||
if (client_id == -1)
|
||||
goto out;
|
||||
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
if (vgasr_priv.clients[i].id == client_id) {
|
||||
client = &vgasr_priv.clients[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
vgasr_priv.delayed_switch_active = false;
|
||||
/* okay we want a switch - test if devices are willing to switch */
|
||||
can_switch = true;
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
can_switch = vgasr_priv.clients[i].can_switch(vgasr_priv.clients[i].pdev);
|
||||
if (can_switch == false) {
|
||||
printk(KERN_ERR "vga_switcheroo: client %d refused switch\n", i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (can_switch == false && delay == false)
|
||||
goto out;
|
||||
|
||||
if (can_switch == true) {
|
||||
pdev_name = pci_name(client->pdev);
|
||||
ret = vga_switchto(client);
|
||||
if (ret)
|
||||
printk(KERN_ERR "vga_switcheroo: switching failed %d\n", ret);
|
||||
} else {
|
||||
printk(KERN_INFO "vga_switcheroo: setting delayed switch to client %d\n", client->id);
|
||||
vgasr_priv.delayed_switch_active = true;
|
||||
vgasr_priv.delayed_client_id = client_id;
|
||||
|
||||
/* we should at least power up the card to
|
||||
make the switch faster */
|
||||
if (client->pwr_state == VGA_SWITCHEROO_OFF)
|
||||
vga_switchon(client);
|
||||
}
|
||||
|
||||
out:
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
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 "vga_switcheroo: 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 "vga_switcheroo: cannot create /sys/kernel/debug/vgaswitcheroo/switch\n");
|
||||
goto fail;
|
||||
}
|
||||
return 0;
|
||||
fail:
|
||||
vga_switcheroo_debugfs_fini(priv);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int vga_switcheroo_process_delayed_switch(void)
|
||||
{
|
||||
struct vga_switcheroo_client *client = NULL;
|
||||
const char *pdev_name;
|
||||
bool can_switch = true;
|
||||
int i;
|
||||
int ret;
|
||||
int err = -EINVAL;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
if (!vgasr_priv.delayed_switch_active)
|
||||
goto err;
|
||||
|
||||
printk(KERN_INFO "vga_switcheroo: processing delayed switch to %d\n", vgasr_priv.delayed_client_id);
|
||||
|
||||
for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
|
||||
if (vgasr_priv.clients[i].id == vgasr_priv.delayed_client_id)
|
||||
client = &vgasr_priv.clients[i];
|
||||
can_switch = vgasr_priv.clients[i].can_switch(vgasr_priv.clients[i].pdev);
|
||||
if (can_switch == false) {
|
||||
printk(KERN_ERR "vga_switcheroo: client %d refused switch\n", i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (can_switch == false || client == NULL)
|
||||
goto err;
|
||||
|
||||
pdev_name = pci_name(client->pdev);
|
||||
ret = vga_switchto(client);
|
||||
if (ret)
|
||||
printk(KERN_ERR "vga_switcheroo: delayed switching failed %d\n", ret);
|
||||
|
||||
vgasr_priv.delayed_switch_active = false;
|
||||
err = 0;
|
||||
err:
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_process_delayed_switch);
|
||||
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -1513,7 +1513,6 @@ register_framebuffer(struct fb_info *fb_info)
|
|||
fb_info->fix.id,
|
||||
registered_fb[i]->fix.id);
|
||||
unregister_framebuffer(registered_fb[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,58 @@
|
|||
/*
|
||||
* Copyright (c) 2010 Red Hat Inc.
|
||||
* Author : Dave Airlie <airlied@redhat.com>
|
||||
*
|
||||
* Licensed under GPLv2
|
||||
*
|
||||
* vga_switcheroo.h - Support for laptop with dual GPU using one set of outputs
|
||||
*/
|
||||
|
||||
#include <acpi/acpi.h>
|
||||
#include <linux/fb.h>
|
||||
|
||||
enum vga_switcheroo_state {
|
||||
VGA_SWITCHEROO_OFF,
|
||||
VGA_SWITCHEROO_ON,
|
||||
};
|
||||
|
||||
enum vga_switcheroo_client_id {
|
||||
VGA_SWITCHEROO_IGD,
|
||||
VGA_SWITCHEROO_DIS,
|
||||
VGA_SWITCHEROO_MAX_CLIENTS,
|
||||
};
|
||||
|
||||
struct vga_switcheroo_handler {
|
||||
int (*switchto)(enum vga_switcheroo_client_id id);
|
||||
int (*power_state)(enum vga_switcheroo_client_id id,
|
||||
enum vga_switcheroo_state state);
|
||||
int (*init)(void);
|
||||
int (*get_client_id)(struct pci_dev *pdev);
|
||||
};
|
||||
|
||||
|
||||
#if defined(CONFIG_VGA_SWITCHEROO)
|
||||
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),
|
||||
bool (*can_switch)(struct pci_dev *dev));
|
||||
|
||||
void vga_switcheroo_client_fb_set(struct pci_dev *dev,
|
||||
struct fb_info *info);
|
||||
|
||||
int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler);
|
||||
void vga_switcheroo_unregister_handler(void);
|
||||
|
||||
int vga_switcheroo_process_delayed_switch(void);
|
||||
|
||||
#else
|
||||
|
||||
static inline void vga_switcheroo_unregister_client(struct pci_dev *dev) {}
|
||||
static inline int vga_switcheroo_register_client(struct pci_dev *dev,
|
||||
void (*set_gpu_state)(struct pci_dev *dev, enum vga_switcheroo_state),
|
||||
bool (*can_switch)(struct pci_dev *dev)) { return 0; }
|
||||
static inline void vga_switcheroo_client_fb_set(struct pci_dev *dev, struct fb_info *info) {}
|
||||
static inline int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler) { return 0; }
|
||||
static inline void vga_switcheroo_unregister_handler(void) {}
|
||||
static inline int vga_switcheroo_process_delayed_switch(void) { return 0; }
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue