1/* 2 * Copyright (c) 2010 Red Hat Inc. 3 * Author : Dave Airlie <airlied@redhat.com> 4 * 5 * 6 * Licensed under GPLv2 7 * 8 * vga_switcheroo.c - Support for laptop with dual GPU using one set of outputs 9 10 Switcher interface - methods require for ATPX and DCM 11 - switchto - this throws the output MUX switch 12 - discrete_set_power - sets the power state for the discrete card 13 14 GPU driver interface 15 - set_gpu_state - this should do the equiv of s/r for the card 16 - this should *not* set the discrete power state 17 - switch_check - check if the device is in a position to switch now 18 */ 19 20#include <linux/module.h> 21#include <linux/dmi.h> 22#include <linux/seq_file.h> 23#include <linux/uaccess.h> 24#include <linux/fs.h> 25#include <linux/debugfs.h> 26#include <linux/fb.h> 27 28#include <linux/pci.h> 29#include <linux/vga_switcheroo.h> 30 31struct vga_switcheroo_client { 32 struct pci_dev *pdev; 33 struct fb_info *fb_info; 34 int pwr_state; 35 void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state); 36 bool (*can_switch)(struct pci_dev *pdev); 37 int id; 38 bool active; 39}; 40 41static DEFINE_MUTEX(vgasr_mutex); 42 43struct vgasr_priv { 44 45 bool active; 46 bool delayed_switch_active; 47 enum vga_switcheroo_client_id delayed_client_id; 48 49 struct dentry *debugfs_root; 50 struct dentry *switch_file; 51 52 int registered_clients; 53 struct vga_switcheroo_client clients[VGA_SWITCHEROO_MAX_CLIENTS]; 54 55 struct vga_switcheroo_handler *handler; 56}; 57 58static int vga_switcheroo_debugfs_init(struct vgasr_priv *priv); 59static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv); 60 61/* only one switcheroo per system */ 62static struct vgasr_priv vgasr_priv; 63 64int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler) 65{ 66 mutex_lock(&vgasr_mutex); 67 if (vgasr_priv.handler) { 68 mutex_unlock(&vgasr_mutex); 69 return -EINVAL; 70 } 71 72 vgasr_priv.handler = handler; 73 mutex_unlock(&vgasr_mutex); 74 return 0; 75} 76EXPORT_SYMBOL(vga_switcheroo_register_handler); 77 78void vga_switcheroo_unregister_handler(void) 79{ 80 mutex_lock(&vgasr_mutex); 81 vgasr_priv.handler = NULL; 82 mutex_unlock(&vgasr_mutex); 83} 84EXPORT_SYMBOL(vga_switcheroo_unregister_handler); 85 86static void vga_switcheroo_enable(void) 87{ 88 int i; 89 int ret; 90 /* call the handler to init */ 91 vgasr_priv.handler->init(); 92 93 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 94 ret = vgasr_priv.handler->get_client_id(vgasr_priv.clients[i].pdev); 95 if (ret < 0) 96 return; 97 98 vgasr_priv.clients[i].id = ret; 99 } 100 vga_switcheroo_debugfs_init(&vgasr_priv); 101 vgasr_priv.active = true; 102} 103 104int vga_switcheroo_register_client(struct pci_dev *pdev, 105 void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state), 106 bool (*can_switch)(struct pci_dev *pdev)) 107{ 108 int index; 109 110 mutex_lock(&vgasr_mutex); 111 /* don't do IGD vs DIS here */ 112 if (vgasr_priv.registered_clients & 1) 113 index = 1; 114 else 115 index = 0; 116 117 vgasr_priv.clients[index].pwr_state = VGA_SWITCHEROO_ON; 118 vgasr_priv.clients[index].pdev = pdev; 119 vgasr_priv.clients[index].set_gpu_state = set_gpu_state; 120 vgasr_priv.clients[index].can_switch = can_switch; 121 vgasr_priv.clients[index].id = -1; 122 if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) 123 vgasr_priv.clients[index].active = true; 124 125 vgasr_priv.registered_clients |= (1 << index); 126 127 /* if we get two clients + handler */ 128 if (vgasr_priv.registered_clients == 0x3 && vgasr_priv.handler) { 129 printk(KERN_INFO "vga_switcheroo: enabled\n"); 130 vga_switcheroo_enable(); 131 } 132 mutex_unlock(&vgasr_mutex); 133 return 0; 134} 135EXPORT_SYMBOL(vga_switcheroo_register_client); 136 137void vga_switcheroo_unregister_client(struct pci_dev *pdev) 138{ 139 int i; 140 141 mutex_lock(&vgasr_mutex); 142 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 143 if (vgasr_priv.clients[i].pdev == pdev) { 144 vgasr_priv.registered_clients &= ~(1 << i); 145 break; 146 } 147 } 148 149 printk(KERN_INFO "vga_switcheroo: disabled\n"); 150 vga_switcheroo_debugfs_fini(&vgasr_priv); 151 vgasr_priv.active = false; 152 mutex_unlock(&vgasr_mutex); 153} 154EXPORT_SYMBOL(vga_switcheroo_unregister_client); 155 156void vga_switcheroo_client_fb_set(struct pci_dev *pdev, 157 struct fb_info *info) 158{ 159 int i; 160 161 mutex_lock(&vgasr_mutex); 162 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 163 if (vgasr_priv.clients[i].pdev == pdev) { 164 vgasr_priv.clients[i].fb_info = info; 165 break; 166 } 167 } 168 mutex_unlock(&vgasr_mutex); 169} 170EXPORT_SYMBOL(vga_switcheroo_client_fb_set); 171 172static int vga_switcheroo_show(struct seq_file *m, void *v) 173{ 174 int i; 175 mutex_lock(&vgasr_mutex); 176 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 177 seq_printf(m, "%d:%c:%s:%s\n", i, 178 vgasr_priv.clients[i].active ? '+' : ' ', 179 vgasr_priv.clients[i].pwr_state ? "Pwr" : "Off", 180 pci_name(vgasr_priv.clients[i].pdev)); 181 } 182 mutex_unlock(&vgasr_mutex); 183 return 0; 184} 185 186static int vga_switcheroo_debugfs_open(struct inode *inode, struct file *file) 187{ 188 return single_open(file, vga_switcheroo_show, NULL); 189} 190 191static int vga_switchon(struct vga_switcheroo_client *client) 192{ 193 int ret; 194 195 ret = vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_ON); 196 /* call the driver callback to turn on device */ 197 client->set_gpu_state(client->pdev, VGA_SWITCHEROO_ON); 198 client->pwr_state = VGA_SWITCHEROO_ON; 199 return 0; 200} 201 202static int vga_switchoff(struct vga_switcheroo_client *client) 203{ 204 /* call the driver callback to turn off device */ 205 client->set_gpu_state(client->pdev, VGA_SWITCHEROO_OFF); 206 vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_OFF); 207 client->pwr_state = VGA_SWITCHEROO_OFF; 208 return 0; 209} 210 211static int vga_switchto(struct vga_switcheroo_client *new_client) 212{ 213 int ret; 214 int i; 215 struct vga_switcheroo_client *active = NULL; 216 217 if (new_client->active == true) 218 return 0; 219 220 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 221 if (vgasr_priv.clients[i].active == true) { 222 active = &vgasr_priv.clients[i]; 223 break; 224 } 225 } 226 if (!active) 227 return 0; 228 229 /* power up the first device */ 230 ret = pci_enable_device(new_client->pdev); 231 if (ret) 232 return ret; 233 234 if (new_client->pwr_state == VGA_SWITCHEROO_OFF) 235 vga_switchon(new_client); 236 237 /* swap shadow resource to denote boot VGA device has changed so X starts on new device */ 238 active->active = false; 239 240 active->pdev->resource[PCI_ROM_RESOURCE].flags &= ~IORESOURCE_ROM_SHADOW; 241 new_client->pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW; 242 243 if (new_client->fb_info) { 244 struct fb_event event; 245 event.info = new_client->fb_info; 246 fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event); 247 } 248 249 ret = vgasr_priv.handler->switchto(new_client->id); 250 if (ret) 251 return ret; 252 253 if (active->pwr_state == VGA_SWITCHEROO_ON) 254 vga_switchoff(active); 255 256 new_client->active = true; 257 return 0; 258} 259 260static ssize_t 261vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf, 262 size_t cnt, loff_t *ppos) 263{ 264 char usercmd[64]; 265 const char *pdev_name; 266 int i, ret; 267 bool delay = false, can_switch; 268 int client_id = -1; 269 struct vga_switcheroo_client *client = NULL; 270 271 if (cnt > 63) 272 cnt = 63; 273 274 if (copy_from_user(usercmd, ubuf, cnt)) 275 return -EFAULT; 276 277 mutex_lock(&vgasr_mutex); 278 279 if (!vgasr_priv.active) { 280 cnt = -EINVAL; 281 goto out; 282 } 283 284 /* pwr off the device not in use */ 285 if (strncmp(usercmd, "OFF", 3) == 0) { 286 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 287 if (vgasr_priv.clients[i].active) 288 continue; 289 if (vgasr_priv.clients[i].pwr_state == VGA_SWITCHEROO_ON) 290 vga_switchoff(&vgasr_priv.clients[i]); 291 } 292 goto out; 293 } 294 /* pwr on the device not in use */ 295 if (strncmp(usercmd, "ON", 2) == 0) { 296 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 297 if (vgasr_priv.clients[i].active) 298 continue; 299 if (vgasr_priv.clients[i].pwr_state == VGA_SWITCHEROO_OFF) 300 vga_switchon(&vgasr_priv.clients[i]); 301 } 302 goto out; 303 } 304 305 /* request a delayed switch - test can we switch now */ 306 if (strncmp(usercmd, "DIGD", 4) == 0) { 307 client_id = VGA_SWITCHEROO_IGD; 308 delay = true; 309 } 310 311 if (strncmp(usercmd, "DDIS", 4) == 0) { 312 client_id = VGA_SWITCHEROO_DIS; 313 delay = true; 314 } 315 316 if (strncmp(usercmd, "IGD", 3) == 0) 317 client_id = VGA_SWITCHEROO_IGD; 318 319 if (strncmp(usercmd, "DIS", 3) == 0) 320 client_id = VGA_SWITCHEROO_DIS; 321 322 if (client_id == -1) 323 goto out; 324 325 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 326 if (vgasr_priv.clients[i].id == client_id) { 327 client = &vgasr_priv.clients[i]; 328 break; 329 } 330 } 331 332 vgasr_priv.delayed_switch_active = false; 333 /* okay we want a switch - test if devices are willing to switch */ 334 can_switch = true; 335 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 336 can_switch = vgasr_priv.clients[i].can_switch(vgasr_priv.clients[i].pdev); 337 if (can_switch == false) { 338 printk(KERN_ERR "vga_switcheroo: client %d refused switch\n", i); 339 break; 340 } 341 } 342 343 if (can_switch == false && delay == false) 344 goto out; 345 346 if (can_switch == true) { 347 pdev_name = pci_name(client->pdev); 348 ret = vga_switchto(client); 349 if (ret) 350 printk(KERN_ERR "vga_switcheroo: switching failed %d\n", ret); 351 } else { 352 printk(KERN_INFO "vga_switcheroo: setting delayed switch to client %d\n", client->id); 353 vgasr_priv.delayed_switch_active = true; 354 vgasr_priv.delayed_client_id = client_id; 355 356 /* we should at least power up the card to 357 make the switch faster */ 358 if (client->pwr_state == VGA_SWITCHEROO_OFF) 359 vga_switchon(client); 360 } 361 362out: 363 mutex_unlock(&vgasr_mutex); 364 return cnt; 365} 366 367static const struct file_operations vga_switcheroo_debugfs_fops = { 368 .owner = THIS_MODULE, 369 .open = vga_switcheroo_debugfs_open, 370 .write = vga_switcheroo_debugfs_write, 371 .read = seq_read, 372 .llseek = seq_lseek, 373 .release = single_release, 374}; 375 376static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv) 377{ 378 if (priv->switch_file) { 379 debugfs_remove(priv->switch_file); 380 priv->switch_file = NULL; 381 } 382 if (priv->debugfs_root) { 383 debugfs_remove(priv->debugfs_root); 384 priv->debugfs_root = NULL; 385 } 386} 387 388static int vga_switcheroo_debugfs_init(struct vgasr_priv *priv) 389{ 390 /* already initialised */ 391 if (priv->debugfs_root) 392 return 0; 393 priv->debugfs_root = debugfs_create_dir("vgaswitcheroo", NULL); 394 395 if (!priv->debugfs_root) { 396 printk(KERN_ERR "vga_switcheroo: Cannot create /sys/kernel/debug/vgaswitcheroo\n"); 397 goto fail; 398 } 399 400 priv->switch_file = debugfs_create_file("switch", 0644, 401 priv->debugfs_root, NULL, &vga_switcheroo_debugfs_fops); 402 if (!priv->switch_file) { 403 printk(KERN_ERR "vga_switcheroo: cannot create /sys/kernel/debug/vgaswitcheroo/switch\n"); 404 goto fail; 405 } 406 return 0; 407fail: 408 vga_switcheroo_debugfs_fini(priv); 409 return -1; 410} 411 412int vga_switcheroo_process_delayed_switch(void) 413{ 414 struct vga_switcheroo_client *client = NULL; 415 const char *pdev_name; 416 bool can_switch = true; 417 int i; 418 int ret; 419 int err = -EINVAL; 420 421 mutex_lock(&vgasr_mutex); 422 if (!vgasr_priv.delayed_switch_active) 423 goto err; 424 425 printk(KERN_INFO "vga_switcheroo: processing delayed switch to %d\n", vgasr_priv.delayed_client_id); 426 427 for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) { 428 if (vgasr_priv.clients[i].id == vgasr_priv.delayed_client_id) 429 client = &vgasr_priv.clients[i]; 430 can_switch = vgasr_priv.clients[i].can_switch(vgasr_priv.clients[i].pdev); 431 if (can_switch == false) { 432 printk(KERN_ERR "vga_switcheroo: client %d refused switch\n", i); 433 break; 434 } 435 } 436 437 if (can_switch == false || client == NULL) 438 goto err; 439 440 pdev_name = pci_name(client->pdev); 441 ret = vga_switchto(client); 442 if (ret) 443 printk(KERN_ERR "vga_switcheroo: delayed switching failed %d\n", ret); 444 445 vgasr_priv.delayed_switch_active = false; 446 err = 0; 447err: 448 mutex_unlock(&vgasr_mutex); 449 return err; 450} 451EXPORT_SYMBOL(vga_switcheroo_process_delayed_switch); 452