]>
Commit | Line | Data |
---|---|---|
917ee75a SF |
1 | /* |
2 | * Gmux driver for Apple laptops | |
3 | * | |
4 | * Copyright (C) Canonical Ltd. <seth.forshee@canonical.com> | |
76b487dd | 5 | * Copyright (C) 2010-2012 Andreas Heider <andreas@meetr.de> |
917ee75a SF |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License version 2 as | |
9 | * published by the Free Software Foundation. | |
10 | */ | |
11 | ||
12 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
13 | ||
14 | #include <linux/module.h> | |
15 | #include <linux/kernel.h> | |
16 | #include <linux/init.h> | |
17 | #include <linux/backlight.h> | |
18 | #include <linux/acpi.h> | |
19 | #include <linux/pnp.h> | |
20 | #include <linux/apple_bl.h> | |
21 | #include <linux/slab.h> | |
96ff7056 | 22 | #include <linux/delay.h> |
76b487dd AH |
23 | #include <linux/pci.h> |
24 | #include <linux/vga_switcheroo.h> | |
4eebd5a4 | 25 | #include <linux/vgaarb.h> |
917ee75a SF |
26 | #include <acpi/video.h> |
27 | #include <asm/io.h> | |
28 | ||
29 | struct apple_gmux_data { | |
30 | unsigned long iostart; | |
31 | unsigned long iolen; | |
96ff7056 MG |
32 | bool indexed; |
33 | struct mutex index_lock; | |
917ee75a | 34 | |
4eebd5a4 | 35 | struct pci_dev *pdev; |
917ee75a | 36 | struct backlight_device *bdev; |
76b487dd AH |
37 | |
38 | /* switcheroo data */ | |
39 | acpi_handle dhandle; | |
40 | int gpe; | |
41 | enum vga_switcheroo_client_id resume_client_id; | |
42 | enum vga_switcheroo_state power_state; | |
43 | struct completion powerchange_done; | |
917ee75a SF |
44 | }; |
45 | ||
76b487dd AH |
46 | static struct apple_gmux_data *apple_gmux_data; |
47 | ||
917ee75a SF |
48 | /* |
49 | * gmux port offsets. Many of these are not yet used, but may be in the | |
50 | * future, and it's useful to have them documented here anyhow. | |
51 | */ | |
52 | #define GMUX_PORT_VERSION_MAJOR 0x04 | |
53 | #define GMUX_PORT_VERSION_MINOR 0x05 | |
54 | #define GMUX_PORT_VERSION_RELEASE 0x06 | |
55 | #define GMUX_PORT_SWITCH_DISPLAY 0x10 | |
56 | #define GMUX_PORT_SWITCH_GET_DISPLAY 0x11 | |
57 | #define GMUX_PORT_INTERRUPT_ENABLE 0x14 | |
58 | #define GMUX_PORT_INTERRUPT_STATUS 0x16 | |
59 | #define GMUX_PORT_SWITCH_DDC 0x28 | |
60 | #define GMUX_PORT_SWITCH_EXTERNAL 0x40 | |
61 | #define GMUX_PORT_SWITCH_GET_EXTERNAL 0x41 | |
62 | #define GMUX_PORT_DISCRETE_POWER 0x50 | |
63 | #define GMUX_PORT_MAX_BRIGHTNESS 0x70 | |
64 | #define GMUX_PORT_BRIGHTNESS 0x74 | |
96ff7056 MG |
65 | #define GMUX_PORT_VALUE 0xc2 |
66 | #define GMUX_PORT_READ 0xd0 | |
67 | #define GMUX_PORT_WRITE 0xd4 | |
917ee75a SF |
68 | |
69 | #define GMUX_MIN_IO_LEN (GMUX_PORT_BRIGHTNESS + 4) | |
70 | ||
71 | #define GMUX_INTERRUPT_ENABLE 0xff | |
72 | #define GMUX_INTERRUPT_DISABLE 0x00 | |
73 | ||
74 | #define GMUX_INTERRUPT_STATUS_ACTIVE 0 | |
75 | #define GMUX_INTERRUPT_STATUS_DISPLAY (1 << 0) | |
76 | #define GMUX_INTERRUPT_STATUS_POWER (1 << 2) | |
77 | #define GMUX_INTERRUPT_STATUS_HOTPLUG (1 << 3) | |
78 | ||
79 | #define GMUX_BRIGHTNESS_MASK 0x00ffffff | |
80 | #define GMUX_MAX_BRIGHTNESS GMUX_BRIGHTNESS_MASK | |
81 | ||
96ff7056 | 82 | static u8 gmux_pio_read8(struct apple_gmux_data *gmux_data, int port) |
917ee75a SF |
83 | { |
84 | return inb(gmux_data->iostart + port); | |
85 | } | |
86 | ||
96ff7056 | 87 | static void gmux_pio_write8(struct apple_gmux_data *gmux_data, int port, |
917ee75a SF |
88 | u8 val) |
89 | { | |
90 | outb(val, gmux_data->iostart + port); | |
91 | } | |
92 | ||
96ff7056 | 93 | static u32 gmux_pio_read32(struct apple_gmux_data *gmux_data, int port) |
917ee75a SF |
94 | { |
95 | return inl(gmux_data->iostart + port); | |
96 | } | |
97 | ||
96ff7056 MG |
98 | static void gmux_pio_write32(struct apple_gmux_data *gmux_data, int port, |
99 | u32 val) | |
7e30ed6b MG |
100 | { |
101 | int i; | |
102 | u8 tmpval; | |
103 | ||
104 | for (i = 0; i < 4; i++) { | |
105 | tmpval = (val >> (i * 8)) & 0xff; | |
e6d9d3d5 | 106 | outb(tmpval, gmux_data->iostart + port + i); |
7e30ed6b MG |
107 | } |
108 | } | |
109 | ||
96ff7056 MG |
110 | static int gmux_index_wait_ready(struct apple_gmux_data *gmux_data) |
111 | { | |
112 | int i = 200; | |
113 | u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); | |
114 | ||
115 | while (i && (gwr & 0x01)) { | |
116 | inb(gmux_data->iostart + GMUX_PORT_READ); | |
117 | gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); | |
118 | udelay(100); | |
119 | i--; | |
120 | } | |
121 | ||
122 | return !!i; | |
123 | } | |
124 | ||
125 | static int gmux_index_wait_complete(struct apple_gmux_data *gmux_data) | |
126 | { | |
127 | int i = 200; | |
128 | u8 gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); | |
129 | ||
130 | while (i && !(gwr & 0x01)) { | |
131 | gwr = inb(gmux_data->iostart + GMUX_PORT_WRITE); | |
132 | udelay(100); | |
133 | i--; | |
134 | } | |
135 | ||
136 | if (gwr & 0x01) | |
137 | inb(gmux_data->iostart + GMUX_PORT_READ); | |
138 | ||
139 | return !!i; | |
140 | } | |
141 | ||
142 | static u8 gmux_index_read8(struct apple_gmux_data *gmux_data, int port) | |
143 | { | |
144 | u8 val; | |
145 | ||
146 | mutex_lock(&gmux_data->index_lock); | |
96ff7056 | 147 | gmux_index_wait_ready(gmux_data); |
c5a50529 BF |
148 | outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ); |
149 | gmux_index_wait_complete(gmux_data); | |
96ff7056 MG |
150 | val = inb(gmux_data->iostart + GMUX_PORT_VALUE); |
151 | mutex_unlock(&gmux_data->index_lock); | |
152 | ||
153 | return val; | |
154 | } | |
155 | ||
156 | static void gmux_index_write8(struct apple_gmux_data *gmux_data, int port, | |
157 | u8 val) | |
158 | { | |
159 | mutex_lock(&gmux_data->index_lock); | |
160 | outb(val, gmux_data->iostart + GMUX_PORT_VALUE); | |
161 | gmux_index_wait_ready(gmux_data); | |
162 | outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE); | |
163 | gmux_index_wait_complete(gmux_data); | |
164 | mutex_unlock(&gmux_data->index_lock); | |
165 | } | |
166 | ||
167 | static u32 gmux_index_read32(struct apple_gmux_data *gmux_data, int port) | |
168 | { | |
169 | u32 val; | |
170 | ||
171 | mutex_lock(&gmux_data->index_lock); | |
96ff7056 | 172 | gmux_index_wait_ready(gmux_data); |
c5a50529 BF |
173 | outb((port & 0xff), gmux_data->iostart + GMUX_PORT_READ); |
174 | gmux_index_wait_complete(gmux_data); | |
96ff7056 MG |
175 | val = inl(gmux_data->iostart + GMUX_PORT_VALUE); |
176 | mutex_unlock(&gmux_data->index_lock); | |
177 | ||
178 | return val; | |
179 | } | |
180 | ||
181 | static void gmux_index_write32(struct apple_gmux_data *gmux_data, int port, | |
182 | u32 val) | |
183 | { | |
184 | int i; | |
185 | u8 tmpval; | |
186 | ||
187 | mutex_lock(&gmux_data->index_lock); | |
188 | ||
189 | for (i = 0; i < 4; i++) { | |
190 | tmpval = (val >> (i * 8)) & 0xff; | |
191 | outb(tmpval, gmux_data->iostart + GMUX_PORT_VALUE + i); | |
192 | } | |
193 | ||
194 | gmux_index_wait_ready(gmux_data); | |
195 | outb(port & 0xff, gmux_data->iostart + GMUX_PORT_WRITE); | |
196 | gmux_index_wait_complete(gmux_data); | |
197 | mutex_unlock(&gmux_data->index_lock); | |
198 | } | |
199 | ||
200 | static u8 gmux_read8(struct apple_gmux_data *gmux_data, int port) | |
201 | { | |
202 | if (gmux_data->indexed) | |
203 | return gmux_index_read8(gmux_data, port); | |
204 | else | |
205 | return gmux_pio_read8(gmux_data, port); | |
206 | } | |
207 | ||
208 | static void gmux_write8(struct apple_gmux_data *gmux_data, int port, u8 val) | |
209 | { | |
210 | if (gmux_data->indexed) | |
211 | gmux_index_write8(gmux_data, port, val); | |
212 | else | |
213 | gmux_pio_write8(gmux_data, port, val); | |
214 | } | |
215 | ||
216 | static u32 gmux_read32(struct apple_gmux_data *gmux_data, int port) | |
217 | { | |
218 | if (gmux_data->indexed) | |
219 | return gmux_index_read32(gmux_data, port); | |
220 | else | |
221 | return gmux_pio_read32(gmux_data, port); | |
222 | } | |
223 | ||
224 | static void gmux_write32(struct apple_gmux_data *gmux_data, int port, | |
225 | u32 val) | |
226 | { | |
227 | if (gmux_data->indexed) | |
228 | gmux_index_write32(gmux_data, port, val); | |
229 | else | |
230 | gmux_pio_write32(gmux_data, port, val); | |
231 | } | |
232 | ||
233 | static bool gmux_is_indexed(struct apple_gmux_data *gmux_data) | |
234 | { | |
235 | u16 val; | |
236 | ||
237 | outb(0xaa, gmux_data->iostart + 0xcc); | |
238 | outb(0x55, gmux_data->iostart + 0xcd); | |
239 | outb(0x00, gmux_data->iostart + 0xce); | |
240 | ||
241 | val = inb(gmux_data->iostart + 0xcc) | | |
242 | (inb(gmux_data->iostart + 0xcd) << 8); | |
243 | ||
244 | if (val == 0x55aa) | |
245 | return true; | |
246 | ||
247 | return false; | |
248 | } | |
249 | ||
917ee75a SF |
250 | static int gmux_get_brightness(struct backlight_device *bd) |
251 | { | |
252 | struct apple_gmux_data *gmux_data = bl_get_data(bd); | |
253 | return gmux_read32(gmux_data, GMUX_PORT_BRIGHTNESS) & | |
254 | GMUX_BRIGHTNESS_MASK; | |
255 | } | |
256 | ||
257 | static int gmux_update_status(struct backlight_device *bd) | |
258 | { | |
259 | struct apple_gmux_data *gmux_data = bl_get_data(bd); | |
260 | u32 brightness = bd->props.brightness; | |
261 | ||
96960880 | 262 | if (bd->props.state & BL_CORE_SUSPENDED) |
a2f01a89 | 263 | return 0; |
96960880 | 264 | |
7e30ed6b | 265 | gmux_write32(gmux_data, GMUX_PORT_BRIGHTNESS, brightness); |
917ee75a SF |
266 | |
267 | return 0; | |
268 | } | |
269 | ||
270 | static const struct backlight_ops gmux_bl_ops = { | |
96960880 | 271 | .options = BL_CORE_SUSPENDRESUME, |
917ee75a SF |
272 | .get_brightness = gmux_get_brightness, |
273 | .update_status = gmux_update_status, | |
274 | }; | |
275 | ||
76b487dd AH |
276 | static int gmux_switchto(enum vga_switcheroo_client_id id) |
277 | { | |
278 | if (id == VGA_SWITCHEROO_IGD) { | |
279 | gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 1); | |
280 | gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DISPLAY, 2); | |
281 | gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 2); | |
282 | } else { | |
283 | gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DDC, 2); | |
284 | gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_DISPLAY, 3); | |
285 | gmux_write8(apple_gmux_data, GMUX_PORT_SWITCH_EXTERNAL, 3); | |
286 | } | |
287 | ||
288 | return 0; | |
289 | } | |
290 | ||
291 | static int gmux_set_discrete_state(struct apple_gmux_data *gmux_data, | |
292 | enum vga_switcheroo_state state) | |
293 | { | |
16735d02 | 294 | reinit_completion(&gmux_data->powerchange_done); |
76b487dd AH |
295 | |
296 | if (state == VGA_SWITCHEROO_ON) { | |
297 | gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1); | |
298 | gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 3); | |
299 | pr_debug("Discrete card powered up\n"); | |
300 | } else { | |
301 | gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 1); | |
302 | gmux_write8(gmux_data, GMUX_PORT_DISCRETE_POWER, 0); | |
303 | pr_debug("Discrete card powered down\n"); | |
304 | } | |
305 | ||
306 | gmux_data->power_state = state; | |
307 | ||
308 | if (gmux_data->gpe >= 0 && | |
309 | !wait_for_completion_interruptible_timeout(&gmux_data->powerchange_done, | |
310 | msecs_to_jiffies(200))) | |
311 | pr_warn("Timeout waiting for gmux switch to complete\n"); | |
312 | ||
313 | return 0; | |
314 | } | |
315 | ||
316 | static int gmux_set_power_state(enum vga_switcheroo_client_id id, | |
317 | enum vga_switcheroo_state state) | |
318 | { | |
319 | if (id == VGA_SWITCHEROO_IGD) | |
320 | return 0; | |
321 | ||
322 | return gmux_set_discrete_state(apple_gmux_data, state); | |
323 | } | |
324 | ||
325 | static int gmux_get_client_id(struct pci_dev *pdev) | |
326 | { | |
327 | /* | |
328 | * Early Macbook Pros with switchable graphics use nvidia | |
329 | * integrated graphics. Hardcode that the 9400M is integrated. | |
330 | */ | |
331 | if (pdev->vendor == PCI_VENDOR_ID_INTEL) | |
332 | return VGA_SWITCHEROO_IGD; | |
333 | else if (pdev->vendor == PCI_VENDOR_ID_NVIDIA && | |
334 | pdev->device == 0x0863) | |
335 | return VGA_SWITCHEROO_IGD; | |
336 | else | |
337 | return VGA_SWITCHEROO_DIS; | |
338 | } | |
339 | ||
340 | static enum vga_switcheroo_client_id | |
341 | gmux_active_client(struct apple_gmux_data *gmux_data) | |
342 | { | |
343 | if (gmux_read8(gmux_data, GMUX_PORT_SWITCH_DISPLAY) == 2) | |
344 | return VGA_SWITCHEROO_IGD; | |
345 | ||
346 | return VGA_SWITCHEROO_DIS; | |
347 | } | |
348 | ||
349 | static struct vga_switcheroo_handler gmux_handler = { | |
350 | .switchto = gmux_switchto, | |
351 | .power_state = gmux_set_power_state, | |
352 | .get_client_id = gmux_get_client_id, | |
353 | }; | |
354 | ||
355 | static inline void gmux_disable_interrupts(struct apple_gmux_data *gmux_data) | |
356 | { | |
357 | gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE, | |
358 | GMUX_INTERRUPT_DISABLE); | |
359 | } | |
360 | ||
361 | static inline void gmux_enable_interrupts(struct apple_gmux_data *gmux_data) | |
362 | { | |
363 | gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_ENABLE, | |
364 | GMUX_INTERRUPT_ENABLE); | |
365 | } | |
366 | ||
367 | static inline u8 gmux_interrupt_get_status(struct apple_gmux_data *gmux_data) | |
368 | { | |
369 | return gmux_read8(gmux_data, GMUX_PORT_INTERRUPT_STATUS); | |
370 | } | |
371 | ||
372 | static void gmux_clear_interrupts(struct apple_gmux_data *gmux_data) | |
373 | { | |
374 | u8 status; | |
375 | ||
376 | /* to clear interrupts write back current status */ | |
377 | status = gmux_interrupt_get_status(gmux_data); | |
378 | gmux_write8(gmux_data, GMUX_PORT_INTERRUPT_STATUS, status); | |
379 | } | |
380 | ||
381 | static void gmux_notify_handler(acpi_handle device, u32 value, void *context) | |
382 | { | |
383 | u8 status; | |
384 | struct pnp_dev *pnp = (struct pnp_dev *)context; | |
385 | struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); | |
386 | ||
387 | status = gmux_interrupt_get_status(gmux_data); | |
388 | gmux_disable_interrupts(gmux_data); | |
389 | pr_debug("Notify handler called: status %d\n", status); | |
390 | ||
391 | gmux_clear_interrupts(gmux_data); | |
392 | gmux_enable_interrupts(gmux_data); | |
393 | ||
394 | if (status & GMUX_INTERRUPT_STATUS_POWER) | |
395 | complete(&gmux_data->powerchange_done); | |
396 | } | |
397 | ||
8aa6c216 | 398 | static int gmux_suspend(struct device *dev) |
76b487dd | 399 | { |
8aa6c216 | 400 | struct pnp_dev *pnp = to_pnp_dev(dev); |
76b487dd | 401 | struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); |
8aa6c216 | 402 | |
76b487dd AH |
403 | gmux_data->resume_client_id = gmux_active_client(gmux_data); |
404 | gmux_disable_interrupts(gmux_data); | |
405 | return 0; | |
406 | } | |
407 | ||
8aa6c216 | 408 | static int gmux_resume(struct device *dev) |
76b487dd | 409 | { |
8aa6c216 | 410 | struct pnp_dev *pnp = to_pnp_dev(dev); |
76b487dd | 411 | struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); |
8aa6c216 | 412 | |
76b487dd AH |
413 | gmux_enable_interrupts(gmux_data); |
414 | gmux_switchto(gmux_data->resume_client_id); | |
415 | if (gmux_data->power_state == VGA_SWITCHEROO_OFF) | |
416 | gmux_set_discrete_state(gmux_data, gmux_data->power_state); | |
417 | return 0; | |
418 | } | |
419 | ||
4eebd5a4 BP |
420 | static struct pci_dev *gmux_get_io_pdev(void) |
421 | { | |
422 | struct pci_dev *pdev = NULL; | |
423 | ||
424 | while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev))) { | |
425 | u16 cmd; | |
426 | ||
427 | pci_read_config_word(pdev, PCI_COMMAND, &cmd); | |
428 | if (!(cmd & PCI_COMMAND_IO)) | |
429 | continue; | |
430 | ||
431 | return pdev; | |
432 | } | |
433 | ||
434 | return NULL; | |
435 | } | |
436 | ||
b859f159 | 437 | static int gmux_probe(struct pnp_dev *pnp, const struct pnp_device_id *id) |
917ee75a SF |
438 | { |
439 | struct apple_gmux_data *gmux_data; | |
440 | struct resource *res; | |
441 | struct backlight_properties props; | |
442 | struct backlight_device *bdev; | |
443 | u8 ver_major, ver_minor, ver_release; | |
444 | int ret = -ENXIO; | |
76b487dd AH |
445 | acpi_status status; |
446 | unsigned long long gpe; | |
4eebd5a4 | 447 | struct pci_dev *pdev = NULL; |
76b487dd AH |
448 | |
449 | if (apple_gmux_data) | |
450 | return -EBUSY; | |
917ee75a SF |
451 | |
452 | gmux_data = kzalloc(sizeof(*gmux_data), GFP_KERNEL); | |
453 | if (!gmux_data) | |
454 | return -ENOMEM; | |
455 | pnp_set_drvdata(pnp, gmux_data); | |
456 | ||
457 | res = pnp_get_resource(pnp, IORESOURCE_IO, 0); | |
458 | if (!res) { | |
459 | pr_err("Failed to find gmux I/O resource\n"); | |
460 | goto err_free; | |
461 | } | |
462 | ||
463 | gmux_data->iostart = res->start; | |
464 | gmux_data->iolen = res->end - res->start; | |
465 | ||
466 | if (gmux_data->iolen < GMUX_MIN_IO_LEN) { | |
467 | pr_err("gmux I/O region too small (%lu < %u)\n", | |
468 | gmux_data->iolen, GMUX_MIN_IO_LEN); | |
469 | goto err_free; | |
470 | } | |
471 | ||
472 | if (!request_region(gmux_data->iostart, gmux_data->iolen, | |
473 | "Apple gmux")) { | |
474 | pr_err("gmux I/O already in use\n"); | |
475 | goto err_free; | |
476 | } | |
477 | ||
478 | /* | |
96ff7056 MG |
479 | * Invalid version information may indicate either that the gmux |
480 | * device isn't present or that it's a new one that uses indexed | |
481 | * io | |
917ee75a | 482 | */ |
96ff7056 | 483 | |
917ee75a SF |
484 | ver_major = gmux_read8(gmux_data, GMUX_PORT_VERSION_MAJOR); |
485 | ver_minor = gmux_read8(gmux_data, GMUX_PORT_VERSION_MINOR); | |
486 | ver_release = gmux_read8(gmux_data, GMUX_PORT_VERSION_RELEASE); | |
487 | if (ver_major == 0xff && ver_minor == 0xff && ver_release == 0xff) { | |
96ff7056 | 488 | if (gmux_is_indexed(gmux_data)) { |
07f377da | 489 | u32 version; |
96ff7056 MG |
490 | mutex_init(&gmux_data->index_lock); |
491 | gmux_data->indexed = true; | |
07f377da BF |
492 | version = gmux_read32(gmux_data, |
493 | GMUX_PORT_VERSION_MAJOR); | |
494 | ver_major = (version >> 24) & 0xff; | |
495 | ver_minor = (version >> 16) & 0xff; | |
496 | ver_release = (version >> 8) & 0xff; | |
96ff7056 | 497 | } else { |
4eebd5a4 | 498 | pr_info("gmux device not present or IO disabled\n"); |
96ff7056 MG |
499 | ret = -ENODEV; |
500 | goto err_release; | |
501 | } | |
917ee75a | 502 | } |
07f377da BF |
503 | pr_info("Found gmux version %d.%d.%d [%s]\n", ver_major, ver_minor, |
504 | ver_release, (gmux_data->indexed ? "indexed" : "classic")); | |
917ee75a | 505 | |
4eebd5a4 BP |
506 | /* |
507 | * Apple systems with gmux are EFI based and normally don't use | |
508 | * VGA. In addition changing IO+MEM ownership between IGP and dGPU | |
509 | * disables IO/MEM used for backlight control on some systems. | |
510 | * Lock IO+MEM to GPU with active IO to prevent switch. | |
511 | */ | |
512 | pdev = gmux_get_io_pdev(); | |
513 | if (pdev && vga_tryget(pdev, | |
514 | VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM)) { | |
515 | pr_err("IO+MEM vgaarb-locking for PCI:%s failed\n", | |
516 | pci_name(pdev)); | |
517 | ret = -EBUSY; | |
518 | goto err_release; | |
519 | } else if (pdev) | |
520 | pr_info("locked IO for PCI:%s\n", pci_name(pdev)); | |
521 | gmux_data->pdev = pdev; | |
522 | ||
917ee75a SF |
523 | memset(&props, 0, sizeof(props)); |
524 | props.type = BACKLIGHT_PLATFORM; | |
525 | props.max_brightness = gmux_read32(gmux_data, GMUX_PORT_MAX_BRIGHTNESS); | |
526 | ||
527 | /* | |
528 | * Currently it's assumed that the maximum brightness is less than | |
529 | * 2^24 for compatibility with old gmux versions. Cap the max | |
530 | * brightness at this value, but print a warning if the hardware | |
531 | * reports something higher so that it can be fixed. | |
532 | */ | |
533 | if (WARN_ON(props.max_brightness > GMUX_MAX_BRIGHTNESS)) | |
534 | props.max_brightness = GMUX_MAX_BRIGHTNESS; | |
535 | ||
536 | bdev = backlight_device_register("gmux_backlight", &pnp->dev, | |
537 | gmux_data, &gmux_bl_ops, &props); | |
538 | if (IS_ERR(bdev)) { | |
539 | ret = PTR_ERR(bdev); | |
540 | goto err_release; | |
541 | } | |
542 | ||
543 | gmux_data->bdev = bdev; | |
544 | bdev->props.brightness = gmux_get_brightness(bdev); | |
545 | backlight_update_status(bdev); | |
546 | ||
547 | /* | |
548 | * The backlight situation on Macs is complicated. If the gmux is | |
549 | * present it's the best choice, because it always works for | |
550 | * backlight control and supports more levels than other options. | |
551 | * Disable the other backlight choices. | |
552 | */ | |
a60b2176 | 553 | acpi_video_dmi_promote_vendor(); |
917ee75a SF |
554 | acpi_video_unregister(); |
555 | apple_bl_unregister(); | |
556 | ||
76b487dd AH |
557 | gmux_data->power_state = VGA_SWITCHEROO_ON; |
558 | ||
3a83f992 | 559 | gmux_data->dhandle = ACPI_HANDLE(&pnp->dev); |
76b487dd AH |
560 | if (!gmux_data->dhandle) { |
561 | pr_err("Cannot find acpi handle for pnp device %s\n", | |
562 | dev_name(&pnp->dev)); | |
563 | ret = -ENODEV; | |
564 | goto err_notify; | |
565 | } | |
566 | ||
567 | status = acpi_evaluate_integer(gmux_data->dhandle, "GMGP", NULL, &gpe); | |
568 | if (ACPI_SUCCESS(status)) { | |
569 | gmux_data->gpe = (int)gpe; | |
570 | ||
571 | status = acpi_install_notify_handler(gmux_data->dhandle, | |
572 | ACPI_DEVICE_NOTIFY, | |
573 | &gmux_notify_handler, pnp); | |
574 | if (ACPI_FAILURE(status)) { | |
575 | pr_err("Install notify handler failed: %s\n", | |
576 | acpi_format_exception(status)); | |
577 | ret = -ENODEV; | |
578 | goto err_notify; | |
579 | } | |
580 | ||
581 | status = acpi_enable_gpe(NULL, gmux_data->gpe); | |
582 | if (ACPI_FAILURE(status)) { | |
583 | pr_err("Cannot enable gpe: %s\n", | |
584 | acpi_format_exception(status)); | |
585 | goto err_enable_gpe; | |
586 | } | |
587 | } else { | |
588 | pr_warn("No GPE found for gmux\n"); | |
589 | gmux_data->gpe = -1; | |
590 | } | |
591 | ||
592 | if (vga_switcheroo_register_handler(&gmux_handler)) { | |
593 | ret = -ENODEV; | |
594 | goto err_register_handler; | |
595 | } | |
596 | ||
597 | init_completion(&gmux_data->powerchange_done); | |
598 | apple_gmux_data = gmux_data; | |
599 | gmux_enable_interrupts(gmux_data); | |
600 | ||
917ee75a SF |
601 | return 0; |
602 | ||
76b487dd AH |
603 | err_register_handler: |
604 | if (gmux_data->gpe >= 0) | |
605 | acpi_disable_gpe(NULL, gmux_data->gpe); | |
606 | err_enable_gpe: | |
607 | if (gmux_data->gpe >= 0) | |
608 | acpi_remove_notify_handler(gmux_data->dhandle, | |
609 | ACPI_DEVICE_NOTIFY, | |
610 | &gmux_notify_handler); | |
611 | err_notify: | |
612 | backlight_device_unregister(bdev); | |
917ee75a | 613 | err_release: |
4eebd5a4 BP |
614 | if (gmux_data->pdev) |
615 | vga_put(gmux_data->pdev, | |
616 | VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM); | |
617 | pci_dev_put(pdev); | |
917ee75a SF |
618 | release_region(gmux_data->iostart, gmux_data->iolen); |
619 | err_free: | |
620 | kfree(gmux_data); | |
621 | return ret; | |
622 | } | |
623 | ||
b859f159 | 624 | static void gmux_remove(struct pnp_dev *pnp) |
917ee75a SF |
625 | { |
626 | struct apple_gmux_data *gmux_data = pnp_get_drvdata(pnp); | |
627 | ||
76b487dd AH |
628 | vga_switcheroo_unregister_handler(); |
629 | gmux_disable_interrupts(gmux_data); | |
630 | if (gmux_data->gpe >= 0) { | |
631 | acpi_disable_gpe(NULL, gmux_data->gpe); | |
632 | acpi_remove_notify_handler(gmux_data->dhandle, | |
633 | ACPI_DEVICE_NOTIFY, | |
634 | &gmux_notify_handler); | |
635 | } | |
636 | ||
4eebd5a4 BP |
637 | if (gmux_data->pdev) { |
638 | vga_put(gmux_data->pdev, | |
639 | VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM); | |
640 | pci_dev_put(gmux_data->pdev); | |
641 | } | |
917ee75a | 642 | backlight_device_unregister(gmux_data->bdev); |
76b487dd | 643 | |
917ee75a | 644 | release_region(gmux_data->iostart, gmux_data->iolen); |
76b487dd | 645 | apple_gmux_data = NULL; |
917ee75a SF |
646 | kfree(gmux_data); |
647 | ||
a60b2176 | 648 | acpi_video_dmi_demote_vendor(); |
917ee75a SF |
649 | acpi_video_register(); |
650 | apple_bl_register(); | |
651 | } | |
652 | ||
653 | static const struct pnp_device_id gmux_device_ids[] = { | |
654 | {"APP000B", 0}, | |
655 | {"", 0} | |
656 | }; | |
657 | ||
8aa6c216 SK |
658 | static const struct dev_pm_ops gmux_dev_pm_ops = { |
659 | .suspend = gmux_suspend, | |
660 | .resume = gmux_resume, | |
661 | }; | |
662 | ||
917ee75a SF |
663 | static struct pnp_driver gmux_pnp_driver = { |
664 | .name = "apple-gmux", | |
665 | .probe = gmux_probe, | |
b859f159 | 666 | .remove = gmux_remove, |
917ee75a | 667 | .id_table = gmux_device_ids, |
8aa6c216 SK |
668 | .driver = { |
669 | .pm = &gmux_dev_pm_ops, | |
670 | }, | |
917ee75a SF |
671 | }; |
672 | ||
99f74f12 | 673 | module_pnp_driver(gmux_pnp_driver); |
917ee75a SF |
674 | MODULE_AUTHOR("Seth Forshee <seth.forshee@canonical.com>"); |
675 | MODULE_DESCRIPTION("Apple Gmux Driver"); | |
676 | MODULE_LICENSE("GPL"); | |
677 | MODULE_DEVICE_TABLE(pnp, gmux_device_ids); |