projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[ixp4xx] refresh Avila/Cambria patches
[openwrt.git] / target / linux / olpc / patches-2.6.24 / 100-olpc.patch
1 Index: linux-2.6.24.7/arch/x86/Kconfig
2 ===================================================================
3 --- linux-2.6.24.7.orig/arch/x86/Kconfig
4 +++ linux-2.6.24.7/arch/x86/Kconfig
5 @@ -1415,6 +1415,9 @@ config PCI_GODIRECT
6 config PCI_GOANY
7 bool "Any"
8
9 +config PCI_GOOLPC
10 + bool "OLPC"
11 +
12 endchoice
13
14 config PCI_BIOS
15 @@ -1425,7 +1428,7 @@ config PCI_BIOS
16 # x86-64 doesn't support PCI BIOS access from long mode so always go direct.
17 config PCI_DIRECT
18 bool
19 - depends on PCI && (X86_64 || (PCI_GODIRECT || PCI_GOANY) || X86_VISWS)
20 + depends on PCI && (X86_64 || (PCI_GODIRECT || PCI_GOANY || PCI_GOOLPC) || X86_VISWS)
21 default y
22
23 config PCI_MMCONFIG
24 @@ -1442,6 +1445,11 @@ config PCI_MMCONFIG
25 bool "Support mmconfig PCI config space access"
26 depends on X86_64 && PCI && ACPI
27
28 +config PCI_OLPC
29 + bool
30 + depends on PCI && PCI_GOOLPC
31 + default y
32 +
33 config DMAR
34 bool "Support for DMA Remapping Devices (EXPERIMENTAL)"
35 depends on X86_64 && PCI_MSI && ACPI && EXPERIMENTAL
36 @@ -1561,6 +1569,21 @@ config K8_NB
37 def_bool y
38 depends on AGP_AMD64 || (X86_64 && (GART_IOMMU || (PCI && NUMA)))
39
40 +config OLPC
41 + bool "OLPC Support"
42 + default n
43 + help
44 + Add OLPC Support
45 +
46 +config OLPC_PM
47 + bool "OLPC power management support"
48 + default n
49 + depends on OLPC
50 +
51 +config OPEN_FIRMWARE
52 + bool "Support for Open Firmware"
53 + default y if OLPC
54 +
55 source "drivers/pcmcia/Kconfig"
56
57 source "drivers/pci/hotplug/Kconfig"
58 Index: linux-2.6.24.7/arch/x86/kernel/Makefile_32
59 ===================================================================
60 --- linux-2.6.24.7.orig/arch/x86/kernel/Makefile_32
61 +++ linux-2.6.24.7/arch/x86/kernel/Makefile_32
62 @@ -50,6 +50,13 @@ obj-y += pcspeaker.o
63
64 obj-$(CONFIG_SCx200) += scx200_32.o
65
66 +obj-$(CONFIG_OLPC) += olpc.o
67 +obj-$(CONFIG_OLPC_PM) += olpc-pm.o olpc-wakeup.o
68 +obj-$(CONFIG_OPEN_FIRMWARE) += ofw.o
69 +obj-$(PROM_FS) += promfs.o
70 +
71 +
72 +
73 # vsyscall_32.o contains the vsyscall DSO images as __initdata.
74 # We must build both images before we can assemble it.
75 # Note: kbuild does not track this dependency due to usage of .incbin
76 Index: linux-2.6.24.7/arch/x86/kernel/ofw.c
77 ===================================================================
78 --- /dev/null
79 +++ linux-2.6.24.7/arch/x86/kernel/ofw.c
80 @@ -0,0 +1,100 @@
81 +/*
82 + * ofw.c - Open Firmware client interface for 32-bit systems.
83 + * This code is intended to be portable to any 32-bit Open Firmware
84 + * implementation with a standard client interface that can be
85 + * called when Linux is running.
86 + *
87 + * Copyright (C) 2007 Mitch Bradley <wmb@firmworks.com>
88 + * Copyright (C) 2007 Andres Salomon <dilinger@debian.org>
89 + */
90 +
91 +#include <stdarg.h>
92 +#include <linux/spinlock.h>
93 +#include <linux/module.h>
94 +#include <asm/ofw.h>
95 +
96 +
97 +int (*call_firmware)(int *);
98 +
99 +static DEFINE_SPINLOCK(prom_lock);
100 +
101 +#define MAXARGS 20
102 +
103 +/*
104 + * The return value from ofw() in all cases is 0 if the attempt to call the
105 + * function succeeded, <0 otherwise. That return value is from the
106 + * gateway function only. Any results from the called function are returned
107 + * via output argument pointers.
108 + *
109 + * Here are call templates for all the standard OFW client services:
110 + *
111 + * ofw("test", 1, 1, namestr, &missing);
112 + * ofw("peer", 1, 1, phandle, &sibling_phandle);
113 + * ofw("child", 1, 1, phandle, &child_phandle);
114 + * ofw("parent", 1, 1, phandle, &parent_phandle);
115 + * ofw("instance_to_package", 1, 1, ihandle, &phandle);
116 + * ofw("getproplen", 2, 1, phandle, namestr, &proplen);
117 + * ofw("getprop", 4, 1, phandle, namestr, bufaddr, buflen, &size);
118 + * ofw("nextprop", 3, 1, phandle, previousstr, bufaddr, &flag);
119 + * ofw("setprop", 4, 1, phandle, namestr, bufaddr, len, &size);
120 + * ofw("canon", 3, 1, devspecstr, bufaddr, buflen, &length);
121 + * ofw("finddevice", 1, 1, devspecstr, &phandle);
122 + * ofw("instance-to-path", 3, 1, ihandle, bufaddr, buflen, &length);
123 + * ofw("package-to-path", 3, 1, phandle, bufaddr, buflen, &length);
124 + * ofw("call_method", numin, numout, in0, in1, ..., &out0, &out1, ...);
125 + * ofw("open", 1, 1, devspecstr, &ihandle);
126 + * ofw("close", 1, 0, ihandle);
127 + * ofw("read", 3, 1, ihandle, addr, len, &actual);
128 + * ofw("write", 3, 1, ihandle, addr, len, &actual);
129 + * ofw("seek", 3, 1, ihandle, pos_hi, pos_lo, &status);
130 + * ofw("claim", 3, 1, virtaddr, size, align, &baseaddr);
131 + * ofw("release", 2, 0, virtaddr, size);
132 + * ofw("boot", 1, 0, bootspecstr);
133 + * ofw("enter", 0, 0);
134 + * ofw("exit", 0, 0);
135 + * ofw("chain", 5, 0, virtaddr, size, entryaddr, argsaddr, len);
136 + * ofw("interpret", numin+1, numout+1, cmdstr, in0, ..., &catchres, &out0, ...);
137 + * ofw("set-callback", 1, 1, newfuncaddr, &oldfuncaddr);
138 + * ofw("set-symbol-lookup", 2, 0, symtovaladdr, valtosymaddr);
139 + * ofw("milliseconds", 0, 1, &ms);
140 + */
141 +
142 +int ofw(char *name, int numargs, int numres, ...)
143 +{
144 + va_list ap;
145 + int argarray[MAXARGS+3];
146 + int argnum = 3;
147 + int retval;
148 + int *intp;
149 + unsigned long flags;
150 +
151 + if (!call_firmware)
152 + return -1;
153 + if ((numargs + numres) > MAXARGS)
154 + return -1; /* spit out an error? */
155 +
156 + argarray[0] = (int) name;
157 + argarray[1] = numargs;
158 + argarray[2] = numres;
159 +
160 + va_start(ap, numres);
161 + while (numargs) {
162 + argarray[argnum++] = va_arg(ap, int);
163 + numargs--;
164 + }
165 +
166 + spin_lock_irqsave(&prom_lock, flags);
167 + retval = call_firmware(argarray);
168 + spin_unlock_irqrestore(&prom_lock, flags);
169 +
170 + if (retval == 0) {
171 + while (numres) {
172 + intp = va_arg(ap, int *);
173 + *intp = argarray[argnum++];
174 + numres--;
175 + }
176 + }
177 + va_end(ap);
178 + return retval;
179 +}
180 +EXPORT_SYMBOL(ofw);
181 Index: linux-2.6.24.7/arch/x86/kernel/olpc.c
182 ===================================================================
183 --- /dev/null
184 +++ linux-2.6.24.7/arch/x86/kernel/olpc.c
185 @@ -0,0 +1,287 @@
186 +/* Support for the OLPC DCON and OLPC EC access
187 + * Copyright (C) 2006, Advanced Micro Devices, Inc.
188 + *
189 + * This program is free software; you can redistribute it and/or modify
190 + * it under the terms of the GNU General Public License as published by
191 + * the Free Software Foundation; either version 2 of the License, or
192 + * (at your option) any later version.
193 + */
194 +
195 +#include <linux/autoconf.h>
196 +#include <linux/kernel.h>
197 +#include <linux/init.h>
198 +#include <linux/mc146818rtc.h>
199 +#include <linux/delay.h>
200 +#include <linux/spinlock.h>
201 +
202 +#include <asm/olpc.h>
203 +#include <asm/ofw.h>
204 +
205 +/* This is our new multi-purpose structure used to contain the
206 + * information about the platform that we detect
207 + */
208 +
209 +struct olpc_platform_t olpc_platform_info;
210 +EXPORT_SYMBOL_GPL(olpc_platform_info);
211 +
212 +/*********************************************************************
213 + * EC locking and access
214 + *********************************************************************/
215 +
216 +static DEFINE_SPINLOCK(ec_lock);
217 +
218 +/* what the timeout *should* be (in ms) */
219 +#define EC_BASE_TIMEOUT 20
220 +
221 +/* the timeout that bugs in the EC might force us to actually use */
222 +static int ec_timeout = EC_BASE_TIMEOUT;
223 +
224 +static int __init olpc_ec_timeout_set(char *str)
225 +{
226 + if (get_option(&str, &ec_timeout) != 1) {
227 + ec_timeout = EC_BASE_TIMEOUT;
228 + printk(KERN_ERR "olpc-ec: invalid argument to "
229 + "'olpc_ec_timeout=', ignoring!\n");
230 + }
231 + printk(KERN_DEBUG "olpc-ec: using %d ms delay for EC commands.\n",
232 + ec_timeout);
233 + return 1;
234 +}
235 +__setup("olpc_ec_timeout=", olpc_ec_timeout_set);
236 +
237 +/*
238 + * These *bf_status functions return whether the buffers are full or not.
239 + */
240 +
241 +static inline unsigned int ibf_status(unsigned int port)
242 +{
243 + return !!(inb(port) & 0x02);
244 +}
245 +
246 +static inline unsigned int obf_status(unsigned int port)
247 +{
248 + return inb(port) & 0x01;
249 +}
250 +
251 +#define wait_on_ibf(p, d) __wait_on_ibf(__LINE__, (p), (d))
252 +static int __wait_on_ibf(unsigned int line, unsigned int port, int desired)
253 +{
254 + unsigned int timeo;
255 + int state = ibf_status(port);
256 +
257 + for (timeo = ec_timeout; state != desired && timeo; timeo--) {
258 + mdelay(1);
259 + state = ibf_status(port);
260 + }
261 +
262 + if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) &&
263 + timeo < (ec_timeout - EC_BASE_TIMEOUT)) {
264 + printk(KERN_WARNING "olpc-ec: %d: waited %u ms for IBF!\n",
265 + line, ec_timeout - timeo);
266 + }
267 +
268 + return !(state == desired);
269 +}
270 +
271 +#define wait_on_obf(p, d) __wait_on_obf(__LINE__, (p), (d))
272 +static int __wait_on_obf(unsigned int line, unsigned int port, int desired)
273 +{
274 + unsigned int timeo;
275 + int state = obf_status(port);
276 +
277 + for (timeo = ec_timeout; state != desired && timeo; timeo--) {
278 + mdelay(1);
279 + state = obf_status(port);
280 + }
281 +
282 + if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) &&
283 + timeo < (ec_timeout - EC_BASE_TIMEOUT)) {
284 + printk(KERN_WARNING "olpc-ec: %d: waited %u ms for OBF!\n",
285 + line, ec_timeout - timeo);
286 + }
287 +
288 + return !(state == desired);
289 +}
290 +
291 +int olpc_ec_cmd(unsigned char cmd, unsigned char *inbuf, size_t inlen,
292 + unsigned char *outbuf, size_t outlen)
293 +{
294 + unsigned long flags;
295 + int ret = -EIO;
296 + int i;
297 +
298 + spin_lock_irqsave(&ec_lock, flags);
299 +
300 + /* Clear OBF */
301 + for (i = 0; i < 10 && (obf_status(0x6c) == 1); i++)
302 + inb(0x68);
303 + if (i == 10) {
304 + printk(KERN_ERR "olpc-ec: timeout while attempting to "
305 + "clear OBF flag!\n");
306 + goto err;
307 + }
308 +
309 + if (wait_on_ibf(0x6c, 0)) {
310 + printk(KERN_ERR "olpc-ec: timeout waiting for EC to "
311 + "quiesce!\n");
312 + goto err;
313 + }
314 +
315 +restart:
316 + /*
317 + * Note that if we time out during any IBF checks, that's a failure;
318 + * we have to return. There's no way for the kernel to clear that.
319 + *
320 + * If we time out during an OBF check, we can restart the command;
321 + * reissuing it will clear the OBF flag, and we should be alright.
322 + * The OBF flag will sometimes misbehave due to what we believe
323 + * is a hardware quirk..
324 + */
325 + printk(KERN_DEBUG "olpc-ec: running cmd 0x%x\n", cmd);
326 + outb(cmd, 0x6c);
327 +
328 + if (wait_on_ibf(0x6c, 0)) {
329 + printk(KERN_ERR "olpc-ec: timeout waiting for EC to read "
330 + "command!\n");
331 + goto err;
332 + }
333 +
334 + if (inbuf && inlen) {
335 + /* write data to EC */
336 + for (i = 0; i < inlen; i++) {
337 + if (wait_on_ibf(0x6c, 0)) {
338 + printk(KERN_ERR "olpc-ec: timeout waiting for"
339 + " EC accept data!\n");
340 + goto err;
341 + }
342 + printk(KERN_DEBUG "olpc-ec: sending cmd arg 0x%x\n",
343 + inbuf[i]);
344 + outb(inbuf[i], 0x68);
345 + }
346 + }
347 + if (outbuf && outlen) {
348 + /* read data from EC */
349 + for (i = 0; i < outlen; i++) {
350 + if (wait_on_obf(0x6c, 1)) {
351 + printk(KERN_ERR "olpc-ec: timeout waiting for"
352 + " EC to provide data!\n");
353 + goto restart;
354 + }
355 + outbuf[i] = inb(0x68);
356 + printk(KERN_DEBUG "olpc-ec: received 0x%x\n",
357 + outbuf[i]);
358 + }
359 + }
360 +
361 + ret = 0;
362 +err:
363 + spin_unlock_irqrestore(&ec_lock, flags);
364 + return ret;
365 +}
366 +EXPORT_SYMBOL_GPL(olpc_ec_cmd);
367 +
368 +/*********************************************************************
369 + * DCON stuff
370 + *********************************************************************/
371 +
372 +static void __init
373 +ec_detect(void)
374 +{
375 + olpc_ec_cmd(0x08, NULL, 0, (unsigned char *) &olpc_platform_info.ecver, 1);
376 +}
377 +
378 +/* Check to see if this version of the OLPC board has VSA built
379 + * in, and set a flag
380 + */
381 +
382 +static void __init vsa_detect(void)
383 +{
384 + u16 rev;
385 +
386 + outw(0xFC53, 0xAC1C);
387 + outw(0x0003, 0xAC1C);
388 +
389 + rev = inw(0xAC1E);
390 +
391 + if (rev == 0x4132)
392 + olpc_platform_info.flags |= OLPC_F_VSA;
393 +}
394 +
395 +static void __init platform_detect(void)
396 +{
397 + size_t propsize;
398 + u32 rev;
399 +
400 + if (ofw("getprop", 4, 1, NULL, "board-revision-int", &rev, 4,
401 + &propsize) || propsize != 4) {
402 + printk(KERN_ERR "ofw: getprop call failed!\n");
403 + rev = 0;
404 + }
405 + olpc_platform_info.boardrev = be32_to_cpu(rev);
406 +}
407 +
408 +static int olpc_dcon_present = -1;
409 +module_param(olpc_dcon_present, int, 0444);
410 +
411 +/* REV_A CMOS map:
412 + * bit 440; DCON present bit
413 + */
414 +
415 +#define OLPC_CMOS_DCON_OFFSET (440 / 8)
416 +#define OLPC_CMOS_DCON_MASK 0x01
417 +
418 +static int __init olpc_init(void)
419 +{
420 + unsigned char *romsig;
421 +
422 + spin_lock_init(&ec_lock);
423 +
424 + romsig = ioremap(0xffffffc0, 16);
425 +
426 + if (!romsig)
427 + return 0;
428 +
429 + if (strncmp(romsig, "CL1 Q", 7))
430 + goto unmap;
431 + if (strncmp(romsig+6, romsig+13, 3)) {
432 + printk(KERN_INFO "OLPC BIOS signature looks invalid. Assuming not OLPC\n");
433 + goto unmap;
434 + }
435 + printk(KERN_INFO "OLPC board with OpenFirmware: %.16s\n", romsig);
436 +
437 + olpc_platform_info.flags |= OLPC_F_PRESENT;
438 +
439 + /* Get the platform revision */
440 + platform_detect();
441 +
442 + /* If olpc_dcon_present isn't set by the command line, then
443 + * "detect" it
444 + */
445 +
446 + if (olpc_dcon_present == -1) {
447 + /* B1 and greater always has a DCON */
448 + if (olpc_board_at_least(olpc_board(0xb1)))
449 + olpc_dcon_present = 1;
450 + }
451 +
452 + if (olpc_dcon_present)
453 + olpc_platform_info.flags |= OLPC_F_DCON;
454 +
455 + /* Get the EC revision */
456 + ec_detect();
457 +
458 + /* Check to see if the VSA exists */
459 + vsa_detect();
460 +
461 + printk(KERN_INFO "OLPC board revision: %s%X (EC=%x)\n",
462 + ((olpc_platform_info.boardrev & 0xf) < 8) ? "pre" : "",
463 + olpc_platform_info.boardrev >> 4,
464 + olpc_platform_info.ecver);
465 +
466 + unmap:
467 + iounmap(romsig);
468 +
469 + return 0;
470 +}
471 +
472 +postcore_initcall(olpc_init);
473 Index: linux-2.6.24.7/arch/x86/kernel/olpc-pm.c
474 ===================================================================
475 --- /dev/null
476 +++ linux-2.6.24.7/arch/x86/kernel/olpc-pm.c
477 @@ -0,0 +1,946 @@
478 +/* olpc-pm.c
479 + * © 2006 Red Hat, Inc.
480 + * Portions also copyright 2006 Advanced Micro Devices, Inc.
481 + * GPLv2
482 + */
483 +
484 +#include <linux/kernel.h>
485 +#include <linux/interrupt.h>
486 +#include <linux/module.h>
487 +#include <linux/delay.h>
488 +#include <linux/input.h>
489 +#include <linux/suspend.h>
490 +#include <linux/bootmem.h>
491 +#include <linux/platform_device.h>
492 +#include <linux/rtc.h>
493 +#include <linux/mc146818rtc.h>
494 +#include <asm/io.h>
495 +
496 +#include <asm/olpc.h>
497 +
498 +/* A few words about accessing the ACPI and PM registers. Long story short,
499 + byte and word accesses of the ACPI and PM registers is broken. The only
500 + way to do it really correctly is to use dword accesses, which we do
501 + throughout this code. For more details, please consult Eratta 17 and 18
502 + here:
503 +
504 + http://www.amd.com/files/connectivitysolutions/geode/geode_gx/34472D_CS5536_B1_specupdate.pdf
505 +*/
506 +
507 +#define PM_IRQ 3
508 +
509 +#define CS5536_PM_PWRBTN (1 << 8)
510 +#define CS5536_PM_RTC (1 << 10)
511 +#define CS5536_PM_WAK (1 << 15)
512 +
513 +#define GPIO_WAKEUP_EC (1 << 31)
514 +#define GPIO_WAKEUP_LID (1 << 30)
515 +
516 +#define PM_MODE_NORMAL 0
517 +#define PM_MODE_TEST 1
518 +#define PM_MODE_MAX 2
519 +
520 +/* These, and the battery EC commands, should be in an olpc.h. */
521 +#define EC_WRITE_SCI_MASK 0x1b
522 +#define EC_READ_SCI_MASK 0x1c
523 +
524 +extern void do_olpc_suspend_lowlevel(void);
525 +
526 +static struct {
527 + unsigned long address;
528 + unsigned short segment;
529 +} ofw_bios_entry = { 0, __KERNEL_CS };
530 +
531 +static int olpc_pm_mode = PM_MODE_NORMAL;
532 +static unsigned long acpi_base;
533 +static unsigned long pms_base;
534 +static int sci_irq;
535 +static int olpc_lid_flag;
536 +
537 +static struct input_dev *pm_inputdev;
538 +static struct input_dev *lid_inputdev;
539 +static struct input_dev *ebook_inputdev;
540 +static struct platform_suspend_ops olpc_pm_ops;
541 +
542 +static int gpio_wake_events = 0;
543 +static int ebook_state = -1;
544 +static u16 olpc_wakeup_mask = 0;
545 +
546 +static unsigned int test_timeout = 0;
547 +static char *wackup_source = "none";
548 +
549 +struct platform_device olpc_powerbutton_dev = {
550 + .name = "powerbutton",
551 + .id = -1,
552 +};
553 +
554 +struct platform_device olpc_lid_dev = {
555 + .name = "lid",
556 + .id = -1,
557 +};
558 +
559 +static void __init init_ebook_state(void)
560 +{
561 + if (olpc_ec_cmd(0x2a, NULL, 0, (unsigned char *) &ebook_state, 1)) {
562 + printk(KERN_WARNING "olpc-pm: failed to get EBOOK state!\n");
563 + ebook_state = 0;
564 + }
565 + ebook_state &= 1;
566 +
567 + /* the input layer needs to know what value to default to as well */
568 + input_report_switch(ebook_inputdev, SW_TABLET_MODE, ebook_state);
569 + input_sync(ebook_inputdev);
570 +}
571 +
572 +static void (*battery_callback)(unsigned long);
573 +static DEFINE_SPINLOCK(battery_callback_lock);
574 +
575 +/* propagate_events is non-NULL if run from workqueue,
576 + NULL when called at init time to flush SCI queue */
577 +static void process_sci_queue(struct work_struct *propagate_events)
578 +{
579 + unsigned char data = 0;
580 + unsigned char battery_events = 0;
581 + int ret;
582 +
583 + do {
584 + ret = olpc_ec_cmd(0x84, NULL, 0, &data, 1);
585 + if (!ret) {
586 + printk(KERN_DEBUG "olpc-pm: SCI 0x%x received\n",
587 + data);
588 +
589 + if (wackup_source && !strcmp(wackup_source, "sci")) {
590 + /*
591 + * XXX: in order for this to not be racy, we
592 + * need assurance that we will never get
593 + * preempted by olpc_do_sleep here!
594 + */
595 + switch (data) {
596 + case EC_SCI_SRC_EMPTY:
597 + wackup_source = "empty sci";
598 + break;
599 + case EC_SCI_SRC_GAME:
600 + wackup_source = "key press";
601 + break;
602 + case EC_SCI_SRC_BATTERY:
603 + wackup_source = "battery";
604 + break;
605 + case EC_SCI_SRC_BATSOC:
606 + wackup_source = "battery state change";
607 + break;
608 + case EC_SCI_SRC_BATERR:
609 + wackup_source = "battery error";
610 + break;
611 + case EC_SCI_SRC_EBOOK:
612 + wackup_source = "ebook";
613 + break;
614 + case EC_SCI_SRC_WLAN:
615 + wackup_source = "wlan packet";
616 + break;
617 + case EC_SCI_SRC_ACPWR:
618 + wackup_source = "ac power";
619 + break;
620 + default:
621 + wackup_source = "unknown";
622 + }
623 + }
624 +
625 + if (data & (EC_SCI_SRC_BATERR | EC_SCI_SRC_BATSOC |
626 + EC_SCI_SRC_BATTERY | EC_SCI_SRC_ACPWR))
627 + battery_events |= data;
628 + else if (data == EC_SCI_SRC_EBOOK) {
629 + ebook_state = !ebook_state;
630 + if (propagate_events) {
631 + input_report_switch(ebook_inputdev,
632 + SW_TABLET_MODE, ebook_state);
633 + input_sync(ebook_inputdev);
634 + }
635 + }
636 + }
637 + } while (data && !ret);
638 +
639 + if (battery_events && battery_callback && propagate_events) {
640 + void (*cbk)(unsigned long);
641 +
642 + /* Older EC versions didn't distinguish between AC and battery
643 + events */
644 + if (olpc_platform_info.ecver < 0x51)
645 + battery_events = EC_SCI_SRC_BATTERY | EC_SCI_SRC_ACPWR;
646 +
647 + spin_lock(&battery_callback_lock);
648 + cbk = battery_callback;
649 + spin_unlock(&battery_callback_lock);
650 +
651 + cbk(battery_events);
652 + }
653 +
654 + if (ret)
655 + printk(KERN_WARNING "Failed to clear SCI queue!\n");
656 +}
657 +
658 +static DECLARE_WORK(sci_work, process_sci_queue);
659 +
660 +void olpc_register_battery_callback(void (*f)(unsigned long))
661 +{
662 + spin_lock(&battery_callback_lock);
663 + battery_callback = f;
664 + spin_unlock(&battery_callback_lock);
665 +}
666 +EXPORT_SYMBOL_GPL(olpc_register_battery_callback);
667 +
668 +void olpc_deregister_battery_callback(void)
669 +{
670 + spin_lock(&battery_callback_lock);
671 + battery_callback = NULL;
672 + spin_unlock(&battery_callback_lock);
673 + cancel_work_sync(&sci_work);
674 +}
675 +EXPORT_SYMBOL_GPL(olpc_deregister_battery_callback);
676 +
677 +
678 +static int olpc_pm_interrupt(int irq, void *id)
679 +{
680 + uint32_t sts, gpe = 0;
681 +
682 + sts = inl(acpi_base + PM1_STS);
683 + outl(sts | 0xFFFF, acpi_base + PM1_STS);
684 +
685 + if (olpc_board_at_least(olpc_board(0xb2))) {
686 + gpe = inl(acpi_base + PM_GPE0_STS);
687 + outl(0xFFFFFFFF, acpi_base + PM_GPE0_STS);
688 + }
689 +
690 + if (sts & CS5536_PM_PWRBTN) {
691 + if (!wackup_source)
692 + wackup_source = "power button";
693 + printk(KERN_DEBUG "olpm-pm: PM_PWRBTN %sevent received\n",
694 + sts & CS5536_PM_WAK ? "wakeup " : "");
695 + if (!(sts & CS5536_PM_WAK)) {
696 + input_report_key(pm_inputdev, KEY_POWER, 1);
697 + input_sync(pm_inputdev);
698 + /* Do we need to delay this? */
699 + input_report_key(pm_inputdev, KEY_POWER, 0);
700 + input_sync(pm_inputdev);
701 + }
702 + }
703 +
704 + if (gpe & GPIO_WAKEUP_EC) {
705 + geode_gpio_clear(OLPC_GPIO_ECSCI, GPIO_NEGATIVE_EDGE_STS);
706 + if (!wackup_source)
707 + wackup_source = "sci";
708 + schedule_work(&sci_work);
709 + }
710 +
711 + if (gpe & GPIO_WAKEUP_LID) {
712 + /* Disable events */
713 + geode_gpio_clear(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
714 +
715 + /* Clear the edge */
716 +
717 + if (olpc_lid_flag)
718 + geode_gpio_clear(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_EN);
719 + else
720 + geode_gpio_clear(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_EN);
721 +
722 + /* Clear the status too */
723 + geode_gpio_set(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_STS);
724 + geode_gpio_set(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_STS);
725 +
726 + /* The line is high when the LID is open, but SW_LID
727 + * should be high when the LID is closed, so we pass the old
728 + * value of olpc_lid_flag
729 + */
730 +
731 + input_report_switch(lid_inputdev, SW_LID, olpc_lid_flag);
732 + input_sync(lid_inputdev);
733 + if (!wackup_source)
734 + wackup_source = "lid";
735 +
736 + /* Swap the status */
737 + olpc_lid_flag = !olpc_lid_flag;
738 +
739 + if (olpc_lid_flag)
740 + geode_gpio_set(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_EN);
741 + else
742 + geode_gpio_set(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_EN);
743 +
744 + /* re-enable the event */
745 + geode_gpio_set(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
746 + }
747 +
748 + return IRQ_HANDLED;
749 +}
750 +
751 +int olpc_ec_mask_set(u8 bits)
752 +{
753 + int ret;
754 + u8 byte;
755 +
756 + ret = olpc_ec_cmd(EC_READ_SCI_MASK, NULL, 0, &byte, 1);
757 + if (ret) {
758 + printk(KERN_ERR "olpc-pm: error getting SCI mask: %d\n", ret);
759 + return ret;
760 + }
761 + /* the high bit is unused, if it is ever unset, that is a good sign
762 + sign of EC communication corruption! */
763 + WARN_ON(!(byte & 0x80));
764 +
765 + byte |= bits;
766 + ret = olpc_ec_cmd(EC_WRITE_SCI_MASK, &byte, 1, NULL, 0);
767 + if (ret)
768 + printk(KERN_ERR "olpc-pm: error setting SCI mask: %d\n", ret);
769 +
770 + return ret;
771 +}
772 +EXPORT_SYMBOL_GPL(olpc_ec_mask_set);
773 +
774 +int olpc_ec_mask_unset(u8 bits)
775 +{
776 + int ret;
777 + u8 byte;
778 +
779 + ret = olpc_ec_cmd(EC_READ_SCI_MASK, NULL, 0, &byte, 1);
780 + if (ret) {
781 + printk(KERN_ERR "olpc-pm: error getting SCI mask: %d\n", ret);
782 + return ret;
783 + }
784 + /* the high bit is unused, if it is ever unset, that is a good sign
785 + sign of EC communication corruption! */
786 + WARN_ON(!(byte & 0x80));
787 +
788 + byte &= ~bits;
789 + ret = olpc_ec_cmd(EC_WRITE_SCI_MASK, &byte, 1, NULL, 0);
790 + if (ret)
791 + printk(KERN_ERR "olpc-pm: error setting SCI mask: %d\n", ret);
792 +
793 + return ret;
794 +}
795 +EXPORT_SYMBOL_GPL(olpc_ec_mask_unset);
796 +
797 +/*
798 + * For now, only support STR. We also don't support suspending on
799 + * B1s, due to difficulties with the cafe FPGA.
800 + */
801 +static int olpc_pm_state_valid(suspend_state_t pm_state)
802 +{
803 + if (pm_state == PM_SUSPEND_MEM && olpc_board_at_least(olpc_board(0xb2)))
804 + return 1;
805 +
806 + return 0;
807 +}
808 +
809 +/* This is a catchall function for operations that just don't belong
810 + * anywhere else. Later we will evaluate if these belong in the
811 + * individual device drivers or the firmware.
812 + * If you add something to this function, please explain yourself with
813 + * a comment.
814 + */
815 +
816 +extern void gxfb_flatpanel_control(int state);
817 +
818 +static u32 gpio_wakeup[2];
819 +static u64 irq_sources[4];
820 +static u64 mfgpt_irq_msr, mfgpt_nr_msr;
821 +
822 +void olpc_fixup_wakeup(void)
823 +{
824 + u32 base = geode_gpio_base();
825 + int i;
826 +
827 + /* Enable the flatpanel sequencing as early as possible, because
828 + it takes ~64ms to resume. This probably belongs in the firmware */
829 +
830 + //gxfb_flatpanel_control(1);
831 +
832 + /* Tell the EC to stop inhibiting SCIs */
833 + olpc_ec_cmd(0x34, NULL, 0, NULL, 0);
834 +
835 + /* Restore the interrupt sources */
836 + wrmsrl(MSR_PIC_YSEL_LOW, irq_sources[0]);
837 + wrmsrl(MSR_PIC_ZSEL_LOW, irq_sources[1]);
838 + wrmsrl(MSR_PIC_YSEL_HIGH, irq_sources[2]);
839 + wrmsrl(MSR_PIC_ZSEL_HIGH, irq_sources[3]);
840 +
841 + /* Restore the X and Y sources for GPIO */
842 + outl(gpio_wakeup[0], base + GPIO_MAP_X);
843 + outl(gpio_wakeup[1], base + GPIO_MAP_Y);
844 +
845 + /* Resture the MFGPT MSRs */
846 + wrmsrl(MFGPT_IRQ_MSR, mfgpt_irq_msr);
847 + wrmsrl(MFGPT_NR_MSR, mfgpt_nr_msr);
848 +
849 + for (i=0;i<2;i++) {
850 + /* tell the wireless module to restart USB communication */
851 + olpc_ec_cmd(0x24, NULL, 0, NULL, 0);
852 + }
853 +
854 + /* Turn all events on */
855 + olpc_ec_mask_set(EC_SCI_SRC_ALL);
856 +}
857 +
858 +void olpc_fixup_sleep(void)
859 +{
860 + u32 base = geode_gpio_base();
861 + int i;
862 +
863 + /* Save the X and Y sources for GPIO */
864 + gpio_wakeup[0] = inl(base + GPIO_MAP_X);
865 + gpio_wakeup[1] = inl(base + GPIO_MAP_Y);
866 +
867 + /* Save the Y and Z unrestricted sources */
868 +
869 + rdmsrl(MSR_PIC_YSEL_LOW, irq_sources[0]);
870 + rdmsrl(MSR_PIC_ZSEL_LOW, irq_sources[1]);
871 + rdmsrl(MSR_PIC_YSEL_HIGH, irq_sources[2]);
872 + rdmsrl(MSR_PIC_ZSEL_HIGH, irq_sources[3]);
873 +
874 + /* Turn off the MFGPT timers on the way down */
875 +
876 + for(i = 0; i < 8; i++) {
877 + u32 val = geode_mfgpt_read(i, MFGPT_REG_SETUP);
878 +
879 + if (val & MFGPT_SETUP_SETUP) {
880 + val &= ~MFGPT_SETUP_CNTEN;
881 + geode_mfgpt_write(i, MFGPT_REG_SETUP, val);
882 + }
883 + }
884 +
885 + /* Save the MFGPT MSRs */
886 + rdmsrl(MFGPT_IRQ_MSR, mfgpt_irq_msr);
887 + rdmsrl(MFGPT_NR_MSR, mfgpt_nr_msr);
888 +
889 + if (device_may_wakeup(&olpc_powerbutton_dev.dev))
890 + olpc_wakeup_mask |= CS5536_PM_PWRBTN;
891 + else
892 + olpc_wakeup_mask &= ~(CS5536_PM_PWRBTN);
893 +
894 + if (device_may_wakeup(&olpc_lid_dev.dev)) {
895 + geode_gpio_set(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
896 + gpio_wake_events |= GPIO_WAKEUP_LID;
897 + } else {
898 + geode_gpio_clear(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
899 + gpio_wake_events &= ~(GPIO_WAKEUP_LID);
900 + }
901 +
902 + /* We don't want to wake up on superfluous events */
903 + olpc_ec_mask_unset(EC_SCI_SRC_BATSOC | EC_SCI_SRC_ACPWR);
904 +
905 + /*
906 + * Cmd 0x32 tells the EC that we're going into suspend; this was
907 + * added to work around hardware races related to SCI events. This
908 + * should cause the EC to inhibit further SCIs while MAIN_ON is
909 + * transitioning low.
910 + *
911 + * There's also some sort of EC race whereby the EC gets its
912 + * IBF/OBF flags confused and all future communication (after
913 + * resuming) fails if we suspend too soon after updating
914 + * the EC SCI mask. Having this command after updating the
915 + * SCI mask allows the EC enough time to finish doing what it's
916 + * doing.
917 + */
918 + olpc_ec_cmd(0x32, NULL, 0, NULL, 0);
919 +}
920 +
921 +static int olpc_pm_enter(suspend_state_t pm_state)
922 +{
923 + /* Only STR is supported */
924 + if (pm_state != PM_SUSPEND_MEM)
925 + return -EINVAL;
926 +
927 + olpc_fixup_sleep();
928 +
929 + /* Set the GPIO wakeup bits */
930 + outl(gpio_wake_events, acpi_base + PM_GPE0_EN);
931 + outl(0xFFFFFFFF, acpi_base + PM_GPE0_STS);
932 +
933 + /* Save CPU state */
934 + do_olpc_suspend_lowlevel();
935 +
936 + olpc_fixup_wakeup();
937 +
938 + /* Restore the SCI wakeup events */
939 + outl(gpio_wake_events, acpi_base + PM_GPE0_EN);
940 +
941 + return 0;
942 +}
943 +
944 +int asmlinkage olpc_do_sleep(u8 sleep_state)
945 +{
946 + void *pgd_addr = __va(read_cr3());
947 + printk(KERN_ERR "olpc_do_sleep!\n"); /* this needs to remain here so
948 + * that gcc doesn't optimize
949 + * away our __va! */
950 + /* FIXME: Set the SCI bits we want to wake up on here */
951 +
952 + /* FIXME: Set any other SCI events that we might want here */
953 +
954 + outl((olpc_wakeup_mask << 16) | 0xFFFF, acpi_base + PM1_STS);
955 +
956 + wackup_source = NULL;
957 +
958 + /* If we are in test mode, then just return (simulate a successful
959 + suspend/resume). Otherwise, if we are doing the real thing,
960 + then go for the gusto */
961 +
962 + if (olpc_pm_mode != PM_MODE_TEST) {
963 + __asm__ __volatile__("movl %0,%%eax" : : "r" (pgd_addr));
964 + __asm__("call *(%%edi); cld"
965 + : : "D" (&ofw_bios_entry));
966 + __asm__ __volatile__("movb $0x34, %al\n\t"
967 + "outb %al, $0x70\n\t"
968 + "movb $0x30, %al\n\t"
969 + "outb %al, $0x71\n\t");
970 +
971 + }
972 + else if (test_timeout > 0) {
973 + int t;
974 +
975 + /* Delay N seconds for testing purposes */
976 +
977 + for(t = 0; t < test_timeout; t++)
978 + mdelay(1000);
979 + }
980 +
981 + return 0;
982 +}
983 +
984 +static void olpc_power_off(void)
985 +{
986 + printk(KERN_INFO "OLPC power off sequence...\n");
987 +
988 + /* Enable all of these controls with 0 delay */
989 + outl(0x40000000, pms_base + PM_SCLK);
990 + outl(0x40000000, pms_base + PM_IN_SLPCTL);
991 + outl(0x40000000, pms_base + PM_WKXD);
992 + outl(0x40000000, pms_base + PM_WKD);
993 +
994 + /* Clear status bits (possibly unnecessary) */
995 + outl(0x0002ffff, pms_base + PM_SSC);
996 + outl(0xffffffff, acpi_base + PM_GPE0_STS);
997 +
998 + /* Write SLP_EN bit to start the machinery */
999 + outl(0x00002000, acpi_base + PM1_CNT);
1000 +}
1001 +
1002 +/* This code will slowly disappear as we fixup the issues in the BIOS */
1003 +
1004 +static void __init olpc_fixup_bios(void)
1005 +{
1006 + unsigned long hi, lo;
1007 +
1008 + if (olpc_has_vsa()) {
1009 + /* The VSA aggressively sets up the ACPI and PM register for
1010 + * trapping - its not enough to force these values in the BIOS -
1011 + * they seem to be changed during PCI init as well.
1012 + */
1013 +
1014 + /* Change the PM registers to decode to the DD */
1015 +
1016 + rdmsr(0x510100e2, lo, hi);
1017 + hi |= 0x80000000;
1018 + wrmsr(0x510100e2, lo, hi);
1019 +
1020 + /* Change the ACPI registers to decode to the DD */
1021 +
1022 + rdmsr(0x510100e3, lo, hi);
1023 + hi |= 0x80000000;
1024 + wrmsr(0x510100e3, lo, hi);
1025 + }
1026 +
1027 + /* GPIO24 controls WORK_AUX */
1028 +
1029 + geode_gpio_set(OLPC_GPIO_WORKAUX, GPIO_OUTPUT_ENABLE);
1030 + geode_gpio_set(OLPC_GPIO_WORKAUX, GPIO_OUTPUT_AUX1);
1031 +
1032 + if (olpc_board_at_least(olpc_board(0xb2))) {
1033 + /* GPIO10 is connected to the thermal alarm */
1034 + geode_gpio_set(OLPC_GPIO_THRM_ALRM, GPIO_INPUT_ENABLE);
1035 + geode_gpio_set(OLPC_GPIO_THRM_ALRM, GPIO_INPUT_AUX1);
1036 +
1037 + /* Set up to get LID events */
1038 + geode_gpio_set(OLPC_GPIO_LID, GPIO_INPUT_ENABLE);
1039 +
1040 + /* Clear edge detection and event enable for now */
1041 + geode_gpio_clear(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
1042 + geode_gpio_clear(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_EN);
1043 + geode_gpio_clear(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_EN);
1044 +
1045 + geode_gpio_set(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_STS);
1046 + geode_gpio_set(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_STS);
1047 +
1048 + /* Set the LID to cause an PME event on group 6 */
1049 + geode_gpio_event_pme(OLPC_GPIO_LID, 6);
1050 +
1051 + /* Set PME group 6 to fire the SCI interrupt */
1052 + geode_gpio_set_irq(6, sci_irq);
1053 + }
1054 +
1055 + geode_gpio_set(OLPC_GPIO_ECSCI, GPIO_INPUT_ENABLE);
1056 +
1057 + /* Clear pending events */
1058 +
1059 + geode_gpio_set(OLPC_GPIO_ECSCI, GPIO_NEGATIVE_EDGE_STS);
1060 + geode_gpio_set(OLPC_GPIO_ECSCI, GPIO_POSITIVE_EDGE_STS);
1061 +
1062 + //geode_gpio_set(OLPC_GPIO_ECSCI, GPIO_NEGATIVE_EDGE_EN);
1063 + geode_gpio_set(OLPC_GPIO_ECSCI, GPIO_EVENTS_ENABLE);
1064 +
1065 + /* Set the SCI to cause a PME event on group 7 */
1066 + geode_gpio_event_pme(OLPC_GPIO_ECSCI, 7);
1067 +
1068 + /* And have group 6 also fire the SCI interrupt */
1069 + geode_gpio_set_irq(7, sci_irq);
1070 +}
1071 +
1072 +/* This provides a control file for setting up testing of the
1073 + power management system. For now, there is just one setting:
1074 + "test" which means that we don't actually enter the power
1075 + off routine.
1076 +*/
1077 +
1078 +static const char * const pm_states[] = {
1079 + [PM_MODE_NORMAL] = "normal",
1080 + [PM_MODE_TEST] = "test",
1081 +};
1082 +
1083 +extern struct mutex pm_mutex;
1084 +extern struct kset power_subsys;
1085 +
1086 +static ssize_t control_show(struct kset *s, char *buf)
1087 +{
1088 + return sprintf(buf, "%s\n", pm_states[olpc_pm_mode]);
1089 +}
1090 +
1091 +static ssize_t control_store(struct kset *s, const char *buf, size_t n)
1092 +{
1093 + int i, len;
1094 + char *p;
1095 +
1096 + p = memchr(buf, '\n', n);
1097 + len = p ? p - buf : n;
1098 +
1099 + /* Grab the mutex */
1100 + mutex_lock(&pm_mutex);
1101 +
1102 + for(i = 0; i < PM_MODE_MAX; i++) {
1103 + if (!strncmp(buf, pm_states[i], len)) {
1104 + olpc_pm_mode = i;
1105 + break;
1106 + }
1107 + }
1108 +
1109 + mutex_unlock(&pm_mutex);
1110 +
1111 + return (i == PM_MODE_MAX) ? -EINVAL : n;
1112 +}
1113 +
1114 +static ssize_t timeout_show(struct kset *s, char *buf)
1115 +{
1116 + return sprintf(buf, "%d\n", test_timeout);
1117 +}
1118 +
1119 +static ssize_t timeout_store(struct kset *s, const char *buf, size_t n)
1120 +{
1121 + unsigned int t = simple_strtoul(buf, NULL, 0);
1122 + test_timeout = t;
1123 +
1124 + return n;
1125 +}
1126 +
1127 +static ssize_t wackup_show(struct kset *s, char *buf)
1128 +{
1129 + return sprintf(buf, "%s\n", wackup_source ? wackup_source : "none");
1130 +}
1131 +
1132 +static struct subsys_attribute control_attr = {
1133 + .attr = {
1134 + .name = "olpc-pm",
1135 + .mode = 0644,
1136 + },
1137 + .show = control_show,
1138 + .store = control_store,
1139 +};
1140 +
1141 +static struct subsys_attribute test_attr = {
1142 + .attr = {
1143 + .name = "test-timeout",
1144 + .mode = 0644,
1145 + },
1146 + .show = timeout_show,
1147 + .store = timeout_store,
1148 +};
1149 +
1150 +static struct subsys_attribute wackup_attr = {
1151 + .attr = {
1152 + .name = "wakeup-source",
1153 + .mode = 0400,
1154 + },
1155 + .show = wackup_show,
1156 +};
1157 +
1158 +static struct attribute * olpc_attributes[] = {
1159 + &control_attr.attr,
1160 + &test_attr.attr,
1161 + &wackup_attr.attr,
1162 + NULL
1163 +};
1164 +
1165 +static struct attribute_group olpc_attrs = {
1166 + .attrs = olpc_attributes,
1167 +};
1168 +
1169 +static int __init alloc_inputdevs(void)
1170 +{
1171 + int ret = -ENOMEM;
1172 +
1173 + pm_inputdev = input_allocate_device();
1174 + if (!pm_inputdev)
1175 + goto err;
1176 +
1177 + pm_inputdev->name = "OLPC PM";
1178 + pm_inputdev->phys = "olpc_pm/input0";
1179 + set_bit(EV_KEY, pm_inputdev->evbit);
1180 + set_bit(KEY_POWER, pm_inputdev->keybit);
1181 +
1182 + ret = input_register_device(pm_inputdev);
1183 + if (ret) {
1184 + printk(KERN_ERR "olpc-pm: failed to register PM input device: %d\n", ret);
1185 + goto err;
1186 + }
1187 +
1188 + lid_inputdev = input_allocate_device();
1189 + if (!lid_inputdev)
1190 + goto err;
1191 +
1192 + lid_inputdev->name = "OLPC lid switch";
1193 + lid_inputdev->phys = "olpc_pm/input1";
1194 + set_bit(EV_SW, lid_inputdev->evbit);
1195 + set_bit(SW_LID, lid_inputdev->swbit);
1196 +
1197 + ret = input_register_device(lid_inputdev);
1198 + if (ret) {
1199 + printk(KERN_ERR "olpc-pm: failed to register lid input device: %d\n", ret);
1200 + goto err;
1201 + }
1202 +
1203 + ebook_inputdev = input_allocate_device();
1204 + if (!ebook_inputdev)
1205 + goto err;
1206 +
1207 + ebook_inputdev->name = "OLPC ebook switch";
1208 + ebook_inputdev->phys = "olpc_pm/input2";
1209 + set_bit(EV_SW, ebook_inputdev->evbit);
1210 + set_bit(SW_TABLET_MODE, ebook_inputdev->swbit);
1211 +
1212 + ret = input_register_device(ebook_inputdev);
1213 + if (ret) {
1214 + printk(KERN_ERR "olpc-pm: failed to register ebook input device: %d\n", ret);
1215 + goto err;
1216 + }
1217 +
1218 + return ret;
1219 +err:
1220 + if (ebook_inputdev) {
1221 + input_unregister_device(ebook_inputdev);
1222 + ebook_inputdev = NULL;
1223 + }
1224 + if (lid_inputdev) {
1225 + input_unregister_device(lid_inputdev);
1226 + lid_inputdev = NULL;
1227 + }
1228 + if (pm_inputdev) {
1229 + input_unregister_device(pm_inputdev);
1230 + pm_inputdev = NULL;
1231 + }
1232 +
1233 + return ret;
1234 +}
1235 +
1236 +static int __init olpc_pm_init(void)
1237 +{
1238 + uint32_t lo, hi;
1239 + int ret;
1240 +
1241 + if (!machine_is_olpc())
1242 + return -ENODEV;
1243 +
1244 + acpi_base = geode_acpi_base();
1245 + pms_base = geode_pms_base();
1246 +
1247 + if (!acpi_base || !pms_base)
1248 + return -ENODEV;
1249 +
1250 + pm_power_off = olpc_power_off;
1251 +
1252 + ret = alloc_inputdevs();
1253 + if (ret)
1254 + return ret;
1255 +
1256 + rdmsr(0x51400020, lo, hi);
1257 + sci_irq = (lo >> 20) & 15;
1258 +
1259 + if (sci_irq) {
1260 + printk(KERN_INFO "SCI is mapped to IRQ %d\n", sci_irq);
1261 + } else {
1262 + /* Zero doesn't mean zero -- it means masked */
1263 + printk(KERN_INFO "SCI unmapped. Mapping to IRQ 3\n");
1264 + sci_irq = 3;
1265 + lo |= 0x00300000;
1266 + wrmsrl(0x51400020, lo);
1267 + }
1268 +
1269 + olpc_fixup_bios();
1270 +
1271 + lo = inl(pms_base + PM_FSD);
1272 +
1273 + /* Lock, enable failsafe, 4 seconds */
1274 + outl(0xc001f400, pms_base + PM_FSD);
1275 +
1276 + /* Here we set up the SCI events we're interested in during
1277 + * real-time. We have no sleep button, and the RTC doesn't make
1278 + * sense, so set up the power button
1279 + */
1280 +
1281 + outl(inl(acpi_base) | ((CS5536_PM_PWRBTN) << 16), acpi_base);
1282 +
1283 + if (olpc_board_at_least(olpc_board(0xb2))) {
1284 + gpio_wake_events |= GPIO_WAKEUP_LID;
1285 +
1286 + /* Get the current value of the GPIO, and set up the edges */
1287 + olpc_lid_flag = geode_gpio_isset(OLPC_GPIO_LID, GPIO_READ_BACK);
1288 +
1289 + /* Watch for the opposite edge */
1290 +
1291 + if (olpc_lid_flag)
1292 + geode_gpio_set(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_EN);
1293 + else
1294 + geode_gpio_set(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_EN);
1295 +
1296 + /* Enable the event */
1297 + geode_gpio_set(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
1298 + }
1299 +
1300 + /* Set up the EC SCI */
1301 +
1302 + gpio_wake_events |= GPIO_WAKEUP_EC;
1303 +
1304 + outl(gpio_wake_events, acpi_base + PM_GPE0_EN);
1305 + outl(0xFFFFFFFF, acpi_base + PM_GPE0_STS);
1306 +
1307 + /* Select level triggered in PIC */
1308 +
1309 + if (sci_irq < 8) {
1310 + lo = inb(0x4d0);
1311 + lo |= 1 << sci_irq;
1312 + outb(lo, 0x4d0);
1313 + } else {
1314 + lo = inb(0x4d1);
1315 + lo |= 1 << (sci_irq - 8);
1316 + outb(lo, 0x4d1);
1317 + }
1318 + /* Clear pending interrupt */
1319 + outl(inl(acpi_base) | 0xFFFF, acpi_base);
1320 + process_sci_queue(0); /* we just want to flush the queue here */
1321 + init_ebook_state();
1322 +
1323 + /* Enable the interrupt */
1324 +
1325 + ret = request_irq(sci_irq, &olpc_pm_interrupt, 0, "SCI", &acpi_base);
1326 +
1327 + if (ret) {
1328 + printk(KERN_ERR "Error registering SCI: %d\n", ret);
1329 + return ret;
1330 + }
1331 +
1332 + ofw_bios_entry.address = 0xF0000 + PAGE_OFFSET;
1333 + suspend_set_ops(&olpc_pm_ops);
1334 +
1335 + sysfs_create_group(&power_subsys.kobj, &olpc_attrs);
1336 +
1337 + return 0;
1338 +}
1339 +
1340 +
1341 +#if defined (CONFIG_RTC_DRV_CMOS) || defined (CONFIG_RTC_DRV_CMOS_MODULE)
1342 +struct resource rtc_platform_resource[2] = {
1343 + {
1344 + .flags = IORESOURCE_IO,
1345 + .start = RTC_PORT(0),
1346 + .end = RTC_PORT(0) + RTC_IO_EXTENT
1347 + },
1348 + {
1349 + .flags = IORESOURCE_IRQ,
1350 + .start = 8,
1351 + .end = 8,
1352 + },
1353 +};
1354 +
1355 +
1356 +static void rtc_wake_on(struct device *dev)
1357 +{
1358 + olpc_wakeup_mask |= CS5536_PM_RTC;
1359 +}
1360 +
1361 +static void rtc_wake_off(struct device *dev)
1362 +{
1363 + olpc_wakeup_mask &= ~(CS5536_PM_RTC);
1364 +}
1365 +
1366 +static struct cmos_rtc_board_info rtc_info = {
1367 + .rtc_day_alarm = 0,
1368 + .rtc_mon_alarm = 0,
1369 + .rtc_century = 0,
1370 + .wake_on = rtc_wake_on,
1371 + .wake_off = rtc_wake_off,
1372 +};
1373 +
1374 +struct platform_device olpc_rtc_device = {
1375 + .name = "rtc_cmos",
1376 + .id = -1,
1377 + .num_resources = ARRAY_SIZE(rtc_platform_resource),
1378 + .dev.platform_data = &rtc_info,
1379 + .resource = rtc_platform_resource,
1380 +};
1381 +
1382 +static int __init olpc_platform_init(void)
1383 +{
1384 + rdmsrl(MSR_RTC_DOMA_OFFSET, rtc_info.rtc_day_alarm);
1385 + rdmsrl(MSR_RTC_MONA_OFFSET, rtc_info.rtc_mon_alarm);
1386 + rdmsrl(MSR_RTC_CEN_OFFSET, rtc_info.rtc_century);
1387 +
1388 + (void)platform_device_register(&olpc_rtc_device);
1389 + device_init_wakeup(&olpc_rtc_device.dev, 1);
1390 +
1391 + (void)platform_device_register(&olpc_powerbutton_dev);
1392 + device_init_wakeup(&olpc_powerbutton_dev.dev, 1);
1393 +
1394 + (void)platform_device_register(&olpc_lid_dev);
1395 + device_init_wakeup(&olpc_lid_dev.dev, 1);
1396 +
1397 + return 0;
1398 +}
1399 +arch_initcall(olpc_platform_init);
1400 +#endif /* CONFIG_RTC_DRV_CMOS */
1401 +
1402 +static void olpc_pm_exit(void)
1403 +{
1404 + /* Clear any pending events, and disable them */
1405 + outl(0xFFFF, acpi_base+2);
1406 +
1407 + free_irq(sci_irq, &acpi_base);
1408 + input_unregister_device(pm_inputdev);
1409 + input_unregister_device(lid_inputdev);
1410 + input_unregister_device(ebook_inputdev);
1411 +}
1412 +
1413 +static struct platform_suspend_ops olpc_pm_ops = {
1414 + .valid = olpc_pm_state_valid,
1415 + .enter = olpc_pm_enter,
1416 +};
1417 +
1418 +module_init(olpc_pm_init);
1419 +module_exit(olpc_pm_exit);
1420 +
1421 +MODULE_LICENSE("GPL");
1422 +MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1423 +MODULE_DESCRIPTION("AMD Geode power management for OLPC CL1");
1424 Index: linux-2.6.24.7/arch/x86/kernel/olpc-sleep.S
1425 ===================================================================
1426 --- /dev/null
1427 +++ linux-2.6.24.7/arch/x86/kernel/olpc-sleep.S
1428 @@ -0,0 +1,39 @@
1429 +.text
1430 +
1431 +ENTRY(olpc_sleep_asm)
1432 +olpc_sleep:
1433 + ;; Get the value of PM1_CNT and store it off
1434 +
1435 + add 08h, ax
1436 + mov bx,dx
1437 + in dx,eax
1438 + or 2000h, ax
1439 + mov ax,di
1440 +
1441 + ;; flush the cache
1442 + wbinvd
1443 +
1444 + ;; GX2 must disable refresh before going into self-refresh
1445 + mov 2000000180xh, ecx
1446 + rdmsr
1447 + mov eax, esi
1448 + and 0FF0000FFh, eax
1449 + wrmsr
1450 +
1451 + ;; Now, put the memory into self refresh
1452 + mov 2004, cx
1453 + xor edx, edx
1454 + xor eax, eax
1455 + mov 04h, al
1456 + wrmsr
1457 +
1458 + ;; Thats all she wrote - time to go to sleep
1459 +
1460 + mov bx, dx
1461 + movzx di, eax
1462 + out eax, dx
1463 +
1464 + ;;
1465 +
1466 +
1467 +
1468 Index: linux-2.6.24.7/arch/x86/kernel/olpc-wakeup.S
1469 ===================================================================
1470 --- /dev/null
1471 +++ linux-2.6.24.7/arch/x86/kernel/olpc-wakeup.S
1472 @@ -0,0 +1,133 @@
1473 +.text
1474 +#include <linux/linkage.h>
1475 +#include <asm/segment.h>
1476 +#include <asm/page.h>
1477 +
1478 + .macro writepost,value
1479 + movb $0x34, %al
1480 + outb %al, $0x70
1481 + movb $\value, %al
1482 + outb %al, $0x71
1483 + .endm
1484 +
1485 +ALIGN
1486 + .align 4096
1487 +
1488 +wakeup_start:
1489 +# jmp wakeup_start
1490 +
1491 + cli
1492 + cld
1493 +
1494 + # Clear any dangerous flags
1495 +
1496 + pushl $0
1497 + popfl
1498 +
1499 + writepost 0x31
1500 +
1501 + # Set up %cr3
1502 + movl $swsusp_pg_dir - __PAGE_OFFSET, %eax
1503 + movl %eax, %cr3
1504 +
1505 + movl saved_cr4, %eax
1506 + movl %eax, %cr4
1507 +
1508 + movl saved_cr0, %eax
1509 + movl %eax, %cr0
1510 +
1511 + jmp 1f
1512 +1:
1513 + ljmpl $__KERNEL_CS,$wakeup_return
1514 +
1515 +
1516 +.org 0x1000
1517 +
1518 +wakeup_return:
1519 + movw $__KERNEL_DS, %ax
1520 + movw %ax, %ss
1521 + movw %ax, %ds
1522 + movw %ax, %es
1523 + movw %ax, %fs
1524 + movw %ax, %gs
1525 +
1526 + lgdt saved_gdt
1527 + lidt saved_idt
1528 + lldt saved_ldt
1529 + ljmp $(__KERNEL_CS),$1f
1530 +1:
1531 + movl %cr3, %eax
1532 + movl %eax, %cr3
1533 + wbinvd
1534 +
1535 + # Go back to the return point
1536 + jmp ret_point
1537 +
1538 +save_registers:
1539 + sgdt saved_gdt
1540 + sidt saved_idt
1541 + sldt saved_ldt
1542 +
1543 + pushl %edx
1544 + movl %cr4, %edx
1545 + movl %edx, saved_cr4
1546 +
1547 + movl %cr0, %edx
1548 + movl %edx, saved_cr0
1549 +
1550 + popl %edx
1551 +
1552 +
1553 + movl %ebx, saved_context_ebx
1554 + movl %ebp, saved_context_ebp
1555 + movl %esi, saved_context_esi
1556 + movl %edi, saved_context_edi
1557 +
1558 + pushfl
1559 + popl saved_context_eflags
1560 +
1561 + ret
1562 +
1563 +
1564 +restore_registers:
1565 + movl saved_context_ebp, %ebp
1566 + movl saved_context_ebx, %ebx
1567 + movl saved_context_esi, %esi
1568 + movl saved_context_edi, %edi
1569 +
1570 + pushl saved_context_eflags
1571 + popfl
1572 +
1573 + ret
1574 +
1575 +
1576 +ENTRY(do_olpc_suspend_lowlevel)
1577 + call save_processor_state
1578 + call save_registers
1579 +
1580 + # This is the stack context we want to remember
1581 + movl %esp, saved_context_esp
1582 +
1583 + pushl $3
1584 + call olpc_do_sleep
1585 +
1586 + jmp wakeup_start
1587 + .p2align 4,,7
1588 +ret_point:
1589 + movl saved_context_esp, %esp
1590 +
1591 + writepost 0x32
1592 +
1593 + call restore_registers
1594 + call restore_processor_state
1595 + ret
1596 +
1597 +.data
1598 +ALIGN
1599 +
1600 +saved_gdt: .long 0,0
1601 +saved_idt: .long 0,0
1602 +saved_ldt: .long 0
1603 +saved_cr4: .long 0
1604 +saved_cr0: .long 0
1605 +
1606 Index: linux-2.6.24.7/arch/x86/kernel/prom.c
1607 ===================================================================
1608 --- /dev/null
1609 +++ linux-2.6.24.7/arch/x86/kernel/prom.c
1610 @@ -0,0 +1,478 @@
1611 +/*
1612 + * Procedures for creating, accessing and interpreting the device tree.
1613 + *
1614 + * Paul Mackerras August 1996.
1615 + * Copyright (C) 1996-2005 Paul Mackerras.
1616 + *
1617 + * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
1618 + * {engebret|bergner}@us.ibm.com
1619 + *
1620 + * Adapted for sparc64 by David S. Miller davem@davemloft.net
1621 + *
1622 + * Adapter for i386/OLPC by Andres Salomon <dilinger@debian.org>
1623 + *
1624 + * This program is free software; you can redistribute it and/or
1625 + * modify it under the terms of the GNU General Public License
1626 + * as published by the Free Software Foundation; either version
1627 + * 2 of the License, or (at your option) any later version.
1628 + */
1629 +
1630 +#include <linux/kernel.h>
1631 +#include <linux/types.h>
1632 +#include <linux/string.h>
1633 +#include <linux/mm.h>
1634 +#include <linux/bootmem.h>
1635 +#include <linux/module.h>
1636 +#include <asm/prom.h>
1637 +#include <asm/ofw.h>
1638 +
1639 +/*
1640 + * XXX: This is very much a stub; right now we're keeping 2 device trees
1641 + * in memory (one for promfs, and one here). That will not remain
1642 + * for long!
1643 + */
1644 +
1645 +static struct device_node *allnodes;
1646 +
1647 +/* use when traversing tree through the allnext, child, sibling,
1648 + * or parent members of struct device_node.
1649 + */
1650 +static DEFINE_RWLOCK(devtree_lock);
1651 +
1652 +int of_device_is_compatible(const struct device_node *device,
1653 + const char *compat)
1654 +{
1655 + const char* cp;
1656 + int cplen, l;
1657 +
1658 + cp = of_get_property(device, "compatible", &cplen);
1659 + if (cp == NULL)
1660 + return 0;
1661 + while (cplen > 0) {
1662 + if (strncmp(cp, compat, strlen(compat)) == 0)
1663 + return 1;
1664 + l = strlen(cp) + 1;
1665 + cp += l;
1666 + cplen -= l;
1667 + }
1668 +
1669 + return 0;
1670 +}
1671 +EXPORT_SYMBOL(of_device_is_compatible);
1672 +
1673 +struct device_node *of_get_parent(const struct device_node *node)
1674 +{
1675 + struct device_node *np;
1676 +
1677 + if (!node)
1678 + return NULL;
1679 +
1680 + np = node->parent;
1681 +
1682 + return np;
1683 +}
1684 +EXPORT_SYMBOL(of_get_parent);
1685 +
1686 +struct device_node *of_get_next_child(const struct device_node *node,
1687 + struct device_node *prev)
1688 +{
1689 + struct device_node *next;
1690 +
1691 + next = prev ? prev->sibling : node->child;
1692 + for (; next != 0; next = next->sibling) {
1693 + break;
1694 + }
1695 +
1696 + return next;
1697 +}
1698 +EXPORT_SYMBOL(of_get_next_child);
1699 +
1700 +struct device_node *of_find_node_by_path(const char *path)
1701 +{
1702 + struct device_node *np = allnodes;
1703 +
1704 + for (; np != 0; np = np->allnext) {
1705 + if (np->full_name != 0 && strcmp(np->full_name, path) == 0)
1706 + break;
1707 + }
1708 +
1709 + return np;
1710 +}
1711 +EXPORT_SYMBOL(of_find_node_by_path);
1712 +
1713 +struct device_node *of_find_node_by_phandle(phandle handle)
1714 +{
1715 + struct device_node *np;
1716 +
1717 + for (np = allnodes; np != 0; np = np->allnext)
1718 + if (np->node == handle)
1719 + break;
1720 +
1721 + return np;
1722 +}
1723 +EXPORT_SYMBOL(of_find_node_by_phandle);
1724 +
1725 +struct device_node *of_find_node_by_name(struct device_node *from,
1726 + const char *name)
1727 +{
1728 + struct device_node *np;
1729 +
1730 + np = from ? from->allnext : allnodes;
1731 + for (; np != NULL; np = np->allnext)
1732 + if (np->name != NULL && strcmp(np->name, name) == 0)
1733 + break;
1734 +
1735 + return np;
1736 +}
1737 +EXPORT_SYMBOL(of_find_node_by_name);
1738 +
1739 +struct device_node *of_find_node_by_type(struct device_node *from,
1740 + const char *type)
1741 +{
1742 + struct device_node *np;
1743 +
1744 + np = from ? from->allnext : allnodes;
1745 + for (; np != 0; np = np->allnext)
1746 + if (np->type != 0 && strcmp(np->type, type) == 0)
1747 + break;
1748 +
1749 + return np;
1750 +}
1751 +EXPORT_SYMBOL(of_find_node_by_type);
1752 +
1753 +struct device_node *of_find_compatible_node(struct device_node *from,
1754 + const char *type, const char *compatible)
1755 +{
1756 + struct device_node *np;
1757 +
1758 + np = from ? from->allnext : allnodes;
1759 + for (; np != 0; np = np->allnext) {
1760 + if (type != NULL
1761 + && !(np->type != 0 && strcmp(np->type, type) == 0))
1762 + continue;
1763 + if (of_device_is_compatible(np, compatible))
1764 + break;
1765 + }
1766 +
1767 + return np;
1768 +}
1769 +EXPORT_SYMBOL(of_find_compatible_node);
1770 +
1771 +struct property *of_find_property(const struct device_node *np,
1772 + const char *name,
1773 + int *lenp)
1774 +{
1775 + struct property *pp;
1776 +
1777 + for (pp = np->properties; pp != 0; pp = pp->next) {
1778 + if (strcasecmp(pp->name, name) == 0) {
1779 + if (lenp != 0)
1780 + *lenp = pp->length;
1781 + break;
1782 + }
1783 + }
1784 + return pp;
1785 +}
1786 +EXPORT_SYMBOL(of_find_property);
1787 +
1788 +/*
1789 + * Find a property with a given name for a given node
1790 + * and return the value.
1791 + */
1792 +const void *of_get_property(const struct device_node *np, const char *name,
1793 + int *lenp)
1794 +{
1795 + struct property *pp = of_find_property(np,name,lenp);
1796 + return pp ? pp->value : NULL;
1797 +}
1798 +EXPORT_SYMBOL(of_get_property);
1799 +
1800 +int of_getintprop_default(struct device_node *np, const char *name, int def)
1801 +{
1802 + struct property *prop;
1803 + int len;
1804 +
1805 + prop = of_find_property(np, name, &len);
1806 + if (!prop || len != 4)
1807 + return def;
1808 +
1809 + return *(int *) prop->value;
1810 +}
1811 +EXPORT_SYMBOL(of_getintprop_default);
1812 +
1813 +int of_n_addr_cells(struct device_node *np)
1814 +{
1815 + const int* ip;
1816 + do {
1817 + if (np->parent)
1818 + np = np->parent;
1819 + ip = of_get_property(np, "#address-cells", NULL);
1820 + if (ip != NULL)
1821 + return *ip;
1822 + } while (np->parent);
1823 + /* No #address-cells property for the root node, default to 2 */
1824 + return 2;
1825 +}
1826 +EXPORT_SYMBOL(of_n_addr_cells);
1827 +
1828 +int of_n_size_cells(struct device_node *np)
1829 +{
1830 + const int* ip;
1831 + do {
1832 + if (np->parent)
1833 + np = np->parent;
1834 + ip = of_get_property(np, "#size-cells", NULL);
1835 + if (ip != NULL)
1836 + return *ip;
1837 + } while (np->parent);
1838 + /* No #size-cells property for the root node, default to 1 */
1839 + return 1;
1840 +}
1841 +EXPORT_SYMBOL(of_n_size_cells);
1842 +
1843 +int of_set_property(struct device_node *dp, const char *name, void *val, int len)
1844 +{
1845 + return -EIO;
1846 +}
1847 +EXPORT_SYMBOL(of_set_property);
1848 +
1849 +static unsigned int prom_early_allocated;
1850 +
1851 +static void * __init prom_early_alloc(unsigned long size)
1852 +{
1853 + void *ret;
1854 +
1855 + ret = kmalloc(size, GFP_KERNEL);
1856 + if (ret != NULL)
1857 + memset(ret, 0, size);
1858 + else
1859 + printk(KERN_ERR "ACK! couldn't allocate prom memory!\n");
1860 +
1861 + prom_early_allocated += size;
1862 +
1863 + return ret;
1864 +}
1865 +
1866 +static int is_root_node(const struct device_node *dp)
1867 +{
1868 + if (!dp)
1869 + return 0;
1870 +
1871 + return (dp->parent == NULL);
1872 +}
1873 +
1874 +static char * __init build_path_component(struct device_node *dp)
1875 +{
1876 + int pathlen;
1877 + char *n, *i;
1878 +
1879 + if (ofw("package-to-path", 3, 1, dp->node, NULL, 0, &pathlen)) {
1880 + printk(KERN_ERR "PROM: unable to get path name from OFW!\n");
1881 + return "ERROR";
1882 + }
1883 + n = prom_early_alloc(pathlen + 1);
1884 + if (ofw("package-to-path", 3, 1, dp->node, n, pathlen+1, &pathlen))
1885 + printk(KERN_ERR "PROM: unable to get path name from OFW\n");
1886 +
1887 + if ((i = strrchr(n, '/')))
1888 + n = ++i; /* we only want the file name */
1889 + return n;
1890 +}
1891 +
1892 +static char * __init build_full_name(struct device_node *dp)
1893 +{
1894 + int len, ourlen, plen;
1895 + char *n;
1896 +
1897 + plen = strlen(dp->parent->full_name);
1898 + ourlen = strlen(dp->path_component_name);
1899 + len = ourlen + plen + 2;
1900 +
1901 + n = prom_early_alloc(len);
1902 + strcpy(n, dp->parent->full_name);
1903 + if (!is_root_node(dp->parent)) {
1904 + strcpy(n + plen, "/");
1905 + plen++;
1906 + }
1907 + strcpy(n + plen, dp->path_component_name);
1908 +
1909 + return n;
1910 +}
1911 +
1912 +static struct property * __init build_one_prop(phandle node, char *prev, char *special_name, void *special_val, int special_len)
1913 +{
1914 + static struct property *tmp = NULL;
1915 + struct property *p;
1916 +
1917 + if (tmp) {
1918 + p = tmp;
1919 + memset(p, 0, sizeof(*p) + 32);
1920 + tmp = NULL;
1921 + } else {
1922 + p = prom_early_alloc(sizeof(struct property) + 32);
1923 + }
1924 +
1925 + p->name = (char *) (p + 1);
1926 + if (special_name) {
1927 + strcpy(p->name, special_name);
1928 + p->length = special_len;
1929 + p->value = prom_early_alloc(special_len);
1930 + memcpy(p->value, special_val, special_len);
1931 + } else {
1932 + int fl;
1933 + if (prev == NULL) {
1934 + if (ofw("nextprop", 3, 1, node, "", p->name, &fl)) {
1935 + printk(KERN_ERR "PROM: %s: nextprop failed!\n", __func__);
1936 + return NULL;
1937 + }
1938 + } else {
1939 + if (ofw("nextprop", 3, 1, node, prev, p->name, &fl)) {
1940 + printk(KERN_ERR "PROM: %s: nextprop failed!\n", __func__);
1941 + return NULL;
1942 + }
1943 + }
1944 + if (strlen(p->name) == 0 || fl != 1) {
1945 + tmp = p;
1946 + return NULL;
1947 + }
1948 + if (ofw("getproplen", 2, 1, node, p->name, &p->length)) {
1949 + printk(KERN_ERR "PROM: %s: getproplen failed!\n", __func__);
1950 + return NULL;
1951 + }
1952 + if (p->length <= 0) {
1953 + p->length = 0;
1954 + } else {
1955 + p->value = prom_early_alloc(p->length + 1);
1956 + if (ofw("getprop", 4, 1, node, p->name, p->value, p->length, &p->length)) {
1957 + printk(KERN_ERR "PROM: %s: getprop failed!\n", __func__);
1958 + return NULL;
1959 + }
1960 + ((unsigned char *)p->value)[p->length] = '\0';
1961 + }
1962 + }
1963 + return p;
1964 +}
1965 +
1966 +static struct property * __init build_prop_list(phandle node)
1967 +{
1968 + struct property *head, *tail;
1969 +
1970 + head = tail = build_one_prop(node, NULL,
1971 + ".node", &node, sizeof(node));
1972 +
1973 + tail->next = build_one_prop(node, NULL, NULL, NULL, 0);
1974 + tail = tail->next;
1975 + while(tail) {
1976 + tail->next = build_one_prop(node, tail->name,
1977 + NULL, NULL, 0);
1978 + tail = tail->next;
1979 + }
1980 +
1981 + return head;
1982 +}
1983 +
1984 +static char * __init get_one_property(phandle node, const char *name)
1985 +{
1986 + char *buf = "<NULL>";
1987 + int len;
1988 +
1989 + if (ofw("getproplen", 2, 1, node, name, &len)) {
1990 + printk(KERN_ERR "PROM: %s: getproplen failed!\n", __func__);
1991 + return NULL;
1992 + }
1993 + if (len > 0) {
1994 + buf = prom_early_alloc(len);
1995 + if (ofw("getprop", 4, 1, node, name, buf, len, &len)) {
1996 + printk(KERN_ERR "PROM: %s: getprop failed!\n", __func__);
1997 + return NULL;
1998 + }
1999 + }
2000 +
2001 + return buf;
2002 +}
2003 +
2004 +static struct device_node * __init create_node(phandle node, struct device_node *parent)
2005 +{
2006 + struct device_node *dp;
2007 +
2008 + if (!node)
2009 + return NULL;
2010 +
2011 + dp = prom_early_alloc(sizeof(*dp));
2012 + dp->parent = parent;
2013 +
2014 + kref_init(&dp->kref);
2015 +
2016 + dp->name = get_one_property(node, "name");
2017 + dp->type = get_one_property(node, "device_type");
2018 + dp->node = node;
2019 +
2020 + dp->properties = build_prop_list(node);
2021 +
2022 + return dp;
2023 +}
2024 +
2025 +static struct device_node * __init build_tree(struct device_node *parent, phandle node, struct device_node ***nextp)
2026 +{
2027 + struct device_node *ret = NULL, *prev_sibling = NULL;
2028 + struct device_node *dp;
2029 + u32 child;
2030 +
2031 + while (1) {
2032 + dp = create_node(node, parent);
2033 + if (!dp)
2034 + break;
2035 +
2036 + if (prev_sibling)
2037 + prev_sibling->sibling = dp;
2038 +
2039 + if (!ret)
2040 + ret = dp;
2041 + prev_sibling = dp;
2042 +
2043 + *(*nextp) = dp;
2044 + *nextp = &dp->allnext;
2045 +
2046 + dp->path_component_name = build_path_component(dp);
2047 + dp->full_name = build_full_name(dp);
2048 +
2049 + if (ofw("child", 1, 1, node, &child)) {
2050 + printk(KERN_ERR "PROM: %s: fetching child failed!\n", __func__);
2051 + return NULL;
2052 + }
2053 + dp->child = build_tree(dp, child, nextp);
2054 +
2055 + if (ofw("peer", 1, 1, node, &node)) {
2056 + printk(KERN_ERR "PROM: %s: fetching peer failed!\n", __func__);
2057 + return NULL;
2058 + }
2059 + }
2060 +
2061 + return ret;
2062 +}
2063 +
2064 +static phandle root_node;
2065 +
2066 +void __init prom_build_devicetree(void)
2067 +{
2068 + struct device_node **nextp;
2069 + u32 child;
2070 +
2071 + if (ofw("peer", 1, 1, 0, &root_node)) {
2072 + printk(KERN_ERR "PROM: unable to get root node from OFW!\n");
2073 + return;
2074 + }
2075 +
2076 + allnodes = create_node(root_node, NULL);
2077 + allnodes->path_component_name = "";
2078 + allnodes->full_name = "/";
2079 +
2080 + nextp = &allnodes->allnext;
2081 + if (ofw("child", 1, 1, allnodes->node, &child)) {
2082 + printk(KERN_ERR "PROM: unable to get child node from OFW!\n");
2083 + return;
2084 + }
2085 + allnodes->child = build_tree(allnodes, child, &nextp);
2086 + printk("PROM: Built device tree with %u bytes of memory.\n",
2087 + prom_early_allocated);
2088 +}
2089 Index: linux-2.6.24.7/arch/x86/pci/olpc.c
2090 ===================================================================
2091 --- /dev/null
2092 +++ linux-2.6.24.7/arch/x86/pci/olpc.c
2093 @@ -0,0 +1,298 @@
2094 +/*
2095 + * olpcpci.c - Low-level PCI config space access for OLPC systems
2096 + * without the VSA PCI virtualization software.
2097 + *
2098 + * The AMD Geode chipset (GX2 processor, cs5536 I/O companion device)
2099 + * has some I/O functions (display, southbridge, sound, USB HCIs, etc)
2100 + * that more or less behave like PCI devices, but the hardware doesn't
2101 + * directly implement the PCI configuration space headers. AMD provides
2102 + * "VSA" (Virtual System Architecture) software that emulates PCI config
2103 + * space for these devices, by trapping I/O accesses to PCI config register
2104 + * (CF8/CFC) and running some code in System Management Mode interrupt state.
2105 + * On the OLPC platform, we don't want to use that VSA code because
2106 + * (a) it slows down suspend/resume, and (b) recompiling it requires special
2107 + * compilers that are hard to get. So instead of letting the complex VSA
2108 + * code simulate the PCI config registers for the on-chip devices, we
2109 + * just simulate them the easy way, by inserting the code into the
2110 + * pci_write_config and pci_read_config path. Most of the config registers
2111 + * are read-only anyway, so the bulk of the simulation is just table lookup.
2112 + */
2113 +
2114 +#include <linux/pci.h>
2115 +#include <linux/init.h>
2116 +#include <asm/olpc.h>
2117 +#include <asm/geode.h>
2118 +#include "pci.h"
2119 +
2120 +static int is_lx;
2121 +
2122 +/*
2123 + * In the tables below, the first two line (8 longwords) are the
2124 + * size masks that are used when the higher level PCI code determines
2125 + * the size of the region by writing ~0 to a base address register
2126 + * and reading back the result.
2127 + *
2128 + * The following lines are the values that are read during normal
2129 + * PCI config access cycles, i.e. not after just having written
2130 + * ~0 to a base address register.
2131 + */
2132 +
2133 +static const u32 lxnb_hdr[] = { /* dev 1 function 0 - devfn = 8 */
2134 + 0x0 , 0x0 , 0x0 , 0x0 ,
2135 + 0x0 , 0x0 , 0x0 , 0x0 ,
2136 +
2137 + 0x281022 , 0x2200005 , 0x6000021 , 0x80f808 , /* AMD Vendor ID */
2138 + 0x0 , 0x0 , 0x0 , 0x0 , /* No virtual registers, hence no BAR for them */
2139 + 0x0 , 0x0 , 0x0 , 0x28100b ,
2140 + 0x0 , 0x0 , 0x0 , 0x0 ,
2141 + 0x0 , 0x0 , 0x0 , 0x0 ,
2142 + 0x0 , 0x0 , 0x0 , 0x0 ,
2143 + 0x0 , 0x0 , 0x0 , 0x0 ,
2144 +};
2145 +
2146 +static const u32 gxnb_hdr[] = { /* dev 1 function 0 - devfn = 8 */
2147 + 0xfffffffd , 0x0 , 0x0 , 0x0 ,
2148 + 0x0 , 0x0 , 0x0 , 0x0 ,
2149 +
2150 + 0x28100b , 0x2200005 , 0x6000021 , 0x80f808 , /* NSC Vendor ID */
2151 + 0xac1d , 0x0 , 0x0 , 0x0 , /* I/O BAR - base of virtual registers */
2152 + 0x0 , 0x0 , 0x0 , 0x28100b ,
2153 + 0x0 , 0x0 , 0x0 , 0x0 ,
2154 + 0x0 , 0x0 , 0x0 , 0x0 ,
2155 + 0x0 , 0x0 , 0x0 , 0x0 ,
2156 + 0x0 , 0x0 , 0x0 , 0x0 ,
2157 +};
2158 +
2159 +static const u32 lxfb_hdr[] = { /* dev 1 function 1 - devfn = 9 */
2160 + 0xff800008 , 0xffffc000 , 0xffffc000 , 0xffffc000 ,
2161 + 0x0 , 0x0 , 0x0 , 0x0 ,
2162 +
2163 + 0x20811022 , 0x2200003 , 0x3000000 , 0x0 , /* AMD Vendor ID */
2164 + 0xfd000000 , 0xfe000000 , 0xfe004000 , 0xfe008000 , /* FB, GP, VG, DF */
2165 + 0xfe00c000 , 0x0 , 0x0 , 0x30100b , /* VIP */
2166 + 0x0 , 0x0 , 0x0 , 0x10e , /* INTA, IRQ14 for graphics accel */
2167 + 0x0 , 0x0 , 0x0 , 0x0 ,
2168 + 0x3d0 , 0x3c0 , 0xa0000 , 0x0 , /* VG IO, VG IO, EGA FB, MONO FB */
2169 + 0x0 , 0x0 , 0x0 , 0x0 ,
2170 +};
2171 +
2172 +static const u32 gxfb_hdr[] = { /* dev 1 function 1 - devfn = 9 */
2173 + 0xff800008 , 0xffffc000 , 0xffffc000 , 0xffffc000 ,
2174 + 0x0 , 0x0 , 0x0 , 0x0 ,
2175 +
2176 + 0x30100b , 0x2200003 , 0x3000000 , 0x0 , /* NSC Vendor ID */
2177 + 0xfd000000 , 0xfe000000 , 0xfe004000 , 0xfe008000 , /* FB, GP, VG, DF */
2178 + 0x0 , 0x0 , 0x0 , 0x30100b ,
2179 + 0x0 , 0x0 , 0x0 , 0x0 ,
2180 + 0x0 , 0x0 , 0x0 , 0x0 ,
2181 + 0x3d0 , 0x3c0 , 0xa0000 , 0x0 , /* VG IO, VG IO, EGA FB, MONO FB */
2182 + 0x0 , 0x0 , 0x0 , 0x0 ,
2183 +};
2184 +
2185 +static const u32 aes_hdr[] = { /* dev 1 function 2 - devfn = 0xa */
2186 + 0xffffc000 , 0x0 , 0x0 , 0x0 ,
2187 + 0x0 , 0x0 , 0x0 , 0x0 ,
2188 +
2189 + 0x20821022 , 0x2a00006 , 0x10100000 , 0x8 , /* NSC Vendor ID */
2190 + 0xfe010000 , 0x0 , 0x0 , 0x0 , /* AES registers */
2191 + 0x0 , 0x0 , 0x0 , 0x20821022 ,
2192 + 0x0 , 0x0 , 0x0 , 0x0 ,
2193 + 0x0 , 0x0 , 0x0 , 0x0 ,
2194 + 0x0 , 0x0 , 0x0 , 0x0 ,
2195 + 0x0 , 0x0 , 0x0 , 0x0 ,
2196 +};
2197 +
2198 +
2199 +static const u32 isa_hdr[] = { /* dev f function 0 - devfn = 78 */
2200 + 0xfffffff9 , 0xffffff01 , 0xffffffc1 , 0xffffffe1 ,
2201 + 0xffffff81 , 0xffffffc1 , 0x0 , 0x0 ,
2202 +
2203 + 0x20901022 , 0x2a00049 , 0x6010003 , 0x802000 ,
2204 + 0x18b1 , 0x1001 , 0x1801 , 0x1881 , /* SMB-8 GPIO-256 MFGPT-64 IRQ-32 */
2205 + 0x1401 , 0x1841 , 0x0 , 0x20901022 , /* PMS-128 ACPI-64 */
2206 + 0x0 , 0x0 , 0x0 , 0x0 ,
2207 + 0x0 , 0x0 , 0x0 , 0x0 ,
2208 + 0x0 , 0x0 , 0x0 , 0xaa5b , /* interrupt steering */
2209 + 0x0 , 0x0 , 0x0 , 0x0 ,
2210 +};
2211 +
2212 +static const u32 ac97_hdr[] = { /* dev f function 3 - devfn = 7b */
2213 + 0xffffff81 , 0x0 , 0x0 , 0x0 ,
2214 + 0x0 , 0x0 , 0x0 , 0x0 ,
2215 +
2216 + 0x20931022 , 0x2a00041 , 0x4010001 , 0x0 ,
2217 + 0x1481 , 0x0 , 0x0 , 0x0 , /* I/O BAR-128 */
2218 + 0x0 , 0x0 , 0x0 , 0x20931022 ,
2219 + 0x0 , 0x0 , 0x0 , 0x205 , /* IntB , IRQ5 */
2220 + 0x0 , 0x0 , 0x0 , 0x0 ,
2221 + 0x0 , 0x0 , 0x0 , 0x0 ,
2222 + 0x0 , 0x0 , 0x0 , 0x0 ,
2223 +};
2224 +
2225 +static const u32 ohci_hdr[] = { /* dev f function 4 - devfn = 7c */
2226 + 0xfffff000 , 0x0 , 0x0 , 0x0 ,
2227 + 0x0 , 0x0 , 0x0 , 0x0 ,
2228 +
2229 + 0x20941022 , 0x2300006 , 0xc031002 , 0x0 ,
2230 + 0xfe01a000 , 0x0 , 0x0 , 0x0 , /* MEMBAR-1000 */
2231 + 0x0 , 0x0 , 0x0 , 0x20941022 ,
2232 + 0x0 , 0x40 , 0x0 , 0x40a , /* CapPtr INT-D, IRQ A */
2233 + 0xc8020001 , 0x0 , 0x0 , 0x0 , /* Capabilities - 40 is R/O, 44 is mask 8103 (power control) */
2234 + 0x0 , 0x0 , 0x0 , 0x0 ,
2235 + 0x0 , 0x0 , 0x0 , 0x0 ,
2236 +};
2237 +
2238 +static const u32 ehci_hdr[] = { /* dev f function 4 - devfn = 7d */
2239 + 0xfffff000 , 0x0 , 0x0 , 0x0 ,
2240 + 0x0 , 0x0 , 0x0 , 0x0 ,
2241 +
2242 + 0x20951022 , 0x2300006 , 0xc032002 , 0x0 ,
2243 + 0xfe01b000 , 0x0 , 0x0 , 0x0 , /* MEMBAR-1000 */
2244 + 0x0 , 0x0 , 0x0 , 0x20951022 ,
2245 + 0x0 , 0x40 , 0x0 , 0x40a , /* CapPtr INT-D, IRQ A */
2246 + 0xc8020001 , 0x0 , 0x0 , 0x0 , /* Capabilities - 40 is R/O, 44 is mask 8103 (power control) */
2247 +#if 0
2248 + 0x1 , 0x40080000 , 0x0 , 0x0 , /* EECP - see section 2.1.7 of EHCI spec */
2249 +#endif
2250 + 0x01000001 , 0x00000000 , 0x0 , 0x0 , /* EECP - see section 2.1.7 of EHCI spec */
2251 + 0x2020 , 0x0 , 0x0 , 0x0 , /* (EHCI page 8) 60 SBRN (R/O), 61 FLADJ (R/W), PORTWAKECAP */
2252 +};
2253 +
2254 +static u32 ff_loc = ~0;
2255 +static u32 zero_loc = 0;
2256 +
2257 +static int bar_probing = 0; /* Set after a write of ~0 to a BAR */
2258 +
2259 +#define NB_SLOT 0x1 /* Northbridge - GX chip - Device 1 */
2260 +#define SB_SLOT 0xf /* Southbridge - CS5536 chip - Device F */
2261 +#define SIMULATED(bus, devfn) (((bus) == 0) && ((PCI_SLOT(devfn) == NB_SLOT) || (PCI_SLOT(devfn) == SB_SLOT)))
2262 +
2263 +static u32 *hdr_addr(const u32 *hdr, int reg)
2264 +{
2265 + u32 addr;
2266 +
2267 + /*
2268 + * This is a little bit tricky. The header maps consist of
2269 + * 0x20 bytes of size masks, followed by 0x70 bytes of header data.
2270 + * In the normal case, when not probing a BAR's size, we want
2271 + * to access the header data, so we add 0x20 to the reg offset,
2272 + * thus skipping the size mask area.
2273 + * In the BAR probing case, we want to access the size mask for
2274 + * the BAR, so we subtract 0x10 (the config header offset for
2275 + * BAR0), and don't skip the size mask area.
2276 + */
2277 +
2278 + addr = (u32)hdr + reg + (bar_probing ? -0x10 : 0x20);
2279 +
2280 + bar_probing = 0;
2281 + return (u32 *)addr;
2282 +}
2283 +
2284 +static int pci_olpc_read(unsigned int seg, unsigned int bus,
2285 + unsigned int devfn, int reg, int len, u32 *value)
2286 +{
2287 + u32 *addr;
2288 +
2289 + /* Use the hardware mechanism for non-simulated devices */
2290 + if (!SIMULATED(bus, devfn))
2291 + return pci_conf1_read(seg, bus, devfn, reg, len, value);
2292 +
2293 + /*
2294 + * No device has config registers past 0x70, so we save table space
2295 + * by not storing entries for the nonexistent registers
2296 + */
2297 + if (reg >= 0x70)
2298 + addr = &zero_loc;
2299 + else {
2300 + switch (devfn) {
2301 + case 0x8:
2302 + addr = hdr_addr(is_lx ? lxnb_hdr : gxnb_hdr, reg);
2303 + break;
2304 + case 0x9:
2305 + addr = hdr_addr(is_lx ? lxfb_hdr : gxfb_hdr, reg);
2306 + break;
2307 + case 0xa:
2308 + addr = is_lx ? hdr_addr(aes_hdr, reg) : &ff_loc;
2309 + break;
2310 + case 0x78:
2311 + addr = hdr_addr(isa_hdr, reg);
2312 + break;
2313 + case 0x7b:
2314 + addr = hdr_addr(ac97_hdr, reg);
2315 + break;
2316 + case 0x7c:
2317 + addr = hdr_addr(ohci_hdr, reg);
2318 + break;
2319 + case 0x7d:
2320 + addr = hdr_addr(ehci_hdr, reg);
2321 + break;
2322 + default:
2323 + addr = &ff_loc;
2324 + break;
2325 + }
2326 + }
2327 + switch (len) {
2328 + case 1:
2329 + *value = *(u8 *) addr;
2330 + break;
2331 + case 2:
2332 + *value = *(u16 *) addr;
2333 + break;
2334 + case 4:
2335 + *value = *addr;
2336 + break;
2337 + default:
2338 + BUG();
2339 + }
2340 +
2341 + return 0;
2342 +}
2343 +
2344 +static int pci_olpc_write(unsigned int seg, unsigned int bus,
2345 + unsigned int devfn, int reg, int len, u32 value)
2346 +{
2347 + /* Use the hardware mechanism for non-simulated devices */
2348 + if (!SIMULATED(bus, devfn))
2349 + return pci_conf1_write(seg, bus, devfn, reg, len, value);
2350 +
2351 + /* XXX we may want to extend this to simulate EHCI power management */
2352 +
2353 + /*
2354 + * Mostly we just discard writes, but if the write is a size probe
2355 + * (i.e. writing ~0 to a BAR), we remember it and arrange to return
2356 + * the appropriate size mask on the next read. This is cheating
2357 + * to some extent, because it depends on the fact that the next
2358 + * access after such a write will always be a read to the same BAR.
2359 + */
2360 +
2361 + if ((reg >= 0x10) && (reg < 0x2c)) {
2362 + /* Write is to a BAR */
2363 + if (value == ~0)
2364 + bar_probing = 1;
2365 + } else {
2366 + /*
2367 + * No warning on writes to ROM BAR, CMD, LATENCY_TIMER,
2368 + * CACHE_LINE_SIZE, or PM registers.
2369 + */
2370 + if ((reg != 0x30) && (reg != 0x04) && (reg != 0x0d) &&
2371 + (reg != 0x0c) && (reg != 0x44))
2372 + printk(KERN_WARNING "OLPC PCI: Config write to devfn %x reg %x value %x\n", devfn, reg, value);
2373 + }
2374 +
2375 + return 0;
2376 +}
2377 +
2378 +static struct pci_raw_ops pci_olpc_conf = {
2379 + .read = pci_olpc_read,
2380 + .write = pci_olpc_write,
2381 +};
2382 +
2383 +void __init pci_olpc_init(void)
2384 +{
2385 + if (!machine_is_olpc() || olpc_has_vsa())
2386 + return;
2387 +
2388 + printk(KERN_INFO "PCI: Using configuration type OLPC\n");
2389 + raw_pci_ops = &pci_olpc_conf;
2390 + is_lx = is_geode_lx();
2391 +}
2392 Index: linux-2.6.24.7/Documentation/kernel-parameters.txt
2393 ===================================================================
2394 --- linux-2.6.24.7.orig/Documentation/kernel-parameters.txt
2395 +++ linux-2.6.24.7/Documentation/kernel-parameters.txt
2396 @@ -1244,6 +1244,13 @@ and is between 256 and 4096 characters.
2397
2398 nr_uarts= [SERIAL] maximum number of UARTs to be registered.
2399
2400 + olpc_ec_timeout= [OLPC] ms delay when issuing EC commands
2401 + Rather than timing out after 20 ms if an EC
2402 + command is not properly ACKed, override the length
2403 + of the timeout. We have interrupts disabled while
2404 + waiting for the ACK, so if this is set too high
2405 + interrupts *may* be lost!
2406 +
2407 opl3= [HW,OSS]
2408 Format: <io>
2409
2410 Index: linux-2.6.24.7/drivers/base/dd.c
2411 ===================================================================
2412 --- linux-2.6.24.7.orig/drivers/base/dd.c
2413 +++ linux-2.6.24.7/drivers/base/dd.c
2414 @@ -293,7 +293,6 @@ static void __device_release_driver(stru
2415 if (drv) {
2416 driver_sysfs_remove(dev);
2417 sysfs_remove_link(&dev->kobj, "driver");
2418 - klist_remove(&dev->knode_driver);
2419
2420 if (dev->bus)
2421 blocking_notifier_call_chain(&dev->bus->bus_notifier,
2422 @@ -306,6 +305,7 @@ static void __device_release_driver(stru
2423 drv->remove(dev);
2424 devres_release_all(dev);
2425 dev->driver = NULL;
2426 + klist_remove(&dev->knode_driver);
2427 put_driver(drv);
2428 }
2429 }
2430 Index: linux-2.6.24.7/drivers/char/vt_ioctl.c
2431 ===================================================================
2432 --- linux-2.6.24.7.orig/drivers/char/vt_ioctl.c
2433 +++ linux-2.6.24.7/drivers/char/vt_ioctl.c
2434 @@ -38,6 +38,9 @@
2435 char vt_dont_switch;
2436 extern struct tty_driver *console_driver;
2437
2438 +/* Add a notifier chain to inform drivers of a VT_TEXT/VT_GRAPHICS switch */
2439 +RAW_NOTIFIER_HEAD(console_notifier_list);
2440 +
2441 #define VT_IS_IN_USE(i) (console_driver->ttys[i] && console_driver->ttys[i]->count)
2442 #define VT_BUSY(i) (VT_IS_IN_USE(i) || i == fg_console || vc_cons[i].d == sel_cons)
2443
2444 @@ -492,6 +495,14 @@ int vt_ioctl(struct tty_struct *tty, str
2445 vc->vc_mode = (unsigned char) arg;
2446 if (console != fg_console)
2447 return 0;
2448 +
2449 + /* Notify listeners if the current fg_console has switched */
2450 +
2451 + raw_notifier_call_chain(&console_notifier_list,
2452 + (arg == KD_TEXT) ?
2453 + CONSOLE_EVENT_SWITCH_TEXT :
2454 + CONSOLE_EVENT_SWITCH_GRAPHICS, 0);
2455 +
2456 /*
2457 * explicitly blank/unblank the screen if switching modes
2458 */
2459 Index: linux-2.6.24.7/drivers/i2c/busses/scx200_acb.c
2460 ===================================================================
2461 --- linux-2.6.24.7.orig/drivers/i2c/busses/scx200_acb.c
2462 +++ linux-2.6.24.7/drivers/i2c/busses/scx200_acb.c
2463 @@ -46,6 +46,10 @@ static int base[MAX_DEVICES] = { 0x820,
2464 module_param_array(base, int, NULL, 0);
2465 MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");
2466
2467 +static unsigned int smbclk = 0x70;
2468 +module_param(smbclk, uint, 0);
2469 +MODULE_PARM_DESC(smbclk, "Specify the SMB_CLK value");
2470 +
2471 #define POLL_TIMEOUT (HZ/5)
2472
2473 enum scx200_acb_state {
2474 @@ -108,6 +112,7 @@ struct scx200_acb_iface {
2475 #define ACBADDR (iface->base + 4)
2476 #define ACBCTL2 (iface->base + 5)
2477 #define ACBCTL2_ENABLE 0x01
2478 +#define ACBCTL3 (iface->base + 6)
2479
2480 /************************************************************************/
2481
2482 @@ -392,11 +397,13 @@ static __init int scx200_acb_probe(struc
2483 {
2484 u8 val;
2485
2486 - /* Disable the ACCESS.bus device and Configure the SCL
2487 - frequency: 16 clock cycles */
2488 - outb(0x70, ACBCTL2);
2489 + /* Disable the ACCESS.bus device and Configure the SCL */
2490 +
2491 + outb((smbclk & 0x7F) << 1, ACBCTL2);
2492 +
2493 + outb((smbclk >> 7) & 0xFF, ACBCTL3);
2494
2495 - if (inb(ACBCTL2) != 0x70) {
2496 + if (inb(ACBCTL2) != ((smbclk & 0x7F) << 1)) {
2497 pr_debug(NAME ": ACBCTL2 readback failed\n");
2498 return -ENXIO;
2499 }
2500 Index: linux-2.6.24.7/drivers/input/keyboard/atkbd.c
2501 ===================================================================
2502 --- linux-2.6.24.7.orig/drivers/input/keyboard/atkbd.c
2503 +++ linux-2.6.24.7/drivers/input/keyboard/atkbd.c
2504 @@ -63,12 +63,25 @@ static int atkbd_extra;
2505 module_param_named(extra, atkbd_extra, bool, 0);
2506 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
2507
2508 +#define ATKBD_KEY_UNKNOWN 0
2509 +#define ATKBD_KEY_NULL 0xFF0000FF
2510 +
2511 +#define ATKBD_SCR_1 0xFF0000FE
2512 +#define ATKBD_SCR_2 0xFF0000FD
2513 +#define ATKBD_SCR_4 0xFF0000FC
2514 +#define ATKBD_SCR_8 0xFF0000FB
2515 +#define ATKBD_SCR_CLICK 0xFF0000FA
2516 +#define ATKBD_SCR_LEFT 0xFF0000F9
2517 +#define ATKBD_SCR_RIGHT 0xFF0000F8
2518 +
2519 +#define ATKBD_SPECIAL 0xFF0000F8
2520 +
2521 /*
2522 * Scancode to keycode tables. These are just the default setting, and
2523 * are loadable via an userland utility.
2524 */
2525
2526 -static unsigned char atkbd_set2_keycode[512] = {
2527 +static unsigned int atkbd_set2_keycode[512] = {
2528
2529 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
2530
2531 @@ -87,11 +100,17 @@ static unsigned char atkbd_set2_keycode[
2532 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
2533
2534 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2535 - 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
2536 +
2537 + 217,100,ATKBD_KEY_NULL, 0, 97,165, 0, 0,
2538 + 156, 0, 0, 0, 0, 0, 0,125,
2539 +
2540 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
2541 159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142,
2542 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
2543 - 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
2544 +
2545 + 226, 0, 0, 0, 0, 0, 0, 0,
2546 + 0,ATKBD_KEY_NULL, 96, 0, 0, 0,143, 0,
2547 +
2548 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
2549 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
2550
2551 @@ -150,19 +169,6 @@ static unsigned char atkbd_unxlate_table
2552 #define ATKBD_RET_HANGEUL 0xf2
2553 #define ATKBD_RET_ERR 0xff
2554
2555 -#define ATKBD_KEY_UNKNOWN 0
2556 -#define ATKBD_KEY_NULL 255
2557 -
2558 -#define ATKBD_SCR_1 254
2559 -#define ATKBD_SCR_2 253
2560 -#define ATKBD_SCR_4 252
2561 -#define ATKBD_SCR_8 251
2562 -#define ATKBD_SCR_CLICK 250
2563 -#define ATKBD_SCR_LEFT 249
2564 -#define ATKBD_SCR_RIGHT 248
2565 -
2566 -#define ATKBD_SPECIAL 248
2567 -
2568 #define ATKBD_LED_EVENT_BIT 0
2569 #define ATKBD_REP_EVENT_BIT 1
2570
2571 @@ -174,7 +180,7 @@ static unsigned char atkbd_unxlate_table
2572 #define ATKBD_XL_HANJA 0x20
2573
2574 static struct {
2575 - unsigned char keycode;
2576 + unsigned int keycode;
2577 unsigned char set2;
2578 } atkbd_scroll_keys[] = {
2579 { ATKBD_SCR_1, 0xc5 },
2580 @@ -200,7 +206,7 @@ struct atkbd {
2581 char phys[32];
2582
2583 unsigned short id;
2584 - unsigned char keycode[512];
2585 + unsigned int keycode[512];
2586 unsigned char set;
2587 unsigned char translated;
2588 unsigned char extra;
2589 @@ -351,7 +357,7 @@ static irqreturn_t atkbd_interrupt(struc
2590 unsigned int code = data;
2591 int scroll = 0, hscroll = 0, click = -1, add_release_event = 0;
2592 int value;
2593 - unsigned char keycode;
2594 + unsigned int keycode;
2595
2596 #ifdef ATKBD_DEBUG
2597 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
2598 @@ -856,9 +862,11 @@ static void atkbd_set_keycode_table(stru
2599 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
2600 }
2601 } else if (atkbd->set == 3) {
2602 - memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
2603 + for (i = 0; i < ARRAY_SIZE(atkbd_set3_keycode); i++)
2604 + atkbd->keycode[i] = atkbd_set3_keycode[i];
2605 } else {
2606 - memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
2607 + for (i = 0; i < ARRAY_SIZE(atkbd_set2_keycode); i++)
2608 + atkbd->keycode[i] = atkbd_set2_keycode[i];
2609
2610 if (atkbd->scroll)
2611 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
2612 @@ -930,8 +938,8 @@ static void atkbd_set_device_attrs(struc
2613 }
2614
2615 input_dev->keycode = atkbd->keycode;
2616 - input_dev->keycodesize = sizeof(unsigned char);
2617 - input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
2618 + input_dev->keycodesize = sizeof(unsigned int);
2619 + input_dev->keycodemax = ARRAY_SIZE(atkbd->keycode);
2620
2621 for (i = 0; i < 512; i++)
2622 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
2623 @@ -1022,6 +1030,10 @@ static int atkbd_connect(struct serio *s
2624 return err;
2625 }
2626
2627 +#ifdef CONFIG_OLPC
2628 +#include <asm/olpc.h>
2629 +#endif
2630 +
2631 /*
2632 * atkbd_reconnect() tries to restore keyboard into a sane state and is
2633 * most likely called on resume.
2634 @@ -1032,6 +1044,12 @@ static int atkbd_reconnect(struct serio
2635 struct atkbd *atkbd = serio_get_drvdata(serio);
2636 struct serio_driver *drv = serio->drv;
2637
2638 +#ifdef CONFIG_OLPC
2639 + if (olpc_board_at_least(olpc_board_pre(0xb3)))
2640 + if (serio->dev.power.power_state.event != PM_EVENT_ON)
2641 + return 0;
2642 +#endif
2643 +
2644 if (!atkbd || !drv) {
2645 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
2646 return -1;
2647 Index: linux-2.6.24.7/drivers/input/mouse/Kconfig
2648 ===================================================================
2649 --- linux-2.6.24.7.orig/drivers/input/mouse/Kconfig
2650 +++ linux-2.6.24.7/drivers/input/mouse/Kconfig
2651 @@ -96,6 +96,16 @@ config MOUSE_PS2_TOUCHKIT
2652
2653 If unsure, say N.
2654
2655 +config MOUSE_PS2_OLPC
2656 + bool "OLPC PS/2 mouse protocol extension" if EMBEDDED
2657 + default n
2658 + depends on MOUSE_PS2 && OLPC
2659 + ---help---
2660 + Say Y here if you have an OLPC PS/2 touchpad connected to
2661 + your system.
2662 +
2663 + If unsure, say N.
2664 +
2665 config MOUSE_SERIAL
2666 tristate "Serial mouse"
2667 select SERIO
2668 Index: linux-2.6.24.7/drivers/input/mouse/Makefile
2669 ===================================================================
2670 --- linux-2.6.24.7.orig/drivers/input/mouse/Makefile
2671 +++ linux-2.6.24.7/drivers/input/mouse/Makefile
2672 @@ -24,3 +24,4 @@ psmouse-$(CONFIG_MOUSE_PS2_LOGIPS2PP) +=
2673 psmouse-$(CONFIG_MOUSE_PS2_LIFEBOOK) += lifebook.o
2674 psmouse-$(CONFIG_MOUSE_PS2_TRACKPOINT) += trackpoint.o
2675 psmouse-$(CONFIG_MOUSE_PS2_TOUCHKIT) += touchkit_ps2.o
2676 +psmouse-$(CONFIG_MOUSE_PS2_OLPC) += olpc.o
2677 Index: linux-2.6.24.7/drivers/input/mouse/olpc.c
2678 ===================================================================
2679 --- /dev/null
2680 +++ linux-2.6.24.7/drivers/input/mouse/olpc.c
2681 @@ -0,0 +1,837 @@
2682 +/*
2683 + * OLPC touchpad PS/2 mouse driver
2684 + *
2685 + * Copyright (c) 2006-2008 One Laptop Per Child
2686 + * Authors:
2687 + * Zephaniah E. Hull
2688 + * Andres Salomon <dilinger@laptop.org>
2689 + *
2690 + * This driver is partly based on the ALPS driver, which is:
2691 + *
2692 + * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au>
2693 + * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com>
2694 + * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru>
2695 + * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz>
2696 + *
2697 + * This program is free software; you can redistribute it and/or modify
2698 + * it under the terms of the GNU General Public License version 2 as
2699 + * published by the Free Software Foundation.
2700 + */
2701 +
2702 +/*
2703 + * The touchpad on the OLPC is fairly wide, with the entire area usable
2704 + * as a tablet (Pen Tablet/PT), and the center 1/3rd also usable as a
2705 + * touchpad (Glide Sensor/GS). The spec from ALPS is available from
2706 + * <http://wiki.laptop.org/go/Touch_Pad/Tablet>. It refers to this
2707 + * device as HGPK (Hybrid GS, PT, and Keymatrix).
2708 + *
2709 + * Earlier version of the device had simultaneous reporting; however, that
2710 + * was removed. Instead, the device now reports packets in one mode, and
2711 + * tells the driver when a mode switch needs to happen.
2712 + */
2713 +
2714 +#define DEBUG
2715 +#include <linux/input.h>
2716 +#include <linux/serio.h>
2717 +#include <linux/libps2.h>
2718 +#include <linux/delay.h>
2719 +#include <asm/olpc.h>
2720 +
2721 +#include "psmouse.h"
2722 +#include "olpc.h"
2723 +
2724 +static int tpdebug;
2725 +module_param(tpdebug, int, 0644);
2726 +
2727 +static int ignore_delta = 60;
2728 +module_param(ignore_delta, int, 0644);
2729 +MODULE_PARM_DESC(ignore_delta, "ignore packets that cause an X or Y delta larger than this value.");
2730 +
2731 +/*
2732 + * With older hardware, a finger-up event is sometimes not sent. If it's been
2733 + * more than 50mS since the last packet, we can safely assume that there was
2734 + * a finger-up event that we never received.
2735 + */
2736 +static void hgpk_fingerup_hack(struct psmouse *psmouse, struct hgpk_packet *p)
2737 +{
2738 + struct hgpk_data *priv = psmouse->private;
2739 + struct timeval now_tv;
2740 + s64 now_ns;
2741 +
2742 + if (psmouse->model >= HGPK_MODEL_C)
2743 + return;
2744 +
2745 + if (p->gs_down || p->pt_down) {
2746 + do_gettimeofday(&now_tv);
2747 + now_ns = timeval_to_ns(&now_tv);
2748 +
2749 + if (priv->late && now_ns >= priv->late) {
2750 + struct input_dev *pt = psmouse->dev;
2751 + struct input_dev *gs = priv->gs;
2752 +
2753 + input_report_key(pt, BTN_TOUCH, 0);
2754 + input_report_key(gs, BTN_TOUCH, 0);
2755 + input_sync(pt);
2756 + input_sync(gs);
2757 + hgpk_dbg(psmouse, "Missing finger-up packet detected, "
2758 + "working around buggy hardware.\n");
2759 + }
2760 + priv->late = now_ns + (50 * NSEC_PER_MSEC);
2761 + } else
2762 + priv->late = 0;
2763 +}
2764 +
2765 +/*
2766 + * C and D series touchpads send an extra finger-up packet to ensure we've
2767 + * seen it. That's all well and good, but for some uncomprehensible reason
2768 + * they sometimes also get stuck in a state where they also send an
2769 + * extra finger-down packet with coordinates of x=0, y=0. This royally
2770 + * screws relative positioning; end users see it as the touchpad jumping
2771 + * around when they first put their finger down. This works around that.
2772 + *
2773 + * *Sigh*. ALPS..
2774 + */
2775 +static void hgpk_fingerdown_hack(struct psmouse *psmouse, struct hgpk_packet *p)
2776 +{
2777 + if (psmouse->model < HGPK_MODEL_C)
2778 + return;
2779 +
2780 + /* we only care about x=0, y=0 packets */
2781 + if (p->x != 0 || p->y != 0)
2782 + return;
2783 +
2784 + /*
2785 + * if we're a gs_down packet but we were not previously down,
2786 + * we're going to assume that this is one of those spurious packets
2787 + * that needs to be worked around.
2788 + */
2789 + if (p->gs_down && !test_bit(BTN_TOUCH, p->dev->key)) {
2790 + hgpk_dbg(psmouse, "spurious GS finger-down packet\n");
2791 + p->gs_down = 0;
2792 + } else if (p->pt_down && !test_bit(BTN_TOUCH, p->dev->key)) {
2793 + hgpk_dbg(psmouse, "spurious PT finger-down packet\n");
2794 + p->pt_down = 0;
2795 + }
2796 +}
2797 +
2798 +/*
2799 + * In general, we have lots of calibration problems that manifest
2800 + * themselves as jumpy mouse pointers. Miscalibration, capacitance issues
2801 + * with the hardware, etc; these make the touchpad detect errant packets
2802 + * at random places all over the place. Since we don't expect large deltas
2803 + * to ever actually be useful, we'll large axis changes that go over our
2804 + * threshold.
2805 + */
2806 +static void hgpk_big_delta_hack(struct psmouse *psmouse, struct hgpk_packet *p)
2807 +{
2808 + struct hgpk_data *priv = psmouse->private;
2809 + struct input_dev *dev = p->dev;
2810 +
2811 + /* afaik, this happens on all hardware */
2812 +
2813 + /* ignore finger-up packets */
2814 + if (!p->pt_down && !p->gs_down)
2815 + goto done;
2816 +
2817 + /* ensure that we're not a finger-down packet */
2818 + if ((p->pt_down && !test_bit(BTN_TOUCH, dev->key)) ||
2819 + (p->gs_down && !test_bit(BTN_TOUCH, dev->key)))
2820 + goto done;
2821 +
2822 + if (abs(dev->abs[ABS_X] - p->x) > ignore_delta ||
2823 + abs(dev->abs[ABS_Y] - p->y) > ignore_delta) {
2824 + hgpk_dbg(psmouse, "axis change (%d,%d) => (%d,%d) is over "
2825 + "delta threshold\n", dev->abs[ABS_X],
2826 + dev->abs[ABS_Y], p->x, p->y);
2827 + input_report_key(dev, BTN_TOUCH, 0);
2828 + input_sync(dev);
2829 +
2830 +
2831 + /* two in a row is a pretty good indicator of miscalibration */
2832 + if (priv->axis_errors++) {
2833 + /* wait 2s for finger removal, and then recalibrate */
2834 + queue_delayed_work(kpsmoused_wq, &priv->recalib_wq,
2835 + msecs_to_jiffies(2000));
2836 + priv->axis_errors = 0;
2837 + }
2838 + return;
2839 + }
2840 +done:
2841 + priv->axis_errors = 0;
2842 +}
2843 +
2844 +/*
2845 + * This is my favorite touchpad hardware bug. I'm entirely not sure what
2846 + * triggers it (I've seen it triggered while the laptop was left on overnight,
2847 + * but my cat could have very well been using it/sleeping on it). However,
2848 + * the touchpad will randomly get stuck in a state where it constantly spews
2849 + * packets without a finger being on it. A recalibration will fix it, but
2850 + * without that it will go on for days (auto-recalibration doesn't catch it,
2851 + * either). The packets tend to either have the same coordinates, or be
2852 + * 1px away from each other; ie, (283,139,6) -> (284,139,5) -> (285,139,5) ->
2853 + * (286,139,6) -> (286,139,6) -> etc. We have a number of workarounds here..
2854 + */
2855 +static void hgpk_spewing_hack(struct psmouse *psmouse, struct hgpk_packet *p)
2856 +{
2857 + struct hgpk_data *priv = psmouse->private;
2858 + struct input_dev *dev = p->dev;
2859 + int repeat_axes;
2860 +
2861 + if (psmouse->model < HGPK_MODEL_C)
2862 + return;
2863 +
2864 + /* ignore 0, 0 packets */
2865 + if (p->x == 0 && p->y == 0)
2866 + return;
2867 +
2868 + /* PT packets don't count */
2869 + if (p->pt_down) {
2870 + priv->repeat_pkts = 0;
2871 + return;
2872 + }
2873 +
2874 + /*
2875 + * If we see 2s+ worth of packets that have at least 2 axis deltas of
2876 + * only 1px, that's a good indication that we're spewing packets.
2877 + * We're going to ignore z=15, though; that's pretty indicative of
2878 + * an actual finger on the touchpad just staying still.
2879 + */
2880 + if (p->z == 0 || p->z == 15)
2881 + goto next_hack;
2882 + repeat_axes = abs(p->x - dev->abs[ABS_X]) < 2 ? 1 : 0;
2883 + repeat_axes += abs(p->y - dev->abs[ABS_Y]) < 2 ? 1 : 0;
2884 + repeat_axes += abs(p->z - dev->abs[ABS_PRESSURE]) < 2 ? 1 : 0;
2885 + if (repeat_axes > 1) {
2886 + priv->repeat_pkts++;
2887 + /* we get 1 packet about every 24mS */
2888 + if (priv->repeat_pkts > 83) {
2889 + queue_delayed_work(kpsmoused_wq, &priv->recalib_wq, 0);
2890 + priv->repeat_pkts = 0;
2891 + }
2892 + }
2893 + else
2894 + priv->repeat_pkts = 0;
2895 + return;
2896 +
2897 +next_hack:
2898 + /*
2899 + * 10s of y and z not changing is another kind of miscalibration.
2900 + */
2901 + repeat_axes = (p->y == dev->abs[ABS_Y]) ? 1 : 0;
2902 + repeat_axes += (p->z == dev->abs[ABS_PRESSURE]) ? 1 : 0;
2903 + if (repeat_axes > 1) {
2904 + priv->repeat_pkts++;
2905 + if (priv->repeat_pkts > 416) {
2906 + queue_delayed_work(kpsmoused_wq, &priv->recalib_wq, 0);
2907 + priv->repeat_pkts = 0;
2908 + }
2909 + }
2910 + else
2911 + priv->repeat_pkts = 0;
2912 +}
2913 +
2914 +/*
2915 + * HGPK Advanced Mode - single-mode format
2916 + *
2917 + * byte 0(PT): 1 1 0 0 1 1 1 1
2918 + * byte 0(GS): 1 1 1 1 1 1 1 1
2919 + * byte 1: 0 x6 x5 x4 x3 x2 x1 x0
2920 + * byte 2(PT): 0 0 x9 x8 x7 ? pt-dsw 0
2921 + * byte 2(GS): 0 x10 x9 x8 x7 ? gs-dsw pt-dsw
2922 + * byte 3: 0 y9 y8 y7 1 0 swr swl
2923 + * byte 4: 0 y6 y5 y4 y3 y2 y1 y0
2924 + * byte 5: 0 z6 z5 z4 z3 z2 z1 z0
2925 + *
2926 + * ?'s are not defined in the protocol spec, may vary between models.
2927 + *
2928 + * swr/swl are the left/right buttons.
2929 + *
2930 + * pt-dsw/gs-dsw indicate that the pt/gs sensor is detecting a
2931 + * pen/finger
2932 + */
2933 +
2934 +static int hgpk_validate_byte(unsigned char *packet, int pktcnt)
2935 +{
2936 + BUG_ON(pktcnt < 1);
2937 +
2938 + if (packet[0] != HGPK_PT && packet[0] != HGPK_GS)
2939 + return -1;
2940 +
2941 + /* bytes 2 - 6 should have 0 in the highest bit */
2942 + if (pktcnt >= 2 && pktcnt <= 6 && (packet[pktcnt - 1] & 0x80))
2943 + return -1;
2944 +
2945 + return 0;
2946 +}
2947 +
2948 +static void hgpk_decode_packet(struct psmouse *psmouse, struct hgpk_packet *p)
2949 +{
2950 + unsigned char *packet = psmouse->packet;
2951 +
2952 + BUG_ON(psmouse->pktcnt < 6);
2953 +
2954 + p->left = packet[3] & 1;
2955 + p->right = !!(packet[3] & 2);
2956 + p->x = packet[1] | ((packet[2] & 0x78) << 4);
2957 + p->y = packet[4] | ((packet[3] & 0x70) << 3);
2958 + p->z = packet[5];
2959 +
2960 + if (packet[0] == HGPK_GS) {
2961 + p->pt_down = !!(packet[2] & 1);
2962 + p->gs_down = !!(packet[2] & 2);
2963 + p->dev = ((struct hgpk_data *) psmouse->private)->gs;
2964 + if (p->pt_down) {
2965 + /* we miss spurious PT finger-downs if pt_down is set */
2966 + p->mode_switch = HGPK_PT;
2967 + p->pt_down = 0;
2968 + } else {
2969 + p->mode_switch = 0;
2970 + }
2971 + } else if (packet[0] == HGPK_PT) {
2972 + p->pt_down = !!(packet[2] & 2);
2973 + p->gs_down = 0;
2974 + p->dev = psmouse->dev;
2975 + p->mode_switch = !p->pt_down ? HGPK_GS : 0;
2976 + }
2977 +
2978 + if (tpdebug) {
2979 + hgpk_dbg(psmouse, "l=%d r=%d p=%d g=%d x=%d y=%d z=%d m=%x\n",
2980 + p->left, p->right, p->pt_down, p->gs_down,
2981 + p->x, p->y, p->z, p->mode_switch);
2982 + }
2983 +}
2984 +
2985 +static void hgpk_process_packet_gspt(struct psmouse *psmouse)
2986 +{
2987 + struct hgpk_data *priv = psmouse->private;
2988 + struct input_dev *pt = psmouse->dev;
2989 + struct input_dev *gs = priv->gs;
2990 + struct hgpk_packet pkt;
2991 +
2992 + hgpk_decode_packet(psmouse, &pkt);
2993 +
2994 + hgpk_fingerup_hack(psmouse, &pkt);
2995 + hgpk_fingerdown_hack(psmouse, &pkt);
2996 + hgpk_big_delta_hack(psmouse, &pkt);
2997 + hgpk_spewing_hack(psmouse, &pkt);
2998 +
2999 + input_report_key(pt, BTN_LEFT, pkt.left);
3000 + input_report_key(pt, BTN_RIGHT, pkt.right);
3001 + input_report_key(pt, BTN_TOUCH, pkt.pt_down);
3002 +
3003 + input_report_key(gs, BTN_LEFT, pkt.left);
3004 + input_report_key(gs, BTN_RIGHT, pkt.right);
3005 + input_report_key(gs, BTN_TOUCH, pkt.gs_down);
3006 +
3007 + input_report_abs(pkt.dev, ABS_X, pkt.x);
3008 + input_report_abs(pkt.dev, ABS_Y, pkt.y);
3009 + input_report_abs(pkt.dev, ABS_PRESSURE, pkt.z);
3010 +
3011 + input_sync(pt);
3012 + input_sync(gs);
3013 +
3014 + if (priv->recalib_window) {
3015 + if (time_before(jiffies, priv->recalib_window)) {
3016 + /*
3017 + * ugh, got a packet inside our recalibration
3018 + * window, schedule another recalibration.
3019 + */
3020 + hgpk_dbg(psmouse, "packet inside calibration window, "
3021 + "queueing another recalibration\n");
3022 + queue_delayed_work(kpsmoused_wq, &priv->recalib_wq,
3023 + msecs_to_jiffies(1000));
3024 + }
3025 + priv->recalib_window = 0;
3026 + }
3027 +
3028 + if (psmouse->model != HGPK_MODEL_A) {
3029 + if (priv->pending_mode && (!pkt.mode_switch ||
3030 + priv->current_mode == pkt.mode_switch)) {
3031 + priv->pending_mode = 0;
3032 + cancel_delayed_work(&priv->switch_wq);
3033 + }
3034 + else if (priv->pending_mode != pkt.mode_switch) {
3035 + priv->pending_mode = pkt.mode_switch;
3036 +
3037 + /* allow for spurious mode_switch packets by delaying */
3038 + queue_delayed_work(kpsmoused_wq, &priv->switch_wq,
3039 + msecs_to_jiffies(50));
3040 + }
3041 + }
3042 +}
3043 +
3044 +static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
3045 +{
3046 + if (hgpk_validate_byte(psmouse->packet, psmouse->pktcnt)) {
3047 + hgpk_dbg(psmouse, "%s: (%d) %02x %02x %02x %02x %02x %02x\n",
3048 + __func__, psmouse->pktcnt, psmouse->packet[0],
3049 + psmouse->packet[1], psmouse->packet[2],
3050 + psmouse->packet[3], psmouse->packet[4],
3051 + psmouse->packet[5]);
3052 + return PSMOUSE_BAD_DATA;
3053 + }
3054 +
3055 + if (psmouse->pktcnt == 6) {
3056 + hgpk_process_packet_gspt(psmouse);
3057 + return PSMOUSE_FULL_PACKET;
3058 + }
3059 +
3060 + return PSMOUSE_GOOD_DATA;
3061 +}
3062 +
3063 +static int hgpk_force_recalibrate(struct psmouse *psmouse)
3064 +{
3065 + struct ps2dev *ps2dev = &psmouse->ps2dev;
3066 + struct hgpk_data *priv = psmouse->private;
3067 + struct input_dev *pt = psmouse->dev;
3068 + struct input_dev *gs = priv->gs;
3069 +
3070 + /* C-series touchpads added the recalibrate command */
3071 + if (psmouse->model < HGPK_MODEL_C)
3072 + return 0;
3073 +
3074 + if (ps2_command(ps2dev, NULL, 0xf5) ||
3075 + ps2_command(ps2dev, NULL, 0xf5) ||
3076 + ps2_command(ps2dev, NULL, 0xe6) ||
3077 + ps2_command(ps2dev, NULL, 0xf5))
3078 + return -1;
3079 +
3080 + /* send a finger-up event so the cursor doesn't jump around */
3081 + input_report_key(pt, BTN_TOUCH, 0);
3082 + input_report_key(gs, BTN_TOUCH, 0);
3083 + input_sync(pt);
3084 + input_sync(gs);
3085 +
3086 + /* according to ALPS, 150mS is required for recalibration */
3087 + msleep(150);
3088 +
3089 + /*
3090 + * XXX: If a finger is down during this delay, recalibration will
3091 + * detect capacitance incorrectly. This is a hardware bug, and
3092 + * we may need to work around that here.
3093 + */
3094 +
3095 + if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE))
3096 + return -1;
3097 +
3098 + /*
3099 + * After we recalibrate, we shouldn't get any packets for 2s. If
3100 + * we do, it's likely that someone's finger was on the touchpad.
3101 + * If someone's finger *was* on the touchpad, it's probably
3102 + * miscalibrated. So, we should schedule another recalibration
3103 + */
3104 + priv->recalib_window = jiffies + msecs_to_jiffies(2000);
3105 +
3106 + return 0;
3107 +}
3108 +
3109 +static enum hgpk_model_t hgpk_get_model(struct psmouse *psmouse)
3110 +{
3111 + struct ps2dev *ps2dev = &psmouse->ps2dev;
3112 + unsigned char param[3];
3113 +
3114 + /* E7, E7, E7, E9 gets us a 3 byte identifier */
3115 + if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
3116 + ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
3117 + ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
3118 + ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
3119 + return -EIO;
3120 +
3121 + hgpk_dbg(psmouse, "ID: %02x %02x %02x", param[0], param[1], param[2]);
3122 +
3123 + /* HGPK signature: 0x67, 0x00, 0x<model> */
3124 + if (param[0] != 0x67 || param[1] != 0x00)
3125 + return -ENODEV;
3126 +
3127 + hgpk_info(psmouse, "OLPC touchpad revision 0x%x\n", param[2]);
3128 + return param[2];
3129 +}
3130 +
3131 +/*
3132 + * Touchpad should be disabled before calling this!
3133 + */
3134 +static int hgpk_new_mode(struct psmouse *psmouse, int mode)
3135 +{
3136 + struct ps2dev *ps2dev = &psmouse->ps2dev;
3137 + struct hgpk_data *priv = psmouse->private;
3138 +
3139 + /*
3140 + * PT mode: F2, F2, F2, E7
3141 + * GS mode: F2, F2, F2, E6
3142 + */
3143 + if (ps2_command(ps2dev, NULL, 0xF2) ||
3144 + ps2_command(ps2dev, NULL, 0xF2) ||
3145 + ps2_command(ps2dev, NULL, 0xF2))
3146 + return -EIO;
3147 +
3148 + if (mode == HGPK_GS) {
3149 + if (ps2_command(ps2dev, NULL, 0xE6))
3150 + return -EIO;
3151 + } else {
3152 + if (ps2_command(ps2dev, NULL, 0xE7))
3153 + return -EIO;
3154 + }
3155 +
3156 + if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE))
3157 + return -EIO;
3158 +
3159 + /* tell the irq handler to stop ignoring packets */
3160 + psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
3161 +
3162 + priv->current_mode = mode;
3163 + priv->pending_mode = 0;
3164 + if (tpdebug)
3165 + hgpk_warn(psmouse, "Switched to mode 0x%x successful.\n", mode);
3166 +
3167 + return 0;
3168 +}
3169 +
3170 +static int hgpk_advanced_mode(struct psmouse *psmouse)
3171 +{
3172 + struct ps2dev *ps2dev = &psmouse->ps2dev;
3173 +
3174 + /* Switch to 'Advanced mode.', four disables in a row. */
3175 + if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
3176 + ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
3177 + ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
3178 + ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE))
3179 + return -1;
3180 +
3181 + return hgpk_new_mode(psmouse, HGPK_GS);
3182 +}
3183 +
3184 +/*
3185 + * This kills power to the touchpad; according to ALPS, current consumption
3186 + * goes down to 50uA after running this. To turn power back on, we drive
3187 + * MS-DAT low.
3188 + */
3189 +static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
3190 +{
3191 + struct ps2dev *ps2dev = &psmouse->ps2dev;
3192 + int timeo;
3193 +
3194 + /* Added on D-series touchpads */
3195 + if (psmouse->model < HGPK_MODEL_D)
3196 + return 0;
3197 +
3198 + if (enable) {
3199 + psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
3200 +
3201 + /*
3202 + * Sending a byte will drive MS-DAT low; this will wake up
3203 + * the controller. Once we get an ACK back from it, it
3204 + * means we can continue with the touchpad re-init. ALPS
3205 + * tells us that 1s should be long enough, so set that as
3206 + * the upper bound.
3207 + */
3208 + for (timeo = 20; timeo > 0; timeo--) {
3209 + if (!ps2_sendbyte(&psmouse->ps2dev,
3210 + PSMOUSE_CMD_DISABLE, 20))
3211 + break;
3212 + msleep(50);
3213 + }
3214 +
3215 + psmouse_reset(psmouse);
3216 +
3217 + if (hgpk_advanced_mode(psmouse)) {
3218 + hgpk_err(psmouse, "Failed to reinit touchpad!\n");
3219 + return -1;
3220 + }
3221 + } else {
3222 + hgpk_dbg(psmouse, "Powering off touchpad.\n");
3223 + psmouse_set_state(psmouse, PSMOUSE_IGNORE);
3224 +
3225 + if (ps2_command(ps2dev, NULL, 0xec) ||
3226 + ps2_command(ps2dev, NULL, 0xec) ||
3227 + ps2_command(ps2dev, NULL, 0xea))
3228 + return -1;
3229 + /* probably won't see an ACK, the touchpad will be off */
3230 + ps2_sendbyte(&psmouse->ps2dev, 0xec, 20);
3231 + }
3232 +
3233 + return 0;
3234 +}
3235 +
3236 +/*
3237 + * poll the touchpad for current motion packet.
3238 + * Used in resync.
3239 + * Note: We can't poll, so always return failure.
3240 + */
3241 +static int hgpk_poll(struct psmouse *psmouse)
3242 +{
3243 + return -1;
3244 +}
3245 +
3246 +static int hgpk_reconnect(struct psmouse *psmouse)
3247 +{
3248 + if (olpc_board_at_least(olpc_board(0xb2)))
3249 + if (psmouse->ps2dev.serio->dev.power.power_state.event != PM_EVENT_ON)
3250 + return 0;
3251 +
3252 + psmouse_reset(psmouse);
3253 +
3254 + if (hgpk_advanced_mode(psmouse)) {
3255 + hgpk_err(psmouse, "failed to reenable advanced mode.\n");
3256 + return -1;
3257 + }
3258 +
3259 + return 0;
3260 +}
3261 +
3262 +static ssize_t hgpk_show_powered(struct device *dev,
3263 + struct device_attribute *attr, char *buf)
3264 +{
3265 + struct serio *serio = to_serio_port(dev);
3266 + struct psmouse *psmouse;
3267 + struct hgpk_data *priv;
3268 + int retval;
3269 +
3270 + retval = serio_pin_driver(serio);
3271 + if (retval)
3272 + return retval;
3273 +
3274 + psmouse = serio_get_drvdata(serio);
3275 + priv = psmouse->private;
3276 +
3277 + retval = sprintf(buf, "%d\n", priv->powered);
3278 + serio_unpin_driver(serio);
3279 + return retval;
3280 +}
3281 +
3282 +static ssize_t hgpk_set_powered(struct device *dev,
3283 + struct device_attribute *attr, const char *buf, size_t count)
3284 +{
3285 + struct serio *serio = to_serio_port(dev);
3286 + struct psmouse *psmouse;
3287 + struct hgpk_data *priv;
3288 + unsigned long val;
3289 + int retval;
3290 +
3291 + if (*buf == '1')
3292 + val = 1;
3293 + else if (*buf == '0')
3294 + val = 0;
3295 + else
3296 + return -EINVAL;
3297 +
3298 + retval = serio_pin_driver(serio);
3299 + if (retval)
3300 + return retval;
3301 +
3302 +/*
3303 + * FUCK IT. I don't fucking care. locking in psmouse is fucking retarded!
3304 + retval = mutex_lock_interruptible(&psmouse_mutex);
3305 + if (retval)
3306 + goto out_unpin;
3307 +*/
3308 +
3309 + psmouse = serio_get_drvdata(serio);
3310 + priv = psmouse->private;
3311 +
3312 + if (val == priv->powered)
3313 + goto done;
3314 +
3315 + retval = hgpk_toggle_power(psmouse, val);
3316 + if (!retval)
3317 + priv->powered = val;
3318 +
3319 +done:
3320 + serio_unpin_driver(serio);
3321 + return retval ? retval : count;
3322 +}
3323 +
3324 +static DEVICE_ATTR(powered, S_IWUSR | S_IRUGO, hgpk_show_powered,
3325 + hgpk_set_powered);
3326 +
3327 +static void hgpk_disconnect(struct psmouse *psmouse)
3328 +{
3329 + struct hgpk_data *priv = psmouse->private;
3330 +
3331 + device_remove_file(&psmouse->ps2dev.serio->dev, &dev_attr_powered);
3332 + psmouse_reset(psmouse);
3333 + flush_scheduled_work();
3334 + input_unregister_device(priv->gs);
3335 + kfree(priv);
3336 +}
3337 +
3338 +static void hgpk_mode_switch(struct work_struct *work)
3339 +{
3340 + struct delayed_work *w = container_of(work, struct delayed_work, work);
3341 + struct hgpk_data *priv = container_of(w, struct hgpk_data, switch_wq);
3342 + struct psmouse *psmouse = priv->psmouse;
3343 + struct ps2dev *ps2dev = &psmouse->ps2dev;
3344 + int pending_mode;
3345 +
3346 + if (tpdebug)
3347 + hgpk_dbg(psmouse, "Starting mode switch to 0x%x. [%lu]\n",
3348 + priv->pending_mode, jiffies);
3349 +
3350 + if (priv->pending_mode == priv->current_mode) {
3351 + priv->pending_mode = 0;
3352 + hgpk_dbg(psmouse, "Already in target mode, no-op.\n");
3353 + return;
3354 + }
3355 +
3356 + /* tell the irq handler to ignore any further packets */
3357 + psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
3358 + priv->late = 0;
3359 +
3360 + if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE))
3361 + goto bad;
3362 +
3363 + /*
3364 + * ALPS tells us that it may take up to 20msec for the disable to
3365 + * take effect; however, ps2_command() will wait up to 200msec for
3366 + * the ACK to come back (and I'm assuming that by the time the
3367 + * hardware sends back its ACK, it has stopped sending bytes).
3368 + */
3369 + pending_mode = priv->pending_mode;
3370 +
3371 + if (hgpk_new_mode(psmouse, priv->pending_mode))
3372 + goto bad;
3373 +
3374 + /*
3375 + * Deal with a potential race condition.
3376 + *
3377 + * If there is a brief tap of a stylus or a fingernail that
3378 + * triggers a mode switch to PT mode, and the stylus/fingernail is
3379 + * lifted after the DISABLE above, but before we reenable in the
3380 + * new mode then we can get stuck in PT mode.
3381 + */
3382 + if (pending_mode == HGPK_PT) {
3383 + priv->pending_mode = HGPK_GS;
3384 + queue_delayed_work(kpsmoused_wq, &priv->switch_wq,
3385 + msecs_to_jiffies(50));
3386 + }
3387 +
3388 + return;
3389 +bad:
3390 + hgpk_warn(psmouse, "Failure to switch modes, resetting device...\n");
3391 + hgpk_reconnect(psmouse);
3392 +}
3393 +
3394 +static void hgpk_recalib_work(struct work_struct *work)
3395 +{
3396 + struct delayed_work *w = container_of(work, struct delayed_work, work);
3397 + struct hgpk_data *priv = container_of(w, struct hgpk_data, recalib_wq);
3398 + struct psmouse *psmouse = priv->psmouse;
3399 +
3400 + if (tpdebug)
3401 + hgpk_dbg(psmouse, "Recalibrating touchpad..\n");
3402 +
3403 + if (hgpk_force_recalibrate(psmouse))
3404 + hgpk_err(psmouse, "Recalibration failed!\n");
3405 +}
3406 +
3407 +int olpc_init(struct psmouse *psmouse)
3408 +{
3409 + struct hgpk_data *priv;
3410 + struct input_dev *pt = psmouse->dev;
3411 + struct input_dev *gs;
3412 +
3413 + priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL);
3414 + gs = input_allocate_device();
3415 + if (!priv || !gs)
3416 + goto init_fail;
3417 +
3418 + psmouse->private = priv;
3419 + priv->gs = gs;
3420 + priv->psmouse = psmouse;
3421 + priv->powered = 1;
3422 +
3423 + psmouse_reset(psmouse);
3424 +
3425 + if (hgpk_advanced_mode(psmouse)) {
3426 + hgpk_err(psmouse, "failed to enable advanced mode\n");
3427 + goto init_fail;
3428 + }
3429 +
3430 + /* Unset things that psmouse-base sets that we don't have */
3431 + pt->evbit[0] &= ~BIT(EV_REL);
3432 + pt->keybit[LONG(BTN_MOUSE)] &= ~BIT(BTN_MIDDLE);
3433 + pt->relbit[0] &= ~(BIT(REL_X) | BIT(REL_Y));
3434 +
3435 + /* Set all the things we *do* have */
3436 + set_bit(EV_KEY, pt->evbit);
3437 + set_bit(EV_ABS, pt->evbit);
3438 +
3439 + set_bit(BTN_LEFT, pt->keybit);
3440 + set_bit(BTN_RIGHT, pt->keybit);
3441 + set_bit(BTN_TOUCH, pt->keybit);
3442 +
3443 + input_set_abs_params(pt, ABS_X, 2, 1000, 0, 0);
3444 + input_set_abs_params(pt, ABS_Y, 0, 717, 0, 0);
3445 + input_set_abs_params(pt, ABS_PRESSURE, 0, 127, 0, 0);
3446 +
3447 + snprintf(priv->phys, sizeof(priv->phys),
3448 + "%s/input1", psmouse->ps2dev.serio->phys);
3449 + gs->phys = priv->phys;
3450 + gs->name = "OLPC ALPS GlideSensor";
3451 + gs->id.bustype = BUS_I8042;
3452 + gs->id.vendor = 0x0002;
3453 + gs->id.product = PSMOUSE_OLPC;
3454 + gs->id.version = psmouse->model;
3455 +
3456 + set_bit(EV_KEY, gs->evbit);
3457 + set_bit(EV_ABS, gs->evbit);
3458 +
3459 + set_bit(BTN_LEFT, gs->keybit);
3460 + set_bit(BTN_RIGHT, gs->keybit);
3461 + set_bit(BTN_TOUCH, gs->keybit);
3462 +
3463 + input_set_abs_params(gs, ABS_X, 350, 512, 0, 0);
3464 + input_set_abs_params(gs, ABS_Y, 70, 325, 0, 0);
3465 + input_set_abs_params(gs, ABS_PRESSURE, 0, 15, 0, 0);
3466 +
3467 + if (input_register_device(gs)) {
3468 + hgpk_err(psmouse, "Failed to register GlideSensor\n");
3469 + goto init_fail;
3470 + }
3471 +
3472 + psmouse->protocol_handler = hgpk_process_byte;
3473 + psmouse->poll = hgpk_poll;
3474 + psmouse->disconnect = hgpk_disconnect;
3475 + psmouse->reconnect = hgpk_reconnect;
3476 + psmouse->pktsize = 6;
3477 +
3478 + /* Disable the idle resync. */
3479 + psmouse->resync_time = 0;
3480 + /* Reset after a lot of bad bytes. */
3481 + psmouse->resetafter = 1024;
3482 +
3483 + INIT_DELAYED_WORK(&priv->switch_wq, hgpk_mode_switch);
3484 + INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work);
3485 +
3486 + if (device_create_file(&psmouse->ps2dev.serio->dev,
3487 + &dev_attr_powered)) {
3488 + hgpk_err(psmouse, "Failed to create sysfs attribute\n");
3489 + goto attr_fail;
3490 + }
3491 +
3492 +
3493 + return 0;
3494 +
3495 +attr_fail:
3496 + input_unregister_device(gs);
3497 + gs = NULL;
3498 +init_fail:
3499 + input_free_device(gs);
3500 + kfree(priv);
3501 + return -1;
3502 +}
3503 +
3504 +int olpc_detect(struct psmouse *psmouse, int set_properties)
3505 +{
3506 + int version;
3507 +
3508 + version = hgpk_get_model(psmouse);
3509 + if (version < 0)
3510 + return version;
3511 +
3512 + if (set_properties) {
3513 + psmouse->vendor = "ALPS";
3514 + psmouse->name = "PenTablet";
3515 + psmouse->model = version;
3516 + }
3517 + return 0;
3518 +}
3519 Index: linux-2.6.24.7/drivers/input/mouse/olpc.h
3520 ===================================================================
3521 --- /dev/null
3522 +++ linux-2.6.24.7/drivers/input/mouse/olpc.h
3523 @@ -0,0 +1,78 @@
3524 +/*
3525 + * OLPC touchpad PS/2 mouse driver
3526 + *
3527 + * Copyright (c) 2006 One Laptop Per Child, inc.
3528 + *
3529 + * This driver is partly based on the ALPS driver.
3530 + * Copyright (c) 2003 Peter Osterlund <petero2@telia.com>
3531 + * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz>
3532 + *
3533 + * This program is free software; you can redistribute it and/or modify it
3534 + * under the terms of the GNU General Public License version 2 as published by
3535 + * the Free Software Foundation.
3536 + */
3537 +
3538 +#ifndef _OLPC_H
3539 +#define _OLPC_H
3540 +
3541 +enum hgpk_model_t {
3542 + HGPK_MODEL_PreA = 0x0a, /* pre-B1s */
3543 + HGPK_MODEL_A = 0x14, /* found on B1s, PT disabled in hardware */
3544 + HGPK_MODEL_B = 0x28, /* B2s, has capacitance issues */
3545 + HGPK_MODEL_C = 0x3c,
3546 + HGPK_MODEL_D = 0x50, /* C1, mass production */
3547 +};
3548 +
3549 +#define HGPK_GS 0xff /* The GlideSensor */
3550 +#define HGPK_PT 0xcf /* The PenTablet */
3551 +
3552 +struct hgpk_packet {
3553 + struct input_dev *dev;
3554 + int x, y, z;
3555 + unsigned char mode_switch;
3556 + unsigned int pt_down:1, gs_down:1;
3557 + unsigned int left:1, right:1;
3558 +};
3559 +
3560 +struct hgpk_data {
3561 + struct input_dev *gs; /* GlideSensor */
3562 + struct psmouse *psmouse;
3563 + char name[32]; /* Name */
3564 + char phys[32]; /* Phys */
3565 + int pending_mode;
3566 + int current_mode;
3567 + s64 late;
3568 + int axis_errors;
3569 + int repeat_pkts;
3570 + int powered;
3571 + unsigned long recalib_window;
3572 + struct delayed_work switch_wq;
3573 + struct delayed_work recalib_wq;
3574 +};
3575 +
3576 +#define hgpk_dbg(psmouse, format, arg...) \
3577 + dev_dbg(&(psmouse)->ps2dev.serio->dev, format, ## arg)
3578 +#define hgpk_err(psmouse, format, arg...) \
3579 + dev_err(&(psmouse)->ps2dev.serio->dev, format, ## arg)
3580 +#define hgpk_info(psmouse, format, arg...) \
3581 + dev_info(&(psmouse)->ps2dev.serio->dev, format, ## arg)
3582 +#define hgpk_warn(psmouse, format, arg...) \
3583 + dev_warn(&(psmouse)->ps2dev.serio->dev, format, ## arg)
3584 +#define hgpk_notice(psmouse, format, arg...) \
3585 + dev_notice(&(psmouse)->ps2dev.serio->dev, format, ## arg)
3586 +
3587 +#ifdef CONFIG_MOUSE_PS2_OLPC
3588 +int olpc_detect(struct psmouse *psmouse, int set_properties);
3589 +int olpc_init(struct psmouse *psmouse);
3590 +#else
3591 +inline int olpc_detect(struct psmouse *psmouse, int set_properties)
3592 +{
3593 + return -ENOSYS;
3594 +}
3595 +inline int olpc_init(struct psmouse *psmouse)
3596 +{
3597 + return -ENOSYS;
3598 +}
3599 +#endif
3600 +
3601 +#endif
3602 Index: linux-2.6.24.7/drivers/input/mouse/psmouse-base.c
3603 ===================================================================
3604 --- linux-2.6.24.7.orig/drivers/input/mouse/psmouse-base.c
3605 +++ linux-2.6.24.7/drivers/input/mouse/psmouse-base.c
3606 @@ -26,6 +26,7 @@
3607 #include "synaptics.h"
3608 #include "logips2pp.h"
3609 #include "alps.h"
3610 +#include "olpc.h"
3611 #include "lifebook.h"
3612 #include "trackpoint.h"
3613 #include "touchkit_ps2.h"
3614 @@ -103,7 +104,7 @@ static struct attribute_group psmouse_at
3615 */
3616 static DEFINE_MUTEX(psmouse_mutex);
3617
3618 -static struct workqueue_struct *kpsmoused_wq;
3619 +struct workqueue_struct *kpsmoused_wq;
3620
3621 struct psmouse_protocol {
3622 enum psmouse_type type;
3623 @@ -221,7 +222,7 @@ static inline void __psmouse_set_state(s
3624 * is not a concern.
3625 */
3626
3627 -static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
3628 +void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
3629 {
3630 serio_pause_rx(psmouse->ps2dev.serio);
3631 __psmouse_set_state(psmouse, new_state);
3632 @@ -320,7 +321,7 @@ static irqreturn_t psmouse_interrupt(str
3633 goto out;
3634 }
3635
3636 - if (psmouse->packet[1] == PSMOUSE_RET_ID) {
3637 + if (psmouse->packet[1] == PSMOUSE_RET_ID || psmouse->packet[1] == PSMOUSE_RET_BAT) {
3638 __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
3639 serio_reconnect(serio);
3640 goto out;
3641 @@ -631,8 +632,21 @@ static int psmouse_extensions(struct psm
3642 }
3643 }
3644
3645 +/*
3646 + * Try OLPC touchpad.
3647 + */
3648 if (max_proto > PSMOUSE_IMEX) {
3649 + if (olpc_detect(psmouse, set_properties) == 0) {
3650 + if (!set_properties || olpc_init(psmouse) == 0)
3651 + return PSMOUSE_OLPC;
3652 +/*
3653 + * Init failed, try basic relative protocols
3654 + */
3655 + max_proto = PSMOUSE_IMEX;
3656 + }
3657 + }
3658
3659 + if (max_proto > PSMOUSE_IMEX) {
3660 if (genius_detect(psmouse, set_properties) == 0)
3661 return PSMOUSE_GENPS;
3662
3663 @@ -763,6 +777,14 @@ static const struct psmouse_protocol psm
3664 .detect = touchkit_ps2_detect,
3665 },
3666 #endif
3667 +#ifdef CONFIG_MOUSE_PS2_OLPC
3668 + {
3669 + .type = PSMOUSE_OLPC,
3670 + .name = "OLPC",
3671 + .alias = "olpc",
3672 + .detect = olpc_detect,
3673 + },
3674 +#endif
3675 {
3676 .type = PSMOUSE_CORTRON,
3677 .name = "CortronPS/2",
3678 Index: linux-2.6.24.7/drivers/input/mouse/psmouse.h
3679 ===================================================================
3680 --- linux-2.6.24.7.orig/drivers/input/mouse/psmouse.h
3681 +++ linux-2.6.24.7/drivers/input/mouse/psmouse.h
3682 @@ -88,6 +88,7 @@ enum psmouse_type {
3683 PSMOUSE_LIFEBOOK,
3684 PSMOUSE_TRACKPOINT,
3685 PSMOUSE_TOUCHKIT_PS2,
3686 + PSMOUSE_OLPC,
3687 PSMOUSE_CORTRON,
3688 PSMOUSE_AUTO /* This one should always be last */
3689 };
3690 @@ -95,7 +96,9 @@ enum psmouse_type {
3691 int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command);
3692 int psmouse_reset(struct psmouse *psmouse);
3693 void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution);
3694 +void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state);
3695
3696 +extern struct workqueue_struct *kpsmoused_wq;
3697
3698 struct psmouse_attribute {
3699 struct device_attribute dattr;
3700 Index: linux-2.6.24.7/drivers/input/serio/i8042.c
3701 ===================================================================
3702 --- linux-2.6.24.7.orig/drivers/input/serio/i8042.c
3703 +++ linux-2.6.24.7/drivers/input/serio/i8042.c
3704 @@ -874,6 +874,11 @@ static long i8042_panic_blink(long count
3705 #undef DELAY
3706
3707 #ifdef CONFIG_PM
3708 +
3709 +#ifdef CONFIG_OLPC
3710 +#include <asm/olpc.h>
3711 +#endif
3712 +
3713 /*
3714 * Here we try to restore the original BIOS settings. We only want to
3715 * do that once, when we really suspend, not when we taking memory
3716 @@ -884,8 +889,15 @@ static long i8042_panic_blink(long count
3717 static int i8042_suspend(struct platform_device *dev, pm_message_t state)
3718 {
3719 if (dev->dev.power.power_state.event != state.event) {
3720 +#ifdef CONFIG_OLPC
3721 + /* Anything newer than B2 remains powered; no reset needed */
3722 + if (!olpc_board_at_least(olpc_board_pre(0xb3))) {
3723 +#endif
3724 if (state.event == PM_EVENT_SUSPEND)
3725 i8042_controller_reset();
3726 +#ifdef CONFIG_OLPC
3727 + }
3728 +#endif
3729
3730 dev->dev.power.power_state = state;
3731 }
3732 @@ -908,9 +920,15 @@ static int i8042_resume(struct platform_
3733 if (dev->dev.power.power_state.event == PM_EVENT_ON)
3734 return 0;
3735
3736 +#ifdef CONFIG_OLPC
3737 + if (!olpc_board_at_least(olpc_board_pre(0xb3))) {
3738 +#endif
3739 error = i8042_controller_check();
3740 if (error)
3741 return error;
3742 +#ifdef CONFIG_OLPC
3743 + }
3744 +#endif
3745
3746 error = i8042_controller_selftest();
3747 if (error)
3748 Index: linux-2.6.24.7/drivers/input/serio/serio.c
3749 ===================================================================
3750 --- linux-2.6.24.7.orig/drivers/input/serio/serio.c
3751 +++ linux-2.6.24.7/drivers/input/serio/serio.c
3752 @@ -910,11 +910,22 @@ static int serio_uevent(struct device *d
3753 #endif /* CONFIG_HOTPLUG */
3754
3755 #ifdef CONFIG_PM
3756 +
3757 +#ifdef CONFIG_OLPC
3758 +#include <asm/olpc.h>
3759 +#endif
3760 +
3761 static int serio_suspend(struct device *dev, pm_message_t state)
3762 {
3763 if (dev->power.power_state.event != state.event) {
3764 +#ifdef CONFIG_OLPC
3765 + if (!olpc_board_at_least(olpc_board_pre(0xb3))) {
3766 +#endif
3767 if (state.event == PM_EVENT_SUSPEND)
3768 serio_cleanup(to_serio_port(dev));
3769 +#ifdef CONFIG_OLPC
3770 + }
3771 +#endif
3772
3773 dev->power.power_state = state;
3774 }
3775 Index: linux-2.6.24.7/drivers/Kconfig
3776 ===================================================================
3777 --- linux-2.6.24.7.orig/drivers/Kconfig
3778 +++ linux-2.6.24.7/drivers/Kconfig
3779 @@ -94,6 +94,8 @@ source "drivers/auxdisplay/Kconfig"
3780
3781 source "drivers/kvm/Kconfig"
3782
3783 +source "drivers/sysprof/Kconfig"
3784 +
3785 source "drivers/uio/Kconfig"
3786
3787 source "drivers/virtio/Kconfig"
3788 Index: linux-2.6.24.7/drivers/Makefile
3789 ===================================================================
3790 --- linux-2.6.24.7.orig/drivers/Makefile
3791 +++ linux-2.6.24.7/drivers/Makefile
3792 @@ -23,6 +23,8 @@ obj-y += char/
3793
3794 obj-$(CONFIG_CONNECTOR) += connector/
3795
3796 +obj-$(CONFIG_SYSPROF) += sysprof/
3797 +
3798 # i810fb and intelfb depend on char/agp/
3799 obj-$(CONFIG_FB_I810) += video/i810/
3800 obj-$(CONFIG_FB_INTEL) += video/intelfb/
3801 Index: linux-2.6.24.7/drivers/media/video/cafe_ccic.c
3802 ===================================================================
3803 --- linux-2.6.24.7.orig/drivers/media/video/cafe_ccic.c
3804 +++ linux-2.6.24.7/drivers/media/video/cafe_ccic.c
3805 @@ -372,6 +372,10 @@ static int cafe_smbus_write_data(struct
3806 rval = value | ((command << TWSIC1_ADDR_SHIFT) & TWSIC1_ADDR);
3807 cafe_reg_write(cam, REG_TWSIC1, rval);
3808 spin_unlock_irqrestore(&cam->dev_lock, flags);
3809 + mdelay(2); /* It'll probably take about 900µs anyway, and the
3810 + CAFÉ is apparently quite sensitive to being poked
3811 + at this point. If we can work out precisely what's
3812 + going on and reduce this delay, it would be nice. */
3813
3814 /*
3815 * Time to wait for the write to complete. THIS IS A RACY
3816 @@ -907,8 +911,6 @@ static int cafe_cam_configure(struct caf
3817 struct v4l2_format fmt;
3818 int ret, zero = 0;
3819
3820 - if (cam->state != S_IDLE)
3821 - return -EINVAL;
3822 fmt.fmt.pix = cam->pix_format;
3823 ret = __cafe_cam_cmd(cam, VIDIOC_INT_INIT, &zero);
3824 if (ret == 0)
3825 @@ -2237,14 +2239,18 @@ static int cafe_pci_suspend(struct pci_d
3826 int ret;
3827 enum cafe_state cstate;
3828
3829 + mutex_lock(&cam->s_mutex);
3830 ret = pci_save_state(pdev);
3831 - if (ret)
3832 + if (ret) {
3833 + cam_warn(cam, "Unable to save PCI state\n");
3834 return ret;
3835 + }
3836 cstate = cam->state; /* HACK - stop_dma sets to idle */
3837 cafe_ctlr_stop_dma(cam);
3838 cafe_ctlr_power_down(cam);
3839 pci_disable_device(pdev);
3840 cam->state = cstate;
3841 + /* hold mutex until restore */
3842 return 0;
3843 }
3844
3845 @@ -2263,16 +2269,18 @@ static int cafe_pci_resume(struct pci_de
3846 cam_warn(cam, "Unable to re-enable device on resume!\n");
3847 return ret;
3848 }
3849 + /* we're still holding mutex from suspend */
3850 cafe_ctlr_init(cam);
3851 cafe_ctlr_power_down(cam);
3852
3853 - mutex_lock(&cam->s_mutex);
3854 - if (cam->users > 0) {
3855 - cafe_ctlr_power_up(cam);
3856 - __cafe_cam_reset(cam);
3857 - }
3858 - mutex_unlock(&cam->s_mutex);
3859 -
3860 + if (cam->users > 0) {
3861 + cafe_ctlr_power_up(cam);
3862 + __cafe_cam_reset(cam);
3863 + }
3864 + else
3865 + cafe_ctlr_power_down(cam);
3866 + mutex_unlock(&cam->s_mutex);
3867 +
3868 set_bit(CF_CONFIG_NEEDED, &cam->flags);
3869 if (cam->state == S_SPECREAD)
3870 cam->state = S_IDLE; /* Don't bother restarting */
3871 Index: linux-2.6.24.7/drivers/misc/Kconfig
3872 ===================================================================
3873 --- linux-2.6.24.7.orig/drivers/misc/Kconfig
3874 +++ linux-2.6.24.7/drivers/misc/Kconfig
3875 @@ -219,6 +219,11 @@ config THINKPAD_ACPI_BAY
3876
3877 If you are not sure, say Y here.
3878
3879 +config EEPROM_93CX6
3880 + tristate "EEPROM 93CX6 support"
3881 + ---help---
3882 + This is a driver for the EEPROM chipsets 93c46 and 93c66.
3883 + The driver supports both read as well as write commands.
3884
3885 config ATMEL_SSC
3886 tristate "Device driver for Atmel SSC peripheral"
3887 Index: linux-2.6.24.7/drivers/mmc/card/block.c
3888 ===================================================================
3889 --- linux-2.6.24.7.orig/drivers/mmc/card/block.c
3890 +++ linux-2.6.24.7/drivers/mmc/card/block.c
3891 @@ -237,6 +237,13 @@ static int mmc_blk_issue_rq(struct mmc_q
3892 if (brq.data.blocks > card->host->max_blk_count)
3893 brq.data.blocks = card->host->max_blk_count;
3894
3895 + if (mmc_card_sd(card) && !card->host->ios.clock) {
3896 + printk(KERN_ERR "%s: I/O to stopped card\n",
3897 + req->rq_disk->disk_name);
3898 + goto cmd_err;
3899 + }
3900 + mmc_set_data_timeout(&brq.data, card);
3901 +
3902 /*
3903 * If the host doesn't support multiple block writes, force
3904 * block writes to single block. SD cards are excepted from
3905 Index: linux-2.6.24.7/drivers/mmc/host/sdhci.c
3906 ===================================================================
3907 --- linux-2.6.24.7.orig/drivers/mmc/host/sdhci.c
3908 +++ linux-2.6.24.7/drivers/mmc/host/sdhci.c
3909 @@ -441,6 +441,12 @@ static void sdhci_prepare_data(struct sd
3910 break;
3911 }
3912
3913 + /*
3914 + * There's an off-by-one error in the hw that we need to
3915 + * compensate for.
3916 + */
3917 + count++;
3918 +
3919 if (count >= 0xF) {
3920 printk(KERN_WARNING "%s: Too large timeout requested!\n",
3921 mmc_hostname(host->mmc));
3922 @@ -728,19 +734,17 @@ static void sdhci_set_power(struct sdhci
3923 if (!(host->chip->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
3924 writeb(0, host->ioaddr + SDHCI_POWER_CONTROL);
3925
3926 - pwr = SDHCI_POWER_ON;
3927 -
3928 switch (1 << power) {
3929 case MMC_VDD_165_195:
3930 - pwr |= SDHCI_POWER_180;
3931 + pwr = SDHCI_POWER_180;
3932 break;
3933 case MMC_VDD_29_30:
3934 case MMC_VDD_30_31:
3935 - pwr |= SDHCI_POWER_300;
3936 + pwr = SDHCI_POWER_300;
3937 break;
3938 case MMC_VDD_32_33:
3939 case MMC_VDD_33_34:
3940 - pwr |= SDHCI_POWER_330;
3941 + pwr = SDHCI_POWER_330;
3942 break;
3943 default:
3944 BUG();
3945 @@ -748,6 +752,10 @@ static void sdhci_set_power(struct sdhci
3946
3947 writeb(pwr, host->ioaddr + SDHCI_POWER_CONTROL);
3948
3949 + pwr |= SDHCI_POWER_ON;
3950 +
3951 + writeb(pwr, host->ioaddr + SDHCI_POWER_CONTROL);
3952 +
3953 out:
3954 host->power = power;
3955 }
3956 Index: linux-2.6.24.7/drivers/mtd/nand/cafe_nand.c
3957 ===================================================================
3958 --- linux-2.6.24.7.orig/drivers/mtd/nand/cafe_nand.c
3959 +++ linux-2.6.24.7/drivers/mtd/nand/cafe_nand.c
3960 @@ -11,6 +11,7 @@
3961 #undef DEBUG
3962 #include <linux/mtd/mtd.h>
3963 #include <linux/mtd/nand.h>
3964 +#include <linux/mtd/partitions.h>
3965 #include <linux/rslib.h>
3966 #include <linux/pci.h>
3967 #include <linux/delay.h>
3968 @@ -52,6 +53,7 @@
3969
3970 struct cafe_priv {
3971 struct nand_chip nand;
3972 + struct mtd_partition *parts;
3973 struct pci_dev *pdev;
3974 void __iomem *mmio;
3975 struct rs_control *rs;
3976 @@ -84,6 +86,10 @@ static unsigned int numtimings;
3977 static int timing[3];
3978 module_param_array(timing, int, &numtimings, 0644);
3979
3980 +#ifdef CONFIG_MTD_PARTITIONS
3981 +static const char *part_probes[] = { "RedBoot", NULL };
3982 +#endif
3983 +
3984 /* Hrm. Why isn't this already conditional on something in the struct device? */
3985 #define cafe_dev_dbg(dev, args...) do { if (debug) dev_dbg(dev, ##args); } while(0)
3986
3987 @@ -620,7 +626,9 @@ static int __devinit cafe_nand_probe(str
3988 {
3989 struct mtd_info *mtd;
3990 struct cafe_priv *cafe;
3991 + struct mtd_partition *parts;
3992 uint32_t ctrl;
3993 + int nr_parts;
3994 int err = 0;
3995
3996 /* Very old versions shared the same PCI ident for all three
3997 @@ -787,7 +795,18 @@ static int __devinit cafe_nand_probe(str
3998 goto out_irq;
3999
4000 pci_set_drvdata(pdev, mtd);
4001 +
4002 + /* We register the whole device first, separate from the partitions */
4003 add_mtd_device(mtd);
4004 +
4005 +#ifdef CONFIG_MTD_PARTITIONS
4006 + nr_parts = parse_mtd_partitions(mtd, part_probes, &parts, 0);
4007 + if (nr_parts > 0) {
4008 + cafe->parts = parts;
4009 + dev_info(&cafe->pdev->dev, "%d RedBoot partitions found\n", nr_parts);
4010 + add_mtd_partitions(mtd, parts, nr_parts);
4011 + }
4012 +#endif
4013 goto out;
4014
4015 out_irq:
4016 Index: linux-2.6.24.7/drivers/mtd/redboot.c
4017 ===================================================================
4018 --- linux-2.6.24.7.orig/drivers/mtd/redboot.c
4019 +++ linux-2.6.24.7/drivers/mtd/redboot.c
4020 @@ -59,16 +59,31 @@ static int parse_redboot_partitions(stru
4021 static char nullstring[] = "unallocated";
4022 #endif
4023
4024 + if ( directory < 0 ) {
4025 + offset = master->size + directory * master->erasesize;
4026 + while (master->block_isbad &&
4027 + master->block_isbad(master, offset)) {
4028 + if (!offset) {
4029 + nogood:
4030 + printk(KERN_NOTICE "Failed to find a non-bad block to check for RedBoot partition table\n");
4031 + return -EIO;
4032 + }
4033 + offset -= master->erasesize;
4034 + }
4035 + } else {
4036 + offset = directory * master->erasesize;
4037 + while (master->block_isbad &&
4038 + master->block_isbad(master, offset)) {
4039 + offset += master->erasesize;
4040 + if (offset == master->size)
4041 + goto nogood;
4042 + }
4043 + }
4044 buf = vmalloc(master->erasesize);
4045
4046 if (!buf)
4047 return -ENOMEM;
4048
4049 - if ( directory < 0 )
4050 - offset = master->size + directory*master->erasesize;
4051 - else
4052 - offset = directory*master->erasesize;
4053 -
4054 printk(KERN_NOTICE "Searching for RedBoot partition table in %s at offset 0x%lx\n",
4055 master->name, offset);
4056
4057 Index: linux-2.6.24.7/drivers/net/forcedeth.c
4058 ===================================================================
4059 --- linux-2.6.24.7.orig/drivers/net/forcedeth.c
4060 +++ linux-2.6.24.7/drivers/net/forcedeth.c
4061 @@ -3559,11 +3559,13 @@ static int nv_request_irq(struct net_dev
4062 }
4063 if (ret != 0 && np->msi_flags & NV_MSI_CAPABLE) {
4064 if ((ret = pci_enable_msi(np->pci_dev)) == 0) {
4065 + pci_intx(np->pci_dev, 0);
4066 np->msi_flags |= NV_MSI_ENABLED;
4067 dev->irq = np->pci_dev->irq;
4068 if (request_irq(np->pci_dev->irq, handler, IRQF_SHARED, dev->name, dev) != 0) {
4069 printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
4070 pci_disable_msi(np->pci_dev);
4071 + pci_intx(np->pci_dev, 1);
4072 np->msi_flags &= ~NV_MSI_ENABLED;
4073 dev->irq = np->pci_dev->irq;
4074 goto out_err;
4075 @@ -3606,6 +3608,7 @@ static void nv_free_irq(struct net_devic
4076 free_irq(np->pci_dev->irq, dev);
4077 if (np->msi_flags & NV_MSI_ENABLED) {
4078 pci_disable_msi(np->pci_dev);
4079 + pci_intx(np->pci_dev, 1);
4080 np->msi_flags &= ~NV_MSI_ENABLED;
4081 }
4082 }
4083 Index: linux-2.6.24.7/drivers/pci/quirks.c
4084 ===================================================================
4085 --- linux-2.6.24.7.orig/drivers/pci/quirks.c
4086 +++ linux-2.6.24.7/drivers/pci/quirks.c
4087 @@ -1360,6 +1360,17 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_IN
4088 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x260b, quirk_intel_pcie_pm);
4089
4090 /*
4091 + * According to Tom Sylla, the Geode does not support PCI power management
4092 + * transition, so we shouldn't need the D3hot delay.
4093 + */
4094 +static void __init quirk_geode_pci_pm(struct pci_dev *dev)
4095 +{
4096 + pci_pm_d3_delay = 0;
4097 +}
4098 +DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_LEGACY, quirk_geode_pci_pm);
4099 +DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA, quirk_geode_pci_pm);
4100 +
4101 +/*
4102 * Toshiba TC86C001 IDE controller reports the standard 8-byte BAR0 size
4103 * but the PIO transfers won't work if BAR0 falls at the odd 8 bytes.
4104 * Re-allocate the region if needed...
4105 Index: linux-2.6.24.7/drivers/power/ds2760_battery.c
4106 ===================================================================
4107 --- linux-2.6.24.7.orig/drivers/power/ds2760_battery.c
4108 +++ linux-2.6.24.7/drivers/power/ds2760_battery.c
4109 @@ -409,6 +409,7 @@ static int ds2760_battery_suspend(struct
4110 struct ds2760_device_info *di = platform_get_drvdata(pdev);
4111
4112 di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
4113 + power_supply_changed(&di->bat);
4114
4115 return 0;
4116 }
4117 Index: linux-2.6.24.7/drivers/power/olpc_battery.c
4118 ===================================================================
4119 --- linux-2.6.24.7.orig/drivers/power/olpc_battery.c
4120 +++ linux-2.6.24.7/drivers/power/olpc_battery.c
4121 @@ -14,12 +14,13 @@
4122 #include <linux/power_supply.h>
4123 #include <linux/jiffies.h>
4124 #include <linux/sched.h>
4125 +#include <asm/io.h>
4126 #include <asm/olpc.h>
4127
4128
4129 #define EC_BAT_VOLTAGE 0x10 /* uint16_t, *9.76/32, mV */
4130 #define EC_BAT_CURRENT 0x11 /* int16_t, *15.625/120, mA */
4131 -#define EC_BAT_ACR 0x12
4132 +#define EC_BAT_ACR 0x12 /* int16_t *416.667 µAh */
4133 #define EC_BAT_TEMP 0x13 /* uint16_t, *100/256, °C */
4134 #define EC_AMB_TEMP 0x14 /* uint16_t, *100/256, °C */
4135 #define EC_BAT_STATUS 0x15 /* uint8_t, bitmask */
4136 @@ -84,6 +85,8 @@ static struct power_supply olpc_ac = {
4137 .get_property = olpc_ac_get_prop,
4138 };
4139
4140 +static char bat_serial[17]; /* Ick */
4141 +
4142 /*********************************************************************
4143 * Battery properties
4144 *********************************************************************/
4145 @@ -94,6 +97,7 @@ static int olpc_bat_get_property(struct
4146 int ret = 0;
4147 int16_t ec_word;
4148 uint8_t ec_byte;
4149 + uint64_t ser_buf;
4150
4151 ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &ec_byte, 1);
4152 if (ret)
4153 @@ -127,8 +131,8 @@ static int olpc_bat_get_property(struct
4154 val->intval = POWER_SUPPLY_STATUS_FULL;
4155 else /* Not _necessarily_ true but EC doesn't tell all yet */
4156 val->intval = POWER_SUPPLY_STATUS_CHARGING;
4157 - break;
4158 }
4159 + break;
4160 case POWER_SUPPLY_PROP_PRESENT:
4161 val->intval = !!(ec_byte & BAT_STAT_PRESENT);
4162 break;
4163 @@ -249,6 +253,22 @@ static int olpc_bat_get_property(struct
4164 ec_word = be16_to_cpu(ec_word);
4165 val->intval = ec_word * 100 / 256;
4166 break;
4167 + case POWER_SUPPLY_PROP_ACCUM_CURRENT:
4168 + ret = olpc_ec_cmd(EC_BAT_ACR, NULL, 0, (void *)&ec_word, 2);
4169 + if (ret)
4170 + return ret;
4171 +
4172 + ec_word = be16_to_cpu(ec_word);
4173 + val->intval = (uint16_t)ec_word;
4174 + break;
4175 + case POWER_SUPPLY_PROP_SERIAL_NUMBER:
4176 + ret = olpc_ec_cmd(EC_BAT_SERIAL, NULL, 0, (void *)&ser_buf, 8);
4177 + if (ret)
4178 + return ret;
4179 +
4180 + sprintf(bat_serial, "%016llx", (long long)be64_to_cpu(ser_buf));
4181 + val->strval = bat_serial;
4182 + break;
4183 default:
4184 ret = -EINVAL;
4185 break;
4186 @@ -268,7 +288,51 @@ static enum power_supply_property olpc_b
4187 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
4188 POWER_SUPPLY_PROP_TEMP,
4189 POWER_SUPPLY_PROP_TEMP_AMBIENT,
4190 + POWER_SUPPLY_PROP_ACCUM_CURRENT,
4191 POWER_SUPPLY_PROP_MANUFACTURER,
4192 + POWER_SUPPLY_PROP_SERIAL_NUMBER,
4193 +};
4194 +
4195 +/* EEPROM reading goes completely around the power_supply API, sadly */
4196 +
4197 +#define EEPROM_START 0x20
4198 +#define EEPROM_END 0x80
4199 +#define EEPROM_SIZE (EEPROM_END - EEPROM_START)
4200 +
4201 +static ssize_t olpc_bat_eeprom_read(struct kobject *kobj, char *buf, loff_t off,
4202 + size_t count)
4203 +{
4204 + uint8_t ec_byte;
4205 + int ret, end;
4206 +
4207 + if (off >= EEPROM_SIZE)
4208 + return 0;
4209 + if (off + count > EEPROM_SIZE)
4210 + count = EEPROM_SIZE - off;
4211 +
4212 + end = EEPROM_START + off + count;
4213 + for (ec_byte = EEPROM_START + off; ec_byte < end; ec_byte++) {
4214 + ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1,
4215 + &buf[ec_byte - EEPROM_START], 1);
4216 + if (ret) {
4217 + printk(KERN_ERR "olpc-battery: EC command "
4218 + "EC_BAT_EEPROM @ 0x%x failed -"
4219 + " %d!\n", ec_byte, ret);
4220 + return -EIO;
4221 + }
4222 + }
4223 +
4224 + return count;
4225 +}
4226 +
4227 +static struct bin_attribute olpc_bat_eeprom = {
4228 + .attr = {
4229 + .name = "eeprom",
4230 + .mode = S_IRUGO,
4231 + .owner = THIS_MODULE,
4232 + },
4233 + .size = 0,
4234 + .read = olpc_bat_eeprom_read,
4235 };
4236
4237 /*********************************************************************
4238 @@ -299,7 +363,7 @@ static int __init olpc_bat_init(void)
4239
4240 if (!olpc_platform_info.ecver)
4241 return -ENXIO;
4242 - if (olpc_platform_info.ecver < 0x43) {
4243 + if (olpc_platform_info.ecver < 0x44) {
4244 printk(KERN_NOTICE "OLPC EC version 0x%02x too old for battery driver.\n", olpc_platform_info.ecver);
4245 return -ENXIO;
4246 }
4247 @@ -324,9 +388,15 @@ static int __init olpc_bat_init(void)
4248 if (ret)
4249 goto battery_failed;
4250
4251 + ret = device_create_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
4252 + if (ret)
4253 + goto eeprom_failed;
4254 +
4255 olpc_register_battery_callback(&olpc_battery_trigger_uevent);
4256 goto success;
4257
4258 +eeprom_failed:
4259 + power_supply_unregister(&olpc_bat);
4260 battery_failed:
4261 power_supply_unregister(&olpc_ac);
4262 ac_failed:
4263 @@ -338,6 +408,7 @@ success:
4264 static void __exit olpc_bat_exit(void)
4265 {
4266 olpc_deregister_battery_callback();
4267 + device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
4268 power_supply_unregister(&olpc_bat);
4269 power_supply_unregister(&olpc_ac);
4270 platform_device_unregister(bat_pdev);
4271 Index: linux-2.6.24.7/drivers/power/power_supply_sysfs.c
4272 ===================================================================
4273 --- linux-2.6.24.7.orig/drivers/power/power_supply_sysfs.c
4274 +++ linux-2.6.24.7/drivers/power/power_supply_sysfs.c
4275 @@ -114,9 +114,11 @@ static struct device_attribute power_sup
4276 POWER_SUPPLY_ATTR(time_to_empty_avg),
4277 POWER_SUPPLY_ATTR(time_to_full_now),
4278 POWER_SUPPLY_ATTR(time_to_full_avg),
4279 + POWER_SUPPLY_ATTR(accum_current),
4280 /* Properties of type `const char *' */
4281 POWER_SUPPLY_ATTR(model_name),
4282 POWER_SUPPLY_ATTR(manufacturer),
4283 + POWER_SUPPLY_ATTR(serial_number),
4284 };
4285
4286 static ssize_t power_supply_show_static_attrs(struct device *dev,
4287 Index: linux-2.6.24.7/drivers/serial/serial_core.c
4288 ===================================================================
4289 --- linux-2.6.24.7.orig/drivers/serial/serial_core.c
4290 +++ linux-2.6.24.7/drivers/serial/serial_core.c
4291 @@ -2013,6 +2013,7 @@ int uart_suspend_port(struct uart_driver
4292 int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
4293 {
4294 struct uart_state *state = drv->state + port->line;
4295 + struct ktermios termios;
4296
4297 mutex_lock(&state->mutex);
4298
4299 @@ -2035,20 +2036,6 @@ int uart_resume_port(struct uart_driver
4300 * Re-enable the console device after suspending.
4301 */
4302 if (uart_console(port)) {
4303 - struct ktermios termios;
4304 -
4305 - /*
4306 - * First try to use the console cflag setting.
4307 - */
4308 - memset(&termios, 0, sizeof(struct ktermios));
4309 - termios.c_cflag = port->cons->cflag;
4310 -
4311 - /*
4312 - * If that's unset, use the tty termios setting.
4313 - */
4314 - if (state->info && state->info->tty && termios.c_cflag == 0)
4315 - termios = *state->info->tty->termios;
4316 -
4317 port->ops->set_termios(port, &termios, NULL);
4318 console_start(port->cons);
4319 }
4320 Index: linux-2.6.24.7/drivers/sysprof/config.h
4321 ===================================================================
4322 --- /dev/null
4323 +++ linux-2.6.24.7/drivers/sysprof/config.h
4324 @@ -0,0 +1,23 @@
4325 +/* config.h. Generated by configure. */
4326 +/* config.h.in. Generated from configure.ac by autoheader. */
4327 +
4328 +/* Look for global separate debug info in this path */
4329 +#define DEBUGDIR "/usr/local/lib/debug"
4330 +
4331 +/* Define to 1 if you have the `iberty' library (-liberty). */
4332 +/* #undef HAVE_LIBIBERTY */
4333 +
4334 +/* Define to the address where bug reports for this package should be sent. */
4335 +#define PACKAGE_BUGREPORT ""
4336 +
4337 +/* Define to the full name of this package. */
4338 +#define PACKAGE_NAME "sysprof"
4339 +
4340 +/* Define to the full name and version of this package. */
4341 +#define PACKAGE_STRING "sysprof 1.0.8"
4342 +
4343 +/* Define to the one symbol short name of this package. */
4344 +#define PACKAGE_TARNAME "sysprof"
4345 +
4346 +/* Define to the version of this package. */
4347 +#define PACKAGE_VERSION "1.0.8"
4348 Index: linux-2.6.24.7/drivers/sysprof/Kconfig
4349 ===================================================================
4350 --- /dev/null
4351 +++ linux-2.6.24.7/drivers/sysprof/Kconfig
4352 @@ -0,0 +1,12 @@
4353 +
4354 +menu "Sysprof"
4355 +
4356 +config SYSPROF
4357 + tristate "Sysprof support"
4358 + help
4359 + Say M here to include the sysprof-module.
4360 +
4361 + Sysprof is a sampling profiler that uses a kernel module,
4362 + sysprof-module, to generate stacktraces which are then interpreted by
4363 + the userspace program "sysprof".
4364 +endmenu
4365 Index: linux-2.6.24.7/drivers/sysprof/Makefile
4366 ===================================================================
4367 --- /dev/null
4368 +++ linux-2.6.24.7/drivers/sysprof/Makefile
4369 @@ -0,0 +1 @@
4370 +obj-$(CONFIG_SYSPROF) += sysprof-module.o
4371 Index: linux-2.6.24.7/drivers/sysprof/sysprof-module.c
4372 ===================================================================
4373 --- /dev/null
4374 +++ linux-2.6.24.7/drivers/sysprof/sysprof-module.c
4375 @@ -0,0 +1,271 @@
4376 +/* -*- c-basic-offset: 8 -*- */
4377 +
4378 +/* Sysprof -- Sampling, systemwide CPU profiler
4379 + * Copyright 2004, Red Hat, Inc.
4380 + * Copyright 2004, 2005, Soeren Sandmann
4381 + *
4382 + * This program is free software; you can redistribute it and/or modify
4383 + * it under the terms of the GNU General Public License as published by
4384 + * the Free Software Foundation; either version 2 of the License, or
4385 + * (at your option) any later version.
4386 + *
4387 + * This program is distributed in the hope that it will be useful,
4388 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4389 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4390 + * GNU General Public License for more details.
4391 + *
4392 + * You should have received a copy of the GNU General Public License
4393 + * along with this program; if not, write to the Free Software
4394 + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
4395 + */
4396 +
4397 +#ifdef CONFIG_SMP
4398 +# define __SMP__
4399 +#endif
4400 +#include <asm/atomic.h>
4401 +#include <linux/kernel.h> /* Needed for KERN_ALERT */
4402 +#include <linux/module.h> /* Needed by all modules */
4403 +#include <linux/sched.h>
4404 +
4405 +#include <linux/proc_fs.h>
4406 +#include <asm/uaccess.h>
4407 +#include <linux/poll.h>
4408 +#include <linux/highmem.h>
4409 +#include <linux/pagemap.h>
4410 +#include <linux/profile.h>
4411 +
4412 +#include "sysprof-module.h"
4413 +
4414 +#include "config.h"
4415 +
4416 +#include <linux/version.h>
4417 +
4418 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
4419 +#include <linux/config.h>
4420 +#endif
4421 +
4422 +#if !CONFIG_PROFILING
4423 +# error Sysprof needs a kernel with profiling support compiled in.
4424 +#endif
4425 +
4426 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
4427 +# error Sysprof needs a Linux 2.6.11 kernel or later
4428 +#endif
4429 +#include <linux/kallsyms.h>
4430 +
4431 +MODULE_LICENSE("GPL");
4432 +MODULE_AUTHOR("Soeren Sandmann (sandmann@daimi.au.dk)");
4433 +
4434 +#define SAMPLES_PER_SECOND (200)
4435 +#define INTERVAL ((HZ <= SAMPLES_PER_SECOND)? 1 : (HZ / SAMPLES_PER_SECOND))
4436 +#define N_TRACES 256
4437 +
4438 +static SysprofStackTrace stack_traces[N_TRACES];
4439 +static SysprofStackTrace * head = &stack_traces[0];
4440 +static SysprofStackTrace * tail = &stack_traces[0];
4441 +DECLARE_WAIT_QUEUE_HEAD (wait_for_trace);
4442 +DECLARE_WAIT_QUEUE_HEAD (wait_for_exit);
4443 +
4444 +/* Macro the names of the registers that are used on each architecture */
4445 +#if defined(CONFIG_X86_64)
4446 +# define REG_FRAME_PTR rbp
4447 +# define REG_INS_PTR rip
4448 +# define REG_STACK_PTR rsp
4449 +#elif defined(CONFIG_X86)
4450 +# define REG_FRAME_PTR ebp
4451 +# define REG_INS_PTR eip
4452 +# define REG_STACK_PTR esp
4453 +#else
4454 +# error Sysprof only supports the i386 and x86-64 architectures
4455 +#endif
4456 +
4457 +typedef struct userspace_reader userspace_reader;
4458 +struct userspace_reader
4459 +{
4460 + struct task_struct *task;
4461 + unsigned long cache_address;
4462 + unsigned long *cache;
4463 +};
4464 +
4465 +typedef struct StackFrame StackFrame;
4466 +struct StackFrame {
4467 + unsigned long next;
4468 + unsigned long return_address;
4469 +};
4470 +
4471 +struct work_struct work;
4472 +
4473 +static int
4474 +read_frame (void *frame_pointer, StackFrame *frame)
4475 +{
4476 +#if 0
4477 + /* This is commented out because we seem to be called with
4478 + * (current_thread_info()->addr_limit.seg)) == 0
4479 + * which means access_ok() _always_ fails.
4480 + *
4481 + * Not sure why (or if) this isn't the case for oprofile
4482 + */
4483 + if (!access_ok(VERIFY_READ, frame_pointer, sizeof(StackFrame)))
4484 + return 1;
4485 +#endif
4486 +
4487 + if (__copy_from_user_inatomic (
4488 + frame, frame_pointer, sizeof (StackFrame)))
4489 + return 1;
4490 +
4491 + return 0;
4492 +}
4493 +
4494 +DEFINE_PER_CPU(int, n_samples);
4495 +
4496 +static int
4497 +timer_notify (struct pt_regs *regs)
4498 +{
4499 + SysprofStackTrace *trace = head;
4500 + int i;
4501 + int is_user;
4502 + static atomic_t in_timer_notify = ATOMIC_INIT(1);
4503 + int n;
4504 +
4505 + n = ++get_cpu_var(n_samples);
4506 + put_cpu_var(n_samples);
4507 +
4508 + if (n % INTERVAL != 0)
4509 + return 0;
4510 +
4511 + /* 0: locked, 1: unlocked */
4512 +
4513 + if (!atomic_dec_and_test(&in_timer_notify))
4514 + goto out;
4515 +
4516 + is_user = user_mode(regs);
4517 +
4518 + if (!current || current->pid == 0)
4519 + goto out;
4520 +
4521 + if (is_user && current->state != TASK_RUNNING)
4522 + goto out;
4523 +
4524 + if (!is_user)
4525 + {
4526 + /* kernel */
4527 +
4528 + trace->pid = current->pid;
4529 + trace->truncated = 0;
4530 + trace->n_addresses = 1;
4531 +
4532 + /* 0x1 is taken by sysprof to mean "in kernel" */
4533 + trace->addresses[0] = (void *)0x1;
4534 + }
4535 + else
4536 + {
4537 + StackFrame *frame_pointer;
4538 + StackFrame frame;
4539 + memset(trace, 0, sizeof (SysprofStackTrace));
4540 +
4541 + trace->pid = current->pid;
4542 + trace->truncated = 0;
4543 +
4544 + i = 0;
4545 +
4546 + trace->addresses[i++] = (void *)regs->REG_INS_PTR;
4547 +
4548 + frame_pointer = (void *)regs->REG_FRAME_PTR;
4549 +
4550 + while (read_frame (frame_pointer, &frame) == 0 &&
4551 + i < SYSPROF_MAX_ADDRESSES &&
4552 + (unsigned long)frame_pointer >= regs->REG_STACK_PTR)
4553 + {
4554 + trace->addresses[i++] = (void *)frame.return_address;
4555 + frame_pointer = (StackFrame *)frame.next;
4556 + }
4557 +
4558 + trace->n_addresses = i;
4559 +
4560 + if (i == SYSPROF_MAX_ADDRESSES)
4561 + trace->truncated = 1;
4562 + else
4563 + trace->truncated = 0;
4564 + }
4565 +
4566 + if (head++ == &stack_traces[N_TRACES - 1])
4567 + head = &stack_traces[0];
4568 +
4569 + wake_up (&wait_for_trace);
4570 +
4571 +out:
4572 + atomic_inc(&in_timer_notify);
4573 + return 0;
4574 +}
4575 +
4576 +static int
4577 +procfile_read(char *buffer,
4578 + char **buffer_location,
4579 + off_t offset,
4580 + int buffer_len,
4581 + int *eof,
4582 + void *data)
4583 +{
4584 + if (head == tail)
4585 + return -EWOULDBLOCK;
4586 +
4587 + *buffer_location = (char *)tail;
4588 +
4589 + BUG_ON(tail->pid == 0);
4590 +
4591 + if (tail++ == &stack_traces[N_TRACES - 1])
4592 + tail = &stack_traces[0];
4593 +
4594 + return sizeof (SysprofStackTrace);
4595 +}
4596 +
4597 +struct proc_dir_entry *trace_proc_file;
4598 +static unsigned int
4599 +procfile_poll(struct file *filp, poll_table *poll_table)
4600 +{
4601 + if (head != tail)
4602 + return POLLIN | POLLRDNORM;
4603 +
4604 + poll_wait(filp, &wait_for_trace, poll_table);
4605 +
4606 + if (head != tail)
4607 + return POLLIN | POLLRDNORM;
4608 +
4609 + return 0;
4610 +}
4611 +
4612 +int
4613 +init_module(void)
4614 +{
4615 + static struct file_operations fops;
4616 +
4617 + trace_proc_file =
4618 + create_proc_entry ("sysprof-trace", S_IFREG | S_IRUGO, &proc_root);
4619 +
4620 + if (!trace_proc_file)
4621 + return 1;
4622 +
4623 + fops = *trace_proc_file->proc_fops;
4624 + fops.poll = procfile_poll;
4625 +
4626 + trace_proc_file->read_proc = procfile_read;
4627 + trace_proc_file->proc_fops = &fops;
4628 + trace_proc_file->size = sizeof (SysprofStackTrace);
4629 +
4630 + register_timer_hook (timer_notify);
4631 +
4632 + printk(KERN_ALERT "sysprof: loaded (%s)\n", PACKAGE_VERSION);
4633 +
4634 + return 0;
4635 +}
4636 +
4637 +void
4638 +cleanup_module(void)
4639 +{
4640 + unregister_timer_hook (timer_notify);
4641 +
4642 + remove_proc_entry("sysprof-trace", &proc_root);
4643 +
4644 + printk(KERN_ALERT "sysprof: unloaded\n");
4645 +}
4646 +
4647 Index: linux-2.6.24.7/drivers/sysprof/sysprof-module.h
4648 ===================================================================
4649 --- /dev/null
4650 +++ linux-2.6.24.7/drivers/sysprof/sysprof-module.h
4651 @@ -0,0 +1,37 @@
4652 +/* Sysprof -- Sampling, systemwide CPU profiler
4653 + * Copyright 2004, Red Hat, Inc.
4654 + * Copyright 2004, 2005, Soeren Sandmann
4655 + *
4656 + * This program is free software; you can redistribute it and/or modify
4657 + * it under the terms of the GNU General Public License as published by
4658 + * the Free Software Foundation; either version 2 of the License, or
4659 + * (at your option) any later version.
4660 + *
4661 + * This program is distributed in the hope that it will be useful,
4662 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4663 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4664 + * GNU General Public License for more details.
4665 + *
4666 + * You should have received a copy of the GNU General Public License
4667 + * along with this program; if not, write to the Free Software
4668 + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
4669 + */
4670 +
4671 +#ifndef SYSPROF_MODULE_H
4672 +#define SYSPROF_MODULE_H
4673 +
4674 +typedef struct SysprofStackTrace SysprofStackTrace;
4675 +
4676 +#define SYSPROF_MAX_ADDRESSES 512
4677 +
4678 +struct SysprofStackTrace
4679 +{
4680 + int pid; /* -1 if in kernel */
4681 + int truncated;
4682 + int n_addresses; /* note: this can be 1 if the process was compiled
4683 + * with -fomit-frame-pointer or is otherwise weird
4684 + */
4685 + void *addresses[SYSPROF_MAX_ADDRESSES];
4686 +};
4687 +
4688 +#endif
4689 Index: linux-2.6.24.7/drivers/usb/core/driver.c
4690 ===================================================================
4691 --- linux-2.6.24.7.orig/drivers/usb/core/driver.c
4692 +++ linux-2.6.24.7/drivers/usb/core/driver.c
4693 @@ -1062,8 +1062,15 @@ static int usb_suspend_both(struct usb_d
4694 break;
4695 }
4696 }
4697 - if (status == 0)
4698 + if (status == 0) {
4699 +
4700 + /* Non-root devices don't need to do anything for FREEZE
4701 + * or PRETHAW. */
4702 + if (udev->parent && (msg.event == PM_EVENT_FREEZE ||
4703 + msg.event == PM_EVENT_PRETHAW))
4704 + goto done;
4705 status = usb_suspend_device(udev, msg);
4706 + }
4707
4708 /* If the suspend failed, resume interfaces that did get suspended */
4709 if (status != 0) {
4710 Index: linux-2.6.24.7/drivers/usb/core/quirks.c
4711 ===================================================================
4712 --- linux-2.6.24.7.orig/drivers/usb/core/quirks.c
4713 +++ linux-2.6.24.7/drivers/usb/core/quirks.c
4714 @@ -48,6 +48,9 @@ static const struct usb_device_id usb_qu
4715 /* SKYMEDI USB_DRIVE */
4716 { USB_DEVICE(0x1516, 0x8628), .driver_info = USB_QUIRK_RESET_RESUME },
4717
4718 + /* Philips PSC805 audio device */
4719 + { USB_DEVICE(0x0471, 0x0155), .driver_info = USB_QUIRK_RESET_RESUME },
4720 +
4721 { } /* terminating entry must be last */
4722 };
4723
4724 Index: linux-2.6.24.7/drivers/usb/core/usb.h
4725 ===================================================================
4726 --- linux-2.6.24.7.orig/drivers/usb/core/usb.h
4727 +++ linux-2.6.24.7/drivers/usb/core/usb.h
4728 @@ -41,6 +41,7 @@ extern void usb_host_cleanup(void);
4729 extern void usb_autosuspend_work(struct work_struct *work);
4730 extern int usb_port_suspend(struct usb_device *dev);
4731 extern int usb_port_resume(struct usb_device *dev);
4732 +extern int usb_reset_suspended_device(struct usb_device *udev);
4733 extern int usb_external_suspend_device(struct usb_device *udev,
4734 pm_message_t msg);
4735 extern int usb_external_resume_device(struct usb_device *udev);
4736 Index: linux-2.6.24.7/drivers/usb/host/ehci-hcd.c
4737 ===================================================================
4738 --- linux-2.6.24.7.orig/drivers/usb/host/ehci-hcd.c
4739 +++ linux-2.6.24.7/drivers/usb/host/ehci-hcd.c
4740 @@ -653,9 +653,16 @@ static irqreturn_t ehci_irq (struct usb_
4741
4742 /* complete the unlinking of some qh [4.15.2.3] */
4743 if (status & STS_IAA) {
4744 - COUNT (ehci->stats.reclaim);
4745 - ehci->reclaim_ready = 1;
4746 - bh = 1;
4747 + if (!ehci->reclaim) {
4748 + printk(KERN_WARNING "%s would set reclaim_ready with nothing to reclaim!\n", __func__);
4749 +printk(KERN_DEBUG "%s: USBCMD: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->command));
4750 +printk(KERN_DEBUG "%s: USBSTS: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->status));
4751 + WARN_ON(1);
4752 + } else {
4753 + COUNT (ehci->stats.reclaim);
4754 + ehci->reclaim_ready = 1;
4755 + bh = 1;
4756 + }
4757 }
4758
4759 /* remote wakeup [4.3.1] */
4760 Index: linux-2.6.24.7/drivers/usb/host/ehci-hub.c
4761 ===================================================================
4762 --- linux-2.6.24.7.orig/drivers/usb/host/ehci-hub.c
4763 +++ linux-2.6.24.7/drivers/usb/host/ehci-hub.c
4764 @@ -132,10 +132,15 @@ static int ehci_bus_suspend (struct usb_
4765 ehci_quiesce (ehci);
4766 hcd->state = HC_STATE_QUIESCING;
4767 }
4768 +printk(KERN_DEBUG "%s: USBCMD: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->command));
4769 +printk(KERN_DEBUG "%s: USBSTS: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->status));
4770 +
4771 ehci->command = ehci_readl(ehci, &ehci->regs->command);
4772 if (ehci->reclaim)
4773 ehci->reclaim_ready = 1;
4774 ehci_work(ehci);
4775 +printk(KERN_DEBUG "%s: USBCMD: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->command));
4776 +printk(KERN_DEBUG "%s: USBSTS: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->status));
4777
4778 /* Unlike other USB host controller types, EHCI doesn't have
4779 * any notion of "global" or bus-wide suspend. The driver has
4780 @@ -175,6 +180,9 @@ static int ehci_bus_suspend (struct usb_
4781 ehci_halt (ehci);
4782 hcd->state = HC_STATE_SUSPENDED;
4783
4784 +printk(KERN_DEBUG "%s: USBCMD: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->command));
4785 +printk(KERN_DEBUG "%s: USBSTS: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->status));
4786 +
4787 /* allow remote wakeup */
4788 mask = INTR_MASK;
4789 if (!device_may_wakeup(&hcd->self.root_hub->dev))
4790 @@ -195,6 +203,18 @@ static int ehci_bus_resume (struct usb_h
4791 u32 temp;
4792 u32 power_okay;
4793 int i;
4794 +#ifdef CONFIG_OLPC
4795 + u32 lo;
4796 + static void __iomem *usb_ehc_addr;
4797 +
4798 + rdmsrl(0x51200009, lo);
4799 + usb_ehc_addr = ioremap(lo, 256);
4800 + writel(readl(usb_ehc_addr+0x54) | 0x1000, usb_ehc_addr+0x54);
4801 + writel(readl(usb_ehc_addr+0x58) | 0x1000, usb_ehc_addr+0x58);
4802 + writel(readl(usb_ehc_addr+0x5C) | 0x1000, usb_ehc_addr+0x5C);
4803 + writel(readl(usb_ehc_addr+0x60) | 0x1000, usb_ehc_addr+0x60);
4804 + iounmap(usb_ehc_addr);
4805 +#endif
4806
4807 if (time_before (jiffies, ehci->next_statechange))
4808 msleep(5);
4809 Index: linux-2.6.24.7/drivers/usb/host/ehci-pci.c
4810 ===================================================================
4811 --- linux-2.6.24.7.orig/drivers/usb/host/ehci-pci.c
4812 +++ linux-2.6.24.7/drivers/usb/host/ehci-pci.c
4813 @@ -247,6 +247,9 @@ static int ehci_pci_suspend(struct usb_h
4814 rc = -EINVAL;
4815 goto bail;
4816 }
4817 +printk(KERN_DEBUG "%s: USBCMD: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->command));
4818 +printk(KERN_DEBUG "%s: USBSTS: 0x%x\n", __func__, ehci_readl(ehci, &ehci->regs->status));
4819 +
4820 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
4821 (void)ehci_readl(ehci, &ehci->regs->intr_enable);
4822
4823 Index: linux-2.6.24.7/drivers/usb/host/ehci-q.c
4824 ===================================================================
4825 --- linux-2.6.24.7.orig/drivers/usb/host/ehci-q.c
4826 +++ linux-2.6.24.7/drivers/usb/host/ehci-q.c
4827 @@ -177,7 +177,7 @@ static int qtd_copy_status (
4828 if (QTD_CERR (token))
4829 status = -EPIPE;
4830 else {
4831 - ehci_dbg (ehci, "devpath %s ep%d%s 3strikes\n",
4832 + printk(KERN_ERR "devpath %s ep%d%s 3strikes\n",
4833 urb->dev->devpath,
4834 usb_pipeendpoint (urb->pipe),
4835 usb_pipein (urb->pipe) ? "in" : "out");
4836 @@ -973,6 +973,11 @@ static void end_unlink_async (struct ehc
4837 struct ehci_qh *qh = ehci->reclaim;
4838 struct ehci_qh *next;
4839
4840 + if (!qh) {
4841 + printk(KERN_CRIT "%s with ehci->reclaim == NULL!\n", __func__);
4842 + WARN_ON(1);
4843 + return;
4844 + }
4845 timer_action_done (ehci, TIMER_IAA_WATCHDOG);
4846
4847 // qh->hw_next = cpu_to_hc32(qh->qh_dma);
4848 Index: linux-2.6.24.7/drivers/usb/host/ohci-pci.c
4849 ===================================================================
4850 --- linux-2.6.24.7.orig/drivers/usb/host/ohci-pci.c
4851 +++ linux-2.6.24.7/drivers/usb/host/ohci-pci.c
4852 @@ -317,6 +317,8 @@ static int ohci_pci_resume (struct usb_h
4853 /* FIXME: we should try to detect loss of VBUS power here */
4854 prepare_for_handover(hcd);
4855
4856 + /* Force the PM core to resume the root hub */
4857 + hcd_to_bus(hcd)->root_hub->dev.power.prev_state.event = PM_EVENT_ON;
4858 return 0;
4859 }
4860
4861 Index: linux-2.6.24.7/drivers/usb/storage/usb.c
4862 ===================================================================
4863 --- linux-2.6.24.7.orig/drivers/usb/storage/usb.c
4864 +++ linux-2.6.24.7/drivers/usb/storage/usb.c
4865 @@ -244,7 +244,7 @@ static int storage_pre_reset(struct usb_
4866 return 0;
4867 }
4868
4869 -static int storage_post_reset(struct usb_interface *iface)
4870 +static void storage_post_reset(struct usb_interface *iface, int reset_resume)
4871 {
4872 struct us_data *us = usb_get_intfdata(iface);
4873
4874 @@ -256,8 +256,10 @@ static int storage_post_reset(struct usb
4875 /* FIXME: Notify the subdrivers that they need to reinitialize
4876 * the device */
4877
4878 - mutex_unlock(&us->dev_mutex);
4879 - return 0;
4880 + /* If this is a reset-resume then the pre_reset routine wasn't
4881 + * called, so we don't need to unlock the mutex. */
4882 + if (!reset_resume)
4883 + mutex_unlock(&us->dev_mutex);
4884 }
4885
4886 /*
4887 Index: linux-2.6.24.7/drivers/video/fbmem.c
4888 ===================================================================
4889 --- linux-2.6.24.7.orig/drivers/video/fbmem.c
4890 +++ linux-2.6.24.7/drivers/video/fbmem.c
4891 @@ -820,6 +820,53 @@ static void try_to_load(int fb)
4892 #endif /* CONFIG_KMOD */
4893
4894 int
4895 +fb_powerup(struct fb_info *info)
4896 +{
4897 + int ret = 0;
4898 +
4899 + if (!info || info->state == FBINFO_STATE_RUNNING)
4900 + return 0;
4901 +
4902 + if (info->fbops->fb_powerup)
4903 + ret = info->fbops->fb_powerup(info);
4904 +
4905 + if (!ret) {
4906 + acquire_console_sem();
4907 + fb_set_suspend(info, 0);
4908 + release_console_sem();
4909 + }
4910 +
4911 + return ret;
4912 +}
4913 +
4914 +int
4915 +fb_powerdown(struct fb_info *info)
4916 +{
4917 + int ret = 0;
4918 +
4919 + if (!info || info->state == FBINFO_STATE_SUSPENDED)
4920 + return 0;
4921 +
4922 + /* Tell everybody that the fbdev is going down */
4923 + acquire_console_sem();
4924 + fb_set_suspend(info, 1);
4925 + release_console_sem();
4926 +
4927 + if (info->fbops->fb_powerdown)
4928 + ret = info->fbops->fb_powerdown(info);
4929 +
4930 + /* If the power down failed, then un-notify */
4931 +
4932 + if (ret) {
4933 + acquire_console_sem();
4934 + fb_set_suspend(info, 0);
4935 + release_console_sem();
4936 + }
4937 +
4938 + return ret;
4939 +}
4940 +
4941 +int
4942 fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
4943 {
4944 struct fb_fix_screeninfo *fix = &info->fix;
4945 Index: linux-2.6.24.7/drivers/video/geode/display_gx.c
4946 ===================================================================
4947 --- linux-2.6.24.7.orig/drivers/video/geode/display_gx.c
4948 +++ linux-2.6.24.7/drivers/video/geode/display_gx.c
4949 @@ -11,26 +11,44 @@
4950 * Free Software Foundation; either version 2 of the License, or * (at your
4951 * option) any later version.
4952 */
4953 +
4954 +#include <linux/kernel.h>
4955 #include <linux/spinlock.h>
4956 #include <linux/fb.h>
4957 #include <linux/delay.h>
4958 #include <asm/io.h>
4959 #include <asm/div64.h>
4960 #include <asm/delay.h>
4961 +#include <asm/olpc.h>
4962
4963 #include "geodefb.h"
4964 #include "display_gx.h"
4965
4966 -#ifdef CONFIG_FB_GEODE_GX_SET_FBSIZE
4967 -unsigned int gx_frame_buffer_size(void)
4968 +static inline void rmwl(u32 val, u32 *reg)
4969 {
4970 - return CONFIG_FB_GEODE_GX_FBSIZE;
4971 + u32 in = readl(reg);
4972 + if (in != val)
4973 + writel(val, reg);
4974 }
4975 -#else
4976 +
4977 unsigned int gx_frame_buffer_size(void)
4978 {
4979 unsigned int val;
4980
4981 +#ifdef CONFIG_OLPC
4982 + if (machine_is_olpc() && !olpc_has_vsa()) {
4983 + u32 hi,lo;
4984 + rdmsr(GLIU0_P2D_RO0, lo, hi);
4985 +
4986 + /* Top page number */
4987 + val = ((hi & 0xff) << 12) | ((lo & 0xfff00000) >> 20);
4988 +
4989 + val -= (lo & 0x000fffff); /* Subtract bottom page number */
4990 + val += 1; /* Adjust page count */
4991 + return (val << 12);
4992 + }
4993 +#endif
4994 +
4995 /* FB size is reported by a virtual register */
4996 /* Virtual register class = 0x02 */
4997 /* VG_MEM_SIZE(512Kb units) = 0x00 */
4998 @@ -41,7 +59,6 @@ unsigned int gx_frame_buffer_size(void)
4999 val = (unsigned int)(inw(0xAC1E)) & 0xFFl;
5000 return (val << 19);
5001 }
5002 -#endif
5003
5004 int gx_line_delta(int xres, int bpp)
5005 {
5006 @@ -63,23 +80,23 @@ static void gx_set_mode(struct fb_info *
5007 gcfg = readl(par->dc_regs + DC_GENERAL_CFG);
5008 dcfg = readl(par->dc_regs + DC_DISPLAY_CFG);
5009
5010 - /* Disable the timing generator. */
5011 - dcfg &= ~(DC_DCFG_TGEN);
5012 - writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
5013 -
5014 - /* Wait for pending memory requests before disabling the FIFO load. */
5015 - udelay(100);
5016 -
5017 - /* Disable FIFO load and compression. */
5018 - gcfg &= ~(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
5019 - writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
5020 -
5021 - /* Setup DCLK and its divisor. */
5022 - par->vid_ops->set_dclk(info);
5023 -
5024 - /*
5025 - * Setup new mode.
5026 - */
5027 + /* Programming the clock is costly and ugly, so avoid if if we can */
5028 +
5029 + if (par->curdclk != info->var.pixclock) {
5030 + /* Disable the timing generator. */
5031 + dcfg &= ~(DC_DCFG_TGEN);
5032 + writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
5033 +
5034 + /* Wait for pending memory requests before disabling the FIFO load. */
5035 + udelay(100);
5036 +
5037 + /* Disable FIFO load and compression. */
5038 + gcfg &= ~(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
5039 + writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
5040 +
5041 + /* Setup DCLK and its divisor. */
5042 + par->vid_ops->set_dclk(info);
5043 + }
5044
5045 /* Clear all unused feature bits. */
5046 gcfg &= DC_GCFG_YUVM | DC_GCFG_VDSE;
5047 @@ -90,12 +107,13 @@ static void gx_set_mode(struct fb_info *
5048 gcfg |= (6 << DC_GCFG_DFHPEL_POS) | (5 << DC_GCFG_DFHPSL_POS) | DC_GCFG_DFLE;
5049
5050 /* Framebuffer start offset. */
5051 - writel(0, par->dc_regs + DC_FB_ST_OFFSET);
5052 + rmwl(0, par->dc_regs + DC_FB_ST_OFFSET);
5053
5054 /* Line delta and line buffer length. */
5055 - writel(info->fix.line_length >> 3, par->dc_regs + DC_GFX_PITCH);
5056 - writel(((info->var.xres * info->var.bits_per_pixel/8) >> 3) + 2,
5057 - par->dc_regs + DC_LINE_SIZE);
5058 + rmwl(info->fix.line_length >> 3, par->dc_regs + DC_GFX_PITCH);
5059 +
5060 + rmwl(((info->var.xres * info->var.bits_per_pixel/8) >> 3) + 2,
5061 + par->dc_regs + DC_LINE_SIZE);
5062
5063
5064 /* Enable graphics and video data and unmask address lines. */
5065 @@ -134,17 +152,16 @@ static void gx_set_mode(struct fb_info *
5066 vblankend = vsyncend + info->var.upper_margin;
5067 vtotal = vblankend;
5068
5069 - writel((hactive - 1) | ((htotal - 1) << 16), par->dc_regs + DC_H_ACTIVE_TIMING);
5070 - writel((hblankstart - 1) | ((hblankend - 1) << 16), par->dc_regs + DC_H_BLANK_TIMING);
5071 - writel((hsyncstart - 1) | ((hsyncend - 1) << 16), par->dc_regs + DC_H_SYNC_TIMING);
5072 -
5073 - writel((vactive - 1) | ((vtotal - 1) << 16), par->dc_regs + DC_V_ACTIVE_TIMING);
5074 - writel((vblankstart - 1) | ((vblankend - 1) << 16), par->dc_regs + DC_V_BLANK_TIMING);
5075 - writel((vsyncstart - 1) | ((vsyncend - 1) << 16), par->dc_regs + DC_V_SYNC_TIMING);
5076 + rmwl((hactive - 1) | ((htotal - 1) << 16), par->dc_regs + DC_H_ACTIVE_TIMING);
5077 + rmwl((hblankstart - 1) | ((hblankend - 1) << 16), par->dc_regs + DC_H_BLANK_TIMING);
5078 + rmwl((hsyncstart - 1) | ((hsyncend - 1) << 16), par->dc_regs + DC_H_SYNC_TIMING);
5079 + rmwl((vactive - 1) | ((vtotal - 1) << 16), par->dc_regs + DC_V_ACTIVE_TIMING);
5080 + rmwl((vblankstart - 1) | ((vblankend - 1) << 16), par->dc_regs + DC_V_BLANK_TIMING);
5081 + rmwl((vsyncstart - 1) | ((vsyncend - 1) << 16), par->dc_regs + DC_V_SYNC_TIMING);
5082
5083 /* Write final register values. */
5084 - writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
5085 - writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
5086 + rmwl(dcfg, par->dc_regs + DC_DISPLAY_CFG);
5087 + rmwl(gcfg, par->dc_regs + DC_GENERAL_CFG);
5088
5089 par->vid_ops->configure_display(info);
5090
5091 Index: linux-2.6.24.7/drivers/video/geode/display_gx.h
5092 ===================================================================
5093 --- linux-2.6.24.7.orig/drivers/video/geode/display_gx.h
5094 +++ linux-2.6.24.7/drivers/video/geode/display_gx.h
5095 @@ -20,6 +20,9 @@ extern struct geode_dc_ops gx_dc_ops;
5096 #define GLD_MSR_CONFIG 0xC0002001
5097 #define GLD_MSR_CONFIG_DM_FP 0x40
5098
5099 +/* Used for memory dection on the OLPC */
5100 +#define GLIU0_P2D_RO0 0x10000029
5101 +
5102 /* Display controller registers */
5103
5104 #define DC_UNLOCK 0x00
5105 Index: linux-2.6.24.7/drivers/video/geode/geodefb.h
5106 ===================================================================
5107 --- linux-2.6.24.7.orig/drivers/video/geode/geodefb.h
5108 +++ linux-2.6.24.7/drivers/video/geode/geodefb.h
5109 @@ -12,6 +12,10 @@
5110 #ifndef __GEODEFB_H__
5111 #define __GEODEFB_H__
5112
5113 +#define FB_POWER_STATE_OFF 0
5114 +#define FB_POWER_STATE_SUSPEND 1
5115 +#define FB_POWER_STATE_ON 2
5116 +
5117 struct geodefb_info;
5118
5119 struct geode_dc_ops {
5120 @@ -21,18 +25,24 @@ struct geode_dc_ops {
5121
5122 struct geode_vid_ops {
5123 void (*set_dclk)(struct fb_info *);
5124 + unsigned int (*get_dclk)(struct fb_info *);
5125 void (*configure_display)(struct fb_info *);
5126 int (*blank_display)(struct fb_info *, int blank_mode);
5127 };
5128
5129 struct geodefb_par {
5130 int enable_crt;
5131 + int fbactive; /* True if the current console is in KD_GRAPHICS mode */
5132 int panel_x; /* dimensions of an attached flat panel, non-zero => enable panel */
5133 int panel_y;
5134 + unsigned int curdclk; /* Used by GX to avoid unnessesary clock switching */
5135 void __iomem *dc_regs;
5136 void __iomem *vid_regs;
5137 + void __iomem *gp_regs;
5138 struct geode_dc_ops *dc_ops;
5139 struct geode_vid_ops *vid_ops;
5140 +
5141 + int state;
5142 };
5143
5144 #endif /* !__GEODEFB_H__ */
5145 Index: linux-2.6.24.7/drivers/video/geode/geode_regs.h
5146 ===================================================================
5147 --- /dev/null
5148 +++ linux-2.6.24.7/drivers/video/geode/geode_regs.h
5149 @@ -0,0 +1,255 @@
5150 +/* This header file defines the registers and suspend/resume
5151 + structures for the Geode GX and LX. The lxfb driver defines
5152 + _GEODELX_ before including this file, which will unlock the
5153 + extra registers that are only valid for LX.
5154 +*/
5155 +
5156 +#ifndef _GEODE_REGS_H_
5157 +#define _GEODE_REGS_H_
5158 +
5159 +/* MSRs */
5160 +
5161 +#define GX_VP_MSR_PAD_SELECT 0xC0002011
5162 +#define LX_VP_MSR_PAD_SELECT 0x48000011
5163 +
5164 +#define GEODE_MSR_GLCP_DOTPLL 0x4c000015
5165 +
5166 +#define GLCP_DOTPLL_RESET (1 << 0)
5167 +#define GLCP_DOTPLL_BYPASS (1 << 15)
5168 +#define GLCP_DOTPLL_HALFPIX (1 << 24)
5169 +#define GLCP_DOTPLL_LOCK (1 << 25)
5170 +
5171 +/* Registers */
5172 +#define VP_FP_START 0x400
5173 +
5174 +
5175 +#ifdef _GEODELX_
5176 +
5177 +#define GP_REG_SIZE 0x7C
5178 +#define DC_REG_SIZE 0xF0
5179 +#define VP_REG_SIZE 0x158
5180 +#define FP_REG_SIZE 0x70
5181 +
5182 +#else
5183 +
5184 +#define GP_REG_SIZE 0x50
5185 +#define DC_REG_SIZE 0x90
5186 +#define VP_REG_SIZE 0x138
5187 +#define FP_REG_SIZE 0x70
5188 +
5189 +#endif
5190 +
5191 +#define DC_PAL_SIZE 0x105
5192 +#define VP_COEFF_COUNT 512
5193 +#define DC_HFILT_SIZE 256
5194 +#define DC_VFILT_SIZE 256
5195 +
5196 +struct geoderegs {
5197 +
5198 + struct {
5199 + u64 padsel;
5200 + u64 dotpll;
5201 +
5202 +#ifdef _GEODELX_
5203 + u64 dfglcfg;
5204 + u64 dcspare;
5205 +#else
5206 + u64 rstpll;
5207 +#endif
5208 + } msr;
5209 +
5210 + union {
5211 + unsigned char b[GP_REG_SIZE];
5212 + struct {
5213 + u32 dst_offset; /* 0x00 */
5214 + u32 src_offset; /* 0x04 */
5215 + u32 stride; /* 0x08 */
5216 + u32 wid_height; /* 0x0C */
5217 + u32 src_color_fg; /* 0x10 */
5218 + u32 src_color_bg; /* 0x14 */
5219 + u32 pat_color_0; /* 0x18 */
5220 + u32 pat_color_1; /* 0x1C */
5221 + u32 pat_color_2; /* 0x20 */
5222 + u32 pat_color_3; /* 0x24 */
5223 + u32 pat_color_4; /* 0x28 */
5224 + u32 pat_color_5; /* 0x2C */
5225 + u32 pat_data_0; /* 0x30 */
5226 + u32 pat_data_1; /* 0x34 */
5227 + u32 raster_mode; /* 0x38 */
5228 + u32 vector_mode; /* 0x3C */
5229 + u32 blt_mode; /* 0x40 */
5230 + u32 blit_status; /* 0x4C */
5231 + u32 hst_src; /* 0x48 */
5232 + u32 base_offset; /* 0x4C */
5233 +
5234 +#ifdef _GEODELX_
5235 + u32 cmd_top; /* 0x50 */
5236 + u32 cmd_bot; /* 0x54 */
5237 + u32 cmd_read; /* 0x58 */
5238 + u32 cmd_write; /* 0x5C */
5239 + u32 ch3_offset; /* 0x60 */
5240 + u32 ch3_mode_str; /* 0x64 */
5241 + u32 ch3_width; /* 0x68 */
5242 + u32 ch3_hsrc; /* 0x6C */
5243 + u32 lut_index; /* 0x70 */
5244 + u32 lut_data; /* 0x74 */
5245 + u32 int_cntrl; /* 0x78 */
5246 +#endif
5247 + } r;
5248 + } gp;
5249 +
5250 + union {
5251 + unsigned char b[DC_REG_SIZE];
5252 +
5253 + struct {
5254 + u32 unlock; /* 0x00 */
5255 + u32 gcfg; /* 0x04 */
5256 + u32 dcfg; /* 0x08 */
5257 + u32 arb; /* 0x0C */
5258 + u32 fb_st_offset; /* 0x10 */
5259 + u32 cb_st_offset; /* 0x14 */
5260 + u32 curs_st_offset; /* 0x18 */
5261 + u32 icon_st_offset; /* 0x1C */
5262 + u32 vid_y_st_offset; /* 0x20 */
5263 + u32 vid_u_st_offset; /* 0x24 */
5264 + u32 vid_v_st_offset; /* 0x28 */
5265 + u32 dctop; /* 0x2c */
5266 + u32 line_size; /* 0x30 */
5267 + u32 gfx_pitch; /* 0x34 */
5268 + u32 vid_yuv_pitch; /* 0x38 */
5269 + u32 rsvd2; /* 0x3C */
5270 + u32 h_active_timing; /* 0x40 */
5271 + u32 h_blank_timing; /* 0x44 */
5272 + u32 h_sync_timing; /* 0x48 */
5273 + u32 rsvd3; /* 0x4C */
5274 + u32 v_active_timing; /* 0x50 */
5275 + u32 v_blank_timing; /* 0x54 */
5276 + u32 v_sync_timing; /* 0x58 */
5277 + u32 fbactive; /* 0x5C */
5278 + u32 dc_cursor_x; /* 0x60 */
5279 + u32 dc_cursor_y; /* 0x64 */
5280 + u32 dc_icon_x; /* 0x68 */
5281 + u32 dc_line_cnt; /* 0x6C */
5282 + u32 rsvd5; /* 0x70 - palette address */
5283 + u32 rsvd6; /* 0x74 - palette data */
5284 + u32 dfifo_diag; /* 0x78 */
5285 + u32 cfifo_diag; /* 0x7C */
5286 + u32 dc_vid_ds_delta; /* 0x80 */
5287 + u32 gliu0_mem_offset; /* 0x84 */
5288 + u32 dv_ctl; /* 0x88 - added by LX */
5289 + u32 dv_acc; /* 0x8C */
5290 +
5291 +#ifdef _GEODELX_
5292 + u32 gfx_scale;
5293 + u32 irq_filt_ctl;
5294 + u32 filt_coeff1;
5295 + u32 filt_coeff2;
5296 + u32 vbi_event_ctl;
5297 + u32 vbi_odd_ctl;
5298 + u32 vbi_hor;
5299 + u32 vbi_ln_odd;
5300 + u32 vbi_ln_event;
5301 + u32 vbi_pitch;
5302 + u32 clr_key;
5303 + u32 clr_key_mask;
5304 + u32 clr_key_x;
5305 + u32 clr_key_y;
5306 + u32 irq;
5307 + u32 rsvd8;
5308 + u32 genlk_ctrl;
5309 + u32 vid_even_y_st_offset; /* 0xD8 */
5310 + u32 vid_even_u_st_offset; /* 0xDC */
5311 + u32 vid_even_v_st_offset; /* 0xE0 */
5312 + u32 v_active_even_timing; /* 0xE4 */
5313 + u32 v_blank_even_timing; /* 0xE8 */
5314 + u32 v_sync_even_timing; /* 0xEC */
5315 +#endif
5316 + } r;
5317 + } dc;
5318 +
5319 + union {
5320 + unsigned char b[VP_REG_SIZE];
5321 +
5322 + struct {
5323 + u64 vcfg; /* 0x00 */
5324 + u64 dcfg; /* 0x08 */
5325 + u64 vx; /* 0x10 */
5326 + u64 vy; /* 0x18 */
5327 + u64 vs; /* 0x20 */
5328 + u64 vck; /* 0x28 */
5329 + u64 vcm; /* 0x30 */
5330 + u64 rsvd1; /* 0x38 - Gamma address*/
5331 + u64 rsvd2; /* 0x40 - Gamma data*/
5332 + u64 slr; /* 0x48 - LX only*/
5333 + u64 misc; /* 0x50 */
5334 + u64 ccs; /* 0x58 */
5335 + u64 vys; /* 0x60 */
5336 + u64 vxs; /* 0x68 */
5337 + u64 rsvd4; /* 0x70 */
5338 + u64 vdc; /* 0x78 */
5339 + u64 vco; /* 0x80 */
5340 + u64 crc; /* 0x88 */
5341 + u64 crc32; /* 0x90 */
5342 + u64 vde; /* 0x98 */
5343 + u64 cck; /* 0xA0 */
5344 + u64 ccm; /* 0xA8 */
5345 + u64 cc1; /* 0xB0 */
5346 + u64 cc2; /* 0xB8 */
5347 + u64 a1x; /* 0xC0 */
5348 + u64 a1y; /* 0xC8 */
5349 + u64 a1c; /* 0xD0 */
5350 + u64 a1t; /* 0xD8 */
5351 + u64 a2x; /* 0xE0 */
5352 + u64 a2y; /* 0xE8 */
5353 + u64 a2c; /* 0xF0 */
5354 + u64 a2t; /* 0xF8 */
5355 + u64 a3x; /* 0x100 */
5356 + u64 a3y; /* 0x108 */
5357 + u64 a3c; /* 0x110 */
5358 + u64 a3t; /* 0x118 */
5359 + u64 vrr; /* 0x120 */
5360 + u64 awt; /* 0x128 */
5361 + u64 vtm; /* 0x130 */
5362 +#ifdef _GEODELX_
5363 + u64 vye; /* 0x138 */
5364 + u64 a1ye; /* 0x140 */
5365 + u32 a2ye; /* 0x148 */
5366 + u32 a3ye; /* 0x150 */
5367 +#endif
5368 + } r;
5369 + } vp;
5370 +
5371 + union {
5372 + unsigned char b[FP_REG_SIZE];
5373 +
5374 + struct {
5375 + u64 pt1; /* 0x400 */
5376 + u64 pt2; /* 0x408 */
5377 + u64 pm; /* 0x410 */
5378 + u64 dfc; /* 0x418 */
5379 + u64 blfsr; /* 0x420 */
5380 + u64 rlfsr; /* 0x428 */
5381 + u64 fmi; /* 0x430 */
5382 + u64 fmd; /* 0x438 */
5383 + u64 rsvd; /* 0x440 */
5384 + u64 dca; /* 0x448 */
5385 + u64 dmd; /* 0x450 */
5386 + u64 crc; /* 0x458 */
5387 + u64 fbb; /* 0x460 */
5388 + u64 crc32; /* 0x468 */
5389 + } r;
5390 + } fp;
5391 +
5392 + u32 pal[DC_PAL_SIZE];
5393 + u32 gamma[256];
5394 +
5395 +#ifdef _GEODELX_
5396 +
5397 + u32 hcoeff[DC_HFILT_SIZE * 2];
5398 + u32 vcoeff[DC_VFILT_SIZE];
5399 +
5400 + u32 vp_coeff[VP_COEFF_COUNT];
5401 +#endif
5402 +};
5403 +
5404 +#endif
5405 Index: linux-2.6.24.7/drivers/video/geode/gxfb_core.c
5406 ===================================================================
5407 --- linux-2.6.24.7.orig/drivers/video/geode/gxfb_core.c
5408 +++ linux-2.6.24.7/drivers/video/geode/gxfb_core.c
5409 @@ -30,12 +30,31 @@
5410 #include <linux/fb.h>
5411 #include <linux/init.h>
5412 #include <linux/pci.h>
5413 +#include <linux/notifier.h>
5414 +#include <linux/vt_kern.h>
5415 +#include <linux/console.h>
5416 +#include <asm/uaccess.h>
5417 +#include <asm/olpc.h>
5418
5419 #include "geodefb.h"
5420 #include "display_gx.h"
5421 #include "video_gx.h"
5422
5423 +#define FBIOSGAMMA _IOW('F', 0x20, void *)
5424 +#define FBIOGGAMMA _IOW('F', 0x21, void *)
5425 +
5426 +#ifdef DEBUG
5427 +
5428 +#define FBIODUMPGP _IOW('F', 0x22, void *)
5429 +#define FBIODUMPDC _IOW('F', 0x23, void *)
5430 +#define FBIODUMPVP _IOW('F', 0x24, void *)
5431 +#define FBIODUMPFP _IOW('F', 0x25, void *)
5432 +
5433 +#endif
5434 +
5435 static char *mode_option;
5436 +static int noclear;
5437 +struct fb_info *gxfb_info;
5438
5439 /* Modes relevant to the GX (taken from modedb.c) */
5440 static const struct fb_videomode gx_modedb[] __initdata = {
5441 @@ -103,8 +122,20 @@ static const struct fb_videomode gx_mode
5442 { NULL, 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3,
5443 FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5444 FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5445 + /* 1200x900-75 - CRT timings for the OLPC mode */
5446 + { NULL, 75, 1200, 900, 8049, 104, 240, 29, 54, 136, 3,
5447 + 0, FB_VMODE_NONINTERLACED, 0 }
5448 };
5449
5450 +#ifdef CONFIG_OLPC
5451 +static const struct fb_videomode gx_dcon_modedb[] __initdata = {
5452 + /* The only mode the DCON has is 1200x900 */
5453 + { NULL, 50, 1200, 900, 17460, 24, 8, 4, 5, 8, 3,
5454 + 0, FB_VMODE_NONINTERLACED, 0 }
5455 +};
5456 +#endif
5457 +
5458 +
5459 static int gxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
5460 {
5461 if (var->xres > 1600 || var->yres > 1200)
5462 @@ -137,7 +168,7 @@ static int gxfb_check_var(struct fb_var_
5463 return 0;
5464 }
5465
5466 -static int gxfb_set_par(struct fb_info *info)
5467 +int gxfb_set_par(struct fb_info *info)
5468 {
5469 struct geodefb_par *par = info->par;
5470
5471 @@ -204,16 +235,26 @@ static int gxfb_blank(int blank_mode, st
5472 return par->vid_ops->blank_display(info, blank_mode);
5473 }
5474
5475 +static int fbsize;
5476 +
5477 static int __init gxfb_map_video_memory(struct fb_info *info, struct pci_dev *dev)
5478 {
5479 struct geodefb_par *par = info->par;
5480 - int fb_len;
5481 int ret;
5482
5483 ret = pci_enable_device(dev);
5484 if (ret < 0)
5485 return ret;
5486
5487 + ret = pci_request_region(dev, 1, "gxfb (graphics processor)");
5488 + if (ret < 0)
5489 + return ret;
5490 +
5491 + par->gp_regs = ioremap(pci_resource_start(dev, 1),
5492 + pci_resource_len(dev, 1));
5493 + if (!par->gp_regs)
5494 + return -ENOMEM;
5495 +
5496 ret = pci_request_region(dev, 3, "gxfb (video processor)");
5497 if (ret < 0)
5498 return ret;
5499 @@ -232,36 +273,118 @@ static int __init gxfb_map_video_memory(
5500 ret = pci_request_region(dev, 0, "gxfb (framebuffer)");
5501 if (ret < 0)
5502 return ret;
5503 - if ((fb_len = gx_frame_buffer_size()) < 0)
5504 - return -ENOMEM;
5505 +
5506 + /* If the fbsize wasn't specified then try to probe it */
5507 +
5508 + if (!fbsize) {
5509 + fbsize = gx_frame_buffer_size();
5510 + if (fbsize == 0)
5511 + return -ENOMEM;
5512 + }
5513 +
5514 info->fix.smem_start = pci_resource_start(dev, 0);
5515 - info->fix.smem_len = fb_len;
5516 + info->fix.smem_len = fbsize;
5517 info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
5518 if (!info->screen_base)
5519 return -ENOMEM;
5520
5521 - /* Set the 16MB aligned base address of the graphics memory region
5522 + /* Set the 16MiB aligned base address of the graphics memory region
5523 * in the display controller */
5524
5525 writel(info->fix.smem_start & 0xFF000000,
5526 par->dc_regs + DC_GLIU0_MEM_OFFSET);
5527
5528 - dev_info(&dev->dev, "%d Kibyte of video memory at 0x%lx\n",
5529 + dev_info(&dev->dev, "%d KiB of video memory at 0x%lx\n",
5530 info->fix.smem_len / 1024, info->fix.smem_start);
5531
5532 return 0;
5533 }
5534
5535 +static int gxfb_ioctl( struct fb_info *info, unsigned int cmd,
5536 + unsigned long arg)
5537 +{
5538 + unsigned int gamma[GXFB_GAMMA_DWORDS];
5539 + int ret = -EINVAL;
5540 + struct geodefb_par *par = info->par;
5541 + int i;
5542 +
5543 + switch(cmd) {
5544 + case FBIOSGAMMA:
5545 + /* Read the gamma information from the user - 256 dwords */
5546 +
5547 + if (copy_from_user(gamma, (void * __user) arg, GXFB_GAMMA_SIZE))
5548 + return -EFAULT;
5549 +
5550 + writel(0, par->vid_regs + GX_GAR);
5551 +
5552 + /* Sequential writes to the data register will increment the
5553 + address automatically */
5554 +
5555 + for(i = 0; i < GXFB_GAMMA_DWORDS; i++)
5556 + writel(gamma[i] & 0xFFFFFF, par->vid_regs + GX_GDR);
5557 +
5558 + writel(readl(par->vid_regs + GX_MISC) & ~GX_MISC_GAM_EN,
5559 + par->vid_regs + GX_MISC);
5560 +
5561 + ret = 0;
5562 + break;
5563 +
5564 + case FBIOGGAMMA:
5565 + if (readl(par->vid_regs + GX_MISC) & GX_MISC_GAM_EN)
5566 + return -EINVAL;
5567 +
5568 + memset(gamma, 0, GXFB_GAMMA_SIZE);
5569 + writel(0, par->vid_regs + GX_GAR);
5570 +
5571 + for(i = 0; i < GXFB_GAMMA_DWORDS;i++)
5572 + gamma[i] = readl(par->vid_regs + GX_GDR);
5573 +
5574 + if (copy_to_user((void * __user) arg, gamma, GXFB_GAMMA_SIZE))
5575 + ret = -EFAULT;
5576 + else
5577 + ret = 0;
5578 +
5579 + break;
5580 +
5581 +#ifdef DEBUG
5582 + case FBIODUMPGP:
5583 + ret = 0;
5584 + dump_regs(info, 0);
5585 + break;
5586 +
5587 + case FBIODUMPDC:
5588 + ret = 0;
5589 + dump_regs(info, 1);
5590 + break;
5591 +
5592 + case FBIODUMPVP:
5593 + ret = 0;
5594 + dump_regs(info, 2);
5595 + break;
5596 +
5597 + case FBIODUMPFP:
5598 + ret = 0;
5599 + dump_regs(info, 3);
5600 + break;
5601 +#endif
5602 + }
5603 +
5604 + return ret;
5605 +}
5606 +
5607 static struct fb_ops gxfb_ops = {
5608 .owner = THIS_MODULE,
5609 .fb_check_var = gxfb_check_var,
5610 .fb_set_par = gxfb_set_par,
5611 .fb_setcolreg = gxfb_setcolreg,
5612 .fb_blank = gxfb_blank,
5613 + .fb_ioctl = gxfb_ioctl,
5614 /* No HW acceleration for now. */
5615 .fb_fillrect = cfb_fillrect,
5616 .fb_copyarea = cfb_copyarea,
5617 .fb_imageblit = cfb_imageblit,
5618 + .fb_powerdown = gxfb_powerdown,
5619 + .fb_powerup = gxfb_powerup,
5620 };
5621
5622 static struct fb_info * __init gxfb_init_fbinfo(struct device *dev)
5623 @@ -303,23 +426,86 @@ static struct fb_info * __init gxfb_init
5624 return info;
5625 }
5626
5627 -static int __init gxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5628 +static int gxfb_console_notify(struct notifier_block *self,
5629 + unsigned long action, void *data)
5630 +{
5631 + if (gxfb_info != NULL) {
5632 + struct geodefb_par *par = gxfb_info->par;
5633 + par->fbactive = (action == CONSOLE_EVENT_SWITCH_TEXT) ? 0 : 1;
5634 + }
5635 +
5636 + return NOTIFY_OK;
5637 +}
5638 +
5639 +static struct notifier_block gxfb_console_notifier = {
5640 + .notifier_call = gxfb_console_notify
5641 +};
5642 +
5643 +#ifdef CONFIG_PM
5644 +
5645 +static int gxfb_suspend(struct pci_dev *pdev, pm_message_t state)
5646 +{
5647 + struct fb_info *info = pci_get_drvdata(pdev);
5648 + struct geodefb_par *par = info->par;
5649 +
5650 + if (pdev->dev.power.power_state.event == state.event)
5651 + return 0;
5652 +
5653 + if (state.event == PM_EVENT_SUSPEND) {
5654 +
5655 + acquire_console_sem();
5656 + gxfb_powerdown(info);
5657 +
5658 + par->state = FB_POWER_STATE_OFF;
5659 + fb_set_suspend(info, 1);
5660 +
5661 + release_console_sem();
5662 + }
5663 +
5664 + pdev->dev.power.power_state = state;
5665 + return 0;
5666 +}
5667 +
5668 +static int gxfb_resume(struct pci_dev *pdev)
5669 +{
5670 + struct fb_info *info = pci_get_drvdata(pdev);
5671 +
5672 + acquire_console_sem();
5673 +
5674 + /* Turn the engine completely on */
5675 +
5676 + if (gxfb_powerup(info))
5677 + printk(KERN_ERR "gxfb: Powerup failed\n");
5678 +
5679 + fb_set_suspend(info, 0);
5680 + release_console_sem();
5681 +
5682 + pdev->dev.power.power_state = PMSG_ON;
5683 + return 0;
5684 +}
5685 +#endif
5686 +
5687 +static int __init gxfb_probe(struct pci_dev *pdev,
5688 + const struct pci_device_id *id)
5689 {
5690 struct geodefb_par *par;
5691 - struct fb_info *info;
5692 int ret;
5693 unsigned long val;
5694
5695 - info = gxfb_init_fbinfo(&pdev->dev);
5696 - if (!info)
5697 + struct fb_videomode *modedb_ptr;
5698 + int modedb_size;
5699 +
5700 + gxfb_info = gxfb_init_fbinfo(&pdev->dev);
5701 + if (gxfb_info == NULL)
5702 return -ENOMEM;
5703 - par = info->par;
5704 +
5705 + par = gxfb_info->par;
5706
5707 /* GX display controller and GX video device. */
5708 par->dc_ops = &gx_dc_ops;
5709 par->vid_ops = &gx_vid_ops;
5710
5711 - if ((ret = gxfb_map_video_memory(info, pdev)) < 0) {
5712 + if ((ret = gxfb_map_video_memory(gxfb_info, pdev)) < 0) {
5713 dev_err(&pdev->dev, "failed to map frame buffer or controller registers\n");
5714 goto err;
5715 }
5716 @@ -333,32 +519,60 @@ static int __init gxfb_probe(struct pci_
5717 else
5718 par->enable_crt = 1;
5719
5720 - ret = fb_find_mode(&info->var, info, mode_option,
5721 - gx_modedb, ARRAY_SIZE(gx_modedb), NULL, 16);
5722 + /* Get the current dotclock */
5723 +
5724 + par->curdclk = (par->vid_ops->get_dclk) ? par->vid_ops->get_dclk(gxfb_info) : 0;
5725 +
5726 + /* We need to determine a display mode right now, so we will
5727 + * check to see if the DCON was previously detected by the BIOS
5728 + * and use that to make our mode database decision.
5729 + */
5730 +
5731 + modedb_ptr = (struct fb_videomode *) gx_modedb;
5732 + modedb_size = ARRAY_SIZE(gx_modedb);
5733 +
5734 +#ifdef CONFIG_OLPC
5735 + if (olpc_has_dcon()) {
5736 + modedb_ptr = (struct fb_videomode *) gx_dcon_modedb;
5737 + modedb_size = ARRAY_SIZE(gx_dcon_modedb);
5738 + }
5739 +#endif
5740 +
5741 + ret = fb_find_mode(&gxfb_info->var, gxfb_info, mode_option,
5742 + modedb_ptr, modedb_size, NULL, 16);
5743 +
5744 if (ret == 0 || ret == 4) {
5745 dev_err(&pdev->dev, "could not find valid video mode\n");
5746 ret = -EINVAL;
5747 goto err;
5748 }
5749
5750 + /* Clear the screen of garbage, unless noclear was specified,
5751 + * in which case we assume the user knows what he is doing */
5752 +
5753 + if (!noclear)
5754 + memset_io(gxfb_info->screen_base, 0, gxfb_info->fix.smem_len);
5755 +
5756 + gxfb_check_var(&gxfb_info->var, gxfb_info);
5757 + gxfb_set_par(gxfb_info);
5758 +
5759 + /* We are powered up */
5760 + par->state = FB_POWER_STATE_ON;
5761
5762 - /* Clear the frame buffer of garbage. */
5763 - memset_io(info->screen_base, 0, info->fix.smem_len);
5764
5765 - gxfb_check_var(&info->var, info);
5766 - gxfb_set_par(info);
5767 + console_event_register(&gxfb_console_notifier);
5768
5769 - if (register_framebuffer(info) < 0) {
5770 + if (register_framebuffer(gxfb_info) < 0) {
5771 ret = -EINVAL;
5772 goto err;
5773 }
5774 - pci_set_drvdata(pdev, info);
5775 - printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
5776 + pci_set_drvdata(pdev, gxfb_info);
5777 + printk(KERN_INFO "fb%d: %s frame buffer device\n", gxfb_info->node, gxfb_info->fix.id);
5778 return 0;
5779
5780 err:
5781 - if (info->screen_base) {
5782 - iounmap(info->screen_base);
5783 + if (gxfb_info->screen_base) {
5784 + iounmap(gxfb_info->screen_base);
5785 pci_release_region(pdev, 0);
5786 }
5787 if (par->vid_regs) {
5788 @@ -370,8 +584,9 @@ static int __init gxfb_probe(struct pci_
5789 pci_release_region(pdev, 2);
5790 }
5791
5792 - if (info)
5793 - framebuffer_release(info);
5794 + if (gxfb_info)
5795 + framebuffer_release(gxfb_info);
5796 +
5797 return ret;
5798 }
5799
5800 @@ -397,9 +612,7 @@ static void gxfb_remove(struct pci_dev *
5801 }
5802
5803 static struct pci_device_id gxfb_id_table[] = {
5804 - { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_GX_VIDEO,
5805 - PCI_ANY_ID, PCI_ANY_ID, PCI_BASE_CLASS_DISPLAY << 16,
5806 - 0xff0000, 0 },
5807 + { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_GX_VIDEO) },
5808 { 0, }
5809 };
5810
5811 @@ -410,22 +623,30 @@ static struct pci_driver gxfb_driver = {
5812 .id_table = gxfb_id_table,
5813 .probe = gxfb_probe,
5814 .remove = gxfb_remove,
5815 +#ifdef CONFIG_PM
5816 + .suspend = gxfb_suspend,
5817 + .resume = gxfb_resume
5818 +#endif
5819 };
5820
5821 #ifndef MODULE
5822 -static int __init gxfb_setup(char *options)
5823 -{
5824 +static int __init gxfb_setup(char *options) {
5825
5826 char *opt;
5827
5828 if (!options || !*options)
5829 return 0;
5830
5831 - while ((opt = strsep(&options, ",")) != NULL) {
5832 + while((opt = strsep(&options, ",")) != NULL) {
5833 if (!*opt)
5834 continue;
5835
5836 - mode_option = opt;
5837 + if (!strncmp(opt, "fbsize:", 7))
5838 + fbsize = simple_strtoul(opt+7, NULL, 0);
5839 + else if (!strcmp(opt, "noclear"))
5840 + noclear = 1;
5841 + else
5842 + mode_option = opt;
5843 }
5844
5845 return 0;
5846 @@ -444,7 +665,6 @@ static int __init gxfb_init(void)
5847 #endif
5848 return pci_register_driver(&gxfb_driver);
5849 }
5850 -
5851 static void __exit gxfb_cleanup(void)
5852 {
5853 pci_unregister_driver(&gxfb_driver);
5854 @@ -456,5 +676,8 @@ module_exit(gxfb_cleanup);
5855 module_param(mode_option, charp, 0);
5856 MODULE_PARM_DESC(mode_option, "video mode (<x>x<y>[-<bpp>][@<refr>])");
5857
5858 +module_param(fbsize, int, 0);
5859 +MODULE_PARM_DESC(fbsize, "video memory size");
5860 +
5861 MODULE_DESCRIPTION("Framebuffer driver for the AMD Geode GX");
5862 MODULE_LICENSE("GPL");
5863 Index: linux-2.6.24.7/drivers/video/geode/Kconfig
5864 ===================================================================
5865 --- linux-2.6.24.7.orig/drivers/video/geode/Kconfig
5866 +++ linux-2.6.24.7/drivers/video/geode/Kconfig
5867 @@ -38,26 +38,6 @@ config FB_GEODE_GX
5868
5869 If unsure, say N.
5870
5871 -config FB_GEODE_GX_SET_FBSIZE
5872 - bool "Manually specify the Geode GX framebuffer size"
5873 - depends on FB_GEODE_GX
5874 - default n
5875 - ---help---
5876 - If you want to manually specify the size of your GX framebuffer,
5877 - say Y here, otherwise say N to dynamically probe it.
5878 -
5879 - Say N unless you know what you are doing.
5880 -
5881 -config FB_GEODE_GX_FBSIZE
5882 - hex "Size of the GX framebuffer, in bytes"
5883 - depends on FB_GEODE_GX_SET_FBSIZE
5884 - default "0x1600000"
5885 - ---help---
5886 - Specify the size of the GX framebuffer. Normally, you will
5887 - want this to be MB aligned. Common values are 0x80000 (8MB)
5888 - and 0x1600000 (16MB). Don't change this unless you know what
5889 - you are doing
5890 -
5891 config FB_GEODE_GX1
5892 tristate "AMD Geode GX1 framebuffer support (EXPERIMENTAL)"
5893 depends on FB && FB_GEODE && EXPERIMENTAL
5894 Index: linux-2.6.24.7/drivers/video/geode/lxfb_core.c
5895 ===================================================================
5896 --- linux-2.6.24.7.orig/drivers/video/geode/lxfb_core.c
5897 +++ linux-2.6.24.7/drivers/video/geode/lxfb_core.c
5898 @@ -21,7 +21,8 @@
5899 #include <linux/fb.h>
5900 #include <linux/init.h>
5901 #include <linux/pci.h>
5902 -#include <linux/uaccess.h>
5903 +#include <asm/uaccess.h>
5904 +#include <asm/olpc.h>
5905
5906 #include "lxfb.h"
5907
5908 @@ -35,186 +36,84 @@ static int fbsize;
5909 */
5910
5911 const struct fb_videomode geode_modedb[] __initdata = {
5912 - /* 640x480-60 */
5913 - { NULL, 60, 640, 480, 39682, 48, 8, 25, 2, 88, 2,
5914 + /* 640x480-60 VESA */
5915 + { NULL, 60, 640, 480, 39682, 48, 16, 33, 10, 96, 2,
5916 + 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5917 + /* 640x480-75 VESA */
5918 + { NULL, 75, 640, 480, 31746, 120, 16, 16, 01, 64, 3,
5919 + 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5920 + /* 640x480-85 VESA */
5921 + { NULL, 85, 640, 480, 27777, 80, 56, 25, 01, 56, 3,
5922 + 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5923 + /* 800x600-60 VESA */
5924 + { NULL, 60, 800, 600, 25000, 88, 40, 23, 01, 128, 4,
5925 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5926 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5927 + /* 800x600-75 VESA */
5928 + { NULL, 75, 800, 600, 20202, 160, 16, 21, 01, 80, 3,
5929 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5930 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5931 + /* 800x600-85 VESA */
5932 + { NULL, 85, 800, 600, 17761, 152, 32, 27, 01, 64, 3,
5933 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5934 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5935 + /* 1024x768-60 VESA */
5936 + { NULL, 60, 1024, 768, 15384, 160, 24, 29, 3, 136, 6,
5937 + 0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5938 + /* 1024x768-75 VESA */
5939 + { NULL, 75, 1024, 768, 12690, 176, 16, 28, 1, 96, 3,
5940 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5941 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5942 + /* 1024x768-85 VESA */
5943 + { NULL, 85, 1024, 768, 10582, 208, 48, 36, 1, 96, 3,
5944 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5945 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5946 + /* 1280x960-60 VESA */
5947 + { NULL, 60, 1280, 960, 9259, 312, 96, 36, 1, 112, 3,
5948 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5949 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5950 + /* 1280x960-85 VESA */
5951 + { NULL, 85, 1280, 960, 6734, 224, 64, 47, 1, 160, 3,
5952 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5953 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5954 + /* 1280x1024-60 VESA */
5955 + { NULL, 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3,
5956 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5957 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5958 + /* 1280x1024-75 VESA */
5959 + { NULL, 75, 1280, 1024, 7407, 248, 16, 38, 1, 144, 3,
5960 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5961 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
5962 + /* 1280x1024-85 VESA */
5963 + { NULL, 85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3,
5964 FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5965 - FB_VMODE_NONINTERLACED, 0 },
5966 - /* 640x400-70 */
5967 - { NULL, 70, 640, 400, 39770, 40, 8, 28, 5, 96, 2,
5968 - FB_SYNC_HOR_HIGH_ACT,
5969 - FB_VMODE_NONINTERLACED, 0 },
5970 - /* 640x480-70 */
5971 - { NULL, 70, 640, 480, 35014, 88, 24, 15, 2, 64, 3,
5972 - 0, FB_VMODE_NONINTERLACED, 0 },
5973 - /* 640x480-72 */
5974 - { NULL, 72, 640, 480, 32102, 120, 16, 20, 1, 40, 3,
5975 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5976 - FB_VMODE_NONINTERLACED, 0 },
5977 - /* 640x480-75 */
5978 - { NULL, 75, 640, 480, 31746, 120, 16, 16, 1, 64, 3,
5979 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5980 - FB_VMODE_NONINTERLACED, 0 },
5981 - /* 640x480-85 */
5982 - { NULL, 85, 640, 480, 27780, 80, 56, 25, 1, 56, 3,
5983 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5984 - FB_VMODE_NONINTERLACED, 0 },
5985 - /* 640x480-90 */
5986 - { NULL, 90, 640, 480, 26392, 96, 32, 22, 1, 64, 3,
5987 - 0, FB_VMODE_NONINTERLACED, 0 },
5988 - /* 640x480-100 */
5989 - { NULL, 100, 640, 480, 23167, 104, 40, 25, 1, 64, 3,
5990 - 0, FB_VMODE_NONINTERLACED, 0 },
5991 - /* 640x480-60 */
5992 - { NULL, 60, 640, 480, 39682, 48, 16, 25, 10, 88, 2,
5993 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
5994 - FB_VMODE_NONINTERLACED, 0 },
5995 - /* 800x600-56 */
5996 - { NULL, 56, 800, 600, 27901, 128, 24, 22, 1, 72, 2,
5997 - 0, FB_VMODE_NONINTERLACED, 0 },
5998 - /* 800x600-60 */
5999 - { NULL, 60, 800, 600, 25131, 72, 32, 23, 1, 136, 4,
6000 - 0, FB_VMODE_NONINTERLACED, 0 },
6001 - /* 800x600-70 */
6002 - { NULL, 70, 800, 600, 21873, 120, 40, 21, 4, 80, 3,
6003 - 0, FB_VMODE_NONINTERLACED, 0 },
6004 - /* 800x600-72 */
6005 - { NULL, 72, 800, 600, 20052, 64, 56, 23, 37, 120, 6,
6006 - 0, FB_VMODE_NONINTERLACED, 0 },
6007 - /* 800x600-75 */
6008 - { NULL, 75, 800, 600, 20202, 160, 16, 21, 1, 80, 3,
6009 - 0, FB_VMODE_NONINTERLACED, 0 },
6010 - /* 800x600-85 */
6011 - { NULL, 85, 800, 600, 17790, 152, 32, 27, 1, 64, 3,
6012 - 0, FB_VMODE_NONINTERLACED, 0 },
6013 - /* 800x600-90 */
6014 - { NULL, 90, 800, 600, 16648, 128, 40, 28, 1, 88, 3,
6015 - 0, FB_VMODE_NONINTERLACED, 0 },
6016 - /* 800x600-100 */
6017 - { NULL, 100, 800, 600, 14667, 136, 48, 27, 1, 88, 3,
6018 - 0, FB_VMODE_NONINTERLACED, 0 },
6019 - /* 800x600-60 */
6020 - { NULL, 60, 800, 600, 25131, 88, 40, 23, 1, 128, 4,
6021 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6022 - FB_VMODE_NONINTERLACED, 0 },
6023 - /* 1024x768-60 */
6024 - { NULL, 60, 1024, 768, 15385, 160, 24, 29, 3, 136, 6,
6025 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6026 - FB_VMODE_NONINTERLACED, 0 },
6027 - /* 1024x768-70 */
6028 - { NULL, 70, 1024, 768, 13346, 144, 24, 29, 3, 136, 6,
6029 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6030 - FB_VMODE_NONINTERLACED, 0 },
6031 - /* 1024x768-72 */
6032 - { NULL, 72, 1024, 768, 12702, 168, 56, 29, 4, 112, 3,
6033 - 0, FB_VMODE_NONINTERLACED, 0 },
6034 - /* 1024x768-75 */
6035 - { NULL, 75, 1024, 768, 12703, 176, 16, 28, 1, 96, 3,
6036 - 0, FB_VMODE_NONINTERLACED, 0 },
6037 - /* 1024x768-85 */
6038 - { NULL, 85, 1024, 768, 10581, 208, 48, 36, 1, 96, 3,
6039 - 0, FB_VMODE_NONINTERLACED, 0 },
6040 - /* 1024x768-90 */
6041 - { NULL, 90, 1024, 768, 9981, 176, 64, 37, 1, 112, 3,
6042 - 0, FB_VMODE_NONINTERLACED, 0 },
6043 - /* 1024x768-100 */
6044 - { NULL, 100, 1024, 768, 8825, 184, 72, 42, 1, 112, 3,
6045 - 0, FB_VMODE_NONINTERLACED, 0 },
6046 - /* 1024x768-60 */
6047 - { NULL, 60, 1024, 768, 15385, 160, 24, 29, 3, 136, 6,
6048 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6049 - FB_VMODE_NONINTERLACED, 0 },
6050 - /* 1152x864-60 */
6051 - { NULL, 60, 1152, 864, 12251, 184, 64, 27, 1, 120, 3,
6052 - 0, FB_VMODE_NONINTERLACED, 0 },
6053 - /* 1152x864-70 */
6054 - { NULL, 70, 1152, 864, 10254, 192, 72, 32, 8, 120, 3,
6055 - 0, FB_VMODE_NONINTERLACED, 0 },
6056 - /* 1152x864-72 */
6057 - { NULL, 72, 1152, 864, 9866, 200, 72, 33, 7, 128, 3,
6058 - 0, FB_VMODE_NONINTERLACED, 0 },
6059 - /* 1152x864-75 */
6060 - { NULL, 75, 1152, 864, 9259, 256, 64, 32, 1, 128, 3,
6061 - 0, FB_VMODE_NONINTERLACED, 0 },
6062 - /* 1152x864-85 */
6063 - { NULL, 85, 1152, 864, 8357, 200, 72, 37, 3, 128, 3,
6064 - 0, FB_VMODE_NONINTERLACED, 0 },
6065 - /* 1152x864-90 */
6066 - { NULL, 90, 1152, 864, 7719, 208, 80, 42, 9, 128, 3,
6067 - 0, FB_VMODE_NONINTERLACED, 0 },
6068 - /* 1152x864-100 */
6069 - { NULL, 100, 1152, 864, 6947, 208, 80, 48, 3, 128, 3,
6070 - 0, FB_VMODE_NONINTERLACED, 0 },
6071 - /* 1152x864-60 */
6072 - { NULL, 60, 1152, 864, 12251, 184, 64, 27, 1, 120, 3,
6073 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6074 - FB_VMODE_NONINTERLACED, 0 },
6075 - /* 1280x1024-60 */
6076 - { NULL, 60, 1280, 1024, 9262, 248, 48, 38, 1, 112, 3,
6077 - 0, FB_VMODE_NONINTERLACED, 0 },
6078 - /* 1280x1024-70 */
6079 - { NULL, 70, 1280, 1024, 7719, 224, 88, 38, 6, 136, 3,
6080 - 0, FB_VMODE_NONINTERLACED, 0 },
6081 - /* 1280x1024-72 */
6082 - { NULL, 72, 1280, 1024, 7490, 224, 88, 39, 7, 136, 3,
6083 - 0, FB_VMODE_NONINTERLACED, 0 },
6084 - /* 1280x1024-75 */
6085 - { NULL, 75, 1280, 1024, 7409, 248, 16, 38, 1, 144, 3,
6086 - 0, FB_VMODE_NONINTERLACED, 0 },
6087 - /* 1280x1024-85 */
6088 - { NULL, 85, 1280, 1024, 6351, 224, 64, 44, 1, 160, 3,
6089 - 0, FB_VMODE_NONINTERLACED, 0 },
6090 - /* 1280x1024-90 */
6091 - { NULL, 90, 1280, 1024, 5791, 240, 96, 51, 12, 144, 3,
6092 - 0, FB_VMODE_NONINTERLACED, 0 },
6093 - /* 1280x1024-100 */
6094 - { NULL, 100, 1280, 1024, 5212, 240, 96, 57, 6, 144, 3,
6095 - 0, FB_VMODE_NONINTERLACED, 0 },
6096 - /* 1280x1024-60 */
6097 - { NULL, 60, 1280, 1024, 9262, 248, 48, 38, 1, 112, 3,
6098 - FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6099 - FB_VMODE_NONINTERLACED, 0 },
6100 - /* 1600x1200-60 */
6101 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
6102 + /* 1600x1200-60 VESA */
6103 { NULL, 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
6104 - 0, FB_VMODE_NONINTERLACED, 0 },
6105 - /* 1600x1200-70 */
6106 - { NULL, 70, 1600, 1200, 5291, 304, 64, 46, 1, 192, 3,
6107 - 0, FB_VMODE_NONINTERLACED, 0 },
6108 - /* 1600x1200-72 */
6109 - { NULL, 72, 1600, 1200, 5053, 288, 112, 47, 13, 176, 3,
6110 - 0, FB_VMODE_NONINTERLACED, 0 },
6111 - /* 1600x1200-75 */
6112 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6113 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
6114 + /* 1600x1200-75 VESA */
6115 { NULL, 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
6116 - 0, FB_VMODE_NONINTERLACED, 0 },
6117 - /* 1600x1200-85 */
6118 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6119 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
6120 + /* 1600x1200-85 VESA */
6121 { NULL, 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3,
6122 - 0, FB_VMODE_NONINTERLACED, 0 },
6123 - /* 1600x1200-90 */
6124 - { NULL, 90, 1600, 1200, 3981, 304, 128, 60, 1, 176, 3,
6125 - 0, FB_VMODE_NONINTERLACED, 0 },
6126 - /* 1600x1200-100 */
6127 - { NULL, 100, 1600, 1200, 3563, 304, 128, 67, 1, 176, 3,
6128 - 0, FB_VMODE_NONINTERLACED, 0 },
6129 - /* 1600x1200-60 */
6130 - { NULL, 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
6131 FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6132 - FB_VMODE_NONINTERLACED, 0 },
6133 - /* 1920x1440-60 */
6134 - { NULL, 60, 1920, 1440, 4273, 344, 128, 56, 1, 208, 3,
6135 - 0, FB_VMODE_NONINTERLACED, 0 },
6136 - /* 1920x1440-70 */
6137 - { NULL, 70, 1920, 1440, 3593, 360, 152, 55, 8, 208, 3,
6138 - 0, FB_VMODE_NONINTERLACED, 0 },
6139 - /* 1920x1440-72 */
6140 - { NULL, 72, 1920, 1440, 3472, 360, 152, 68, 4, 208, 3,
6141 - 0, FB_VMODE_NONINTERLACED, 0 },
6142 - /* 1920x1440-75 */
6143 - { NULL, 75, 1920, 1440, 3367, 352, 144, 56, 1, 224, 3,
6144 - 0, FB_VMODE_NONINTERLACED, 0 },
6145 - /* 1920x1440-85 */
6146 - { NULL, 85, 1920, 1440, 2929, 368, 152, 68, 1, 216, 3,
6147 - 0, FB_VMODE_NONINTERLACED, 0 },
6148 + FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
6149 + /* 1200x900-75 - CRT timings for the OLPC mode */
6150 + { NULL, 75, 1200, 900, 8049, 104, 240, 29, 54, 136, 3,
6151 + 0, FB_VMODE_NONINTERLACED, 0 }
6152 };
6153
6154 +#ifdef CONFIG_OLPC
6155 +const struct fb_videomode olpc_dcon_modedb[] __initdata = {
6156 + /* The only mode the DCON has is 1200x900 */
6157 + { NULL, 50, 1200, 900, 17460, 24, 8, 4, 5, 8, 3,
6158 + FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
6159 + FB_VMODE_NONINTERLACED, 0 }
6160 +};
6161 +#endif
6162 +
6163 static int lxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
6164 {
6165 if (var->xres > 1920 || var->yres > 1440)
6166 @@ -255,8 +154,7 @@ static int lxfb_set_par(struct fb_info *
6167 fb_alloc_cmap(&info->cmap, 1<<info->var.bits_per_pixel, 0);
6168 }
6169
6170 - info->fix.line_length = lx_get_pitch(info->var.xres,
6171 - info->var.bits_per_pixel);
6172 + info->fix.line_length = lx_get_pitch(info->var.xres, info->var.bits_per_pixel);
6173
6174 lx_set_mode(info);
6175 return 0;
6176 @@ -371,24 +269,61 @@ static int __init lxfb_map_video_memory(
6177 writel(info->fix.smem_start & 0xFF000000,
6178 par->dc_regs + DC_PHY_MEM_OFFSET);
6179
6180 - writel(0, par->dc_regs + DC_UNLOCK);
6181 -
6182 dev_info(&dev->dev, "%d KB of video memory at 0x%lx\n",
6183 info->fix.smem_len / 1024, info->fix.smem_start);
6184
6185 return 0;
6186 }
6187
6188 +static int lxfb_set_gamma(struct fb_info *info, void * __user data)
6189 +{
6190 + unsigned int gamma[LXFB_GAMMA_DWORDS];
6191 +
6192 + if (copy_from_user(gamma, data, LXFB_GAMMA_SIZE))
6193 + return -EFAULT;
6194 +
6195 + lx_set_gamma(info, gamma, LXFB_GAMMA_SIZE);
6196 + return 0;
6197 +}
6198 +
6199 +static int lxfb_get_gamma(struct fb_info *info, void * __user data)
6200 +{
6201 + unsigned int gamma[LXFB_GAMMA_DWORDS];
6202 + memset(gamma, 0, sizeof(gamma));
6203 +
6204 + lx_get_gamma(info, gamma, LXFB_GAMMA_DWORDS);
6205 +
6206 + return copy_to_user(data, gamma, LXFB_GAMMA_SIZE) ?
6207 + -EFAULT : 0;
6208 +}
6209 +
6210 +static int lxfb_ioctl( struct fb_info *info, unsigned int cmd,
6211 + unsigned long arg)
6212 +{
6213 + switch(cmd) {
6214 + case FBIOSGAMMA:
6215 + return lxfb_set_gamma(info, (void * __user) arg);
6216 +
6217 + case FBIOGGAMMA:
6218 + return lxfb_get_gamma(info, (void * __user) arg);
6219 + }
6220 +
6221 + return -ENOTTY;
6222 +}
6223 +
6224 static struct fb_ops lxfb_ops = {
6225 .owner = THIS_MODULE,
6226 .fb_check_var = lxfb_check_var,
6227 .fb_set_par = lxfb_set_par,
6228 .fb_setcolreg = lxfb_setcolreg,
6229 .fb_blank = lxfb_blank,
6230 + .fb_ioctl = lxfb_ioctl,
6231 /* No HW acceleration for now. */
6232 .fb_fillrect = cfb_fillrect,
6233 .fb_copyarea = cfb_copyarea,
6234 .fb_imageblit = cfb_imageblit,
6235 + .fb_powerdown = lx_shutdown,
6236 + .fb_powerup = lx_powerup,
6237 };
6238
6239 static struct fb_info * __init lxfb_init_fbinfo(struct device *dev)
6240 @@ -431,6 +366,45 @@ static struct fb_info * __init lxfb_init
6241 return info;
6242 }
6243
6244 +#ifdef CONFIG_PM
6245 +
6246 +static int lxfb_suspend(struct pci_dev *pdev, pm_message_t state)
6247 +{
6248 + struct fb_info *info = pci_get_drvdata(pdev);
6249 +
6250 + if (pdev->dev.power.power_state.event == state.event)
6251 + return 0;
6252 +
6253 + if (state.event == PM_EVENT_SUSPEND) {
6254 +
6255 + acquire_console_sem();
6256 + lx_shutdown(info);
6257 + fb_set_suspend(info, 1);
6258 + release_console_sem();
6259 + }
6260 +
6261 + pdev->dev.power.power_state = state;
6262 + return 0;
6263 +}
6264 +
6265 +static int lxfb_resume(struct pci_dev *pdev)
6266 +{
6267 + struct fb_info *info = pci_get_drvdata(pdev);
6268 +
6269 + acquire_console_sem();
6270 +
6271 + /* Turn the engine completely on */
6272 +
6273 + lx_powerup(info);
6274 + fb_set_suspend(info, 0);
6275 + release_console_sem();
6276 +
6277 + pdev->dev.power.power_state = PMSG_ON;
6278 + return 0;
6279 +}
6280 +
6281 +#endif
6282 +
6283 static int __init lxfb_probe(struct pci_dev *pdev,
6284 const struct pci_device_id *id)
6285 {
6286 @@ -467,6 +441,13 @@ static int __init lxfb_probe(struct pci_
6287 modedb_ptr = (struct fb_videomode *) geode_modedb;
6288 modedb_size = ARRAY_SIZE(geode_modedb);
6289
6290 +#ifdef CONFIG_OLPC
6291 + if (olpc_has_dcon()) {
6292 + modedb_ptr = (struct fb_videomode *) olpc_dcon_modedb;
6293 + modedb_size = ARRAY_SIZE(olpc_dcon_modedb);
6294 + }
6295 +#endif
6296 +
6297 ret = fb_find_mode(&info->var, info, mode_option,
6298 modedb_ptr, modedb_size, NULL, 16);
6299
6300 @@ -556,6 +537,10 @@ static struct pci_driver lxfb_driver = {
6301 .id_table = lxfb_id_table,
6302 .probe = lxfb_probe,
6303 .remove = lxfb_remove,
6304 +#ifdef CONFIG_PM
6305 + .suspend = lxfb_suspend,
6306 + .resume = lxfb_resume
6307 +#endif
6308 };
6309
6310 #ifndef MODULE
6311 Index: linux-2.6.24.7/drivers/video/geode/lxfb.h
6312 ===================================================================
6313 --- linux-2.6.24.7.orig/drivers/video/geode/lxfb.h
6314 +++ linux-2.6.24.7/drivers/video/geode/lxfb.h
6315 @@ -25,10 +25,23 @@ void lx_set_mode(struct fb_info *);
6316 void lx_get_gamma(struct fb_info *, unsigned int *, int);
6317 void lx_set_gamma(struct fb_info *, unsigned int *, int);
6318 unsigned int lx_framebuffer_size(void);
6319 +int lx_shutdown(struct fb_info *);
6320 +int lx_powerup(struct fb_info *);
6321 int lx_blank_display(struct fb_info *, int);
6322 void lx_set_palette_reg(struct fb_info *, unsigned int, unsigned int,
6323 unsigned int, unsigned int);
6324
6325 +
6326 +
6327 +/* ioctl() defines */
6328 +
6329 +#define FBIOSGAMMA _IOW('F', 0x20, void *)
6330 +#define FBIOGGAMMA _IOW('F', 0x21, void *)
6331 +
6332 +/* General definitions */
6333 +#define LXFB_GAMMA_DWORDS 256 /* number of dwords in the gamma ram */
6334 +#define LXFB_GAMMA_SIZE (LXFB_GAMMA_DWORDS * sizeof(unsigned int))
6335 +
6336 /* MSRS */
6337
6338 #define MSR_LX_GLD_CONFIG 0x48002001
6339 @@ -127,7 +140,7 @@ void lx_set_palette_reg(struct fb_info *
6340
6341 #define DC_GFX_SCALE 0x90
6342 #define DC_IRQ_FILT_CTL 0x94
6343 -
6344 +#define DC_IRQFILT_H_FILT_SEL 0x00000400
6345
6346 #define DC_IRQ 0xC8
6347 #define DC_IRQ_MASK (1 << 0)
6348 Index: linux-2.6.24.7/drivers/video/geode/lxfb_ops.c
6349 ===================================================================
6350 --- linux-2.6.24.7.orig/drivers/video/geode/lxfb_ops.c
6351 +++ linux-2.6.24.7/drivers/video/geode/lxfb_ops.c
6352 @@ -11,11 +11,15 @@
6353 #include <linux/kernel.h>
6354 #include <linux/errno.h>
6355 #include <linux/fb.h>
6356 -#include <linux/uaccess.h>
6357 -#include <linux/delay.h>
6358 +#include <asm/uaccess.h>
6359 +#include <asm/delay.h>
6360 +#include <asm/olpc.h>
6361
6362 #include "lxfb.h"
6363
6364 +#define _GEODELX_
6365 +#include "geode_regs.h"
6366 +
6367 /* TODO
6368 * Support panel scaling
6369 * Add acceleration
6370 @@ -290,6 +294,19 @@ unsigned int lx_framebuffer_size(void)
6371 {
6372 unsigned int val;
6373
6374 +#ifdef CONFIG_OLPC
6375 + if (machine_is_olpc() && !olpc_has_vsa()) {
6376 + u32 hi,lo;
6377 + rdmsr(MSR_LX_GLIU0_P2D_RO0, lo, hi);
6378 +
6379 + /* Top page number */
6380 + val = ((hi & 0xff) << 12) | ((lo & 0xfff00000) >> 20);
6381 + val -= (lo & 0x000fffff); /* Subtract bottom page number */
6382 + val += 1; /* Adjust page count */
6383 + return (val << 12);
6384 + }
6385 +#endif
6386 +
6387 /* The frame buffer size is reported by a VSM in VSA II */
6388 /* Virtual Register Class = 0x02 */
6389 /* VG_MEM_SIZE (1MB units) = 0x00 */
6390 @@ -301,6 +318,34 @@ unsigned int lx_framebuffer_size(void)
6391 return (val << 20);
6392 }
6393
6394 +void lx_set_gamma(struct fb_info *info, unsigned int *gamma, int len)
6395 +{
6396 + int i;
6397 + struct lxfb_par *par = info->par;
6398 +
6399 + writel(0, par->df_regs + DF_PAR);
6400 +
6401 + /* Sequential writes to the data register will increment the
6402 + address automatically */
6403 +
6404 + for(i = 0; i < len; i++)
6405 + writel(gamma[i] & 0xFFFFFF, par->df_regs + DF_PDR);
6406 +
6407 + writel(readl(par->df_regs + DF_MISC) & ~DF_MISC_GAM_BYPASS,
6408 + par->df_regs + DF_MISC);
6409 +}
6410 +
6411 +void lx_get_gamma(struct fb_info *info, unsigned int *gamma, int len)
6412 +{
6413 + int i;
6414 + struct lxfb_par *par = info->par;
6415 +
6416 + writel(0, par->df_regs + DF_PAR);
6417 +
6418 + for(i = 0; i < len;i++)
6419 + gamma[i] = readl(par->df_regs + DF_PDR);
6420 +}
6421 +
6422 void lx_set_mode(struct fb_info *info)
6423 {
6424 struct lxfb_par *par = info->par;
6425 @@ -313,6 +358,7 @@ void lx_set_mode(struct fb_info *info)
6426 int vactive, vblankstart, vsyncstart, vsyncend, vblankend, vtotal;
6427
6428 /* Unlock the DC registers */
6429 + readl(par->dc_regs + DC_UNLOCK);
6430 writel(DC_UNLOCK_CODE, par->dc_regs + DC_UNLOCK);
6431
6432 lx_graphics_disable(info);
6433 @@ -483,54 +529,408 @@ void lx_set_palette_reg(struct fb_info *
6434 writel(val, par->dc_regs + DC_PAL_DATA);
6435 }
6436
6437 +static int lx_blank_mode = FB_BLANK_UNBLANK;
6438 +
6439 int lx_blank_display(struct fb_info *info, int blank_mode)
6440 {
6441 struct lxfb_par *par = info->par;
6442 - u32 dcfg, fp_pm;
6443 - int blank, hsync, vsync;
6444 + u32 dcfg, val;
6445 +
6446 + if (blank_mode == lx_blank_mode)
6447 + return 0;
6448 +
6449 + writel(DC_UNLOCK_CODE, par->dc_regs + DC_UNLOCK);
6450 +
6451 + if (lx_blank_mode == FB_BLANK_POWERDOWN) {
6452 + val = readl(par->df_regs + DF_FP_PM);
6453 + writel(val | DF_FP_PM_P, par->df_regs + DF_FP_PM);
6454 + val = readl(par->df_regs + DF_MISC) & ~DF_MISC_DAC_PWRDN;
6455 + writel(val, par->df_regs + DF_MISC);
6456 +
6457 + val = readl(par->dc_regs + DC_GENERAL_CFG) | DC_GCFG_DFLE;
6458 + writel(val, par->dc_regs + DC_GENERAL_CFG);
6459 +
6460 + val = readl(par->dc_regs + DC_DISPLAY_CFG) | DC_DCFG_TGEN;
6461 + writel(val, par->dc_regs + DC_DISPLAY_CFG);
6462 + }
6463 +
6464 + dcfg = readl(par->df_regs + DF_DISPLAY_CFG);
6465
6466 /* CRT power saving modes. */
6467 switch (blank_mode) {
6468 case FB_BLANK_UNBLANK:
6469 - blank = 0; hsync = 1; vsync = 1;
6470 + dcfg |= DF_DCFG_CRT_EN | DF_DCFG_HSYNC_EN | DF_DCFG_VSYNC_EN;
6471 + dcfg |= DF_DCFG_DAC_BL_EN;
6472 break;
6473 case FB_BLANK_NORMAL:
6474 - blank = 1; hsync = 1; vsync = 1;
6475 + dcfg |= DF_DCFG_CRT_EN | DF_DCFG_HSYNC_EN | DF_DCFG_VSYNC_EN;
6476 + dcfg |= DF_DCFG_DAC_BL_EN;
6477 break;
6478 case FB_BLANK_VSYNC_SUSPEND:
6479 - blank = 1; hsync = 1; vsync = 0;
6480 + dcfg |= DF_DCFG_CRT_EN | DF_DCFG_HSYNC_EN | DF_DCFG_DAC_BL_EN;
6481 + dcfg &= ~DF_DCFG_VSYNC_EN;
6482 break;
6483 case FB_BLANK_HSYNC_SUSPEND:
6484 - blank = 1; hsync = 0; vsync = 1;
6485 + dcfg |= DF_DCFG_CRT_EN | DF_DCFG_VSYNC_EN | DF_DCFG_DAC_BL_EN;
6486 + dcfg &= ~DF_DCFG_HSYNC_EN;
6487 break;
6488 case FB_BLANK_POWERDOWN:
6489 - blank = 1; hsync = 0; vsync = 0;
6490 + dcfg &= ~DF_DCFG_DAC_BL_EN;
6491 + dcfg &= ~(DF_DCFG_CRT_EN | DF_DCFG_HSYNC_EN | DF_DCFG_VSYNC_EN);
6492 break;
6493 default:
6494 + writel(0, par->dc_regs + DC_UNLOCK);
6495 return -EINVAL;
6496 }
6497
6498 - dcfg = readl(par->df_regs + DF_DISPLAY_CFG);
6499 - dcfg &= ~(DF_DCFG_DAC_BL_EN
6500 - | DF_DCFG_HSYNC_EN | DF_DCFG_VSYNC_EN);
6501 - if (!blank)
6502 - dcfg |= DF_DCFG_DAC_BL_EN;
6503 - if (hsync)
6504 - dcfg |= DF_DCFG_HSYNC_EN;
6505 - if (vsync)
6506 - dcfg |= DF_DCFG_VSYNC_EN;
6507 - writel(dcfg, par->df_regs + DF_DISPLAY_CFG);
6508 + /* Turn off the engine when we are in power down mode */
6509 + if (blank_mode == FB_BLANK_POWERDOWN) {
6510 + val = readl(par->df_regs + DF_MISC) | DF_MISC_DAC_PWRDN;
6511 + writel(val, par->df_regs + DF_MISC);
6512 +
6513 + val = readl(par->dc_regs + DC_DISPLAY_CFG);
6514 + val &= ~DC_DCFG_TGEN;
6515 + writel(val, par->dc_regs + DC_DISPLAY_CFG);
6516 +
6517 + udelay(1000);
6518 +
6519 + val = readl(par->dc_regs + DC_GENERAL_CFG) & ~DC_GCFG_DFLE;
6520 + writel(val, par->dc_regs + DC_GENERAL_CFG);
6521 +
6522 + val = readl(par->df_regs + DF_FP_PM);
6523 + writel(val & ~DF_FP_PM_P, par->df_regs + DF_FP_PM);
6524 + }
6525
6526 + writel(0, par->dc_regs + DC_UNLOCK);
6527 +
6528 + lx_blank_mode = blank_mode;
6529 + return 0;
6530 +}
6531 +
6532 +static struct geoderegs saved_regs;
6533 +
6534 +static void lx_save_regs(struct fb_info *info, struct geoderegs *regs)
6535 +{
6536 + struct lxfb_par *par = info->par;
6537 + int i;
6538 + u32 filt;
6539 +
6540 + /* Wait for the command buffer to empty */
6541 + while(!(readl(par->gp_regs + 0x44) & (1 << 4)));
6542 +
6543 + /* Unlock the DC */
6544 + writel(DC_UNLOCK_CODE, par->dc_regs + DC_UNLOCK);
6545 +
6546 + rdmsrl(MSR_LX_DF_PADSEL, regs->msr.padsel);
6547 + rdmsrl(MSR_LX_GLCP_DOTPLL, regs->msr.dotpll);
6548 + rdmsrl(MSR_LX_DF_GLCONFIG, regs->msr.dfglcfg);
6549 + rdmsrl(MSR_LX_DC_SPARE, regs->msr.dcspare);
6550 +
6551 + writel(0x4758, par->dc_regs + 0x00);
6552 +
6553 + memcpy(regs->gp.b, par->gp_regs, GP_REG_SIZE);
6554 + memcpy(regs->dc.b, par->dc_regs, DC_REG_SIZE);
6555 + memcpy(regs->vp.b, par->df_regs, VP_REG_SIZE);
6556 + memcpy(regs->fp.b, par->df_regs + VP_FP_START, FP_REG_SIZE);
6557 +
6558 + /* Save the palette */
6559 + writel(0, par->dc_regs + 0x70);
6560 /* Power on/off flat panel */
6561 + for(i = 0; i < DC_PAL_SIZE; i++)
6562 + regs->pal[i] = readl(par->dc_regs + 0x74);
6563
6564 - if (par->output & OUTPUT_PANEL) {
6565 - fp_pm = readl(par->df_regs + DF_FP_PM);
6566 - if (blank_mode == FB_BLANK_POWERDOWN)
6567 - fp_pm &= ~DF_FP_PM_P;
6568 - else
6569 - fp_pm |= DF_FP_PM_P;
6570 - writel(fp_pm, par->df_regs + DF_FP_PM);
6571 + /* save the filter coefficients */
6572 +
6573 + filt = readl(par->dc_regs + 0x94);
6574 + filt |= DC_IRQFILT_H_FILT_SEL;
6575 +
6576 + for(i = 0; i < DC_HFILT_SIZE; i++) {
6577 + writel((filt & 0xFFFFFF00) | i, par->dc_regs + 0x94);
6578 + regs->hcoeff[i << 1] = readl(par->dc_regs + 0x98);
6579 + regs->hcoeff[(i << 1) + 1] = readl(par->dc_regs + 0x9c);
6580 + }
6581 +
6582 + filt &= ~DC_IRQFILT_H_FILT_SEL;
6583 +
6584 + for(i = 0; i < DC_VFILT_SIZE; i++) {
6585 + writel((filt & 0xFFFFFF00) | i, par->dc_regs + 0x94);
6586 + regs->vcoeff[i] = readl(par->dc_regs + 0x98);
6587 }
6588
6589 + /* Save the vg filter coefficients */
6590 + for(i = 0; i < VP_COEFF_COUNT; i++)
6591 + regs->vp_coeff[i] =
6592 + readl(par->df_regs + 0x1000 + (i << 2));
6593 +
6594 + /* Save the VP gamma */
6595 +
6596 + writel(0, par->df_regs + 0x38);
6597 +
6598 + for(i = 0; i <= 0xFF; i++)
6599 + regs->gamma[i] = readl(par->df_regs + 0x40);
6600 +}
6601 +
6602 +static void lx_restore_dc(struct lxfb_par *par, struct geoderegs *regs)
6603 +{
6604 + u32 filt;
6605 + int i;
6606 +
6607 + /* Unlock the registers */
6608 + writel(DC_UNLOCK_CODE, par->dc_regs + 0x00);
6609 +
6610 + /* Restore the framebuffer offset */
6611 + writel(regs->dc.r.gliu0_mem_offset, par->dc_regs + 0x84);
6612 +
6613 + /* Blank the configuration registers while we restore */
6614 + writel(0, par->dc_regs + 0x04);
6615 + writel(0, par->dc_regs + 0x08);
6616 +
6617 + /* Restore the bulk of the registers */
6618 +
6619 + writel(regs->dc.r.arb, par->dc_regs + 0x0C);
6620 + writel(regs->dc.r.fb_st_offset, par->dc_regs + 0x10);
6621 + writel(regs->dc.r.cb_st_offset, par->dc_regs + 0x14);
6622 + writel(regs->dc.r.curs_st_offset, par->dc_regs + 0x18);
6623 +
6624 + /* skip 0x1c */
6625 +
6626 + writel(regs->dc.r.vid_y_st_offset, par->dc_regs + 0x20);
6627 + writel(regs->dc.r.vid_u_st_offset, par->dc_regs + 0x24);
6628 + writel(regs->dc.r.vid_v_st_offset, par->dc_regs + 0x28);
6629 +
6630 + writel(regs->dc.r.dctop, par->dc_regs + 0x2c);
6631 + writel(regs->dc.r.line_size, par->dc_regs + 0x30);
6632 + writel(regs->dc.r.gfx_pitch, par->dc_regs + 0x34);
6633 + writel(regs->dc.r.vid_yuv_pitch, par->dc_regs + 0x38);
6634 + writel(regs->dc.r.h_active_timing, par->dc_regs + 0x40);
6635 + writel(regs->dc.r.h_blank_timing, par->dc_regs + 0x44);
6636 + writel(regs->dc.r.h_sync_timing, par->dc_regs + 0x48);
6637 + writel(regs->dc.r.v_active_timing, par->dc_regs + 0x50);
6638 + writel(regs->dc.r.v_blank_timing, par->dc_regs + 0x54);
6639 + writel(regs->dc.r.v_sync_timing, par->dc_regs + 0x58);
6640 + writel(regs->dc.r.fbactive, par->dc_regs + 0x5c);
6641 + writel(regs->dc.r.dc_cursor_x, par->dc_regs + 0x60);
6642 + writel(regs->dc.r.dc_cursor_y, par->dc_regs + 0x64);
6643 +
6644 + /* skip 0x68, 0x6c, 0x70, 0x74, 0x78, 0x7c */
6645 +
6646 + writel(regs->dc.r.dc_vid_ds_delta, par->dc_regs + 0x80);
6647 +
6648 + /* 0x84 was written above */
6649 +
6650 + writel(regs->dc.r.dv_ctl | 0x01, par->dc_regs + 0x88);
6651 + writel(regs->dc.r.gfx_scale, par->dc_regs + 0x90);
6652 + writel(regs->dc.r.irq_filt_ctl, par->dc_regs + 0x94);
6653 +
6654 + /* skip 0x98, 0x9c */
6655 +
6656 + writel(regs->dc.r.vbi_event_ctl, par->dc_regs + 0xA0);
6657 + writel(regs->dc.r.vbi_odd_ctl, par->dc_regs + 0xA4);
6658 + writel(regs->dc.r.vbi_hor, par->dc_regs + 0xA8);
6659 + writel(regs->dc.r.vbi_ln_odd, par->dc_regs + 0xAC);
6660 + writel(regs->dc.r.vbi_ln_event, par->dc_regs + 0xB0);
6661 + writel(regs->dc.r.vbi_pitch, par->dc_regs + 0xB4);
6662 + writel(regs->dc.r.clr_key, par->dc_regs + 0xB8);
6663 + writel(regs->dc.r.clr_key_mask, par->dc_regs + 0xBC);
6664 + writel(regs->dc.r.clr_key_x, par->dc_regs + 0xC0);
6665 + writel(regs->dc.r.clr_key_y, par->dc_regs + 0xC4);
6666 + writel(regs->dc.r.irq, par->dc_regs + 0xC8);
6667 + writel(regs->dc.r.genlk_ctrl, par->dc_regs + 0xD4);
6668 + writel(regs->dc.r.vid_even_y_st_offset, par->dc_regs + 0xD8);
6669 + writel(regs->dc.r.vid_even_u_st_offset, par->dc_regs + 0xDC);
6670 + writel(regs->dc.r.vid_even_v_st_offset, par->dc_regs + 0xE0);
6671 + writel(regs->dc.r.v_active_even_timing, par->dc_regs + 0xE4);
6672 + writel(regs->dc.r.v_blank_even_timing, par->dc_regs + 0xE8);
6673 + writel(regs->dc.r.v_sync_even_timing, par->dc_regs + 0xEC);
6674 +
6675 + /* Restore the palette */
6676 + writel(0, par->dc_regs + 0x70);
6677 +
6678 + for(i = 0; i < DC_PAL_SIZE; i++)
6679 + writel(regs->pal[i], par->dc_regs + 0x74);
6680 +
6681 + /* Restore the horizontal filter coefficients */
6682 + filt = readl(par->dc_regs + 0x94);
6683 + filt |= DC_IRQFILT_H_FILT_SEL;
6684 +
6685 + for(i = 0; i < DC_HFILT_SIZE; i++) {
6686 + writel(((filt & 0xFFFFFF00) | i), par->dc_regs + 0x94);
6687 + writel(regs->hcoeff[i << 1], par->dc_regs + 0x98);
6688 + writel(regs->hcoeff[(i << 1) + 1], par->dc_regs + 0x9c);
6689 + }
6690 +
6691 + filt &= ~DC_IRQFILT_H_FILT_SEL;
6692 +
6693 + for(i = 0; i < DC_VFILT_SIZE; i++) {
6694 + writel(((filt & 0xFFFFFF00) | i), par->dc_regs + 0x94);
6695 + writel(regs->vcoeff[i], par->dc_regs + 0x98);
6696 + }
6697 +
6698 + /* Turn on the dotpll */
6699 + lx_set_dotpll((u32) (regs->msr.dotpll >> 32));
6700 +
6701 + /* Restore MSRs */
6702 + wrmsrl(MSR_LX_DC_SPARE, regs->msr.dcspare);
6703 +
6704 + /* Restore the configuration registers */
6705 +
6706 + writel(regs->dc.r.dcfg, par->dc_regs + 0x08);
6707 + writel(regs->dc.r.gcfg, par->dc_regs + 0x04);
6708 +
6709 + /* Lock the DC again */
6710 + writel(0, par->dc_regs + 0x00);
6711 +}
6712 +
6713 +static void lx_restore_vp(struct lxfb_par *par, struct geoderegs *regs)
6714 +{
6715 + u32 val;
6716 + int i;
6717 +
6718 + /* Restore MSRs */
6719 +
6720 + wrmsrl(MSR_LX_DF_GLCONFIG, regs->msr.dfglcfg);
6721 + wrmsrl(MSR_LX_DF_PADSEL, regs->msr.padsel);
6722 +
6723 + /* Restore the registers */
6724 +
6725 + writel((u32) regs->vp.r.vx, par->df_regs + 0x10);
6726 + writel((u32) regs->vp.r.vy, par->df_regs + 0x18);
6727 + writel((u32) regs->vp.r.vs, par->df_regs + 0x20);
6728 + writel((u32) regs->vp.r.vck, par->df_regs + 0x28);
6729 + writel((u32) regs->vp.r.vcm, par->df_regs + 0x30);
6730 + /* skip 0x38 and 0x40 */
6731 + writel((u32) regs->vp.r.slr, par->df_regs + 0x48);
6732 + writel((u32) regs->vp.r.misc, par->df_regs + 0x50);
6733 + /* skip 0x58 */
6734 + writel((u32) regs->vp.r.vys, par->df_regs + 0x60);
6735 + writel((u32) regs->vp.r.vxs, par->df_regs + 0x68);
6736 + writel((u32) regs->vp.r.vde, par->df_regs + 0x98);
6737 + writel((u32) regs->vp.r.cck, par->df_regs + 0xA0);
6738 + writel((u32) regs->vp.r.ccm, par->df_regs + 0xA8);
6739 + writel((u32) regs->vp.r.cc1, par->df_regs + 0xB0);
6740 + writel((u32) regs->vp.r.cc2, par->df_regs + 0xB8);
6741 + writel((u32) regs->vp.r.a1x, par->df_regs + 0xC0);
6742 + writel((u32) regs->vp.r.a1y, par->df_regs + 0xC8);
6743 + writel((u32) regs->vp.r.a1c, par->df_regs + 0xD0);
6744 + writel((u32) regs->vp.r.a1t, par->df_regs + 0xD8);
6745 + writel((u32) regs->vp.r.a2x, par->df_regs + 0xE0);
6746 + writel((u32) regs->vp.r.a2y, par->df_regs + 0xE8);
6747 + writel((u32) regs->vp.r.a2c, par->df_regs + 0xF0);
6748 + writel((u32) regs->vp.r.a2t, par->df_regs + 0xF8);
6749 + writel((u32) regs->vp.r.a3x, par->df_regs + 0x100);
6750 + writel((u32) regs->vp.r.a3y, par->df_regs + 0x108);
6751 + writel((u32) regs->vp.r.a3c, par->df_regs + 0x110);
6752 + writel((u32) regs->vp.r.a3t, par->df_regs + 0x118);
6753 + writel((u32) regs->vp.r.vrr, par->df_regs + 0x120);
6754 + writel((u32) regs->vp.r.vye, par->df_regs + 0x138);
6755 + writel((u32) regs->vp.r.a1ye, par->df_regs + 0x140);
6756 + writel((u32) regs->vp.r.a2ye, par->df_regs + 0x148);
6757 + writel((u32) regs->vp.r.a3ye, par->df_regs + 0x150);
6758 +
6759 + /* Panel */
6760 +
6761 + writel((u32) regs->fp.r.pt1, par->df_regs + 0x400);
6762 + writel((u32) regs->fp.r.pt2, par->df_regs + 0x408);
6763 + writel((u32) regs->fp.r.dfc, par->df_regs + 0x418);
6764 +
6765 + /* Restore panel power */
6766 +
6767 + val = readl(par->df_regs + 0x410);
6768 +
6769 + if (regs->fp.r.pm & (1 << 24)) {
6770 + if (!(val & 0x09))
6771 + writel(regs->fp.r.pm, par->df_regs + 0x410);
6772 + }
6773 + else {
6774 + if (!(val & 0x05))
6775 + writel(regs->fp.r.pm, par->df_regs + 0x410);
6776 + }
6777 +
6778 + /* Restore the vp palette */
6779 +
6780 + writel(0, par->df_regs + 0x38);
6781 +
6782 + for(i = 0; i <= 0xFF; i++)
6783 + writel((u32) regs->gamma[i], par->df_regs + 0x40);
6784 +
6785 + /* Restore filter coefficients */
6786 +
6787 + for(i = 0; i < VP_COEFF_COUNT; i++)
6788 + writel(regs->vp_coeff[i],
6789 + par->df_regs + 0x1000 + (i << 2));
6790 +
6791 + /* Restore the configuration registers */
6792 +
6793 + writel((u32) regs->vp.r.dcfg, par->df_regs + 0x08);
6794 + writel((u32) regs->vp.r.vcfg, par->df_regs + 0x00);
6795 +}
6796 +
6797 +static void lx_restore_gp(struct lxfb_par *par, struct geoderegs *regs)
6798 +{
6799 + writel(regs->gp.r.dst_offset, par->gp_regs + 0x00);
6800 + writel(regs->gp.r.src_offset, par->gp_regs + 0x04);
6801 + writel(regs->gp.r.stride, par->gp_regs + 0x08);
6802 + writel(regs->gp.r.wid_height, par->gp_regs + 0x0C);
6803 + writel(regs->gp.r.src_color_fg, par->gp_regs + 0x10);
6804 + writel(regs->gp.r.src_color_bg, par->gp_regs + 0x14);
6805 + writel(regs->gp.r.pat_color_0, par->gp_regs + 0x18);
6806 + writel(regs->gp.r.pat_color_1, par->gp_regs + 0x1C);
6807 + writel(regs->gp.r.pat_color_2, par->gp_regs + 0x20);
6808 + writel(regs->gp.r.pat_color_3, par->gp_regs + 0x24);
6809 + writel(regs->gp.r.pat_color_4, par->gp_regs + 0x28);
6810 + writel(regs->gp.r.pat_color_5, par->gp_regs + 0x2C);
6811 + writel(regs->gp.r.pat_data_0, par->gp_regs + 0x30);
6812 + writel(regs->gp.r.pat_data_1, par->gp_regs + 0x34);
6813 +
6814 + /* Writing to these registers would cause a blt to happen */
6815 + /* 0x38, 0x3c, 0x40 */
6816 +
6817 + /* Status register (0x44) is read only */
6818 +
6819 + writel(regs->gp.r.hst_src, par->gp_regs + 0x48);
6820 + writel(regs->gp.r.base_offset, par->gp_regs + 0x4c);
6821 + writel(regs->gp.r.cmd_top, par->gp_regs + 0x50);
6822 + writel(regs->gp.r.cmd_bot, par->gp_regs + 0x54);
6823 + writel(regs->gp.r.cmd_read, par->gp_regs + 0x58);
6824 + writel(regs->gp.r.cmd_write, par->gp_regs + 0x5C);
6825 + writel(regs->gp.r.ch3_offset, par->gp_regs + 0x60);
6826 + writel(regs->gp.r.ch3_mode_str, par->gp_regs + 0x64);
6827 + writel(regs->gp.r.ch3_width, par->gp_regs + 0x6C);
6828 + writel(regs->gp.r.ch3_hsrc, par->gp_regs + 0x70);
6829 +
6830 + writel(regs->gp.r.int_cntrl, par->gp_regs + 0x70);
6831 +}
6832 +
6833 +static void lx_restore_regs(struct fb_info *info, struct geoderegs *regs)
6834 +{
6835 + struct lxfb_par *par = info->par;
6836 +
6837 + lx_restore_gp(par, regs);
6838 + lx_restore_vp(par, regs);
6839 + lx_restore_dc(par, regs);
6840 +}
6841 +
6842 +static int lx_power_on = 1;
6843 +
6844 +int lx_shutdown(struct fb_info *info)
6845 +{
6846 + if (lx_power_on == 0)
6847 + return 0;
6848 +
6849 + lx_save_regs(info, &saved_regs);
6850 + lx_graphics_disable(info);
6851 +
6852 + lx_power_on = 0;
6853 + return 0;
6854 +}
6855 +
6856 +int lx_powerup(struct fb_info *info)
6857 +{
6858 + if (lx_power_on == 1)
6859 + return 0;
6860 +
6861 + lx_restore_regs(info, &saved_regs);
6862 +
6863 + lx_power_on = 1;
6864 return 0;
6865 }
6866 Index: linux-2.6.24.7/drivers/video/geode/Makefile
6867 ===================================================================
6868 --- linux-2.6.24.7.orig/drivers/video/geode/Makefile
6869 +++ linux-2.6.24.7/drivers/video/geode/Makefile
6870 @@ -5,5 +5,5 @@ obj-$(CONFIG_FB_GEODE_GX) += gxfb.o
6871 obj-$(CONFIG_FB_GEODE_LX) += lxfb.o
6872
6873 gx1fb-objs := gx1fb_core.o display_gx1.o video_cs5530.o
6874 -gxfb-objs := gxfb_core.o display_gx.o video_gx.o
6875 +gxfb-objs := gxfb_core.o display_gx.o video_gx.o suspend_gx.o
6876 lxfb-objs := lxfb_core.o lxfb_ops.o
6877 Index: linux-2.6.24.7/drivers/video/geode/suspend_gx.c
6878 ===================================================================
6879 --- /dev/null
6880 +++ linux-2.6.24.7/drivers/video/geode/suspend_gx.c
6881 @@ -0,0 +1,272 @@
6882 +#include <linux/fb.h>
6883 +#include <asm/io.h>
6884 +#include <asm/msr.h>
6885 +
6886 +#include "geodefb.h"
6887 +#include "video_gx.h"
6888 +
6889 +void gx_set_dotpll(struct fb_info *info, struct geoderegs *regs)
6890 +{
6891 + int timeout = 1000;
6892 +
6893 + u64 rstpll, dotpll;
6894 +
6895 + rdmsrl(MSR_GLCP_SYS_RSTPLL, rstpll);
6896 + rdmsrl(MSR_GLCP_DOTPLL, dotpll);
6897 +
6898 + dotpll &= 0x00000000ffffffffull;
6899 + dotpll |= regs->msr.dotpll & 0xffffffff00000000ull;
6900 +
6901 + dotpll |= MSR_GLCP_DOTPLL_DOTRESET;
6902 + dotpll &= ~MSR_GLCP_DOTPLL_BYPASS;
6903 +
6904 + wrmsrl(MSR_GLCP_DOTPLL, dotpll);
6905 +
6906 + rstpll |= (regs->msr.rstpll &
6907 + ( MSR_GLCP_SYS_RSTPLL_DOTPREDIV2 |
6908 + MSR_GLCP_SYS_RSTPLL_DOTPREMULT2 |
6909 + MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3));
6910 +
6911 + wrmsrl(MSR_GLCP_SYS_RSTPLL, rstpll);
6912 + dotpll &= ~(MSR_GLCP_DOTPLL_DOTRESET);
6913 + wrmsrl(MSR_GLCP_DOTPLL, dotpll);
6914 +
6915 + do {
6916 + rdmsrl(MSR_GLCP_DOTPLL, dotpll);
6917 + } while (timeout-- && !(dotpll & MSR_GLCP_DOTPLL_LOCK));
6918 +}
6919 +
6920 +/* FIXME: Make sure nothing is read to clear */
6921 +
6922 +void gx_save_regs(struct fb_info *info, struct geoderegs *regs)
6923 +{
6924 + struct geodefb_par *par = info->par;
6925 + int i;
6926 +
6927 + /* Wait for the BLT engine to stop being busy */
6928 + while(readl(par->gp_regs + 0x44) & 0x05);
6929 +
6930 + rdmsrl(GX_VP_MSR_PAD_SELECT, regs->msr.padsel);
6931 + rdmsrl(MSR_GLCP_DOTPLL, regs->msr.dotpll);
6932 + rdmsrl(MSR_GLCP_SYS_RSTPLL, regs->msr.rstpll);
6933 +
6934 + writel(0x4758, par->dc_regs + 0x00);
6935 +
6936 + memcpy(regs->gp.b, par->gp_regs, GP_REG_SIZE);
6937 + memcpy(regs->dc.b, par->dc_regs, DC_REG_SIZE);
6938 + memcpy(regs->vp.b, par->vid_regs, VP_REG_SIZE);
6939 + memcpy(regs->fp.b, par->vid_regs + 0x400, FP_REG_SIZE);
6940 +
6941 + /* Save the palettes */
6942 + writel(0, par->dc_regs + 0x70);
6943 +
6944 + for(i = 0; i < DC_PAL_SIZE; i++)
6945 + regs->pal[i] = readl(par->dc_regs + 0x74);
6946 +
6947 + writel(0, par->vid_regs + 0x38);
6948 +
6949 + for(i = 0; i < 0xFF; i++)
6950 + regs->gamma[i] = readl(par->vid_regs + 0x40);
6951 +}
6952 +
6953 +void gx_restore_regs(struct fb_info *info, struct geoderegs *regs)
6954 +{
6955 + struct geodefb_par *par = info->par;
6956 + u32 val, i;
6957 +
6958 + /* DOTPLL */
6959 + gx_set_dotpll(info, regs);
6960 +
6961 + /* GP */
6962 +
6963 + writel(regs->gp.r.dst_offset, par->gp_regs + 0x00);
6964 + writel(regs->gp.r.src_offset, par->gp_regs + 0x04);
6965 + writel(regs->gp.r.stride, par->gp_regs + 0x08);
6966 + writel(regs->gp.r.wid_height, par->gp_regs + 0x0C);
6967 + writel(regs->gp.r.src_color_fg, par->gp_regs + 0x10);
6968 + writel(regs->gp.r.src_color_bg, par->gp_regs + 0x14);
6969 + writel(regs->gp.r.pat_color_0, par->gp_regs + 0x18);
6970 + writel(regs->gp.r.pat_color_1, par->gp_regs + 0x1C);
6971 + writel(regs->gp.r.pat_color_2, par->gp_regs + 0x20);
6972 + writel(regs->gp.r.pat_color_3, par->gp_regs + 0x24);
6973 + writel(regs->gp.r.pat_color_4, par->gp_regs + 0x28);
6974 + writel(regs->gp.r.pat_color_5, par->gp_regs + 0x2C);
6975 + writel(regs->gp.r.pat_data_0, par->gp_regs + 0x30);
6976 + writel(regs->gp.r.pat_data_1, par->gp_regs + 0x34);
6977 +
6978 + /* Don't write the raster / vector / blt mode regs */
6979 + /* status register is read only */
6980 +
6981 + writel(regs->gp.r.hst_src, par->gp_regs + 0x48);
6982 + writel(regs->gp.r.base_offset, par->gp_regs + 0x4c);
6983 +
6984 + /* DC */
6985 +
6986 + /* Write the unlock value */
6987 + writel(0x4758, par->dc_regs + 0x00);
6988 +
6989 + writel(0, par->dc_regs + 0x70);
6990 +
6991 + for(i = 0; i < DC_PAL_SIZE; i++)
6992 + writel(regs->pal[i], par->dc_regs + 0x74);
6993 +
6994 + /* Write the gcfg register without the enables */
6995 + writel(regs->dc.r.gcfg & ~0x0F, par->dc_regs + 0x04);
6996 +
6997 + /* Write the vcfg register without the enables */
6998 + writel(regs->dc.r.dcfg & ~0x19, par->dc_regs + 0x08);
6999 +
7000 + /* Write the rest of the active registers */
7001 +
7002 + writel(regs->dc.r.fb_st_offset, par->dc_regs + 0x10);
7003 + writel(regs->dc.r.cb_st_offset, par->dc_regs + 0x14);
7004 + writel(regs->dc.r.curs_st_offset, par->dc_regs + 0x18);
7005 + writel(regs->dc.r.icon_st_offset, par->dc_regs + 0x1C);
7006 + writel(regs->dc.r.vid_y_st_offset, par->dc_regs + 0x20);
7007 + writel(regs->dc.r.vid_u_st_offset, par->dc_regs + 0x24);
7008 + writel(regs->dc.r.vid_v_st_offset, par->dc_regs + 0x28);
7009 + writel(regs->dc.r.line_size, par->dc_regs + 0x30);
7010 + writel(regs->dc.r.gfx_pitch, par->dc_regs + 0x34);
7011 + writel(regs->dc.r.vid_yuv_pitch, par->dc_regs + 0x38);
7012 + writel(regs->dc.r.h_active_timing, par->dc_regs + 0x40);
7013 + writel(regs->dc.r.h_blank_timing, par->dc_regs + 0x44);
7014 + writel(regs->dc.r.h_sync_timing, par->dc_regs + 0x48);
7015 + writel(regs->dc.r.v_active_timing, par->dc_regs + 0x50);
7016 + writel(regs->dc.r.v_blank_timing, par->dc_regs + 0x54);
7017 + writel(regs->dc.r.v_sync_timing, par->dc_regs + 0x58);
7018 + writel(regs->dc.r.dc_cursor_x, par->dc_regs + 0x60);
7019 + writel(regs->dc.r.dc_cursor_y, par->dc_regs + 0x64);
7020 + writel(regs->dc.r.dc_icon_x, par->dc_regs + 0x68);
7021 +
7022 + /* Don't write the line_cnt or diag registers */
7023 +
7024 + writel(regs->dc.r.dc_vid_ds_delta, par->dc_regs + 0x80);
7025 + writel(regs->dc.r.gliu0_mem_offset, par->dc_regs + 0x84);
7026 + writel(regs->dc.r.dv_acc, par->dc_regs + 0x8C);
7027 +
7028 + /* VP */
7029 +
7030 + /* MSR */
7031 + wrmsrl(GX_VP_MSR_PAD_SELECT, regs->msr.padsel);
7032 +
7033 + writel(0, par->vid_regs + 0x38);
7034 +
7035 + for(i = 0; i < 0xFF; i++)
7036 + writel((u32) regs->gamma[i], par->vid_regs + 0x40);
7037 +
7038 + /* Don't enable video yet */
7039 + writel((u32) regs->vp.r.vcfg & ~0x01, par->vid_regs + 0x00);
7040 +
7041 + /* Don't enable the CRT yet */
7042 + writel((u32) regs->vp.r.dcfg & ~0x0F, par->vid_regs + 0x08);
7043 +
7044 + /* Write the rest of the VP registers */
7045 +
7046 + writel((u32) regs->vp.r.vx, par->vid_regs + 0x10);
7047 + writel((u32) regs->vp.r.vy, par->vid_regs + 0x18);
7048 + writel((u32) regs->vp.r.vs, par->vid_regs + 0x20);
7049 + writel((u32) regs->vp.r.vck, par->vid_regs + 0x28);
7050 + writel((u32) regs->vp.r.vcm, par->vid_regs + 0x30);
7051 + writel((u32) regs->vp.r.misc, par->vid_regs + 0x50);
7052 + writel((u32) regs->vp.r.ccs, par->vid_regs + 0x58);
7053 + writel((u32) regs->vp.r.vdc, par->vid_regs + 0x78);
7054 + writel((u32) regs->vp.r.vco, par->vid_regs + 0x80);
7055 + writel((u32) regs->vp.r.crc, par->vid_regs + 0x88);
7056 + writel((u32) regs->vp.r.vde, par->vid_regs + 0x98);
7057 + writel((u32) regs->vp.r.cck, par->vid_regs + 0xA0);
7058 + writel((u32) regs->vp.r.ccm, par->vid_regs + 0xA8);
7059 + writel((u32) regs->vp.r.cc1, par->vid_regs + 0xB0);
7060 + writel((u32) regs->vp.r.cc2, par->vid_regs + 0xB8);
7061 + writel((u32) regs->vp.r.a1x, par->vid_regs + 0xC0);
7062 + writel((u32) regs->vp.r.a1y, par->vid_regs + 0xC8);
7063 + writel((u32) regs->vp.r.a1c, par->vid_regs + 0xD0);
7064 + writel((u32) regs->vp.r.a1t, par->vid_regs + 0xD8);
7065 + writel((u32) regs->vp.r.a2x, par->vid_regs + 0xE0);
7066 + writel((u32) regs->vp.r.a2y, par->vid_regs + 0xE8);
7067 + writel((u32) regs->vp.r.a2c, par->vid_regs + 0xF0);
7068 + writel((u32) regs->vp.r.a2t, par->vid_regs + 0xF8);
7069 + writel((u32) regs->vp.r.a3x, par->vid_regs + 0x100);
7070 + writel((u32) regs->vp.r.a3y, par->vid_regs + 0x108);
7071 + writel((u32) regs->vp.r.a3c, par->vid_regs + 0x110);
7072 + writel((u32) regs->vp.r.a3t, par->vid_regs + 0x118);
7073 + writel((u32) regs->vp.r.vrr, par->vid_regs + 0x120);
7074 +
7075 +
7076 + /* FP registers */
7077 +
7078 + writel((u32) regs->fp.r.pt1, par->vid_regs + 0x400);
7079 + writel((u32) regs->fp.r.pt2, par->vid_regs + 0x408);
7080 +
7081 + writel((u32) regs->fp.r.dfc, par->vid_regs + 0x418);
7082 + writel(regs->fp.r.blfsr, par->vid_regs + 0x420);
7083 + writel(regs->fp.r.rlfsr, par->vid_regs + 0x428);
7084 + writel(regs->fp.r.fmi, par->vid_regs + 0x430);
7085 + writel(regs->fp.r.fmd, par->vid_regs + 0x438);
7086 + writel(regs->fp.r.dca, par->vid_regs + 0x448);
7087 + writel(regs->fp.r.dmd, par->vid_regs + 0x450);
7088 + writel(regs->fp.r.crc, par->vid_regs + 0x458);
7089 + writel(regs->fp.r.fbb, par->vid_regs + 0x460);
7090 +
7091 + /* Final enables */
7092 +
7093 + val = readl(par->vid_regs + 0x410);
7094 +
7095 + /* Control the panel */
7096 + if (regs->fp.r.pm & (1 << 24)) {
7097 +
7098 + if (!(val & 0x09))
7099 + writel(regs->fp.r.pm, par->vid_regs + 0x410);
7100 + }
7101 + else {
7102 + if (!(val & 0x05))
7103 + writel(regs->fp.r.pm, par->vid_regs + 0x410);
7104 + }
7105 +
7106 + /* Turn everything on */
7107 +
7108 + writel(regs->dc.r.gcfg, par->dc_regs + 0x04);
7109 + writel((u32) regs->vp.r.vcfg, par->vid_regs + 0x00);
7110 + writel((u32) regs->vp.r.dcfg, par->vid_regs + 0x08);
7111 + writel(regs->dc.r.dcfg, par->dc_regs + 0x08);
7112 +}
7113 +
7114 +
7115 +#ifdef DEBUG
7116 +
7117 +void dump_regs(struct fb_info *info, int mode) {
7118 +
7119 + struct geodefb_par *par = info->par;
7120 + u32 val;
7121 + int i;
7122 +
7123 + if (mode == 0) {
7124 + for(i = 0; i < GP_REG_SIZE; i += 4) {
7125 + val = readl(par->gp_regs + i);
7126 + }
7127 + }
7128 +
7129 + if (mode == 1) {
7130 + writel(0x4758, par->dc_regs + 0x00);
7131 +
7132 + for(i = 0; i < DC_REG_SIZE; i += 4) {
7133 + val = readl(par->dc_regs + i);
7134 + printk("DC%x: %x\n", i, val);
7135 + }
7136 + }
7137 +
7138 + if (mode == 2) {
7139 + for(i = 0; i < VP_REG_SIZE; i += 8) {
7140 + val = readl(par->vid_regs + i);
7141 + printk("VP%x: %x\n", i, val);
7142 + }
7143 + }
7144 +
7145 + if (mode == 3) {
7146 + for(i = 0; i < FP_REG_SIZE; i += 8) {
7147 + val = readl(par->vid_regs + 0x400 + i);
7148 + printk("FP%x: %x\n", i, val);
7149 + }
7150 + }
7151 +}
7152 +
7153 +#endif
7154 Index: linux-2.6.24.7/drivers/video/geode/video_gx.c
7155 ===================================================================
7156 --- linux-2.6.24.7.orig/drivers/video/geode/video_gx.c
7157 +++ linux-2.6.24.7/drivers/video/geode/video_gx.c
7158 @@ -16,10 +16,14 @@
7159 #include <asm/io.h>
7160 #include <asm/delay.h>
7161 #include <asm/msr.h>
7162 +#include <asm/olpc.h>
7163
7164 #include "geodefb.h"
7165 #include "video_gx.h"
7166 +#include "display_gx.h"
7167
7168 +/* This structure is used to store the saved registers during suspend */
7169 +static struct geoderegs gx_saved_regs;
7170
7171 /*
7172 * Tables of register settings for various DOTCLKs.
7173 @@ -58,7 +62,7 @@ static const struct gx_pll_entry gx_pll_
7174 { 13888, POSTDIV3, 0x000007E1 }, /* 72.0000 */
7175 { 13426, PREMULT2, 0x00000F4A }, /* 74.4810 */
7176 { 13333, 0, 0x00000052 }, /* 75.0000 */
7177 - { 12698, 0, 0x00000056 }, /* 78.7500 */
7178 + { 12698, 0, 0x00000056 }, /* 78.7500 */
7179 { 12500, POSTDIV3|PREMULT2, 0x00000709 }, /* 80.0000 */
7180 { 11135, PREMULT2, 0x00000262 }, /* 89.8000 */
7181 { 10582, 0, 0x000002D2 }, /* 94.5000 */
7182 @@ -117,8 +121,9 @@ static const struct gx_pll_entry gx_pll_
7183 { 4357, 0, 0x0000057D }, /* 229.5000 */
7184 };
7185
7186 -static void gx_set_dclk_frequency(struct fb_info *info)
7187 +void gx_set_dclk_frequency(struct fb_info *info)
7188 {
7189 + struct geodefb_par *par = info->par;
7190 const struct gx_pll_entry *pll_table;
7191 int pll_table_len;
7192 int i, best_i;
7193 @@ -173,115 +178,169 @@ static void gx_set_dclk_frequency(struct
7194 do {
7195 rdmsrl(MSR_GLCP_DOTPLL, dotpll);
7196 } while (timeout-- && !(dotpll & MSR_GLCP_DOTPLL_LOCK));
7197 +
7198 + par->curdclk = pll_table[best_i].dotpll_value;
7199 }
7200
7201 -static void
7202 -gx_configure_tft(struct fb_info *info)
7203 +/* Find out the current clock - we will use this information to avoid
7204 + re-programming it if we don't need to */
7205 +
7206 +unsigned int gx_get_dclk(struct fb_info *info)
7207 {
7208 - struct geodefb_par *par = info->par;
7209 - unsigned long val;
7210 - unsigned long fp;
7211 + const struct gx_pll_entry *pll_table;
7212 + int pll_table_len;
7213 + u64 dotpll;
7214 + int i;
7215
7216 - /* Set up the DF pad select MSR */
7217 + if (cpu_data(0).x86_mask == 1) {
7218 + pll_table = gx_pll_table_14MHz;
7219 + pll_table_len = ARRAY_SIZE(gx_pll_table_14MHz);
7220 + } else {
7221 + pll_table = gx_pll_table_48MHz;
7222 + pll_table_len = ARRAY_SIZE(gx_pll_table_48MHz);
7223 + }
7224
7225 - rdmsrl(GX_VP_MSR_PAD_SELECT, val);
7226 - val &= ~GX_VP_PAD_SELECT_MASK;
7227 - val |= GX_VP_PAD_SELECT_TFT;
7228 - wrmsrl(GX_VP_MSR_PAD_SELECT, val);
7229 + rdmsrl(MSR_GLCP_DOTPLL, dotpll);
7230
7231 - /* Turn off the panel */
7232 + for(i = 0; i < pll_table_len; i++) {
7233 + if (pll_table[i].dotpll_value == (u32) (dotpll >> 32))
7234 + break;
7235 + }
7236 +
7237 + return (i == pll_table_len) ? 0 : pll_table[i].pixclock;
7238 +}
7239
7240 - fp = readl(par->vid_regs + GX_FP_PM);
7241 - fp &= ~GX_FP_PM_P;
7242 - writel(fp, par->vid_regs + GX_FP_PM);
7243
7244 - /* Set timing 1 */
7245 +#define CMP(val, mask, res) (((val) & (mask)) == (res))
7246
7247 - fp = readl(par->vid_regs + GX_FP_PT1);
7248 - fp &= GX_FP_PT1_VSIZE_MASK;
7249 - fp |= info->var.yres << GX_FP_PT1_VSIZE_SHIFT;
7250 - writel(fp, par->vid_regs + GX_FP_PT1);
7251 +static void
7252 +gx_configure_tft(struct fb_info *info) {
7253
7254 - /* Timing 2 */
7255 - /* Set bits that are always on for TFT */
7256 + struct geodefb_par *par = info->par;
7257 + u32 val, fp = 0, fp1, fp2, sync = 0;
7258
7259 - fp = 0x0F100000;
7260 + /* Set up the DF pad select MSR */
7261
7262 - /* Add sync polarity */
7263 + rdmsrl(GX_VP_MSR_PAD_SELECT, val);
7264 +
7265 + if ((val & GX_VP_PAD_SELECT_MASK) != GX_VP_PAD_SELECT_TFT) {
7266 + val &= ~GX_VP_PAD_SELECT_MASK;
7267 + val |= GX_VP_PAD_SELECT_TFT;
7268 + wrmsrl(GX_VP_MSR_PAD_SELECT, val);
7269 + }
7270
7271 if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT))
7272 - fp |= GX_FP_PT2_VSP;
7273 + sync |= GX_FP_PT2_VSP;
7274
7275 if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT))
7276 - fp |= GX_FP_PT2_HSP;
7277 + sync |= GX_FP_PT2_HSP;
7278
7279 - writel(fp, par->vid_regs + GX_FP_PT2);
7280 + /* We only need to turn off the panel if something changed */
7281
7282 - /* Set the dither control */
7283 - writel(0x70, par->vid_regs + GX_FP_DFC);
7284 + fp1 = readl(par->vid_regs + GX_FP_PT1);
7285 + fp2 = readl(par->vid_regs + GX_FP_PT2);
7286 +
7287 + if (!CMP(fp1, GX_FP_PT1_VSIZE_MASK, info->var.yres << GX_FP_PT1_VSIZE_SHIFT) ||
7288 + (fp2 != (0x0F100000 | sync))) {
7289 +
7290 + /* Turn off the panel */
7291 +
7292 +#ifdef NOTUSED
7293 + /* Do we really need to turn off the panel? */
7294 + /* Possibly - we have a glitch somewhere */
7295
7296 - /* Enable the FP data and power (in case the BIOS didn't) */
7297 + fp = readl(par->vid_regs + GX_FP_PM);
7298 + fp &= ~GX_FP_PM_P;
7299 + writel(fp, par->vid_regs + GX_FP_PM);
7300 +#endif
7301
7302 - fp = readl(par->vid_regs + GX_DCFG);
7303 - fp |= GX_DCFG_FP_PWR_EN | GX_DCFG_FP_DATA_EN;
7304 - writel(fp, par->vid_regs + GX_DCFG);
7305 + /* Timing 1 */
7306 + fp1 &= GX_FP_PT1_VSIZE_MASK;
7307 + fp1 |= info->var.yres << GX_FP_PT1_VSIZE_SHIFT;
7308 + writel(fp, par->vid_regs + GX_FP_PT1);
7309
7310 - /* Unblank the panel */
7311 + /* Timing 2 */
7312 + writel(0x0F100000 | sync, par->vid_regs + GX_FP_PT2);
7313 + }
7314 +
7315 + /* Set the dither control */
7316 + if (readl(par->vid_regs + GX_FP_DFC) != 0x70) {
7317 + writel(0x70, par->vid_regs + GX_FP_DFC);
7318 + }
7319 +
7320 + /* Turn on the panel */
7321
7322 fp = readl(par->vid_regs + GX_FP_PM);
7323 - fp |= GX_FP_PM_P;
7324 - writel(fp, par->vid_regs + GX_FP_PM);
7325 +
7326 + if (!(fp & 0x09))
7327 + writel(fp | GX_FP_PM_P, par->vid_regs + GX_FP_PM);
7328 }
7329
7330 +#define DCFG_DEFAULT_VAL GX_DCFG_CRT_SYNC_SKW_DFLT | GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN | \
7331 +GX_DCFG_CRT_EN | GX_DCFG_DAC_BL_EN
7332 +
7333 static void gx_configure_display(struct fb_info *info)
7334 {
7335 struct geodefb_par *par = info->par;
7336 - u32 dcfg, misc;
7337 + u32 dcfg, misc, sync = 0;
7338
7339 /* Set up the MISC register */
7340 -
7341 misc = readl(par->vid_regs + GX_MISC);
7342
7343 - /* Power up the DAC */
7344 - misc &= ~(GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN);
7345 + /* We leave gamma enabled if it was already enabled.
7346 + Although the hardware enables it without setting
7347 + up the gamma table, the BIOS or bootloader ought
7348 + to have either disabled it or loaded a table by now */
7349
7350 - /* Disable gamma correction */
7351 - misc |= GX_MISC_GAM_EN;
7352
7353 - writel(misc, par->vid_regs + GX_MISC);
7354
7355 - /* Write the display configuration */
7356 - dcfg = readl(par->vid_regs + GX_DCFG);
7357 + if (par->enable_crt) {
7358 + /* Power up the CRT DACs */
7359 + if (misc & ( GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN)) {
7360 + misc &= ~(GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN);
7361 + writel(misc, par->vid_regs + GX_MISC);
7362 + }
7363
7364 - /* Disable hsync and vsync */
7365 - dcfg &= ~(GX_DCFG_VSYNC_EN | GX_DCFG_HSYNC_EN);
7366 - writel(dcfg, par->vid_regs + GX_DCFG);
7367 + if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT))
7368 + sync |= GX_DCFG_CRT_HSYNC_POL;
7369
7370 - /* Clear bits from existing mode. */
7371 - dcfg &= ~(GX_DCFG_CRT_SYNC_SKW_MASK
7372 - | GX_DCFG_CRT_HSYNC_POL | GX_DCFG_CRT_VSYNC_POL
7373 - | GX_DCFG_VSYNC_EN | GX_DCFG_HSYNC_EN);
7374 + if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT))
7375 + sync |= GX_DCFG_CRT_VSYNC_POL;
7376 + }
7377 + else {
7378 + /* Turn off the CRT DACs in FP mode - we don't need them */
7379 + if ((misc & (GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN))) {
7380 + misc |= (GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN);
7381 + writel(misc, par->vid_regs + GX_MISC);
7382 + }
7383 + }
7384
7385 - /* Set default sync skew. */
7386 - dcfg |= GX_DCFG_CRT_SYNC_SKW_DFLT;
7387 + /* Write the display configuration */
7388 + dcfg = readl(par->vid_regs + GX_DCFG);
7389
7390 - /* Enable hsync and vsync. */
7391 - dcfg |= GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN;
7392 + if (!CMP(dcfg, DCFG_DEFAULT_VAL | GX_DCFG_CRT_HSYNC_POL | GX_DCFG_CRT_VSYNC_POL,
7393 + DCFG_DEFAULT_VAL | sync)) {
7394
7395 - /* Sync polarities. */
7396 - if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
7397 - dcfg |= GX_DCFG_CRT_HSYNC_POL;
7398 - if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
7399 - dcfg |= GX_DCFG_CRT_VSYNC_POL;
7400 + /* Disable hsync and vsync */
7401 + dcfg &= ~(GX_DCFG_VSYNC_EN | GX_DCFG_HSYNC_EN);
7402 + writel(dcfg, par->vid_regs + GX_DCFG);
7403
7404 - /* Enable the display logic */
7405 - /* Set up the DACS to blank normally */
7406 + /* Clear bits from existing mode. */
7407 + dcfg &= ~(GX_DCFG_CRT_SYNC_SKW_MASK
7408 + | GX_DCFG_CRT_HSYNC_POL | GX_DCFG_CRT_VSYNC_POL
7409 + | GX_DCFG_VSYNC_EN | GX_DCFG_HSYNC_EN);
7410
7411 - dcfg |= GX_DCFG_CRT_EN | GX_DCFG_DAC_BL_EN;
7412 + /* Set default sync skew. */
7413 + dcfg |= GX_DCFG_CRT_SYNC_SKW_DFLT;
7414
7415 - /* Enable the external DAC VREF? */
7416 + /* Enable hsync and vsync. */
7417 + dcfg |= GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN;
7418
7419 - writel(dcfg, par->vid_regs + GX_DCFG);
7420 + /* Enable the display logic */
7421 + dcfg |= GX_DCFG_CRT_EN | GX_DCFG_DAC_BL_EN;
7422 +
7423 + writel(dcfg, par->vid_regs + GX_DCFG);
7424 + }
7425
7426 /* Set up the flat panel (if it is enabled) */
7427
7428 @@ -289,6 +348,100 @@ static void gx_configure_display(struct
7429 gx_configure_tft(info);
7430 }
7431
7432 +int gxfb_powerdown(struct fb_info *info)
7433 +{
7434 + struct geodefb_par *par = info->par;
7435 +
7436 + /* We're already suspended */
7437 +
7438 + if (par->state != FB_POWER_STATE_ON)
7439 + return 0;
7440 +
7441 + /* Save the registers */
7442 + gx_save_regs(info, &gx_saved_regs);
7443 +
7444 + /* Shut down the engine */
7445 +
7446 + writel(gx_saved_regs.vp.r.vcfg & ~0x01, par->vid_regs + GX_VCFG);
7447 + writel(gx_saved_regs.vp.r.dcfg & ~0x0F, par->vid_regs + GX_DCFG);
7448 +
7449 + /* Turn off the flat panel unless we are attached to a DCON */
7450 + if (!olpc_has_dcon())
7451 + writel(gx_saved_regs.fp.r.pm & ~GX_FP_PM_P, par->vid_regs + GX_FP_PM);
7452 +
7453 + writel(0x4758, par->dc_regs + DC_UNLOCK);
7454 +
7455 + writel(gx_saved_regs.dc.r.gcfg & ~0x0F,
7456 + par->dc_regs + DC_GENERAL_CFG);
7457 +
7458 + writel(gx_saved_regs.dc.r.dcfg & ~0x19,
7459 + par->dc_regs + DC_DISPLAY_CFG);
7460 +
7461 + par->state = FB_POWER_STATE_SUSPEND;
7462 +
7463 + return 0;
7464 +}
7465 +
7466 +int gxfb_powerup(struct fb_info *info)
7467 +{
7468 + struct geodefb_par *par = info->par;
7469 + u32 val;
7470 +
7471 + if (par->state == FB_POWER_STATE_SUSPEND) {
7472 +
7473 + writel(gx_saved_regs.dc.r.dcfg,
7474 + par->dc_regs + DC_DISPLAY_CFG);
7475 +
7476 + writel(gx_saved_regs.vp.r.vcfg, par->vid_regs + GX_VCFG);
7477 + writel(gx_saved_regs.vp.r.dcfg, par->vid_regs + GX_DCFG);
7478 +
7479 + val = readl(par->vid_regs + GX_FP_PM);
7480 +
7481 + /* power up the panel if it needs it; we don't always power it down */
7482 + if (!(val & 0x09)) {
7483 + writel(gx_saved_regs.fp.r.pm, par->vid_regs + GX_FP_PM);
7484 + mdelay(64);
7485 + }
7486 + }
7487 +
7488 + /* If the panel is currently on its way up, then wait up to 100ms
7489 + for it */
7490 +
7491 + if (readl(par->vid_regs + GX_FP_PM) & 0x08) {
7492 + int i;
7493 +
7494 + for(i = 0; i < 10; i++) {
7495 + if (readl(par->vid_regs + GX_FP_PM) & 0x01)
7496 + break;
7497 +
7498 + mdelay(10);
7499 + }
7500 +
7501 + if (i == 10)
7502 + printk(KERN_ERR "gxfb: Panel power up timed out\n");
7503 + }
7504 +
7505 + if (par->state == FB_POWER_STATE_ON)
7506 + return 0;
7507 +
7508 + switch(par->state) {
7509 + case FB_POWER_STATE_OFF:
7510 + gx_restore_regs(info, &gx_saved_regs);
7511 + break;
7512 +
7513 + case FB_POWER_STATE_SUSPEND:
7514 + /* Do this because it will turn on the FIFO which will
7515 + start the line count */
7516 + writel(gx_saved_regs.dc.r.gcfg,
7517 + par->dc_regs + DC_GENERAL_CFG);
7518 + writel(0x0, par->dc_regs + DC_UNLOCK);
7519 + break;
7520 + }
7521 +
7522 + par->state = FB_POWER_STATE_ON;
7523 + return 0;
7524 +}
7525 +
7526 static int gx_blank_display(struct fb_info *info, int blank_mode)
7527 {
7528 struct geodefb_par *par = info->par;
7529 @@ -315,6 +468,7 @@ static int gx_blank_display(struct fb_in
7530 default:
7531 return -EINVAL;
7532 }
7533 +
7534 dcfg = readl(par->vid_regs + GX_DCFG);
7535 dcfg &= ~(GX_DCFG_DAC_BL_EN
7536 | GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN);
7537 @@ -326,7 +480,7 @@ static int gx_blank_display(struct fb_in
7538 dcfg |= GX_DCFG_VSYNC_EN;
7539 writel(dcfg, par->vid_regs + GX_DCFG);
7540
7541 - /* Power on/off flat panel. */
7542 + /* Power on/off flat panel */
7543
7544 if (par->enable_crt == 0) {
7545 fp_pm = readl(par->vid_regs + GX_FP_PM);
7546 @@ -340,8 +494,37 @@ static int gx_blank_display(struct fb_in
7547 return 0;
7548 }
7549
7550 +extern struct fb_info *gxfb_info;
7551 +
7552 +/* This function controls the flatpanel power sequencing - this is used
7553 + by the OLPC power management engine to enable the FP sequencing much
7554 + earlier in the resume process
7555 +*/
7556 +
7557 +void gxfb_flatpanel_control(int state)
7558 +{
7559 + struct geodefb_par *par = gxfb_info->par;
7560 + u32 val, fp = readl(par->vid_regs + GX_FP_PM);
7561 + val = fp;
7562 +
7563 + /* Turn on the panel if it isn't aleady */
7564 +
7565 + if (state) {
7566 + if (!(val & 0x01))
7567 + val |= GX_FP_PM_P;
7568 + }
7569 + else {
7570 + if (!(val & 0x02))
7571 + val &= ~GX_FP_PM_P;
7572 + }
7573 +
7574 + if (val != fp)
7575 + writel(val, par->vid_regs + GX_FP_PM);
7576 +}
7577 +
7578 struct geode_vid_ops gx_vid_ops = {
7579 .set_dclk = gx_set_dclk_frequency,
7580 + .get_dclk = gx_get_dclk,
7581 .configure_display = gx_configure_display,
7582 .blank_display = gx_blank_display,
7583 };
7584 Index: linux-2.6.24.7/drivers/video/geode/video_gx.h
7585 ===================================================================
7586 --- linux-2.6.24.7.orig/drivers/video/geode/video_gx.h
7587 +++ linux-2.6.24.7/drivers/video/geode/video_gx.h
7588 @@ -11,6 +11,8 @@
7589 #ifndef __VIDEO_GX_H__
7590 #define __VIDEO_GX_H__
7591
7592 +#include "geode_regs.h"
7593 +
7594 extern struct geode_vid_ops gx_vid_ops;
7595
7596 /* GX Flatpanel control MSR */
7597 @@ -20,6 +22,8 @@ extern struct geode_vid_ops gx_vid_ops;
7598
7599 /* Geode GX video processor registers */
7600
7601 +#define GX_VCFG 0x0000
7602 +
7603 #define GX_DCFG 0x0008
7604 # define GX_DCFG_CRT_EN 0x00000001
7605 # define GX_DCFG_HSYNC_EN 0x00000002
7606 @@ -42,6 +46,14 @@ extern struct geode_vid_ops gx_vid_ops;
7607 #define GX_MISC_DAC_PWRDN 0x00000400
7608 #define GX_MISC_A_PWRDN 0x00000800
7609
7610 +/* Gamma correction RAM - address and data registers */
7611 +
7612 +#define GX_GAR 0x038
7613 +#define GX_GDR 0x040
7614 +
7615 +#define GXFB_GAMMA_DWORDS 256 /* number of dwords in the gamma ram */
7616 +#define GXFB_GAMMA_SIZE (GXFB_GAMMA_DWORDS * sizeof(unsigned int))
7617 +
7618 /* Geode GX flat panel display control registers */
7619
7620 #define GX_FP_PT1 0x0400
7621 @@ -69,4 +81,13 @@ extern struct geode_vid_ops gx_vid_ops;
7622 # define MSR_GLCP_DOTPLL_BYPASS (0x0000000000008000ull)
7623 # define MSR_GLCP_DOTPLL_LOCK (0x0000000002000000ull)
7624
7625 +int gxfb_powerdown(struct fb_info *info);
7626 +int gxfb_powerup(struct fb_info *info);
7627 +
7628 +void gx_set_dclk_frequency(struct fb_info *info);
7629 +unsigned int gx_get_dclk(struct fb_info *info);
7630 +
7631 +void gx_save_regs(struct fb_info *info, struct geoderegs *regs);
7632 +void gx_restore_regs(struct fb_info *info, struct geoderegs *regs);
7633 +
7634 #endif /* !__VIDEO_GX_H__ */
7635 Index: linux-2.6.24.7/drivers/video/Kconfig
7636 ===================================================================
7637 --- linux-2.6.24.7.orig/drivers/video/Kconfig
7638 +++ linux-2.6.24.7/drivers/video/Kconfig
7639 @@ -1869,6 +1869,15 @@ config FB_PS3_DEFAULT_SIZE_M
7640 The default value can be overridden on the kernel command line
7641 using the "ps3fb" option (e.g. "ps3fb=9M");
7642
7643 +config FB_OLPC_DCON
7644 + tristate "One Laptop Per Child Display CONtroller support"
7645 + depends on OLPC
7646 + select I2C
7647 + ---help---
7648 + Add support for the OLPC DCON controller. This controller is only
7649 + available on OLPC platforms. Unless you have one of these
7650 + platforms, you will want to say 'N'.
7651 +
7652 config FB_XILINX
7653 tristate "Xilinx frame buffer support"
7654 depends on FB && XILINX_VIRTEX
7655 Index: linux-2.6.24.7/drivers/video/Makefile
7656 ===================================================================
7657 --- linux-2.6.24.7.orig/drivers/video/Makefile
7658 +++ linux-2.6.24.7/drivers/video/Makefile
7659 @@ -111,6 +111,7 @@ obj-$(CONFIG_FB_PNX4008_DUM_RGB) += pnx
7660 obj-$(CONFIG_FB_IBM_GXT4500) += gxt4500.o
7661 obj-$(CONFIG_FB_PS3) += ps3fb.o
7662 obj-$(CONFIG_FB_SM501) += sm501fb.o
7663 +obj-$(CONFIG_FB_OLPC_DCON) += olpc_dcon.o
7664 obj-$(CONFIG_FB_XILINX) += xilinxfb.o
7665 obj-$(CONFIG_FB_OMAP) += omap/
7666
7667 Index: linux-2.6.24.7/drivers/video/modedb.c
7668 ===================================================================
7669 --- linux-2.6.24.7.orig/drivers/video/modedb.c
7670 +++ linux-2.6.24.7/drivers/video/modedb.c
7671 @@ -33,6 +33,8 @@ const char *fb_mode_option;
7672 * Standard video mode definitions (taken from XFree86)
7673 */
7674
7675 +#define DEFAULT_MODEDB_INDEX 0
7676 +
7677 static const struct fb_videomode modedb[] = {
7678 {
7679 /* 640x400 @ 70 Hz, 31.5 kHz hsync */
7680 @@ -508,7 +510,8 @@ int fb_find_mode(struct fb_var_screeninf
7681 }
7682
7683 if (!default_mode)
7684 - default_mode = &db[0];
7685 + default_mode = (db == modedb) ?
7686 + &modedb[DEFAULT_MODEDB_INDEX] : &db[0];
7687
7688 if (!default_bpp)
7689 default_bpp = 8;
7690 Index: linux-2.6.24.7/drivers/video/olpc_dcon.c
7691 ===================================================================
7692 --- /dev/null
7693 +++ linux-2.6.24.7/drivers/video/olpc_dcon.c
7694 @@ -0,0 +1,946 @@
7695 +/*
7696 + * Mainly by David Woodhouse, somewhat modified by Jordan Crouse
7697 + *
7698 + * Copyright © 2006-2007 Red Hat, Inc.
7699 + * Copyright © 2006-2007 Advanced Micro Devices, Inc.
7700 + *
7701 + * This program is free software. You can redistribute it and/or
7702 + * modify it under the terms of version 2 of the GNU General Public
7703 + * License as published by the Free Software Foundation.
7704 + */
7705 +
7706 +
7707 +#include <linux/kernel.h>
7708 +#include <linux/fb.h>
7709 +#include <linux/console.h>
7710 +#include <linux/i2c.h>
7711 +#include <linux/platform_device.h>
7712 +#include <linux/i2c-id.h>
7713 +#include <linux/pci.h>
7714 +#include <linux/vt_kern.h>
7715 +#include <linux/pci_ids.h>
7716 +#include <linux/interrupt.h>
7717 +#include <linux/delay.h>
7718 +#include <linux/backlight.h>
7719 +#include <linux/device.h>
7720 +#include <linux/notifier.h>
7721 +#include <asm/uaccess.h>
7722 +#include <linux/ctype.h>
7723 +#include <linux/reboot.h>
7724 +#include <asm/tsc.h>
7725 +#include <asm/olpc.h>
7726 +#include <asm/geode.h>
7727 +
7728 +#include "olpc_dcon.h"
7729 +
7730 +/* Module definitions */
7731 +
7732 +static int resumeline = 898;
7733 +module_param(resumeline, int, 0444);
7734 +
7735 +static int noinit;
7736 +module_param(noinit, int, 0444);
7737 +
7738 +/* Default off since it doesn't work on DCON ASIC in B-test OLPC board */
7739 +static int useaa = 1;
7740 +module_param(useaa, int, 0444);
7741 +
7742 +/* I2C structures */
7743 +
7744 +static struct i2c_driver dcon_driver;
7745 +static struct i2c_client *dcon_client;
7746 +
7747 +/* Platform devices */
7748 +static struct platform_device *dcon_device;
7749 +
7750 +/* Backlight device */
7751 +static struct backlight_device *dcon_bl_dev;
7752 +
7753 +/* Base address of the GPIO registers */
7754 +static unsigned long gpio_base;
7755 +
7756 +static struct fb_info *fbinfo;
7757 +
7758 +/* Current source, initialized at probe time */
7759 +static int dcon_source;
7760 +
7761 +/* Desired source */
7762 +static int dcon_pending;
7763 +
7764 +/* Current output type */
7765 +static int dcon_output = DCON_OUTPUT_COLOR;
7766 +
7767 +/* Current sleep status (not yet implemented) */
7768 +static int dcon_sleep_val = DCON_ACTIVE;
7769 +
7770 +/* Shadow register for the DCON_REG_MODE register */
7771 +static unsigned short dcon_disp_mode;
7772 +
7773 +/* Variables used during switches */
7774 +static int dcon_switched;
7775 +
7776 +static DECLARE_WAIT_QUEUE_HEAD(dcon_wait_queue);
7777 +
7778 +static unsigned short normal_i2c[] = { 0x0D, I2C_CLIENT_END };
7779 +I2C_CLIENT_INSMOD;
7780 +
7781 +#define dcon_write(reg,val) i2c_smbus_write_word_data(dcon_client,reg,val)
7782 +#define dcon_read(reg) i2c_smbus_read_word_data(dcon_client,reg)
7783 +
7784 +/* The current backlight value - this saves us some smbus traffic */
7785 +static int bl_val = -1;
7786 +
7787 +/* ===== API functions - these are called by a variety of users ==== */
7788 +
7789 +static int dcon_request_irq(void);
7790 +
7791 +static int dcon_hw_init(struct i2c_client *client, int is_init)
7792 +{
7793 + uint16_t ver;
7794 + int rc = 0;
7795 +
7796 + ver = i2c_smbus_read_word_data(client, DCON_REG_ID);
7797 + if ((ver >> 8) != 0xDC) {
7798 + printk(KERN_ERR "olpc-dcon: DCON ID not 0xDCxx: 0x%04x "
7799 + "instead.\n", ver);
7800 + rc = -ENXIO;
7801 + goto err;
7802 + }
7803 +
7804 + if (is_init) {
7805 + printk(KERN_INFO "olpc-dcon: Discovered DCON version %x\n",
7806 + ver & 0xFF);
7807 + if ((rc = dcon_request_irq())) {
7808 + printk(KERN_ERR "olpc-dcon: Unable to grab IRQ.\n");
7809 + goto err;
7810 + }
7811 + }
7812 +
7813 + if (ver < 0xdc02 && !noinit) {
7814 + /* Initialize the DCON registers */
7815 +
7816 + /* Start with work-arounds for DCON ASIC */
7817 + i2c_smbus_write_word_data(client, 0x4b, 0x00cc);
7818 + i2c_smbus_write_word_data(client, 0x4b, 0x00cc);
7819 + i2c_smbus_write_word_data(client, 0x4b, 0x00cc);
7820 + i2c_smbus_write_word_data(client, 0x0b, 0x007a);
7821 + i2c_smbus_write_word_data(client, 0x36, 0x025c);
7822 + i2c_smbus_write_word_data(client, 0x37, 0x025e);
7823 +
7824 + /* Initialise SDRAM */
7825 +
7826 + i2c_smbus_write_word_data(client, 0x3b, 0x002b);
7827 + i2c_smbus_write_word_data(client, 0x41, 0x0101);
7828 + i2c_smbus_write_word_data(client, 0x42, 0x0101);
7829 + }
7830 + else if (!noinit) {
7831 + /* SDRAM setup/hold time */
7832 + i2c_smbus_write_word_data(client, 0x3a, 0xc040);
7833 + i2c_smbus_write_word_data(client, 0x41, 0x0000);
7834 + i2c_smbus_write_word_data(client, 0x41, 0x0101);
7835 + i2c_smbus_write_word_data(client, 0x42, 0x0101);
7836 + }
7837 +
7838 + /* Colour swizzle, AA, no passthrough, backlight */
7839 + if (is_init) {
7840 + dcon_disp_mode = MODE_PASSTHRU | MODE_BL_ENABLE | MODE_CSWIZZLE;
7841 + if (useaa)
7842 + dcon_disp_mode |= MODE_COL_AA;
7843 + }
7844 + i2c_smbus_write_word_data(client, DCON_REG_MODE, dcon_disp_mode);
7845 +
7846 +
7847 + /* Set the scanline to interrupt on during resume */
7848 +
7849 + i2c_smbus_write_word_data(client, DCON_REG_SCAN_INT, resumeline);
7850 +
7851 +err:
7852 + return rc;
7853 +}
7854 +
7855 +/*
7856 + * The smbus doesn't always come back due to what is believed to be
7857 + * hardware (power rail) bugs. For older models where this is known to
7858 + * occur, our solution is to attempt to wait for the bus to stabilize;
7859 + * if it doesn't happen, cut power to the dcon, repower it, and wait
7860 + * for the bus to stabilize. Rinse, repeat until we have a working
7861 + * smbus. For newer models, we simply BUG(); we want to know if this
7862 + * still happens despite the power fixes that have been made!
7863 + */
7864 +static int dcon_bus_stabilize(struct i2c_client *client, int is_powered_down)
7865 +{
7866 + unsigned long timeout;
7867 + int x;
7868 +
7869 +power_up:
7870 + if (is_powered_down) {
7871 + x = 1;
7872 + if ((x = olpc_ec_cmd(0x26, (unsigned char *) &x, 1, NULL, 0))) {
7873 + printk(KERN_WARNING "olpc-dcon: unable to force dcon "
7874 + "to power up: %d!\n", x);
7875 + return x;
7876 + }
7877 + msleep(10); /* we'll be conservative */
7878 + }
7879 +
7880 + /*
7881 + * According to HiMax, when powering the DCON up we should hold
7882 + * SMB_DATA high for 8 SMB_CLK cycles. This will force the DCON
7883 + * state machine to reset to a (sane) initial state. Mitch Bradley
7884 + * did some testing and discovered that holding for 16 SMB_CLK cycles
7885 + * worked a lot more reliably, so that's what we do here.
7886 + *
7887 + * According to the cs5536 spec, to set GPIO14 to SMB_CLK we must
7888 + * simultaneously set AUX1 IN/OUT to GPIO14; ditto for SMB_DATA and
7889 + * GPIO15.
7890 + */
7891 + geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_VAL);
7892 + geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_ENABLE);
7893 + geode_gpio_clear(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
7894 + geode_gpio_clear(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX2);
7895 + geode_gpio_clear(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
7896 +
7897 + for (x = 0; x < 16; x++) {
7898 + udelay(5);
7899 + geode_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
7900 + udelay(5);
7901 + geode_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
7902 + }
7903 + udelay(5);
7904 + geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
7905 + geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
7906 +
7907 + for (x = -1, timeout = 50; timeout && x < 0; timeout--) {
7908 + msleep(1);
7909 + x = dcon_read(DCON_REG_ID);
7910 + }
7911 + if (x < 0) {
7912 + printk(KERN_ERR "olpc-dcon: unable to stabilize dcon's "
7913 + "smbus, reasserting power and praying.\n");
7914 + BUG_ON(olpc_board_at_least(olpc_board(0xc2)));
7915 + x = 0;
7916 + olpc_ec_cmd(0x26, (unsigned char *) &x, 1, NULL, 0);
7917 + msleep(100);
7918 + is_powered_down = 1;
7919 + goto power_up; /* argh, stupid hardware.. */
7920 + }
7921 +
7922 + if (is_powered_down)
7923 + return dcon_hw_init(client, 0);
7924 + return 0;
7925 +}
7926 +
7927 +
7928 +/* Backlight notes - turning off the backlight enable bit in the DCON
7929 + * doesn't save us any power over just pushing the BL to zero, so we
7930 + * don't use that bit in this code.
7931 + */
7932 +
7933 +static int dcon_get_backlight(void)
7934 +{
7935 + if (dcon_client == NULL)
7936 + return 0;
7937 +
7938 + if (bl_val == -1)
7939 + bl_val = dcon_read(DCON_REG_BRIGHT) & 0x0F;
7940 +
7941 + return bl_val;
7942 +}
7943 +
7944 +static void dcon_set_backlight(int level)
7945 +{
7946 + if (dcon_client == NULL)
7947 + return;
7948 +
7949 + if (bl_val == (level & 0x0F))
7950 + return;
7951 +
7952 + bl_val = level & 0x0F;
7953 + dcon_write(DCON_REG_BRIGHT, bl_val);
7954 +
7955 + /* Purposely turn off the backlight when we go to level 0 */
7956 +
7957 + if (bl_val == 0) {
7958 + dcon_disp_mode &= ~MODE_BL_ENABLE;
7959 + dcon_write(DCON_REG_MODE, dcon_disp_mode);
7960 + }
7961 + else if (!(dcon_disp_mode & MODE_BL_ENABLE)) {
7962 + dcon_disp_mode |= MODE_BL_ENABLE;
7963 + dcon_write(DCON_REG_MODE, dcon_disp_mode);
7964 + }
7965 +}
7966 +
7967 +/* Set the output type to either color or mono */
7968 +
7969 +static int dcon_set_output(int arg)
7970 +{
7971 + if (dcon_output == arg)
7972 + return 0;
7973 +
7974 + dcon_output = arg;
7975 +
7976 + if (arg == DCON_OUTPUT_MONO) {
7977 + dcon_disp_mode &= ~(MODE_CSWIZZLE | MODE_COL_AA);
7978 + dcon_disp_mode |= MODE_MONO_LUMA;
7979 + }
7980 + else {
7981 + dcon_disp_mode &= ~(MODE_MONO_LUMA);
7982 + dcon_disp_mode |= MODE_CSWIZZLE;
7983 + if (useaa)
7984 + dcon_disp_mode |= MODE_COL_AA;
7985 + }
7986 +
7987 + dcon_write(DCON_REG_MODE, dcon_disp_mode);
7988 + return 0;
7989 +}
7990 +
7991 +/* For now, this will be really stupid - we need to address how
7992 + * DCONLOAD works in a sleep and account for it accordingly
7993 + */
7994 +
7995 +static void dcon_sleep(int state)
7996 +{
7997 + int x;
7998 +
7999 + /* Turn off the backlight and put the DCON to sleep */
8000 +
8001 + if (state == dcon_sleep_val)
8002 + return;
8003 +
8004 + if (!olpc_board_at_least(olpc_board(0xc2)))
8005 + return;
8006 +
8007 + if (state == DCON_SLEEP) {
8008 + x = 0;
8009 + if ((x = olpc_ec_cmd(0x26, (unsigned char *) &x, 1, NULL, 0)))
8010 + printk(KERN_WARNING "olpc-dcon: unable to force dcon "
8011 + "to power down: %d!\n", x);
8012 + else
8013 + dcon_sleep_val = state;
8014 + }
8015 + else {
8016 + /* Only re-enable the backlight if the backlight value is set */
8017 + if (bl_val != 0)
8018 + dcon_disp_mode |= MODE_BL_ENABLE;
8019 +
8020 + if ((x=dcon_bus_stabilize(dcon_client, 1)))
8021 + printk(KERN_WARNING "olpc-dcon: unable to reinit dcon"
8022 + " hardware: %d!\n", x);
8023 + else
8024 + dcon_sleep_val = state;
8025 + }
8026 +
8027 + /* We should turn off some stuff in the framebuffer - but what? */
8028 +}
8029 +
8030 +/* Set the source of the display (CPU or DCON) */
8031 +
8032 +static void dcon_source_switch(struct work_struct *work)
8033 +{
8034 + DECLARE_WAITQUEUE(wait, current);
8035 + int source = dcon_pending;
8036 +
8037 + if (dcon_source == source)
8038 + return;
8039 +
8040 + dcon_switched = 0;
8041 +
8042 + switch (source) {
8043 + case DCON_SOURCE_CPU:
8044 +
8045 + /* Enable the scanline interrupt bit */
8046 + if (dcon_write(DCON_REG_MODE, dcon_disp_mode | MODE_SCAN_INT))
8047 + printk(KERN_ERR "olpc-dcon: couldn't enable scanline interrupt!\n");
8048 + else {
8049 + /* Wait up to one second for the scanline interrupt */
8050 + wait_event_timeout(dcon_wait_queue, dcon_switched == 1, HZ);
8051 + }
8052 +
8053 + if (!dcon_switched)
8054 + printk(KERN_ERR "olpc-dcon: Timeout entering CPU mode; expect a screen glitch.\n");
8055 +
8056 + /*
8057 + * Ideally we'd like to disable interrupts here so that the
8058 + * fb unblanking and DCON turn on happen at a known time value;
8059 + * however, we can't do that right now with fb_blank
8060 + * messing with semaphores.
8061 + *
8062 + * For now, we just hope..
8063 + */
8064 + acquire_console_sem();
8065 + if (fb_blank(fbinfo, FB_BLANK_UNBLANK)) {
8066 + release_console_sem();
8067 + printk(KERN_ERR "olpc-dcon: Failed to enter CPU mode\n");
8068 + dcon_pending = DCON_SOURCE_DCON;
8069 + return;
8070 + }
8071 + release_console_sem();
8072 +
8073 + /* And turn off the DCON */
8074 + outl(1<<11, gpio_base + GPIOx_OUT_VAL);
8075 +
8076 + /* Turn off the scanline interrupt */
8077 + if (dcon_write(DCON_REG_MODE, dcon_disp_mode))
8078 + printk(KERN_ERR "olpc-dcon: couldn't disable scanline interrupt!\n");
8079 +
8080 + printk(KERN_INFO "olpc-dcon: The CPU has control\n");
8081 + break;
8082 + case DCON_SOURCE_DCON:
8083 + {
8084 + int t;
8085 +
8086 + add_wait_queue(&dcon_wait_queue, &wait);
8087 + set_current_state(TASK_UNINTERRUPTIBLE);
8088 +
8089 + /* Clear GPIO11 (DCONLOAD) - this implies that the DCON is in
8090 + control */
8091 +
8092 + outl(1 << (11 + 16), gpio_base + GPIOx_OUT_VAL);
8093 +
8094 + t = schedule_timeout(HZ/2);
8095 + remove_wait_queue(&dcon_wait_queue, &wait);
8096 + set_current_state(TASK_RUNNING);
8097 +
8098 + if (!dcon_switched)
8099 + printk(KERN_ERR "olpc-dcon: Timeout entering DCON mode; expect a screen glitch.\n");
8100 +
8101 + acquire_console_sem();
8102 + if (fb_blank(fbinfo, FB_BLANK_POWERDOWN))
8103 + printk(KERN_ERR "olpc-dcon: couldn't blank fb!\n");
8104 + release_console_sem();
8105 +
8106 + printk(KERN_INFO "olpc-dcon: The DCON has control\n");
8107 + break;
8108 + }
8109 + default:
8110 + BUG();
8111 + }
8112 +
8113 + dcon_source = source;
8114 +}
8115 +
8116 +static DECLARE_WORK(dcon_work, dcon_source_switch);
8117 +
8118 +static int dcon_set_source(int arg)
8119 +{
8120 + if (arg != DCON_SOURCE_CPU && arg != DCON_SOURCE_DCON)
8121 + return -EINVAL;
8122 +
8123 + if (dcon_pending == arg)
8124 + return 0;
8125 +
8126 + dcon_pending = arg;
8127 + if ((dcon_source != arg) && !work_pending(&dcon_work))
8128 + schedule_work(&dcon_work);
8129 +
8130 + return 0;
8131 +}
8132 +
8133 +static int dcon_set_source_sync(int arg)
8134 +{
8135 + int ret = dcon_set_source(arg);
8136 + if (!ret)
8137 + flush_scheduled_work();
8138 + return ret;
8139 +}
8140 +
8141 +static int dconbl_set(struct backlight_device *dev) {
8142 +
8143 + int level = dev->props.brightness;
8144 +
8145 + if (dev->props.power != FB_BLANK_UNBLANK)
8146 + level = 0;
8147 +
8148 + dcon_set_backlight(level);
8149 + return 0;
8150 +}
8151 +
8152 +static int dconbl_get(struct backlight_device *dev) {
8153 + return dcon_get_backlight();
8154 +}
8155 +
8156 +static ssize_t dcon_mode_show(struct device *dev,
8157 + struct device_attribute *attr, char *buf)
8158 +{
8159 + return sprintf(buf, "%4.4X\n", dcon_disp_mode);
8160 +}
8161 +
8162 +static ssize_t dcon_sleep_show(struct device *dev,
8163 + struct device_attribute *attr, char *buf)
8164 +{
8165 + return sprintf(buf, "%d\n", dcon_sleep_val);
8166 +}
8167 +
8168 +static ssize_t /* __deprecated */ dcon_source_show(struct device *dev,
8169 + struct device_attribute *attr, char *buf)
8170 +{
8171 + printk(KERN_WARNING "olpc-dcon: using deprecated sysfs 'source' interface; use 'freeze' instead!\n");
8172 + return sprintf(buf, "%d\n", dcon_source);
8173 +}
8174 +
8175 +static ssize_t dcon_freeze_show(struct device *dev,
8176 + struct device_attribute *attr, char *buf)
8177 +{
8178 + return sprintf(buf, "%d\n", dcon_source == DCON_SOURCE_DCON ? 1 : 0);
8179 +}
8180 +
8181 +static ssize_t dcon_output_show(struct device *dev,
8182 + struct device_attribute *attr, char *buf)
8183 +{
8184 + return sprintf(buf, "%d\n", dcon_output);
8185 +}
8186 +
8187 +static ssize_t dcon_resumeline_show(struct device *dev,
8188 + struct device_attribute *attr, char *buf)
8189 +{
8190 + return sprintf(buf, "%d\n", resumeline);
8191 +}
8192 +
8193 +static int _strtoul(const char *buf, int len, unsigned int *val)
8194 +{
8195 +
8196 + char *endp;
8197 + unsigned int output = simple_strtoul(buf, &endp, 0);
8198 + int size = endp - buf;
8199 +
8200 + if (*endp && isspace(*endp))
8201 + size++;
8202 +
8203 + if (size != len)
8204 + return -EINVAL;
8205 +
8206 + *val = output;
8207 + return 0;
8208 +}
8209 +
8210 +static ssize_t dcon_output_store(struct device *dev,
8211 + struct device_attribute *attr, const char *buf, size_t count)
8212 +{
8213 + int output;
8214 + int rc = -EINVAL;
8215 +
8216 + if (_strtoul(buf, count, &output))
8217 + return -EINVAL;
8218 +
8219 + if (output == DCON_OUTPUT_COLOR || output == DCON_OUTPUT_MONO) {
8220 + dcon_set_output(output);
8221 + rc = count;
8222 + }
8223 +
8224 + return rc;
8225 +}
8226 +
8227 +static ssize_t /* __deprecated */ dcon_source_store(struct device *dev,
8228 + struct device_attribute *attr, const char *buf, size_t count)
8229 +{
8230 + int output;
8231 + int rc = -EINVAL;
8232 +
8233 + printk(KERN_WARNING "olpc-dcon: using deprecated sysfs 'source' interface; use 'freeze' instead!\n");
8234 + if (_strtoul(buf, count, &output))
8235 + return -EINVAL;
8236 +
8237 + dcon_set_source(output);
8238 + rc = count;
8239 +
8240 + return rc;
8241 +}
8242 +
8243 +static ssize_t dcon_freeze_store(struct device *dev,
8244 + struct device_attribute *attr, const char *buf, size_t count)
8245 +{
8246 + int output;
8247 + int rc = -EINVAL;
8248 +
8249 + if (_strtoul(buf, count, &output))
8250 + return rc;
8251 +
8252 + dcon_set_source(output ? DCON_SOURCE_DCON : DCON_SOURCE_CPU);
8253 + rc = count;
8254 +
8255 + return rc;
8256 +}
8257 +
8258 +static ssize_t dcon_resumeline_store(struct device *dev,
8259 + struct device_attribute *attr, const char *buf, size_t count)
8260 +{
8261 + int rl;
8262 + int rc = -EINVAL;
8263 +
8264 + if (_strtoul(buf, count, &rl))
8265 + return rc;
8266 +
8267 + resumeline = rl;
8268 + dcon_write(DCON_REG_SCAN_INT, resumeline);
8269 + rc = count;
8270 +
8271 + return rc;
8272 +}
8273 +
8274 +static ssize_t dcon_sleep_store(struct device *dev,
8275 + struct device_attribute *attr, const char *buf, size_t count)
8276 +{
8277 + int output;
8278 +
8279 + if (_strtoul(buf, count, &output))
8280 + return -EINVAL;
8281 +
8282 + dcon_sleep(output ? DCON_SLEEP : DCON_ACTIVE);
8283 + return count;
8284 +}
8285 +
8286 +static struct device_attribute dcon_device_files[] = {
8287 + __ATTR(mode, 0444, dcon_mode_show, NULL),
8288 + __ATTR(sleep, 0644, dcon_sleep_show, dcon_sleep_store),
8289 + __ATTR(source, 0644, dcon_source_show, dcon_source_store),
8290 + __ATTR(freeze, 0644, dcon_freeze_show, dcon_freeze_store),
8291 + __ATTR(output, 0644, dcon_output_show, dcon_output_store),
8292 + __ATTR(resumeline, 0644, dcon_resumeline_show, dcon_resumeline_store),
8293 +};
8294 +
8295 +static struct backlight_ops dcon_bl_ops = {
8296 + .get_brightness = dconbl_get,
8297 + .update_status = dconbl_set
8298 +};
8299 +
8300 +/* List of GPIOs that we care about:
8301 + (in) GPIO12 -- DCONBLNK
8302 + (in) GPIO[56] -- DCONSTAT[01]
8303 + (out) GPIO11 -- DCONLOAD
8304 +*/
8305 +
8306 +#define IN_GPIOS ((1<<5) | (1<<6) | (1<<7) | (1<<12))
8307 +#define OUT_GPIOS (1<<11)
8308 +
8309 +static irqreturn_t dcon_interrupt(int, void *);
8310 +
8311 +static int dcon_request_irq(void)
8312 +{
8313 + unsigned long lo, hi;
8314 + unsigned char lob;
8315 +
8316 + rdmsr(MSR_LBAR_GPIO, lo, hi);
8317 +
8318 + /* Check the mask and whether GPIO is enabled (sanity check) */
8319 + if (hi != 0x0000f001) {
8320 + printk(KERN_ERR "GPIO not enabled -- cannot use DCON\n");
8321 + return -ENODEV;
8322 + }
8323 +
8324 + /* Mask off the IO base address */
8325 + gpio_base = lo & 0x0000ff00;
8326 +
8327 + /* Turn off the event enable for GPIO7 just to be safe */
8328 + outl(1 << (16+7), gpio_base + GPIOx_EVNT_EN);
8329 +
8330 + /* Set the directions for the GPIO pins */
8331 + outl(OUT_GPIOS | (IN_GPIOS << 16), gpio_base + GPIOx_OUT_EN);
8332 + outl(IN_GPIOS | (OUT_GPIOS << 16), gpio_base + GPIOx_IN_EN);
8333 +
8334 + /* Set up the interrupt mappings */
8335 +
8336 + /* Set the IRQ to pair 2 */
8337 + geode_gpio_event_irq(OLPC_GPIO_DCON_IRQ, 2);
8338 +
8339 + /* Enable group 2 to trigger the DCON interrupt */
8340 + geode_gpio_set_irq(2, DCON_IRQ);
8341 +
8342 + /* Select edge level for interrupt (in PIC) */
8343 +
8344 + lob = inb(0x4d0);
8345 + lob &= ~(1 << DCON_IRQ);
8346 + outb(lob, 0x4d0);
8347 +
8348 + /* Register the interupt handler */
8349 + if (request_irq(DCON_IRQ, &dcon_interrupt, 0, "DCON", &dcon_driver))
8350 + return -EIO;
8351 +
8352 + /* Clear INV_EN for GPIO7 (DCONIRQ) */
8353 + outl((1<<(16+7)), gpio_base + GPIOx_INV_EN);
8354 +
8355 + /* Enable filter for GPIO12 (DCONBLANK) */
8356 + outl(1<<(12), gpio_base + GPIOx_IN_FLTR_EN);
8357 +
8358 + /* Disable filter for GPIO7 */
8359 + outl(1<<(16+7), gpio_base + GPIOx_IN_FLTR_EN);
8360 +
8361 + /* Disable event counter for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
8362 +
8363 + outl(1<<(16+7), gpio_base + GPIOx_EVNTCNT_EN);
8364 + outl(1<<(16+12), gpio_base + GPIOx_EVNTCNT_EN);
8365 +
8366 + /* Add GPIO12 to the Filter Event Pair #7 */
8367 + outb(12, gpio_base + GPIO_FE7_SEL);
8368 +
8369 + /* Turn off negative Edge Enable for GPIO12 */
8370 + outl(1<<(16+12), gpio_base + GPIOx_NEGEDGE_EN);
8371 +
8372 + /* Enable negative Edge Enable for GPIO7 */
8373 + outl(1<<7, gpio_base + GPIOx_NEGEDGE_EN);
8374 +
8375 + /* Zero the filter amount for Filter Event Pair #7 */
8376 + outw(0, gpio_base + GPIO_FLT7_AMNT);
8377 +
8378 + /* Clear the negative edge status for GPIO7 and GPIO12 */
8379 + outl((1<<7) | (1<<12), gpio_base+0x4c);
8380 +
8381 + /* FIXME: Clear the posiitive status as well, just to be sure */
8382 + outl((1<<7) | (1<<12), gpio_base+0x48);
8383 +
8384 + /* Enable events for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
8385 + outl((1<<(7))|(1<<12), gpio_base + GPIOx_EVNT_EN);
8386 +
8387 + /* Determine the current state by reading the GPIO bit */
8388 + /* Earlier stages of the boot process have established the state */
8389 + dcon_source = inl(gpio_base + GPIOx_OUT_VAL) & (1<<11)
8390 + ? DCON_SOURCE_CPU
8391 + : DCON_SOURCE_DCON;
8392 + dcon_pending = dcon_source;
8393 +
8394 + return 0;
8395 +}
8396 +
8397 +static int dcon_reboot_notify(struct notifier_block *nb, unsigned long foo, void *bar)
8398 +{
8399 + if (dcon_client == NULL)
8400 + return 0;
8401 +
8402 + /* Turn off the DCON. Entirely. */
8403 + dcon_write(DCON_REG_MODE, 0x39);
8404 + dcon_write(DCON_REG_MODE, 0x32);
8405 + return 0;
8406 +}
8407 +
8408 +static int dcon_conswitch_notify(struct notifier_block *nb,
8409 + unsigned long mode, void *dummy)
8410 +{
8411 + if (mode == CONSOLE_EVENT_SWITCH_TEXT)
8412 + dcon_sleep(DCON_ACTIVE);
8413 +
8414 + return 0;
8415 +}
8416 +
8417 +static struct notifier_block dcon_nb = {
8418 + .notifier_call = dcon_reboot_notify,
8419 + .priority = -1,
8420 +};
8421 +
8422 +static struct notifier_block dcon_console_nb = {
8423 + .notifier_call = dcon_conswitch_notify,
8424 + .priority = -1,
8425 +};
8426 +
8427 +static int unfreeze_on_panic(struct notifier_block *nb, unsigned long e, void *p)
8428 +{
8429 + outl(1<<11, gpio_base + GPIOx_OUT_VAL);
8430 + return NOTIFY_DONE;
8431 +}
8432 +
8433 +static struct notifier_block dcon_panic_nb = {
8434 + .notifier_call = unfreeze_on_panic,
8435 +};
8436 +
8437 +static int dcon_probe(struct i2c_adapter *adap, int addr, int kind)
8438 +{
8439 + struct i2c_client *client;
8440 + int rc, i;
8441 +
8442 + if (!olpc_has_dcon()) {
8443 + printk("olpc-dcon: No DCON is attached.\n");
8444 + return -ENODEV;
8445 + }
8446 +
8447 + if (num_registered_fb >= 1)
8448 + fbinfo = registered_fb[0];
8449 +
8450 + if (adap->id != I2C_HW_SMBUS_SCX200) {
8451 + printk(KERN_ERR "olpc-dcon: Invalid I2C bus (%d not %d)\n",
8452 + adap->id, I2C_HW_SMBUS_SCX200);
8453 + return -ENXIO;
8454 + }
8455 +
8456 + client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
8457 + if (client == NULL)
8458 + return -ENOMEM;
8459 +
8460 + strncpy(client->name, "OLPC-DCON", I2C_NAME_SIZE);
8461 + client->addr = addr;
8462 + client->adapter = adap;
8463 + client->driver = &dcon_driver;
8464 +
8465 + if ((rc = i2c_attach_client(client)) != 0) {
8466 + printk(KERN_ERR "olpc-dcon: Unable to attach the I2C client.\n");
8467 + goto eclient;
8468 + }
8469 +
8470 + rc = dcon_hw_init(client, 1);
8471 + if (rc)
8472 + goto ei2c;
8473 +
8474 + /* Add the DCON device */
8475 +
8476 + dcon_device = platform_device_alloc("dcon", -1);
8477 +
8478 + if (dcon_device == NULL) {
8479 + printk(KERN_ERR "dcon: Unable to create the DCON device\n");
8480 + rc = -ENOMEM;
8481 + goto eirq;
8482 + }
8483 +
8484 + if ((rc = platform_device_add(dcon_device))) {
8485 + printk(KERN_ERR "dcon: Unable to add the DCON device\n");
8486 + goto edev;
8487 + }
8488 +
8489 + for(i = 0; i < ARRAY_SIZE(dcon_device_files); i++)
8490 + device_create_file(&dcon_device->dev, &dcon_device_files[i]);
8491 +
8492 + /* Add the backlight device for the DCON */
8493 +
8494 + dcon_client = client;
8495 +
8496 + dcon_bl_dev = backlight_device_register("dcon-bl", &dcon_device->dev,
8497 + NULL, &dcon_bl_ops);
8498 +
8499 + if (IS_ERR(dcon_bl_dev)) {
8500 + printk(KERN_INFO "Could not register the backlight device for the DCON (%ld)\n", PTR_ERR(dcon_bl_dev));
8501 + dcon_bl_dev = NULL;
8502 + }
8503 + else {
8504 + dcon_bl_dev->props.max_brightness = 15;
8505 + dcon_bl_dev->props.power = FB_BLANK_UNBLANK;
8506 + dcon_bl_dev->props.brightness = dcon_get_backlight();
8507 +
8508 + backlight_update_status(dcon_bl_dev);
8509 + }
8510 +
8511 + register_reboot_notifier(&dcon_nb);
8512 + console_event_register(&dcon_console_nb);
8513 + atomic_notifier_chain_register(&panic_notifier_list, &dcon_panic_nb);
8514 +
8515 + return 0;
8516 +
8517 + edev:
8518 + platform_device_unregister(dcon_device);
8519 + dcon_device = NULL;
8520 + eirq:
8521 + free_irq(DCON_IRQ, &dcon_driver);
8522 + ei2c:
8523 + i2c_detach_client(client);
8524 + eclient:
8525 + kfree(client);
8526 +
8527 + return rc;
8528 +}
8529 +
8530 +static int dcon_attach(struct i2c_adapter *adap)
8531 +{
8532 + int ret;
8533 +
8534 + ret = i2c_probe(adap, &addr_data, dcon_probe);
8535 +
8536 + if (dcon_client == NULL)
8537 + printk(KERN_ERR "olpc-dcon: No DCON found on SMBus\n");
8538 +
8539 + return ret;
8540 +}
8541 +
8542 +static int dcon_detach(struct i2c_client *client)
8543 +{
8544 + int rc;
8545 + dcon_client = NULL;
8546 +
8547 + unregister_reboot_notifier(&dcon_nb);
8548 + console_event_unregister(&dcon_console_nb);
8549 + atomic_notifier_chain_unregister(&panic_notifier_list, &dcon_panic_nb);
8550 +
8551 + free_irq(DCON_IRQ, &dcon_driver);
8552 +
8553 + if ((rc = i2c_detach_client(client)) == 0)
8554 + kfree(i2c_get_clientdata(client));
8555 +
8556 + if (dcon_bl_dev != NULL)
8557 + backlight_device_unregister(dcon_bl_dev);
8558 +
8559 + if (dcon_device != NULL)
8560 + platform_device_unregister(dcon_device);
8561 + cancel_work_sync(&dcon_work);
8562 +
8563 + return rc;
8564 +}
8565 +
8566 +
8567 +#ifdef CONFIG_PM
8568 +static int dcon_suspend(struct i2c_client *client, pm_message_t state)
8569 +{
8570 + if (dcon_sleep_val != DCON_ACTIVE)
8571 + return 0;
8572 +
8573 + /* Set up the DCON to have the source */
8574 + return dcon_set_source_sync(DCON_SOURCE_DCON);
8575 +}
8576 +
8577 +static int dcon_resume(struct i2c_client *client)
8578 +{
8579 + if (dcon_sleep_val != DCON_ACTIVE)
8580 + return 0;
8581 +
8582 + dcon_bus_stabilize(client, 0);
8583 +
8584 + return dcon_set_source(DCON_SOURCE_CPU);
8585 +}
8586 +
8587 +#endif
8588 +
8589 +static irqreturn_t dcon_interrupt(int irq, void *id)
8590 +{
8591 + int status = inl(gpio_base + GPIOx_READ_BACK) >> 5;
8592 +
8593 + /* Clear the negative edge status for GPIO7 */
8594 + outl(1 << 7, gpio_base + GPIOx_NEGEDGE_STS);
8595 +
8596 + switch (status & 3) {
8597 + case 3:
8598 + printk(KERN_DEBUG "olpc-dcon: DCONLOAD_MISSED interrupt\n");
8599 + break;
8600 + case 2: /* switch to DCON mode */
8601 + case 1: /* switch to CPU mode */
8602 + dcon_switched = 1;
8603 + wake_up(&dcon_wait_queue);
8604 + break;
8605 + case 0:
8606 + printk(KERN_DEBUG "olpc-dcon: scanline interrupt w/CPU\n");
8607 + }
8608 +
8609 + return IRQ_HANDLED;
8610 +}
8611 +
8612 +static struct i2c_driver dcon_driver = {
8613 + .driver = {
8614 + .name = "OLPC-DCON",
8615 + },
8616 + .id = I2C_DRIVERID_DCON,
8617 + .attach_adapter = dcon_attach,
8618 + .detach_client = dcon_detach,
8619 +#ifdef CONFIG_PM
8620 + .suspend = dcon_suspend,
8621 + .resume = dcon_resume,
8622 +#endif
8623 +};
8624 +
8625 +
8626 +static int __init olpc_dcon_init(void)
8627 +{
8628 + i2c_add_driver(&dcon_driver);
8629 + return 0;
8630 +}
8631 +
8632 +static void __exit olpc_dcon_exit(void)
8633 +{
8634 + i2c_del_driver(&dcon_driver);
8635 +}
8636 +
8637 +module_init(olpc_dcon_init);
8638 +module_exit(olpc_dcon_exit);
8639 +
8640 +MODULE_LICENSE("GPL");
8641 Index: linux-2.6.24.7/drivers/video/olpc_dcon.h
8642 ===================================================================
8643 --- /dev/null
8644 +++ linux-2.6.24.7/drivers/video/olpc_dcon.h
8645 @@ -0,0 +1,75 @@
8646 +#ifndef OLPC_DCON_H_
8647 +#define OLPC_DCON_H_
8648 +
8649 +/* DCON registers */
8650 +
8651 +#define DCON_REG_ID 0
8652 +#define DCON_REG_MODE 1
8653 +
8654 +#define MODE_PASSTHRU (1<<0)
8655 +#define MODE_SLEEP (1<<1)
8656 +#define MODE_SLEEP_AUTO (1<<2)
8657 +#define MODE_BL_ENABLE (1<<3)
8658 +#define MODE_BLANK (1<<4)
8659 +#define MODE_CSWIZZLE (1<<5)
8660 +#define MODE_COL_AA (1<<6)
8661 +#define MODE_MONO_LUMA (1<<7)
8662 +#define MODE_SCAN_INT (1<<8)
8663 +#define MODE_CLOCKDIV (1<<9)
8664 +#define MODE_DEBUG (1<<14)
8665 +#define MODE_SELFTEST (1<<15)
8666 +
8667 +#define DCON_REG_HRES 2
8668 +#define DCON_REG_HTOTAL 3
8669 +#define DCON_REG_HSYNC_WIDTH 4
8670 +#define DCON_REG_VRES 5
8671 +#define DCON_REG_VTOTAL 6
8672 +#define DCON_REG_VSYNC_WIDTH 7
8673 +#define DCON_REG_TIMEOUT 8
8674 +#define DCON_REG_SCAN_INT 9
8675 +#define DCON_REG_BRIGHT 10
8676 +
8677 +/* GPIO registers (CS5536) */
8678 +
8679 +#define MSR_LBAR_GPIO 0x5140000C
8680 +
8681 +#define GPIOx_OUT_VAL 0x00
8682 +#define GPIOx_OUT_EN 0x04
8683 +#define GPIOx_IN_EN 0x20
8684 +#define GPIOx_INV_EN 0x24
8685 +#define GPIOx_IN_FLTR_EN 0x28
8686 +#define GPIOx_EVNTCNT_EN 0x2C
8687 +#define GPIOx_READ_BACK 0x30
8688 +#define GPIOx_EVNT_EN 0x38
8689 +#define GPIOx_NEGEDGE_EN 0x44
8690 +#define GPIOx_NEGEDGE_STS 0x4C
8691 +#define GPIO_FLT7_AMNT 0xD8
8692 +#define GPIO_MAP_X 0xE0
8693 +#define GPIO_MAP_Y 0xE4
8694 +#define GPIO_FE7_SEL 0xF7
8695 +
8696 +
8697 +/* Status values */
8698 +
8699 +#define DCONSTAT_SCANINT 0
8700 +#define DCONSTAT_SCANINT_DCON 1
8701 +#define DCONSTAT_DISPLAYLOAD 2
8702 +#define DCONSTAT_MISSED 3
8703 +
8704 +/* Source values */
8705 +
8706 +#define DCON_SOURCE_DCON 0
8707 +#define DCON_SOURCE_CPU 1
8708 +
8709 +/* Output values */
8710 +#define DCON_OUTPUT_COLOR 0
8711 +#define DCON_OUTPUT_MONO 1
8712 +
8713 +/* Sleep values */
8714 +#define DCON_ACTIVE 0
8715 +#define DCON_SLEEP 1
8716 +
8717 +/* Interrupt */
8718 +#define DCON_IRQ 6
8719 +
8720 +#endif
8721 Index: linux-2.6.24.7/fs/jffs2/nodelist.h
8722 ===================================================================
8723 --- linux-2.6.24.7.orig/fs/jffs2/nodelist.h
8724 +++ linux-2.6.24.7/fs/jffs2/nodelist.h
8725 @@ -197,7 +197,7 @@ struct jffs2_inode_cache {
8726 #define RAWNODE_CLASS_XATTR_DATUM 1
8727 #define RAWNODE_CLASS_XATTR_REF 2
8728
8729 -#define INOCACHE_HASHSIZE 128
8730 +#define INOCACHE_HASHSIZE 1024
8731
8732 #define write_ofs(c) ((c)->nextblock->offset + (c)->sector_size - (c)->nextblock->free_size)
8733
8734 Index: linux-2.6.24.7/fs/Kconfig
8735 ===================================================================
8736 --- linux-2.6.24.7.orig/fs/Kconfig
8737 +++ linux-2.6.24.7/fs/Kconfig
8738 @@ -1031,6 +1031,37 @@ config HUGETLBFS
8739 config HUGETLB_PAGE
8740 def_bool HUGETLBFS
8741
8742 +config PROMFS_FS
8743 + tristate "PromFS IEEE 1275 file system support"
8744 + depends on SPARC || PPC || OLPC
8745 + help
8746 + PromFS is a file system interface to various IEEE-1275 compatible
8747 + firmwares. If you have such a firmware (Sparc64, PowerPC, and
8748 + some other architectures and embedded systems have such firmwares,
8749 + with names like "OpenBoot (tm)" and "OpenFirmware"), say Y here
8750 + to be able to access the firmware's device-tree from Linux.
8751 +
8752 + The firmware device-tree is available as a virtual file system,
8753 + can be mounted under /prom with the command "mount -t promfs
8754 + none /prom".
8755 +
8756 + To compile PromFS support as a module, choose M here; the module
8757 + will be called promfs. If unsure, choose M.
8758 +
8759 +config RAMFS
8760 + bool
8761 + default y
8762 + ---help---
8763 + Ramfs is a file system which keeps all files in RAM. It allows
8764 + read and write access.
8765 +
8766 + It is more of an programming example than a useable file system. If
8767 + you need a file system which lives in RAM with limit checking use
8768 + tmpfs.
8769 +
8770 + To compile this as a module, choose M here: the module will be called
8771 + ramfs.
8772 +
8773 config CONFIGFS_FS
8774 tristate "Userspace-driven configuration filesystem (EXPERIMENTAL)"
8775 depends on SYSFS && EXPERIMENTAL
8776 Index: linux-2.6.24.7/fs/Makefile
8777 ===================================================================
8778 --- linux-2.6.24.7.orig/fs/Makefile
8779 +++ linux-2.6.24.7/fs/Makefile
8780 @@ -110,6 +110,7 @@ obj-$(CONFIG_ADFS_FS) += adfs/
8781 obj-$(CONFIG_FUSE_FS) += fuse/
8782 obj-$(CONFIG_UDF_FS) += udf/
8783 obj-$(CONFIG_SUN_OPENPROMFS) += openpromfs/
8784 +obj-$(CONFIG_PROMFS_FS) += promfs/
8785 obj-$(CONFIG_JFS_FS) += jfs/
8786 obj-$(CONFIG_XFS_FS) += xfs/
8787 obj-$(CONFIG_9P_FS) += 9p/
8788 Index: linux-2.6.24.7/fs/promfs/Makefile
8789 ===================================================================
8790 --- /dev/null
8791 +++ linux-2.6.24.7/fs/promfs/Makefile
8792 @@ -0,0 +1 @@
8793 +obj-$(CONFIG_PROMFS_FS) += promfs.o
8794 Index: linux-2.6.24.7/fs/promfs/promfs.c
8795 ===================================================================
8796 --- /dev/null
8797 +++ linux-2.6.24.7/fs/promfs/promfs.c
8798 @@ -0,0 +1,295 @@
8799 +/*
8800 + * promfs.c - generic inode/dentry functions for IEEE 1275-based filesystems.
8801 + *
8802 + * This is based heavily upon prior ieee1275 and other virtual filesystems
8803 + * implementations; openpromfs, proc_devtree.c, oprofilefs, procfs, ...
8804 + *
8805 + * Copyright (C) 2007 Andres Salomon <dilinger@debian.org>
8806 + *
8807 + * This program is free software; you can redistribute it and/or modify
8808 + * it under the terms of the GNU General Public License as published by
8809 + * the Free Software Foundation; either version 2 of the License, or
8810 + * (at your option) any later version.
8811 + *
8812 + * This program is distributed in the hope that it will be useful,
8813 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
8814 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8815 + * GNU General Public License for more details.
8816 + *
8817 + * You should have received a copy of the GNU General Public License along
8818 + * with this program; if not, write to the Free Software Foundation, Inc.,
8819 + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
8820 + */
8821 +
8822 +#include <linux/init.h>
8823 +#include <linux/module.h>
8824 +#include <linux/pagemap.h>
8825 +#include <linux/fs.h>
8826 +//#include <linux/promfs.h>
8827 +#include <asm/prom.h>
8828 +
8829 +#define PROMFS_MAGIC 0x1f2f3fff
8830 +
8831 +MODULE_LICENSE("GPL");
8832 +MODULE_AUTHOR("Andres Salomon");
8833 +
8834 +struct promfs_inode
8835 +{
8836 + struct inode ino;
8837 + struct property *prop;
8838 +};
8839 +
8840 +static inline struct promfs_inode *to_promfs_inode(struct inode *inode)
8841 +{
8842 + return container_of(inode, struct promfs_inode, ino);
8843 +}
8844 +
8845 +#if 0
8846 +static DEFINE_SPINLOCK(promfs_lock);
8847 +
8848 +static struct of_node *of_tree = NULL;
8849 +static DEFINE_RWLOCK(of_tree_lock);
8850 +
8851 +void __init of_build_tree(void)
8852 +{
8853 +
8854 +
8855 +}
8856 +#endif
8857 +
8858 +static int promfs_open_file(struct inode *inode, struct file *file)
8859 +{
8860 + struct promfs_inode *ino;
8861 +
8862 + ino = to_promfs_inode(inode);
8863 + if (!ino->prop)
8864 + return -EIO;
8865 + file->private_data = ino->prop;
8866 +
8867 + return 0;
8868 +}
8869 +
8870 +static ssize_t promfs_read_file(struct file *file, char __user *data,
8871 + size_t len, loff_t *ppos)
8872 +{
8873 + struct property *prop = (struct property *) file->private_data;
8874 + return simple_read_from_buffer(data, len, ppos, prop->value,
8875 + prop->length);
8876 +}
8877 +
8878 +static ssize_t promfs_write_file(struct file *file, char const __user *buf,
8879 + size_t count, loff_t * offset)
8880 +{
8881 + /* TODO.... 'cause, y'know, it would be nice. */
8882 + return -EIO;
8883 +}
8884 +
8885 +static struct file_operations promfs_file_ops = {
8886 + .open = promfs_open_file,
8887 + .read = promfs_read_file,
8888 + .write = promfs_write_file,
8889 +};
8890 +
8891 +static struct kmem_cache *promfs_inode_cachep;
8892 +
8893 +static struct inode *promfs_alloc_inode(struct super_block *sb)
8894 +{
8895 + struct promfs_inode *pr_ino;
8896 +
8897 + pr_ino = kmem_cache_alloc(promfs_inode_cachep, GFP_KERNEL);
8898 + if (!pr_ino)
8899 + return NULL;
8900 + pr_ino->prop = NULL;
8901 +
8902 + return &pr_ino->ino;
8903 +}
8904 +
8905 +static void promfs_destroy_inode(struct inode *inode)
8906 +{
8907 + kmem_cache_free(promfs_inode_cachep, to_promfs_inode(inode));
8908 +}
8909 +
8910 +static void promfs_read_inode(struct inode *inode)
8911 +{
8912 + inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
8913 +}
8914 +
8915 +static int promfs_remount(struct super_block *sb, int *flags, char *data)
8916 +{
8917 + *flags |= MS_NOATIME;
8918 + return 0;
8919 +}
8920 +
8921 +static struct super_operations promfs_s_ops = {
8922 + .alloc_inode = promfs_alloc_inode,
8923 + .destroy_inode = promfs_destroy_inode,
8924 + .read_inode = promfs_read_inode,
8925 + .statfs = simple_statfs,
8926 + .drop_inode = generic_delete_inode,
8927 + .remount_fs = promfs_remount,
8928 +};
8929 +
8930 +static struct inode *promfs_get_inode(struct super_block *sb, int mode)
8931 +{
8932 + struct inode *inode = new_inode(sb);
8933 +
8934 + if (inode) {
8935 + inode->i_mode = mode;
8936 + inode->i_uid = 0;
8937 + inode->i_gid = 0;
8938 + inode->i_blocks = 0;
8939 + inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
8940 + }
8941 +
8942 + return inode;
8943 +}
8944 +
8945 +static int promfs_create_file(struct super_block *sb, struct dentry *root,
8946 + struct property *prop, const struct file_operations *fops)
8947 +{
8948 + struct dentry *dentry;
8949 + struct inode *inode;
8950 + struct promfs_inode *ino;
8951 +
8952 + dentry = d_alloc_name(root, prop->name);
8953 + if (!dentry)
8954 + goto err;
8955 +
8956 + inode = promfs_get_inode(sb, S_IFREG | 0644);
8957 + if (!inode)
8958 + goto err_dput;
8959 + inode->i_fop = fops;
8960 + ino = to_promfs_inode(inode);
8961 + ino->prop = prop;
8962 + d_add(dentry, inode);
8963 +
8964 + return 0;
8965 +
8966 +err_dput:
8967 + dput(dentry);
8968 +err:
8969 + return -EFAULT;
8970 +}
8971 +
8972 +struct dentry *promfs_create_dir(struct super_block *sb, struct dentry *root,
8973 + char const *name)
8974 +{
8975 + struct dentry *dentry;
8976 + struct inode *inode;
8977 +
8978 + dentry = d_alloc_name(root, name);
8979 + if (!dentry)
8980 + goto err;
8981 +
8982 + inode = promfs_get_inode(sb, S_IFDIR | 0755);
8983 + if (!inode)
8984 + goto err_dput;
8985 + inode->i_op = &simple_dir_inode_operations;
8986 + inode->i_fop = &simple_dir_operations;
8987 + d_add(dentry, inode);
8988 + return dentry;
8989 +
8990 +err_dput:
8991 + dput(dentry);
8992 +err:
8993 + return NULL;
8994 +}
8995 +
8996 +void promfs_populate(struct super_block *sb, struct dentry *root,
8997 + struct device_node *node)
8998 +{
8999 + struct dentry *dentry;
9000 + struct device_node *child;
9001 + struct property *prop;
9002 +
9003 + if (!node)
9004 + return;
9005 +
9006 + for (child = node->child; child; child = child->sibling) {
9007 + dentry = promfs_create_dir(sb, root, child->path_component_name);
9008 + promfs_populate(sb, dentry, child);
9009 + }
9010 + for (prop = node->properties; prop; prop = prop->next)
9011 + promfs_create_file(sb, root, prop, &promfs_file_ops);
9012 +}
9013 +
9014 +static int promfs_fill_super(struct super_block *sb, void *data, int silent)
9015 +{
9016 + struct inode *root_inode;
9017 + struct dentry *root_dentry;
9018 + struct promfs_inode *inode;
9019 +
9020 + sb->s_blocksize = PAGE_CACHE_SIZE;
9021 + sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
9022 + sb->s_magic = PROMFS_MAGIC;
9023 + sb->s_op = &promfs_s_ops;
9024 + sb->s_time_gran = 1;
9025 + sb->s_flags |= MS_NOATIME;
9026 +
9027 + root_inode = promfs_get_inode(sb, S_IFDIR | 0755);
9028 + if (!root_inode)
9029 + goto err;
9030 + root_inode->i_op = &simple_dir_inode_operations;
9031 + root_inode->i_fop = &simple_dir_operations;
9032 +
9033 + inode = to_promfs_inode(root_inode);
9034 +
9035 + root_dentry = d_alloc_root(root_inode);
9036 + if (!root_dentry)
9037 + goto err_iput;
9038 + sb->s_root = root_dentry;
9039 +
9040 + promfs_populate(sb, root_dentry, of_find_node_by_path("/"));
9041 + return 0;
9042 +
9043 +err_iput:
9044 + iput(root_inode);
9045 +err:
9046 + return -ENOMEM;
9047 +}
9048 +
9049 +static int promfs_get_sb(struct file_system_type *fs_type, int flags,
9050 + const char *dev_name, void *data, struct vfsmount *mnt)
9051 +{
9052 + return get_sb_single(fs_type, flags, data, promfs_fill_super, mnt);
9053 +}
9054 +
9055 +static struct file_system_type promfs_fs_type = {
9056 + .owner = THIS_MODULE,
9057 + .name = "promfs",
9058 + .get_sb = promfs_get_sb,
9059 + .kill_sb = kill_litter_super,
9060 +};
9061 +
9062 +static void init_once(void *i, struct kmem_cache *cachep, unsigned long fl)
9063 +{
9064 + struct promfs_inode *inode = (struct promfs_inode *) i;
9065 + inode_init_once(&inode->ino);
9066 +}
9067 +
9068 +static int __init init_promfs(void)
9069 +{
9070 + int err;
9071 +
9072 + prom_build_devicetree();
9073 + promfs_inode_cachep = kmem_cache_create("promfs_inode_cache",
9074 + sizeof(struct promfs_inode), 0,
9075 + SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, init_once, NULL);
9076 + if (!promfs_inode_cachep)
9077 + return -ENOMEM;
9078 +
9079 + err = register_filesystem(&promfs_fs_type);
9080 + if (err)
9081 + kmem_cache_destroy(promfs_inode_cachep);
9082 +
9083 + return err;
9084 +}
9085 +
9086 +static void __exit exit_promfs(void)
9087 +{
9088 + unregister_filesystem(&promfs_fs_type);
9089 + kmem_cache_destroy(promfs_inode_cachep);
9090 +}
9091 +
9092 +module_init(init_promfs);
9093 +module_exit(exit_promfs);
9094 Index: linux-2.6.24.7/include/asm-x86/ofw.h
9095 ===================================================================
9096 --- /dev/null
9097 +++ linux-2.6.24.7/include/asm-x86/ofw.h
9098 @@ -0,0 +1,16 @@
9099 +/*
9100 + * Definitions for Open Firmware client interface on 32-bit system.
9101 + * OF Cell size is 4. Integer properties are encoded big endian,
9102 + * as with all OF implementations.
9103 + *
9104 + * This program is free software; you can redistribute it and/or
9105 + * modify it under the terms of the GNU General Public License
9106 + * as published by the Free Software Foundation; either version
9107 + * 2 of the License, or (at your option) any later version.
9108 + */
9109 +#ifndef _OFW_H
9110 +#define _OFW_H
9111 +
9112 +extern int ofw(char *, int, int, ...);
9113 +
9114 +#endif
9115 Index: linux-2.6.24.7/include/asm-x86/olpc.h
9116 ===================================================================
9117 --- /dev/null
9118 +++ linux-2.6.24.7/include/asm-x86/olpc.h
9119 @@ -0,0 +1,107 @@
9120 +/* OLPC machine specific definitions */
9121 +
9122 +#ifndef ASM_OLPC_H_
9123 +#define ASM_OLPC_H_
9124 +
9125 +#include <asm/geode.h>
9126 +
9127 +struct olpc_platform_t {
9128 + int flags;
9129 + u32 boardrev;
9130 + int ecver;
9131 +};
9132 +
9133 +#define OLPC_F_PRESENT 0x01
9134 +#define OLPC_F_DCON 0x02
9135 +#define OLPC_F_VSA 0x04
9136 +
9137 +/*
9138 + * OLPC board IDs contain the major build number within the mask 0x0ff0,
9139 + * and the minor build number withing 0x000f. Pre-builds have a minor
9140 + * number less than 8, and normal builds start at 8. For example, 0x0B10
9141 + * is a PreB1, and 0x0C18 is a C1.
9142 + */
9143 +
9144 +static inline u32 olpc_board(u8 id)
9145 +{
9146 + return (id << 4) | 0x8;
9147 +}
9148 +
9149 +static inline u32 olpc_board_pre(u8 id)
9150 +{
9151 + return id << 4;
9152 +}
9153 +
9154 +#ifndef CONFIG_OLPC
9155 +
9156 +static inline int machine_is_olpc(void) { return 0; }
9157 +static inline int olpc_has_dcon(void) { return 0; }
9158 +static inline int olpc_has_vsa(void) { return 0; }
9159 +
9160 +#else
9161 +
9162 +extern struct olpc_platform_t olpc_platform_info;
9163 +
9164 +static inline int
9165 +machine_is_olpc(void)
9166 +{
9167 + return (olpc_platform_info.flags & OLPC_F_PRESENT) ? 1 : 0;
9168 +}
9169 +
9170 +static inline int
9171 +olpc_has_dcon(void)
9172 +{
9173 + return (olpc_platform_info.flags & OLPC_F_DCON) ? 1 : 0;
9174 +}
9175 +
9176 +static inline int
9177 +olpc_has_vsa(void)
9178 +{
9179 + return (olpc_platform_info.flags & OLPC_F_VSA) ? 1 : 0;
9180 +}
9181 +
9182 +static inline int olpc_board_at_least(u32 rev)
9183 +{
9184 + return olpc_platform_info.boardrev >= rev;
9185 +}
9186 +
9187 +#endif
9188 +
9189 +/* EC functions */
9190 +
9191 +int olpc_ec_cmd(unsigned char cmd, unsigned char *inbuf, size_t inlen,
9192 + unsigned char *outbuf, size_t outlen);
9193 +
9194 +void olpc_register_battery_callback(void (*f)(unsigned long));
9195 +void olpc_deregister_battery_callback(void);
9196 +
9197 +/* EC commands and responses */
9198 +
9199 +/* SCI source values */
9200 +
9201 +#define EC_SCI_SRC_EMPTY 0x00
9202 +#define EC_SCI_SRC_GAME 0x01
9203 +#define EC_SCI_SRC_BATTERY 0x02
9204 +#define EC_SCI_SRC_BATSOC 0x04
9205 +#define EC_SCI_SRC_BATERR 0x08
9206 +#define EC_SCI_SRC_EBOOK 0x10
9207 +#define EC_SCI_SRC_WLAN 0x20
9208 +#define EC_SCI_SRC_ACPWR 0x40
9209 +#define EC_SCI_SRC_ALL 0x7F
9210 +
9211 +int olpc_ec_mask_set(u8 bits);
9212 +int olpc_ec_mask_unset(u8 bits);
9213 +
9214 +/* GPIO assignments */
9215 +
9216 +#define OLPC_GPIO_MIC_AC (1 << 1)
9217 +#define OLPC_GPIO_DCON_IRQ (1 << 7)
9218 +#define OLPC_GPIO_THRM_ALRM (1 << 10)
9219 +#define OLPC_GPIO_SMB_CLK (1 << 14)
9220 +#define OLPC_GPIO_SMB_DATA (1 << 15)
9221 +#define OLPC_GPIO_WORKAUX (1 << 24)
9222 +#define OLPC_GPIO_LID (1 << 26)
9223 +#define OLPC_GPIO_ECSCI (1 << 27)
9224 +
9225 +#endif
9226 +
9227 Index: linux-2.6.24.7/include/asm-x86/prom.h
9228 ===================================================================
9229 --- /dev/null
9230 +++ linux-2.6.24.7/include/asm-x86/prom.h
9231 @@ -0,0 +1,108 @@
9232 +#ifndef _I386_PROM_H
9233 +#define _I386_PROM_H
9234 +#ifdef __KERNEL__
9235 +
9236 +
9237 +/*
9238 + * Definitions for talking to the Open Firmware PROM on
9239 + * Power Macintosh computers.
9240 + *
9241 + * Copyright (C) 1996-2005 Paul Mackerras.
9242 + *
9243 + * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
9244 + * Updates for SPARC64 by David S. Miller
9245 + * Updates for i386/OLPC by Andres Salomon
9246 + *
9247 + * This program is free software; you can redistribute it and/or
9248 + * modify it under the terms of the GNU General Public License
9249 + * as published by the Free Software Foundation; either version
9250 + * 2 of the License, or (at your option) any later version.
9251 + */
9252 +
9253 +#include <linux/types.h>
9254 +#include <linux/proc_fs.h>
9255 +#include <asm/atomic.h>
9256 +
9257 +typedef u32 phandle;
9258 +typedef u32 ihandle;
9259 +
9260 +struct property {
9261 + char *name;
9262 + int length;
9263 + void *value;
9264 + struct property *next;
9265 +};
9266 +
9267 +struct device_node {
9268 + const char *name;
9269 + const char *type;
9270 + phandle node;
9271 +// phandle linux_phandle;
9272 + char *path_component_name;
9273 + char *full_name;
9274 +
9275 + struct property *properties;
9276 + struct property *deadprops; /* removed properties */
9277 + struct device_node *parent;
9278 + struct device_node *child;
9279 + struct device_node *sibling;
9280 + struct device_node *next; /* next device of same type */
9281 + struct device_node *allnext; /* next in list of all nodes */
9282 + struct proc_dir_entry *pde; /* this node's proc directory */
9283 + struct kref kref;
9284 + unsigned long _flags;
9285 + void *data;
9286 +};
9287 +
9288 +/* flag descriptions */
9289 +#define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */
9290 +
9291 +#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
9292 +#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
9293 +
9294 +#define OF_BAD_ADDR ((u64)-1)
9295 +
9296 +static inline void set_node_proc_entry(struct device_node *dn, struct proc_dir_entry *de)
9297 +{
9298 + dn->pde = de;
9299 +}
9300 +
9301 +extern struct device_node *of_find_node_by_name(struct device_node *from,
9302 + const char *name);
9303 +#define for_each_node_by_name(dn, name) \
9304 + for (dn = of_find_node_by_name(NULL, name); dn; \
9305 + dn = of_find_node_by_name(dn, name))
9306 +extern struct device_node *of_find_node_by_type(struct device_node *from,
9307 + const char *type);
9308 +#define for_each_node_by_type(dn, type) \
9309 + for (dn = of_find_node_by_type(NULL, type); dn; \
9310 + dn = of_find_node_by_type(dn, type))
9311 +extern struct device_node *of_find_compatible_node(struct device_node *from,
9312 + const char *type, const char *compat);
9313 +extern struct device_node *of_find_node_by_path(const char *path);
9314 +extern struct device_node *of_find_node_by_phandle(phandle handle);
9315 +extern struct device_node *of_get_parent(const struct device_node *node);
9316 +extern struct device_node *of_get_next_child(const struct device_node *node,
9317 + struct device_node *prev);
9318 +extern struct property *of_find_property(const struct device_node *np,
9319 + const char *name,
9320 + int *lenp);
9321 +//extern struct device_node *of_node_get(struct device_node *node);
9322 +//extern void of_node_put(struct device_node *node);
9323 +extern int of_device_is_compatible(const struct device_node *device,
9324 + const char *);
9325 +extern const void *of_get_property(const struct device_node *node,
9326 + const char *name,
9327 + int *lenp);
9328 +#define get_property(node,name,lenp) of_get_property(node,name,lenp)
9329 +extern int of_set_property(struct device_node *node, const char *name, void *val, int len);
9330 +extern int of_getintprop_default(struct device_node *np,
9331 + const char *name,
9332 + int def);
9333 +extern int of_n_addr_cells(struct device_node *np);
9334 +extern int of_n_size_cells(struct device_node *np);
9335 +
9336 +extern void prom_build_devicetree(void);
9337 +
9338 +#endif /* __KERNEL__ */
9339 +#endif
9340 Index: linux-2.6.24.7/include/linux/battery.h
9341 ===================================================================
9342 --- /dev/null
9343 +++ linux-2.6.24.7/include/linux/battery.h
9344 @@ -0,0 +1,101 @@
9345 +/*
9346 + * Driver model for batteries
9347 + *
9348 + * © 2006 David Woodhouse <dwmw2@infradead.org>
9349 + *
9350 + * Based on LED Class support, by John Lenz and Richard Purdie:
9351 + *
9352 + * © 2005 John Lenz <lenz@cs.wisc.edu>
9353 + * © 2005-2006 Richard Purdie <rpurdie@openedhand.com>
9354 + *
9355 + * This program is free software; you can redistribute it and/or modify
9356 + * it under the terms of the GNU General Public License version 2 as
9357 + * published by the Free Software Foundation.
9358 + *
9359 + */
9360 +#ifndef __LINUX_BATTERY_H__
9361 +#define __LINUX_BATTERY_H__
9362 +
9363 +struct device;
9364 +struct class_device;
9365 +
9366 +/*
9367 + * Battery Core
9368 + */
9369 +#define PWRDEV_TYPE_BATTERY 0
9370 +#define PWRDEV_TYPE_AC 1
9371 +
9372 +#define BAT_STAT_PRESENT (1<<0)
9373 +#define BAT_STAT_LOW (1<<1)
9374 +#define BAT_STAT_FULL (1<<2)
9375 +#define BAT_STAT_CHARGING (1<<3)
9376 +#define BAT_STAT_DISCHARGING (1<<4)
9377 +#define BAT_STAT_OVERTEMP (1<<5)
9378 +#define BAT_STAT_CRITICAL (1<<6)
9379 +#define BAT_STAT_FIRE (1<<7)
9380 +#define BAT_STAT_CHARGE_DONE (1<<8)
9381 +
9382 +/* Thou shalt not export any attributes in sysfs except these, and
9383 + with these units: */
9384 +#define BAT_INFO_STATUS "status" /* Not free-form. Use
9385 + provided function */
9386 +#define BAT_INFO_TEMP1 "temp1" /* °C/1000 */
9387 +#define BAT_INFO_TEMP1_NAME "temp1_name" /* string */
9388 +
9389 +#define BAT_INFO_TEMP2 "temp2" /* °C/1000 */
9390 +#define BAT_INFO_TEMP2_NAME "temp2_name" /* string */
9391 +
9392 +#define BAT_INFO_VOLTAGE "voltage" /* mV */
9393 +#define BAT_INFO_VOLTAGE_DESIGN "voltage_design" /* mV */
9394 +
9395 +#define BAT_INFO_CURRENT "current" /* mA */
9396 +#define BAT_INFO_CURRENT_NOW "current_now" /* mA */
9397 +
9398 +#define BAT_INFO_POWER "power" /* mW */
9399 +#define BAT_INFO_POWER_NOW "power_now" /* mW */
9400 +
9401 +/* The following capacity/charge properties are represented in either
9402 + mA or mW. The CAP_UNITS property MUST be provided if any of these are. */
9403 +#define BAT_INFO_RATE "rate" /* CAP_UNITS */
9404 +#define BAT_INFO_CAP_LEFT "capacity_left" /* CAP_UNITS*h */
9405 +#define BAT_INFO_CAP_DESIGN "capacity_design" /* CAP_UNITS*h */
9406 +#define BAT_INFO_CAP_LAST_FULL "capacity_last_full" /* CAP_UNITS*h */
9407 +#define BAT_INFO_CAP_LOW "capacity_low_thresh" /* CAP_UNITS*h */
9408 +#define BAT_INFO_CAP_WARN "capacity_warn_thresh" /* CAP_UNITS*h */
9409 +#define BAT_INFO_CAP_UNITS "capacity_units" /* string: must be
9410 + either mA or mW */
9411 +
9412 +#define BAT_INFO_CAP_PCT "capacity_percentage" /* integer */
9413 +
9414 +#define BAT_INFO_TIME_EMPTY "time_to_empty" /* seconds */
9415 +#define BAT_INFO_TIME_EMPTY_NOW "time_to_empty_now" /* seconds */
9416 +#define BAT_INFO_TIME_FULL "time_to_full" /* seconds */
9417 +#define BAT_INFO_TIME_FULL_NOW "time_to_full_now" /* seconds */
9418 +
9419 +#define BAT_INFO_MANUFACTURER "manufacturer" /* string */
9420 +#define BAT_INFO_TECHNOLOGY "technology" /* string */
9421 +#define BAT_INFO_MODEL "model" /* string */
9422 +#define BAT_INFO_SERIAL "serial" /* string */
9423 +#define BAT_INFO_OEM_INFO "oem_info" /* string */
9424 +
9425 +#define BAT_INFO_CYCLE_COUNT "cycle_count" /* integer */
9426 +#define BAT_INFO_DATE_MFR "date_manufactured" /* YYYY[-MM[-DD]] */
9427 +#define BAT_INFO_DATE_FIRST_USE "date_first_use" /* YYYY[-MM[-DD]] */
9428 +
9429 +struct battery_dev {
9430 + int status_cap;
9431 + int id;
9432 + int type;
9433 + const char *name;
9434 +
9435 + struct device *dev;
9436 +};
9437 +
9438 +int battery_device_register(struct device *parent,
9439 + struct battery_dev *battery_cdev);
9440 +void battery_device_unregister(struct battery_dev *battery_cdev);
9441 +
9442 +
9443 +ssize_t battery_attribute_show_status(char *buf, unsigned long status);
9444 +ssize_t battery_attribute_show_ac_status(char *buf, unsigned long status);
9445 +#endif /* __LINUX_BATTERY_H__ */
9446 Index: linux-2.6.24.7/include/linux/fb.h
9447 ===================================================================
9448 --- linux-2.6.24.7.orig/include/linux/fb.h
9449 +++ linux-2.6.24.7/include/linux/fb.h
9450 @@ -666,6 +666,12 @@ struct fb_ops {
9451 /* restore saved state */
9452 void (*fb_restore_state)(struct fb_info *info);
9453
9454 + /* Shut down the graphics engine to save power */
9455 + int (*fb_powerdown)(struct fb_info *info);
9456 +
9457 + /* Power it back up */
9458 + int (*fb_powerup)(struct fb_info *info);
9459 +
9460 /* get capability given var */
9461 void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
9462 struct fb_var_screeninfo *var);
9463 @@ -945,6 +951,9 @@ extern int fb_get_color_depth(struct fb_
9464 extern int fb_get_options(char *name, char **option);
9465 extern int fb_new_modelist(struct fb_info *info);
9466
9467 +extern int fb_powerdown(struct fb_info *info);
9468 +extern int fb_powerup(struct fb_info *info);
9469 +
9470 extern struct fb_info *registered_fb[FB_MAX];
9471 extern int num_registered_fb;
9472 extern struct class *fb_class;
9473 Index: linux-2.6.24.7/include/linux/i2c-id.h
9474 ===================================================================
9475 --- linux-2.6.24.7.orig/include/linux/i2c-id.h
9476 +++ linux-2.6.24.7/include/linux/i2c-id.h
9477 @@ -125,6 +125,7 @@
9478 #define I2C_DRIVERID_LM4857 92 /* LM4857 Audio Amplifier */
9479 #define I2C_DRIVERID_VP27SMPX 93 /* Panasonic VP27s tuner internal MPX */
9480 #define I2C_DRIVERID_CS4270 94 /* Cirrus Logic 4270 audio codec */
9481 +#define I2C_DRIVERID_DCON 95
9482
9483 #define I2C_DRIVERID_I2CDEV 900
9484 #define I2C_DRIVERID_ARP 902 /* SMBus ARP Client */
9485 Index: linux-2.6.24.7/include/linux/isl_38xx.h
9486 ===================================================================
9487 --- /dev/null
9488 +++ linux-2.6.24.7/include/linux/isl_38xx.h
9489 @@ -0,0 +1,127 @@
9490 +/*
9491 + * Copyright (C) 2002 Intersil Americas Inc.
9492 + *
9493 + * This program is free software; you can redistribute it and/or modify
9494 + * it under the terms of the GNU General Public License as published by
9495 + * the Free Software Foundation; either version 2 of the License
9496 + *
9497 + * This program is distributed in the hope that it will be useful,
9498 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
9499 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9500 + * GNU General Public License for more details.
9501 + *
9502 + * You should have received a copy of the GNU General Public License
9503 + * along with this program; if not, write to the Free Software
9504 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
9505 + */
9506 +
9507 +#ifndef _LINUX_ISL_38XX_H
9508 +#define _LINUX_ISL_38XX_H
9509 +
9510 +#include <asm/io.h>
9511 +
9512 +#define ISL38XX_CB_RX_QSIZE 8
9513 +#define ISL38XX_CB_TX_QSIZE 32
9514 +
9515 +/* ISL38XX Access Point Specific definitions */
9516 +#define ISL38XX_MAX_WDS_LINKS 8
9517 +
9518 +/* ISL38xx Client Specific definitions */
9519 +#define ISL38XX_PSM_ACTIVE_STATE 0
9520 +#define ISL38XX_PSM_POWERSAVE_STATE 1
9521 +
9522 +/* ISL38XX Host Interface Definitions */
9523 +#define ISL38XX_PCI_MEM_SIZE 0x02000
9524 +#define ISL38XX_MEMORY_WINDOW_SIZE 0x01000
9525 +#define ISL38XX_DEV_FIRMWARE_ADDRES 0x20000
9526 +#define ISL38XX_WRITEIO_DELAY 10 /* in us */
9527 +#define ISL38XX_RESET_DELAY 50 /* in ms */
9528 +#define ISL38XX_WAIT_CYCLE 10 /* in 10ms */
9529 +#define ISL38XX_MAX_WAIT_CYCLES 10
9530 +
9531 +/* PCI Memory Area */
9532 +#define ISL38XX_HARDWARE_REG 0x0000
9533 +#define ISL38XX_CARDBUS_CIS 0x0800
9534 +#define ISL38XX_DIRECT_MEM_WIN 0x1000
9535 +
9536 +/* Hardware registers */
9537 +#define ISL38XX_DEV_INT_REG 0x0000
9538 +#define ISL38XX_INT_IDENT_REG 0x0010
9539 +#define ISL38XX_INT_ACK_REG 0x0014
9540 +#define ISL38XX_INT_EN_REG 0x0018
9541 +#define ISL38XX_GEN_PURP_COM_REG_1 0x0020
9542 +#define ISL38XX_GEN_PURP_COM_REG_2 0x0024
9543 +#define ISL38XX_CTRL_BLK_BASE_REG ISL38XX_GEN_PURP_COM_REG_1
9544 +#define ISL38XX_DIR_MEM_BASE_REG 0x0030
9545 +#define ISL38XX_CTRL_STAT_REG 0x0078
9546 +
9547 +/* High end mobos queue up pci writes, the following
9548 + * is used to "read" from after a write to force flush */
9549 +#define ISL38XX_PCI_POSTING_FLUSH ISL38XX_INT_EN_REG
9550 +
9551 +/**
9552 + * isl38xx_w32_flush - PCI iomem write helper
9553 + * @base: (host) memory base address of the device
9554 + * @val: 32bit value (host order) to write
9555 + * @offset: byte offset into @base to write value to
9556 + *
9557 + * This helper takes care of writing a 32bit datum to the
9558 + * specified offset into the device's pci memory space, and making sure
9559 + * the pci memory buffers get flushed by performing one harmless read
9560 + * from the %ISL38XX_PCI_POSTING_FLUSH offset.
9561 + */
9562 +static inline void
9563 +isl38xx_w32_flush(void __iomem *base, u32 val, unsigned long offset)
9564 +{
9565 + writel(val, base + offset);
9566 + (void) readl(base + ISL38XX_PCI_POSTING_FLUSH);
9567 +}
9568 +
9569 +/* Device Interrupt register bits */
9570 +#define ISL38XX_DEV_INT_RESET 0x0001
9571 +#define ISL38XX_DEV_INT_UPDATE 0x0002
9572 +#define ISL38XX_DEV_INT_WAKEUP 0x0008
9573 +#define ISL38XX_DEV_INT_SLEEP 0x0010
9574 +#define ISL38XX_DEV_INT_ABORT 0x0020
9575 +/* thos two only used in USB */
9576 +#define ISL38XX_DEV_INT_DATA 0x0040
9577 +#define ISL38XX_DEV_INT_MGMT 0x0080
9578 +
9579 +#define ISL38XX_DEV_INT_PCIUART_CTS 0x4000
9580 +#define ISL38XX_DEV_INT_PCIUART_DR 0x8000
9581 +
9582 +/* Interrupt Identification/Acknowledge/Enable register bits */
9583 +#define ISL38XX_INT_IDENT_UPDATE 0x0002
9584 +#define ISL38XX_INT_IDENT_INIT 0x0004
9585 +#define ISL38XX_INT_IDENT_WAKEUP 0x0008
9586 +#define ISL38XX_INT_IDENT_SLEEP 0x0010
9587 +#define ISL38XX_INT_IDENT_PCIUART_CTS 0x4000
9588 +#define ISL38XX_INT_IDENT_PCIUART_DR 0x8000
9589 +
9590 +#define ISL38XX_INT_SOURCES (ISL38XX_INT_IDENT_UPDATE | \
9591 + ISL38XX_INT_IDENT_INIT | \
9592 + ISL38XX_INT_IDENT_WAKEUP | \
9593 + ISL38XX_INT_IDENT_SLEEP | \
9594 + ISL38XX_INT_IDENT_PCIUART_CTS | \
9595 + ISL38XX_INT_IDENT_PCIUART_DR)
9596 +
9597 +/* Control/Status register bits */
9598 +/* Looks like there are other meaningful bits
9599 + 0x20004400 seen in normal operation,
9600 + 0x200044db at 'timeout waiting for mgmt response'
9601 +*/
9602 +#define ISL38XX_CTRL_STAT_SLEEPMODE 0x00000200
9603 +#define ISL38XX_CTRL_STAT_CLKRUN 0x00800000
9604 +#define ISL38XX_CTRL_STAT_RESET 0x10000000
9605 +#define ISL38XX_CTRL_STAT_RAMBOOT 0x20000000
9606 +#define ISL38XX_CTRL_STAT_STARTHALTED 0x40000000
9607 +#define ISL38XX_CTRL_STAT_HOST_OVERRIDE 0x80000000
9608 +
9609 +/* Some flags for the isl hardware registers controlling DMA inside the
9610 + * chip */
9611 +#define ISL38XX_DMA_STATUS_DONE 0x00000001
9612 +#define ISL38XX_DMA_STATUS_READY 0x00000002
9613 +#define NET2280_EPA_FIFO_PCI_ADDR 0x20000000
9614 +#define ISL38XX_DMA_MASTER_CONTROL_TRIGGER 0x00000004
9615 +
9616 +#endif /* _LINUX_ISL_38XX_H */
9617 Index: linux-2.6.24.7/include/linux/pm.h
9618 ===================================================================
9619 --- linux-2.6.24.7.orig/include/linux/pm.h
9620 +++ linux-2.6.24.7/include/linux/pm.h
9621 @@ -178,6 +178,9 @@ struct dev_pm_info {
9622 unsigned can_wakeup:1;
9623 #ifdef CONFIG_PM_SLEEP
9624 unsigned should_wakeup:1;
9625 + pm_message_t prev_state;
9626 + void * saved_state;
9627 + struct device * pm_parent;
9628 struct list_head entry;
9629 #endif
9630 };
9631 Index: linux-2.6.24.7/include/linux/power_supply.h
9632 ===================================================================
9633 --- linux-2.6.24.7.orig/include/linux/power_supply.h
9634 +++ linux-2.6.24.7/include/linux/power_supply.h
9635 @@ -98,9 +98,11 @@ enum power_supply_property {
9636 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
9637 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
9638 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
9639 + POWER_SUPPLY_PROP_ACCUM_CURRENT,
9640 /* Properties of type `const char *' */
9641 POWER_SUPPLY_PROP_MODEL_NAME,
9642 POWER_SUPPLY_PROP_MANUFACTURER,
9643 + POWER_SUPPLY_PROP_SERIAL_NUMBER,
9644 };
9645
9646 enum power_supply_type {
9647 @@ -169,9 +171,10 @@ struct power_supply_info {
9648
9649 extern void power_supply_changed(struct power_supply *psy);
9650 extern int power_supply_am_i_supplied(struct power_supply *psy);
9651 +extern void power_supply_status_changed(struct power_supply *psy);
9652
9653 extern int power_supply_register(struct device *parent,
9654 - struct power_supply *psy);
9655 + struct power_supply *psy);
9656 extern void power_supply_unregister(struct power_supply *psy);
9657
9658 /* For APM emulation, think legacy userspace. */
9659 Index: linux-2.6.24.7/include/linux/vt_kern.h
9660 ===================================================================
9661 --- linux-2.6.24.7.orig/include/linux/vt_kern.h
9662 +++ linux-2.6.24.7/include/linux/vt_kern.h
9663 @@ -96,4 +96,23 @@ struct vt_spawn_console {
9664 };
9665 extern struct vt_spawn_console vt_spawn_con;
9666
9667 +/* A notifier list for console events */
9668 +extern struct raw_notifier_head console_notifier_list;
9669 +
9670 +/* Called when the FG console switches to KD_TEXT mode */
9671 +#define CONSOLE_EVENT_SWITCH_TEXT 0x01
9672 +
9673 +/* Called when the FG console switches to KD_GRAPHICS mode */
9674 +#define CONSOLE_EVENT_SWITCH_GRAPHICS 0x02
9675 +
9676 +static inline int console_event_register(struct notifier_block *n)
9677 +{
9678 + return raw_notifier_chain_register(&console_notifier_list, n);
9679 +}
9680 +
9681 +static inline int console_event_unregister(struct notifier_block *n)
9682 +{
9683 + return raw_notifier_chain_unregister(&console_notifier_list, n);
9684 +}
9685 +
9686 #endif /* _VT_KERN_H */
9687 Index: linux-2.6.24.7/include/sound/ac97_codec.h
9688 ===================================================================
9689 --- linux-2.6.24.7.orig/include/sound/ac97_codec.h
9690 +++ linux-2.6.24.7/include/sound/ac97_codec.h
9691 @@ -281,10 +281,12 @@
9692 /* specific - Analog Devices */
9693 #define AC97_AD_TEST 0x5a /* test register */
9694 #define AC97_AD_TEST2 0x5c /* undocumented test register 2 */
9695 +#define AC97_AD_HPFD_SHIFT 12 /* High Pass Filter Disable */
9696 #define AC97_AD_CODEC_CFG 0x70 /* codec configuration */
9697 #define AC97_AD_JACK_SPDIF 0x72 /* Jack Sense & S/PDIF */
9698 #define AC97_AD_SERIAL_CFG 0x74 /* Serial Configuration */
9699 #define AC97_AD_MISC 0x76 /* Misc Control Bits */
9700 +#define AC97_AD_VREFD_SHIFT 2 /* V_REFOUT Disable (AD1888) */
9701
9702 /* specific - Cirrus Logic */
9703 #define AC97_CSR_ACMODE 0x5e /* AC Mode Register */
9704 Index: linux-2.6.24.7/kernel/power/console.c
9705 ===================================================================
9706 --- linux-2.6.24.7.orig/kernel/power/console.c
9707 +++ linux-2.6.24.7/kernel/power/console.c
9708 @@ -9,7 +9,7 @@
9709 #include <linux/console.h>
9710 #include "power.h"
9711
9712 -#if defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE)
9713 +#if defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE) && !defined(CONFIG_DISABLE_SUSPEND_VT_SWITCH)
9714 #define SUSPEND_CONSOLE (MAX_NR_CONSOLES-1)
9715
9716 static int orig_fgconsole, orig_kmsg;
9717 Index: linux-2.6.24.7/kernel/power/Kconfig
9718 ===================================================================
9719 --- linux-2.6.24.7.orig/kernel/power/Kconfig
9720 +++ linux-2.6.24.7/kernel/power/Kconfig
9721 @@ -37,9 +37,22 @@ config PM_DEBUG
9722 code. This is helpful when debugging and reporting PM bugs, like
9723 suspend support.
9724
9725 +config DISABLE_SUSPEND_VT_SWITCH
9726 + bool "Disable the console switch prior to suspend (DANGEROUS)"
9727 + depends on PM_DEBUG
9728 + default n
9729 + ---help---
9730 + This option disables the automatic switch to VT console that happens
9731 + prior to Linux going into a suspend/sleep. Your video card/framebuffer
9732 + must be able to properly restore the display (even if X is doing
9733 + something crazy!) in this scenario. This is useful for saving
9734 + precious milliseconds during suspend and resume.
9735 +
9736 + If unsure, say N.
9737 +
9738 config PM_VERBOSE
9739 bool "Verbose Power Management debugging"
9740 - depends on PM_DEBUG
9741 + depends on VT_CONSOLE && PM && EXPERIMENTAL
9742 default n
9743 ---help---
9744 This option enables verbose messages from the Power Management code.
9745 Index: linux-2.6.24.7/kernel/power/main.c
9746 ===================================================================
9747 --- linux-2.6.24.7.orig/kernel/power/main.c
9748 +++ linux-2.6.24.7/kernel/power/main.c
9749 @@ -76,11 +76,13 @@ static int suspend_prepare(void)
9750 if (!suspend_ops || !suspend_ops->enter)
9751 return -EPERM;
9752
9753 +#ifndef CONFIG_OLPC_PM
9754 error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
9755 if (error)
9756 goto Finish;
9757
9758 pm_prepare_console();
9759 +#endif
9760
9761 if (freeze_processes()) {
9762 error = -EAGAIN;
9763 Index: linux-2.6.24.7/scripts/kconfig/conf.c
9764 ===================================================================
9765 --- linux-2.6.24.7.orig/scripts/kconfig/conf.c
9766 +++ linux-2.6.24.7/scripts/kconfig/conf.c
9767 @@ -22,6 +22,7 @@ enum {
9768 ask_new,
9769 ask_silent,
9770 set_default,
9771 + set_silentdefault,
9772 set_yes,
9773 set_mod,
9774 set_no,
9775 @@ -64,10 +65,11 @@ static void strip(char *str)
9776
9777 static void check_stdin(void)
9778 {
9779 - if (!valid_stdin && input_mode == ask_silent) {
9780 + if (!valid_stdin && (input_mode == ask_silent ||
9781 + input_mode == set_silentdefault)) {
9782 printf(_("aborted!\n\n"));
9783 printf(_("Console input/output is redirected. "));
9784 - printf(_("Run 'make oldconfig' to update configuration.\n\n"));
9785 + printf(_("Configuration file needs to be updated.\n\n"));
9786 exit(1);
9787 }
9788 }
9789 @@ -102,6 +104,7 @@ static int conf_askvalue(struct symbol *
9790 break;
9791 case ask_new:
9792 case ask_silent:
9793 + case set_silentdefault:
9794 if (sym_has_value(sym)) {
9795 printf("%s\n", def);
9796 return 0;
9797 @@ -352,6 +355,7 @@ static int conf_choice(struct menu *menu
9798 switch (input_mode) {
9799 case ask_new:
9800 case ask_silent:
9801 + case set_silentdefault:
9802 if (!is_new) {
9803 cnt = def;
9804 printf("%d\n", cnt);
9805 @@ -424,7 +428,9 @@ static void conf(struct menu *menu)
9806
9807 switch (prop->type) {
9808 case P_MENU:
9809 - if (input_mode == ask_silent && rootEntry != menu) {
9810 + if ((input_mode == ask_silent ||
9811 + input_mode == set_silentdefault) &&
9812 + rootEntry != menu) {
9813 check_conf(menu);
9814 return;
9815 }
9816 @@ -508,6 +514,16 @@ int main(int ac, char **av)
9817 input_mode = ask_silent;
9818 valid_stdin = isatty(0) && isatty(1) && isatty(2);
9819 break;
9820 + case 'S':
9821 + input_mode = set_silentdefault;
9822 + valid_stdin = isatty(0) && isatty(1) && isatty(2);
9823 + defconfig_file = av[i++];
9824 + if (!defconfig_file) {
9825 + printf("%s: No default config file specified\n",
9826 + av[0]);
9827 + exit(1);
9828 + }
9829 + break;
9830 case 'd':
9831 input_mode = set_default;
9832 break;
9833 @@ -557,6 +573,14 @@ int main(int ac, char **av)
9834 exit(1);
9835 }
9836 break;
9837 + case set_silentdefault:
9838 + if (conf_read(defconfig_file)) {
9839 + printf("***\n"
9840 + "*** Can't find default configuration \"%s\"!\n"
9841 + "***\n", defconfig_file);
9842 + exit(1);
9843 + }
9844 + break;
9845 case ask_silent:
9846 if (stat(".config", &tmpstat)) {
9847 printf(_("***\n"
9848 @@ -597,7 +621,7 @@ int main(int ac, char **av)
9849 break;
9850 }
9851
9852 - if (input_mode != ask_silent) {
9853 + if (input_mode != ask_silent && input_mode != set_silentdefault) {
9854 rootEntry = &rootmenu;
9855 conf(&rootmenu);
9856 if (input_mode == ask_all) {
9857 @@ -610,19 +634,21 @@ int main(int ac, char **av)
9858 fprintf(stderr, _("\n*** Kernel configuration requires explicit update.\n\n"));
9859 return 1;
9860 }
9861 - } else
9862 + } else if (input_mode != set_silentdefault)
9863 goto skip_check;
9864
9865 do {
9866 conf_cnt = 0;
9867 check_conf(&rootmenu);
9868 } while (conf_cnt);
9869 - if (conf_write(NULL)) {
9870 + if (conf_write(NULL, input_mode == ask_silent ||
9871 + input_mode == set_silentdefault)) {
9872 fprintf(stderr, _("\n*** Error during writing of the kernel configuration.\n\n"));
9873 return 1;
9874 }
9875 skip_check:
9876 - if (input_mode == ask_silent && conf_write_autoconf()) {
9877 + if ((input_mode == ask_silent || input_mode == set_silentdefault) &&
9878 + conf_write_autoconf()) {
9879 fprintf(stderr, _("\n*** Error during writing of the kernel configuration.\n\n"));
9880 return 1;
9881 }
9882 Index: linux-2.6.24.7/scripts/kconfig/confdata.c
9883 ===================================================================
9884 --- linux-2.6.24.7.orig/scripts/kconfig/confdata.c
9885 +++ linux-2.6.24.7/scripts/kconfig/confdata.c
9886 @@ -393,7 +393,7 @@ int conf_read(const char *name)
9887 return 0;
9888 }
9889
9890 -int conf_write(const char *name)
9891 +int conf_write(const char *name, int quiet)
9892 {
9893 FILE *out;
9894 struct symbol *sym;
9895 @@ -548,9 +548,10 @@ int conf_write(const char *name)
9896 return 1;
9897 }
9898
9899 - printf(_("#\n"
9900 - "# configuration written to %s\n"
9901 - "#\n"), newname);
9902 + if (!quiet)
9903 + printf("#\n"
9904 + "# configuration written to %s\n"
9905 + "#\n", newname);
9906
9907 sym_set_change_count(0);
9908
9909 Index: linux-2.6.24.7/scripts/kconfig/gconf.c
9910 ===================================================================
9911 --- linux-2.6.24.7.orig/scripts/kconfig/gconf.c
9912 +++ linux-2.6.24.7/scripts/kconfig/gconf.c
9913 @@ -621,7 +621,7 @@ void on_load1_activate(GtkMenuItem * men
9914
9915 void on_save_activate(GtkMenuItem * menuitem, gpointer user_data)
9916 {
9917 - if (conf_write(NULL))
9918 + if (conf_write(NULL, 0))
9919 text_insert_msg(_("Error"), _("Unable to save configuration !"));
9920 }
9921
9922 @@ -634,7 +634,7 @@ store_filename(GtkFileSelection * file_s
9923 fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
9924 (user_data));
9925
9926 - if (conf_write(fn))
9927 + if (conf_write(fn, 0))
9928 text_insert_msg(_("Error"), _("Unable to save configuration !"));
9929
9930 gtk_widget_destroy(GTK_WIDGET(user_data));
9931 Index: linux-2.6.24.7/scripts/kconfig/lkc_proto.h
9932 ===================================================================
9933 --- linux-2.6.24.7.orig/scripts/kconfig/lkc_proto.h
9934 +++ linux-2.6.24.7/scripts/kconfig/lkc_proto.h
9935 @@ -3,7 +3,7 @@
9936 P(conf_parse,void,(const char *name));
9937 P(conf_read,int,(const char *name));
9938 P(conf_read_simple,int,(const char *name, int));
9939 -P(conf_write,int,(const char *name));
9940 +P(conf_write,int,(const char *name, int));
9941 P(conf_write_autoconf,int,(void));
9942 P(conf_get_changed,bool,(void));
9943 P(conf_set_changed_callback, void,(void (*fn)(void)));
9944 Index: linux-2.6.24.7/scripts/kconfig/Makefile
9945 ===================================================================
9946 --- linux-2.6.24.7.orig/scripts/kconfig/Makefile
9947 +++ linux-2.6.24.7/scripts/kconfig/Makefile
9948 @@ -69,6 +69,9 @@ endif
9949 %_defconfig: $(obj)/conf
9950 $(Q)$< -D arch/$(SRCARCH)/configs/$@ $(Kconfig)
9951
9952 +%_silentdefconfig: $(obj)/conf
9953 + $(Q)$< -S arch/$(ARCH)/configs/$(subst _silentdefconfig,_defconfig,$@) arch/$(ARCH)/Kconfig
9954 +
9955 # Help text used by make help
9956 help:
9957 @echo ' config - Update current config utilising a line-oriented program'
9958 Index: linux-2.6.24.7/scripts/kconfig/mconf.c
9959 ===================================================================
9960 --- linux-2.6.24.7.orig/scripts/kconfig/mconf.c
9961 +++ linux-2.6.24.7/scripts/kconfig/mconf.c
9962 @@ -885,7 +885,7 @@ static void conf_save(void)
9963 case 0:
9964 if (!dialog_input_result[0])
9965 return;
9966 - if (!conf_write(dialog_input_result)) {
9967 + if (!conf_write(dialog_input_result, 0)) {
9968 set_config_filename(dialog_input_result);
9969 return;
9970 }
9971 @@ -945,7 +945,7 @@ int main(int ac, char **av)
9972
9973 switch (res) {
9974 case 0:
9975 - if (conf_write(filename)) {
9976 + if (conf_write(filename, 0)) {
9977 fprintf(stderr, _("\n\n"
9978 "Error during writing of the kernel configuration.\n"
9979 "Your kernel configuration changes were NOT saved."
9980 Index: linux-2.6.24.7/scripts/kconfig/qconf.cc
9981 ===================================================================
9982 --- linux-2.6.24.7.orig/scripts/kconfig/qconf.cc
9983 +++ linux-2.6.24.7/scripts/kconfig/qconf.cc
9984 @@ -1458,7 +1458,7 @@ void ConfigMainWindow::loadConfig(void)
9985
9986 void ConfigMainWindow::saveConfig(void)
9987 {
9988 - if (conf_write(NULL))
9989 + if (conf_write(NULL, 0))
9990 QMessageBox::information(this, "qconf", "Unable to save configuration!");
9991 }
9992
9993 @@ -1467,7 +1467,7 @@ void ConfigMainWindow::saveConfigAs(void
9994 QString s = QFileDialog::getSaveFileName(".config", NULL, this);
9995 if (s.isNull())
9996 return;
9997 - if (conf_write(QFile::encodeName(s)))
9998 + if (conf_write(QFile::encodeName(s), 0))
9999 QMessageBox::information(this, "qconf", "Unable to save configuration!");
10000 }
10001
10002 @@ -1619,7 +1619,7 @@ void ConfigMainWindow::closeEvent(QClose
10003 mb.setButtonText(QMessageBox::Cancel, "Cancel Exit");
10004 switch (mb.exec()) {
10005 case QMessageBox::Yes:
10006 - conf_write(NULL);
10007 + conf_write(NULL, 0);
10008 case QMessageBox::No:
10009 e->accept();
10010 break;
10011 Index: linux-2.6.24.7/sound/pci/ac97/ac97_patch.c
10012 ===================================================================
10013 --- linux-2.6.24.7.orig/sound/pci/ac97/ac97_patch.c
10014 +++ linux-2.6.24.7/sound/pci/ac97/ac97_patch.c
10015 @@ -2029,8 +2029,9 @@ static const struct snd_kcontrol_new snd
10016 .get = snd_ac97_ad1888_lohpsel_get,
10017 .put = snd_ac97_ad1888_lohpsel_put
10018 },
10019 - AC97_SINGLE("V_REFOUT Enable", AC97_AD_MISC, 2, 1, 1),
10020 - AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2, 12, 1, 1),
10021 + AC97_SINGLE("V_REFOUT Enable", AC97_AD_MISC, AC97_AD_VREFD_SHIFT, 1, 1),
10022 + AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2,
10023 + AC97_AD_HPFD_SHIFT, 1, 1),
10024 AC97_SINGLE("Spread Front to Surround and Center/LFE", AC97_AD_MISC, 7, 1, 0),
10025 {
10026 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10027 Index: linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio.c
10028 ===================================================================
10029 --- linux-2.6.24.7.orig/sound/pci/cs5535audio/cs5535audio.c
10030 +++ linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio.c
10031 @@ -145,7 +145,7 @@ static unsigned short snd_cs5535audio_ac
10032 return snd_cs5535audio_codec_read(cs5535au, reg);
10033 }
10034
10035 -static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
10036 +static int __devinit snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
10037 {
10038 struct snd_card *card = cs5535au->card;
10039 struct snd_ac97_bus *pbus;
10040 @@ -160,10 +160,14 @@ static int snd_cs5535audio_mixer(struct
10041 return err;
10042
10043 memset(&ac97, 0, sizeof(ac97));
10044 - ac97.scaps = AC97_SCAP_AUDIO|AC97_SCAP_SKIP_MODEM;
10045 + ac97.scaps = AC97_SCAP_AUDIO | AC97_SCAP_SKIP_MODEM
10046 + | AC97_SCAP_POWER_SAVE;
10047 ac97.private_data = cs5535au;
10048 ac97.pci = cs5535au->pci;
10049
10050 + /* olpc_prequirks is dummied out if not olpc */
10051 + olpc_prequirks(card, &ac97);
10052 +
10053 if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) {
10054 snd_printk(KERN_ERR "mixer failed\n");
10055 return err;
10056 @@ -171,6 +175,12 @@ static int snd_cs5535audio_mixer(struct
10057
10058 snd_ac97_tune_hardware(cs5535au->ac97, ac97_quirks, ac97_quirk);
10059
10060 + /* olpc_quirks is dummied out if not olpc */
10061 + if (( err = olpc_quirks(card, cs5535au->ac97)) < 0) {
10062 + snd_printk(KERN_ERR "olpc quirks failed\n");
10063 + return err;
10064 + }
10065 +
10066 return 0;
10067 }
10068
10069 Index: linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio.h
10070 ===================================================================
10071 --- linux-2.6.24.7.orig/sound/pci/cs5535audio/cs5535audio.h
10072 +++ linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio.h
10073 @@ -78,6 +78,7 @@ struct cs5535audio_dma {
10074 unsigned int buf_addr, buf_bytes;
10075 unsigned int period_bytes, periods;
10076 u32 saved_prd;
10077 + int pcm_open_flag;
10078 };
10079
10080 struct cs5535audio {
10081 @@ -93,8 +94,21 @@ struct cs5535audio {
10082 struct cs5535audio_dma dmas[NUM_CS5535AUDIO_DMAS];
10083 };
10084
10085 +#ifdef CONFIG_PM
10086 int snd_cs5535audio_suspend(struct pci_dev *pci, pm_message_t state);
10087 int snd_cs5535audio_resume(struct pci_dev *pci);
10088 +#endif
10089 +
10090 +#ifdef CONFIG_OLPC
10091 +void olpc_prequirks(struct snd_card *card, struct snd_ac97_template *ac97) __devinit;
10092 +int olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97) __devinit;
10093 +int olpc_ai_enable(struct snd_ac97 *ac97, u8 val);
10094 +#else
10095 +#define olpc_prequirks(arg,arg2) do {} while (0)
10096 +#define olpc_quirks(arg,arg2) (0)
10097 +#define olpc_ai_enable(a, v) (0)
10098 +#endif
10099 +
10100 int __devinit snd_cs5535audio_pcm(struct cs5535audio *cs5535audio);
10101
10102 #endif /* __SOUND_CS5535AUDIO_H */
10103 Index: linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio_olpc.c
10104 ===================================================================
10105 --- /dev/null
10106 +++ linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio_olpc.c
10107 @@ -0,0 +1,110 @@
10108 +#include <sound/driver.h>
10109 +#include <sound/core.h>
10110 +#include <sound/info.h>
10111 +#include <sound/control.h>
10112 +#include <sound/ac97_codec.h>
10113 +
10114 +#include <asm/olpc.h>
10115 +#include "cs5535audio.h"
10116 +
10117 +/*
10118 + * OLPC has an additional feature on top of the regular AD1888 codec features.
10119 + * It has an Analog Input mode that is switched into (after disabling the
10120 + * High Pass Filter) via GPIO. It is only supported on B2 and later models.
10121 + */
10122 +
10123 +int olpc_ai_enable(struct snd_ac97 *ac97, u8 val)
10124 +{
10125 + int err;
10126 +
10127 + /*
10128 + * update the High Pass Filter (via AC97_AD_TEST2), and then set
10129 + * Analog Input mode through a GPIO.
10130 + */
10131 +
10132 + if (val) {
10133 + err = snd_ac97_update_bits(ac97, AC97_AD_TEST2,
10134 + 1<<AC97_AD_HPFD_SHIFT, 1<<AC97_AD_HPFD_SHIFT);
10135 + geode_gpio_set(OLPC_GPIO_MIC_AC, GPIO_OUTPUT_VAL);
10136 + }
10137 + else {
10138 + err = snd_ac97_update_bits(ac97, AC97_AD_TEST2,
10139 + 1<<AC97_AD_HPFD_SHIFT, 0);
10140 + geode_gpio_clear(OLPC_GPIO_MIC_AC, GPIO_OUTPUT_VAL);
10141 + }
10142 + if (err < 0)
10143 + snd_printk(KERN_ERR "Error updating AD_TEST2: %d\n", err);
10144 +
10145 + return err;
10146 +}
10147 +EXPORT_SYMBOL_GPL(olpc_ai_enable);
10148 +
10149 +static int snd_cs5535audio_ai_info(struct snd_kcontrol *kcontrol,
10150 + struct snd_ctl_elem_info *uinfo)
10151 +{
10152 + uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
10153 + uinfo->count = 1;
10154 + uinfo->value.integer.min = 0;
10155 + uinfo->value.integer.max = 1;
10156 + return 0;
10157 +}
10158 +
10159 +static int snd_cs5535audio_ai_get(struct snd_kcontrol *kcontrol,
10160 + struct snd_ctl_elem_value *ucontrol)
10161 +{
10162 + ucontrol->value.integer.value[0] = geode_gpio_isset(OLPC_GPIO_MIC_AC,
10163 + GPIO_OUTPUT_VAL);
10164 + return 0;
10165 +}
10166 +
10167 +static int snd_cs5535audio_ai_put(struct snd_kcontrol *kcontrol,
10168 + struct snd_ctl_elem_value *ucontrol)
10169 +{
10170 + struct cs5535audio *cs5535au = snd_kcontrol_chip(kcontrol);
10171 + struct snd_ac97 *ac97 = cs5535au->ac97;
10172 +
10173 + olpc_ai_enable(ac97, ucontrol->value.integer.value[0]);
10174 +
10175 + return 1;
10176 +}
10177 +
10178 +static struct snd_kcontrol_new snd_cs5535audio_controls __devinitdata =
10179 +{
10180 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10181 + .name = "DC Mode Enable",
10182 + .info = snd_cs5535audio_ai_info,
10183 + .get = snd_cs5535audio_ai_get,
10184 + .put = snd_cs5535audio_ai_put,
10185 + .private_value = 0
10186 +};
10187 +
10188 +void __devinit olpc_prequirks(struct snd_card *card,
10189 + struct snd_ac97_template *ac97)
10190 +{
10191 + /* Bail if this isn't an OLPC platform */
10192 + if (!machine_is_olpc())
10193 + return;
10194 +
10195 + /* If on an OLPC B3 or higher, invert EAPD. */
10196 + if (olpc_board_at_least(olpc_board_pre(0xb3)))
10197 + ac97->scaps |= AC97_SCAP_INV_EAPD;
10198 +}
10199 +
10200 +int __devinit olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
10201 +{
10202 + struct snd_ctl_elem_id elem;
10203 +
10204 + /* Bail if this isn't an OLPC platform */
10205 + if (!machine_is_olpc())
10206 + return 0;
10207 +
10208 + /* drop the original ad1888 HPF control */
10209 + memset(&elem, 0, sizeof(elem));
10210 + elem.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
10211 + strcpy(elem.name, "High Pass Filter Enable");
10212 + snd_ctl_remove_id(card, &elem);
10213 +
10214 + /* add the override for OLPC's HPF */
10215 + return snd_ctl_add(card, snd_ctl_new1(&snd_cs5535audio_controls,
10216 + ac97->private_data));
10217 +}
10218 Index: linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio_pcm.c
10219 ===================================================================
10220 --- linux-2.6.24.7.orig/sound/pci/cs5535audio/cs5535audio_pcm.c
10221 +++ linux-2.6.24.7/sound/pci/cs5535audio/cs5535audio_pcm.c
10222 @@ -259,6 +259,9 @@ static int snd_cs5535audio_hw_params(str
10223 err = cs5535audio_build_dma_packets(cs5535au, dma, substream,
10224 params_periods(hw_params),
10225 params_period_bytes(hw_params));
10226 + if (!err)
10227 + dma->pcm_open_flag = 1;
10228 +
10229 return err;
10230 }
10231
10232 @@ -267,6 +270,15 @@ static int snd_cs5535audio_hw_free(struc
10233 struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
10234 struct cs5535audio_dma *dma = substream->runtime->private_data;
10235
10236 + if (dma->pcm_open_flag) {
10237 + if (substream == cs5535au->playback_substream)
10238 + snd_ac97_update_power(cs5535au->ac97,
10239 + AC97_PCM_FRONT_DAC_RATE, 0);
10240 + else
10241 + snd_ac97_update_power(cs5535au->ac97,
10242 + AC97_PCM_LR_ADC_RATE, 0);
10243 + dma->pcm_open_flag = 0;
10244 + }
10245 cs5535audio_clear_dma_packets(cs5535au, dma, substream);
10246 return snd_pcm_lib_free_pages(substream);
10247 }
10248 @@ -341,6 +353,7 @@ static int snd_cs5535audio_capture_open(
10249 int err;
10250 struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
10251 struct snd_pcm_runtime *runtime = substream->runtime;
10252 + struct snd_ac97 *ac97 = cs5535au->ac97;
10253
10254 runtime->hw = snd_cs5535audio_capture;
10255 cs5535au->capture_substream = substream;
10256 @@ -348,11 +361,29 @@ static int snd_cs5535audio_capture_open(
10257 if ((err = snd_pcm_hw_constraint_integer(runtime,
10258 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
10259 return err;
10260 - return 0;
10261 +
10262 +#ifdef CONFIG_OLPC
10263 + /* Disable Analog Input */
10264 + olpc_ai_enable(ac97, 0);
10265 + /* Enable V_ref bias while recording. */
10266 + snd_ac97_update_bits(ac97, AC97_AD_MISC, 1<<AC97_AD_VREFD_SHIFT, 0);
10267 +#endif
10268 + return err;
10269 }
10270
10271 static int snd_cs5535audio_capture_close(struct snd_pcm_substream *substream)
10272 {
10273 +#ifdef CONFIG_OLPC
10274 + struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
10275 + struct snd_ac97 *ac97 = cs5535au->ac97;
10276 +
10277 + /* Disable Analog Input */
10278 + olpc_ai_enable(ac97, 0);
10279 + /* Disable V_ref bias. */
10280 + snd_ac97_update_bits(ac97, AC97_AD_MISC, 1<<AC97_AD_VREFD_SHIFT,
10281 + 1<<AC97_AD_VREFD_SHIFT);
10282 +#endif
10283 +
10284 return 0;
10285 }
10286
10287 Index: linux-2.6.24.7/sound/pci/cs5535audio/Makefile
10288 ===================================================================
10289 --- linux-2.6.24.7.orig/sound/pci/cs5535audio/Makefile
10290 +++ linux-2.6.24.7/sound/pci/cs5535audio/Makefile
10291 @@ -5,5 +5,9 @@
10292 snd-cs5535audio-y := cs5535audio.o cs5535audio_pcm.o
10293 snd-cs5535audio-$(CONFIG_PM) += cs5535audio_pm.o
10294
10295 +ifdef CONFIG_OLPC
10296 +snd-cs5535audio-objs += cs5535audio_olpc.o
10297 +endif
10298 +
10299 # Toplevel Module Dependency
10300 obj-$(CONFIG_SND_CS5535AUDIO) += snd-cs5535audio.o
Personal OpenWRT clone
This page took 0.452957 seconds and 5 git commands to generate.