target/linux/olpc/patches-2.6.23/100-olpc.patch

   1 Index: linux-2.6.23.17/arch/i386/Kconfig
   2 ===================================================================
   3 --- linux-2.6.23.17.orig/arch/i386/Kconfig
   4 +++ linux-2.6.23.17/arch/i386/Kconfig
   5 @@ -796,6 +796,15 @@ config SECCOMP
   6
   7           If unsure, say Y. Only embedded should say N here.
   8
   9 +config VGA_NOPROBE
  10 +       bool "Don't probe VGA at boot" if EMBEDDED
  11 +       default n
  12 +       help
  13 +         Saying Y here will cause the kernel to not probe VGA at boot time.
  14 +         This will break everything that depends on the probed screen
  15 +         data.  Say N here unless you are absolutely sure this is what you
  16 +         want.
  17 +
  18  source kernel/Kconfig.hz
  19
  20  config KEXEC
  21 @@ -1120,6 +1129,9 @@ config PCI_GODIRECT
  22  config PCI_GOANY
  23         bool "Any"
  24
  25 +config PCI_GOOLPC
  26 +       bool "OLPC"
  27 +
  28  endchoice
  29
  30  config PCI_BIOS
  31 @@ -1129,7 +1141,7 @@ config PCI_BIOS
  32
  33  config PCI_DIRECT
  34         bool
  35 -       depends on PCI && ((PCI_GODIRECT || PCI_GOANY) || X86_VISWS)
  36 +       depends on PCI && ((PCI_GODIRECT || PCI_GOANY || PCI_GOOLPC) || X86_VISWS)
  37         default y
  38
  39  config PCI_MMCONFIG
  40 @@ -1137,6 +1149,11 @@ config PCI_MMCONFIG
  41         depends on PCI && ACPI && (PCI_GOMMCONFIG || PCI_GOANY)
  42         default y
  43
  44 +config PCI_OLPC
  45 +       bool
  46 +       depends on PCI && PCI_GOOLPC
  47 +       default y
  48 +
  49  source "drivers/pci/pcie/Kconfig"
  50
  51  source "drivers/pci/Kconfig"
  52 @@ -1206,10 +1223,43 @@ config SCx200HR_TIMER
  53           processor goes idle (as is done by the scheduler).  The
  54           other workaround is idle=poll boot option.
  55
  56 +config GEODE_MFGPT_TIMER
  57 +       bool "Geode Multi-Function General Purpose Timer (mfgpt) Support"
  58 +       depends on MGEODE_LX && GENERIC_TIME && GENERIC_CLOCKEVENTS
  59 +       default y
  60 +       help
  61 +         This driver provides a clock event source based on the MFGPT
  62 +         timer(s) in the CS5535 and CS5536 companion chip for the geode.
  63 +         MFGPTs have a better resolution and max interval than the
  64 +         generic PIT, and are suitable for use as high-res timers.
  65 +
  66  config K8_NB
  67         def_bool y
  68         depends on AGP_AMD64
  69
  70 +config OLPC
  71 +       bool "OLPC Support"
  72 +       default n
  73 +       help
  74 +         Add support for detecting the unique features of the OLPC
  75 +         Childrens Machine
  76 +
  77 +config OLPC_PM
  78 +       tristate "OLPC power management support"
  79 +       default y
  80 +       depends on OLPC
  81 +       help
  82 +         Add support for the Geode power management facilities on the
  83 +        OLPC Childrens Machine
  84 +
  85 +config OPEN_FIRMWARE
  86 +       bool "Support for Open Firmware"
  87 +       default y if OLPC
  88 +       help
  89 +         This option adds support for the implementation of Open Firmware
  90 +         that is used on the OLPC Children's Machine.
  91 +         If unsure, say N here.
  92 +
  93  source "drivers/pcmcia/Kconfig"
  94
  95  source "drivers/pci/hotplug/Kconfig"
  96 Index: linux-2.6.23.17/arch/i386/kernel/Makefile
  97 ===================================================================
  98 --- linux-2.6.23.17.orig/arch/i386/kernel/Makefile
  99 +++ linux-2.6.23.17/arch/i386/kernel/Makefile
 100 @@ -39,13 +39,17 @@ obj-$(CONFIG_VM86)          += vm86.o
 101  obj-$(CONFIG_EARLY_PRINTK)     += early_printk.o
 102  obj-$(CONFIG_HPET_TIMER)       += hpet.o
 103  obj-$(CONFIG_K8_NB)            += k8.o
 104 -obj-$(CONFIG_MGEODE_LX)                += geode.o
 105 +obj-$(CONFIG_MGEODE_LX)                += geode.o mfgpt.o
 106
 107  obj-$(CONFIG_VMI)              += vmi.o vmiclock.o
 108  obj-$(CONFIG_PARAVIRT)         += paravirt.o
 109  obj-y                          += pcspeaker.o
 110
 111  obj-$(CONFIG_SCx200)           += scx200.o
 112 +obj-$(CONFIG_OLPC)             += olpc.o
 113 +obj-$(CONFIG_OLPC_PM)          += olpc-pm.o olpc-wakeup.o
 114 +obj-$(CONFIG_OPEN_FIRMWARE)    += ofw.o
 115 +obj-$(CONFIG_PROMFS_FS)                += prom.o
 116
 117  # vsyscall.o contains the vsyscall DSO images as __initdata.
 118  # We must build both images before we can assemble it.
 119 Index: linux-2.6.23.17/arch/i386/kernel/geode.c
 120 ===================================================================
 121 --- linux-2.6.23.17.orig/arch/i386/kernel/geode.c
 122 +++ linux-2.6.23.17/arch/i386/kernel/geode.c
 123 @@ -145,10 +145,14 @@ EXPORT_SYMBOL_GPL(geode_gpio_setup_event
 124
 125  static int __init geode_southbridge_init(void)
 126  {
 127 +       int timers;
 128 +
 129         if (!is_geode())
 130                 return -ENODEV;
 131
 132         init_lbars();
 133 +       timers = geode_mfgpt_detect();
 134 +       printk(KERN_INFO "geode-mfgpt:  %d timers available.\n", timers);
 135         return 0;
 136  }
 137
 138 Index: linux-2.6.23.17/arch/i386/kernel/head.S
 139 ===================================================================
 140 --- linux-2.6.23.17.orig/arch/i386/kernel/head.S
 141 +++ linux-2.6.23.17/arch/i386/kernel/head.S
 142 @@ -117,8 +117,34 @@ ENTRY(startup_32)
 143         movl $(COMMAND_LINE_SIZE/4),%ecx
 144         rep
 145         movsl
 146 +
 147 +#ifdef CONFIG_OPEN_FIRMWARE
 148 +/*
 149 + * If Open Firmware booted us, save the OFW client interface callback address
 150 + * and preserve the OFW page mappings by priming the kernel's new page
 151 + * directory area with a copy of the OFW page directory.  That lets OFW stay
 152 + * resident in high memory (high in both the virtual and physical spaces)
 153 + * for at least long enough to copy out the device tree.
 154 + */
 155  1:
 156 +       movl $(boot_params - __PAGE_OFFSET + OFW_INFO_OFFSET), %ebp
 157 +       cmpl $0x2057464F, (%ebp)        /* Magic number "OFW " */
 158 +       jne 1f
 159 +
 160 +       mov 0x8(%ebp), %eax     /* Save callback address */
 161 +       mov %eax, call_firmware - __PAGE_OFFSET
 162 +
 163 +       /* Copy the OFW pdir into swapper_pg_dir */
 164 +       movl %esi, %edx         /* save %esi */
 165 +       movl $(swapper_pg_dir - __PAGE_OFFSET), %edi
 166 +       movl %cr3, %esi         /* Source is current pg_dir base address */
 167 +       movl $1024, %ecx        /* Number of page directory entries */
 168 +       rep
 169 +       movsl
 170 +       movl %edx, %esi         /* restore %esi */
 171 +#endif
 172
 173 +1:
 174  /*
 175   * Initialize page tables.  This creates a PDE and a set of page
 176   * tables, which are located immediately beyond _end.  The variable
 177 @@ -129,6 +155,7 @@ ENTRY(startup_32)
 178   * Warning: don't use %esi or the stack in this code.  However, %esp
 179   * can be used as a GPR if you really need it...
 180   */
 181 +
 182  page_pde_offset = (__PAGE_OFFSET >> 20);
 183
 184         movl $(pg0 - __PAGE_OFFSET), %edi
 185 Index: linux-2.6.23.17/arch/i386/kernel/setup.c
 186 ===================================================================
 187 --- linux-2.6.23.17.orig/arch/i386/kernel/setup.c
 188 +++ linux-2.6.23.17/arch/i386/kernel/setup.c
 189 @@ -362,8 +362,10 @@ void __init zone_sizes_init(void)
 190  {
 191         unsigned long max_zone_pfns[MAX_NR_ZONES];
 192         memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
 193 +#ifdef CONFIG_ZONE_DMA
 194         max_zone_pfns[ZONE_DMA] =
 195                 virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
 196 +#endif
 197         max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
 198  #ifdef CONFIG_HIGHMEM
 199         max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
 200 @@ -428,6 +430,9 @@ void __init setup_bootmem_allocator(void
 201          */
 202         acpi_reserve_bootmem();
 203  #endif
 204 +#ifdef CONFIG_OLPC_PM
 205 +       reserve_bootmem(0xf0000, PAGE_SIZE);
 206 +#endif
 207  #ifdef CONFIG_X86_FIND_SMP_CONFIG
 208         /*
 209          * Find and reserve possible boot-time SMP configuration:
 210 Index: linux-2.6.23.17/arch/i386/pci/Makefile
 211 ===================================================================
 212 --- linux-2.6.23.17.orig/arch/i386/pci/Makefile
 213 +++ linux-2.6.23.17/arch/i386/pci/Makefile
 214 @@ -3,6 +3,7 @@ obj-y                           := i386.o init.o
 215  obj-$(CONFIG_PCI_BIOS)         += pcbios.o
 216  obj-$(CONFIG_PCI_MMCONFIG)     += mmconfig.o direct.o mmconfig-shared.o
 217  obj-$(CONFIG_PCI_DIRECT)       += direct.o
 218 +obj-$(CONFIG_PCI_OLPC)         += olpc.o
 219
 220  pci-y                          := fixup.o
 221  pci-$(CONFIG_ACPI)             += acpi.o
 222 Index: linux-2.6.23.17/arch/i386/pci/init.c
 223 ===================================================================
 224 --- linux-2.6.23.17.orig/arch/i386/pci/init.c
 225 +++ linux-2.6.23.17/arch/i386/pci/init.c
 226 @@ -14,6 +14,9 @@ static __init int pci_access_init(void)
 227  #ifdef CONFIG_PCI_MMCONFIG
 228         pci_mmcfg_init(type);
 229  #endif
 230 +#ifdef CONFIG_PCI_OLPC
 231 +       pci_olpc_init();
 232 +#endif
 233         if (raw_pci_ops)
 234                 return 0;
 235  #ifdef CONFIG_PCI_BIOS
 236 Index: linux-2.6.23.17/arch/i386/pci/pci.h
 237 ===================================================================
 238 --- linux-2.6.23.17.orig/arch/i386/pci/pci.h
 239 +++ linux-2.6.23.17/arch/i386/pci/pci.h
 240 @@ -93,6 +93,7 @@ extern void pci_direct_init(int type);
 241  extern void pci_pcbios_init(void);
 242  extern void pci_mmcfg_init(int type);
 243  extern void pcibios_sort(void);
 244 +extern void pci_olpc_init(void);
 245
 246  /* pci-mmconfig.c */
 247
 248 Index: linux-2.6.23.17/drivers/Makefile
 249 ===================================================================
 250 --- linux-2.6.23.17.orig/drivers/Makefile
 251 +++ linux-2.6.23.17/drivers/Makefile
 252 @@ -23,6 +23,8 @@ obj-y                         += char/
 253
 254  obj-$(CONFIG_CONNECTOR)                += connector/
 255
 256 +obj-$(CONFIG_SYSPROF)          += sysprof/
 257 +
 258  # i810fb and intelfb depend on char/agp/
 259  obj-$(CONFIG_FB_I810)           += video/i810/
 260  obj-$(CONFIG_FB_INTEL)          += video/intelfb/
 261 Index: linux-2.6.23.17/drivers/char/vt_ioctl.c
 262 ===================================================================
 263 --- linux-2.6.23.17.orig/drivers/char/vt_ioctl.c
 264 +++ linux-2.6.23.17/drivers/char/vt_ioctl.c
 265 @@ -37,6 +37,9 @@
 266  char vt_dont_switch;
 267  extern struct tty_driver *console_driver;
 268
 269 +/* Add a notifier chain to inform drivers of a VT_TEXT/VT_GRAPHICS switch */
 270 +RAW_NOTIFIER_HEAD(console_notifier_list);
 271 +
 272  #define VT_IS_IN_USE(i)        (console_driver->ttys[i] && console_driver->ttys[i]->count)
 273  #define VT_BUSY(i)     (VT_IS_IN_USE(i) || i == fg_console || vc_cons[i].d == sel_cons)
 274
 275 @@ -491,6 +494,14 @@ int vt_ioctl(struct tty_struct *tty, str
 276                 vc->vc_mode = (unsigned char) arg;
 277                 if (console != fg_console)
 278                         return 0;
 279 +
 280 +               /* Notify listeners if the current fg_console has switched */
 281 +
 282 +               raw_notifier_call_chain(&console_notifier_list,
 283 +                       (arg == KD_TEXT) ?
 284 +                       CONSOLE_EVENT_SWITCH_TEXT :
 285 +                       CONSOLE_EVENT_SWITCH_GRAPHICS, 0);
 286 +
 287                 /*
 288                  * explicitly blank/unblank the screen if switching modes
 289                  */
 290 Index: linux-2.6.23.17/drivers/i2c/busses/scx200_acb.c
 291 ===================================================================
 292 --- linux-2.6.23.17.orig/drivers/i2c/busses/scx200_acb.c
 293 +++ linux-2.6.23.17/drivers/i2c/busses/scx200_acb.c
 294 @@ -46,6 +46,10 @@ static int base[MAX_DEVICES] = { 0x820,
 295  module_param_array(base, int, NULL, 0);
 296  MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");
 297
 298 +static unsigned int smbclk = 0x70;
 299 +module_param(smbclk, uint, 0);
 300 +MODULE_PARM_DESC(smbclk, "Specify the SMB_CLK value");
 301 +
 302  #define POLL_TIMEOUT   (HZ/5)
 303
 304  enum scx200_acb_state {
 305 @@ -108,6 +112,7 @@ struct scx200_acb_iface {
 306  #define ACBADDR                (iface->base + 4)
 307  #define ACBCTL2                (iface->base + 5)
 308  #define    ACBCTL2_ENABLE      0x01
 309 +#define ACBCTL3        (iface->base + 6)
 310
 311  /************************************************************************/
 312
 313 @@ -392,11 +397,13 @@ static __init int scx200_acb_probe(struc
 314  {
 315         u8 val;
 316
 317 -       /* Disable the ACCESS.bus device and Configure the SCL
 318 -          frequency: 16 clock cycles */
 319 -       outb(0x70, ACBCTL2);
 320 +       /* Disable the ACCESS.bus device and Configure the SCL */
 321 +
 322 +       outb((smbclk & 0x7F) << 1, ACBCTL2);
 323 +
 324 +       outb((smbclk >> 7) & 0xFF, ACBCTL3);
 325
 326 -       if (inb(ACBCTL2) != 0x70) {
 327 +       if (inb(ACBCTL2) != ((smbclk & 0x7F) << 1)) {
 328                 pr_debug(NAME ": ACBCTL2 readback failed\n");
 329                 return -ENXIO;
 330         }
 331 Index: linux-2.6.23.17/drivers/input/keyboard/atkbd.c
 332 ===================================================================
 333 --- linux-2.6.23.17.orig/drivers/input/keyboard/atkbd.c
 334 +++ linux-2.6.23.17/drivers/input/keyboard/atkbd.c
 335 @@ -63,12 +63,25 @@ static int atkbd_extra;
 336  module_param_named(extra, atkbd_extra, bool, 0);
 337  MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
 338
 339 +#define ATKBD_KEY_UNKNOWN        0
 340 +#define ATKBD_KEY_NULL         0xFF0000FF
 341 +
 342 +#define ATKBD_SCR_1            0xFF0000FE
 343 +#define ATKBD_SCR_2            0xFF0000FD
 344 +#define ATKBD_SCR_4            0xFF0000FC
 345 +#define ATKBD_SCR_8            0xFF0000FB
 346 +#define ATKBD_SCR_CLICK                0xFF0000FA
 347 +#define ATKBD_SCR_LEFT         0xFF0000F9
 348 +#define ATKBD_SCR_RIGHT                0xFF0000F8
 349 +
 350 +#define ATKBD_SPECIAL          0xFF0000F8
 351 +
 352  /*
 353   * Scancode to keycode tables. These are just the default setting, and
 354   * are loadable via an userland utility.
 355   */
 356
 357 -static unsigned char atkbd_set2_keycode[512] = {
 358 +static unsigned int atkbd_set2_keycode[512] = {
 359
 360  #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
 361
 362 @@ -87,11 +100,17 @@ static unsigned char atkbd_set2_keycode[
 363          82, 83, 80, 76, 77, 72,  1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
 364
 365           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 366 -       217,100,255,  0, 97,165,  0,  0,156,  0,  0,  0,  0,  0,  0,125,
 367 +
 368 +       217,100,ATKBD_KEY_NULL,  0, 97,165,  0,  0,
 369 +       156,  0,  0,  0,  0,  0,  0,125,
 370 +
 371         173,114,  0,113,  0,  0,  0,126,128,  0,  0,140,  0,  0,  0,127,
 372         159,  0,115,  0,164,  0,  0,116,158,  0,172,166,  0,  0,  0,142,
 373         157,  0,  0,  0,  0,  0,  0,  0,155,  0, 98,  0,  0,163,  0,  0,
 374 -       226,  0,  0,  0,  0,  0,  0,  0,  0,255, 96,  0,  0,  0,143,  0,
 375 +
 376 +       226,  0,  0,  0,  0,  0,  0,  0,
 377 +         0,ATKBD_KEY_NULL, 96,  0,  0,  0,143,  0,
 378 +
 379           0,  0,  0,  0,  0,  0,  0,  0,  0,107,  0,105,102,  0,  0,112,
 380         110,111,108,112,106,103,  0,119,  0,118,109,  0, 99,104,119,  0,
 381
 382 @@ -150,19 +169,6 @@ static unsigned char atkbd_unxlate_table
 383  #define ATKBD_RET_HANGEUL      0xf2
 384  #define ATKBD_RET_ERR          0xff
 385
 386 -#define ATKBD_KEY_UNKNOWN        0
 387 -#define ATKBD_KEY_NULL         255
 388 -
 389 -#define ATKBD_SCR_1            254
 390 -#define ATKBD_SCR_2            253
 391 -#define ATKBD_SCR_4            252
 392 -#define ATKBD_SCR_8            251
 393 -#define ATKBD_SCR_CLICK                250
 394 -#define ATKBD_SCR_LEFT         249
 395 -#define ATKBD_SCR_RIGHT                248
 396 -
 397 -#define ATKBD_SPECIAL          248
 398 -
 399  #define ATKBD_LED_EVENT_BIT    0
 400  #define ATKBD_REP_EVENT_BIT    1
 401
 402 @@ -174,7 +180,7 @@ static unsigned char atkbd_unxlate_table
 403  #define ATKBD_XL_HANJA         0x20
 404
 405  static struct {
 406 -       unsigned char keycode;
 407 +       unsigned int keycode;
 408         unsigned char set2;
 409  } atkbd_scroll_keys[] = {
 410         { ATKBD_SCR_1,     0xc5 },
 411 @@ -200,7 +206,7 @@ struct atkbd {
 412         char phys[32];
 413
 414         unsigned short id;
 415 -       unsigned char keycode[512];
 416 +       unsigned int keycode[512];
 417         unsigned char set;
 418         unsigned char translated;
 419         unsigned char extra;
 420 @@ -351,7 +357,7 @@ static irqreturn_t atkbd_interrupt(struc
 421         unsigned int code = data;
 422         int scroll = 0, hscroll = 0, click = -1, add_release_event = 0;
 423         int value;
 424 -       unsigned char keycode;
 425 +       unsigned int keycode;
 426
 427  #ifdef ATKBD_DEBUG
 428         printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
 429 @@ -856,9 +862,11 @@ static void atkbd_set_keycode_table(stru
 430                                                 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
 431                 }
 432         } else if (atkbd->set == 3) {
 433 -               memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
 434 +               for (i = 0; i < ARRAY_SIZE(atkbd_set3_keycode); i++)
 435 +                       atkbd->keycode[i] = atkbd_set3_keycode[i];
 436         } else {
 437 -               memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
 438 +               for (i = 0; i < ARRAY_SIZE(atkbd_set2_keycode); i++)
 439 +                       atkbd->keycode[i] = atkbd_set2_keycode[i];
 440
 441                 if (atkbd->scroll)
 442                         for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
 443 @@ -925,8 +933,8 @@ static void atkbd_set_device_attrs(struc
 444         }
 445
 446         input_dev->keycode = atkbd->keycode;
 447 -       input_dev->keycodesize = sizeof(unsigned char);
 448 -       input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
 449 +       input_dev->keycodesize = sizeof(unsigned int);
 450 +       input_dev->keycodemax = ARRAY_SIZE(atkbd->keycode);
 451
 452         for (i = 0; i < 512; i++)
 453                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
 454 @@ -1017,6 +1025,10 @@ static int atkbd_connect(struct serio *s
 455         return err;
 456  }
 457
 458 +#ifdef CONFIG_OLPC
 459 +#include <asm/olpc.h>
 460 +#endif
 461 +
 462  /*
 463   * atkbd_reconnect() tries to restore keyboard into a sane state and is
 464   * most likely called on resume.
 465 @@ -1027,6 +1039,12 @@ static int atkbd_reconnect(struct serio
 466         struct atkbd *atkbd = serio_get_drvdata(serio);
 467         struct serio_driver *drv = serio->drv;
 468
 469 +#ifdef CONFIG_OLPC
 470 +       if (olpc_rev_after(OLPC_REV_B2))
 471 +               if (serio->dev.power.power_state.event != PM_EVENT_ON)
 472 +                       return 0;
 473 +#endif
 474 +
 475         if (!atkbd || !drv) {
 476                 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
 477                 return -1;
 478 Index: linux-2.6.23.17/drivers/input/mouse/Kconfig
 479 ===================================================================
 480 --- linux-2.6.23.17.orig/drivers/input/mouse/Kconfig
 481 +++ linux-2.6.23.17/drivers/input/mouse/Kconfig
 482 @@ -96,6 +96,16 @@ config MOUSE_PS2_TOUCHKIT
 483
 484           If unsure, say N.
 485
 486 +config MOUSE_PS2_OLPC
 487 +       bool "OLPC PS/2 mouse protocol extension" if EMBEDDED
 488 +       default n
 489 +       depends on MOUSE_PS2 && OLPC
 490 +       ---help---
 491 +         Say Y here if you have an OLPC PS/2 touchpad connected to
 492 +         your system.
 493 +
 494 +         If unsure, say N.
 495 +
 496  config MOUSE_SERIAL
 497         tristate "Serial mouse"
 498         select SERIO
 499 Index: linux-2.6.23.17/drivers/input/mouse/Makefile
 500 ===================================================================
 501 --- linux-2.6.23.17.orig/drivers/input/mouse/Makefile
 502 +++ linux-2.6.23.17/drivers/input/mouse/Makefile
 503 @@ -24,3 +24,4 @@ psmouse-$(CONFIG_MOUSE_PS2_LOGIPS2PP) +=
 504  psmouse-$(CONFIG_MOUSE_PS2_LIFEBOOK)   += lifebook.o
 505  psmouse-$(CONFIG_MOUSE_PS2_TRACKPOINT) += trackpoint.o
 506  psmouse-$(CONFIG_MOUSE_PS2_TOUCHKIT)   += touchkit_ps2.o
 507 +psmouse-$(CONFIG_MOUSE_PS2_OLPC)       += olpc.o
 508 Index: linux-2.6.23.17/drivers/input/mouse/psmouse-base.c
 509 ===================================================================
 510 --- linux-2.6.23.17.orig/drivers/input/mouse/psmouse-base.c
 511 +++ linux-2.6.23.17/drivers/input/mouse/psmouse-base.c
 512 @@ -26,6 +26,7 @@
 513  #include "synaptics.h"
 514  #include "logips2pp.h"
 515  #include "alps.h"
 516 +#include "olpc.h"
 517  #include "lifebook.h"
 518  #include "trackpoint.h"
 519  #include "touchkit_ps2.h"
 520 @@ -103,7 +104,7 @@ static struct attribute_group psmouse_at
 521   */
 522  static DEFINE_MUTEX(psmouse_mutex);
 523
 524 -static struct workqueue_struct *kpsmoused_wq;
 525 +struct workqueue_struct *kpsmoused_wq;
 526
 527  struct psmouse_protocol {
 528         enum psmouse_type type;
 529 @@ -320,7 +321,7 @@ static irqreturn_t psmouse_interrupt(str
 530                         goto out;
 531                 }
 532
 533 -               if (psmouse->packet[1] == PSMOUSE_RET_ID) {
 534 +               if (psmouse->packet[1] == PSMOUSE_RET_ID || psmouse->packet[1] == PSMOUSE_RET_BAT) {
 535                         __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
 536                         serio_reconnect(serio);
 537                         goto out;
 538 @@ -631,8 +632,21 @@ static int psmouse_extensions(struct psm
 539                 }
 540         }
 541
 542 +/*
 543 + * Try OLPC touchpad.
 544 + */
 545         if (max_proto > PSMOUSE_IMEX) {
 546 +               if (olpc_detect(psmouse, set_properties) == 0) {
 547 +                       if (!set_properties || olpc_init(psmouse) == 0)
 548 +                               return PSMOUSE_OLPC;
 549 +/*
 550 + * Init failed, try basic relative protocols
 551 + */
 552 +                       max_proto = PSMOUSE_IMEX;
 553 +               }
 554 +       }
 555
 556 +       if (max_proto > PSMOUSE_IMEX) {
 557                 if (genius_detect(psmouse, set_properties) == 0)
 558                         return PSMOUSE_GENPS;
 559
 560 @@ -762,6 +776,14 @@ static const struct psmouse_protocol psm
 561                 .detect         = touchkit_ps2_detect,
 562         },
 563  #endif
 564 +#ifdef CONFIG_MOUSE_PS2_OLPC
 565 +       {
 566 +               .type           = PSMOUSE_OLPC,
 567 +               .name           = "OLPC",
 568 +               .alias          = "olpc",
 569 +               .detect         = olpc_detect,
 570 +       },
 571 +#endif
 572         {
 573                 .type           = PSMOUSE_CORTRON,
 574                 .name           = "CortronPS/2",
 575 Index: linux-2.6.23.17/drivers/input/mouse/psmouse.h
 576 ===================================================================
 577 --- linux-2.6.23.17.orig/drivers/input/mouse/psmouse.h
 578 +++ linux-2.6.23.17/drivers/input/mouse/psmouse.h
 579 @@ -89,6 +89,7 @@ enum psmouse_type {
 580         PSMOUSE_TRACKPOINT,
 581         PSMOUSE_TOUCHKIT_PS2,
 582         PSMOUSE_CORTRON,
 583 +       PSMOUSE_OLPC,
 584         PSMOUSE_AUTO            /* This one should always be last */
 585  };
 586
 587 @@ -96,6 +97,7 @@ int psmouse_sliced_command(struct psmous
 588  int psmouse_reset(struct psmouse *psmouse);
 589  void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution);
 590
 591 +extern struct workqueue_struct *kpsmoused_wq;
 592
 593  struct psmouse_attribute {
 594         struct device_attribute dattr;
 595 Index: linux-2.6.23.17/drivers/input/serio/i8042.c
 596 ===================================================================
 597 --- linux-2.6.23.17.orig/drivers/input/serio/i8042.c
 598 +++ linux-2.6.23.17/drivers/input/serio/i8042.c
 599 @@ -868,6 +868,11 @@ static long i8042_panic_blink(long count
 600  #undef DELAY
 601
 602  #ifdef CONFIG_PM
 603 +
 604 +#ifdef CONFIG_OLPC
 605 +#include <asm/olpc.h>
 606 +#endif
 607 +
 608  /*
 609   * Here we try to restore the original BIOS settings. We only want to
 610   * do that once, when we really suspend, not when we taking memory
 611 @@ -878,8 +883,15 @@ static long i8042_panic_blink(long count
 612  static int i8042_suspend(struct platform_device *dev, pm_message_t state)
 613  {
 614         if (dev->dev.power.power_state.event != state.event) {
 615 +#ifdef CONFIG_OLPC
 616 +               /* Anything newer than B2 remains powered; no reset needed */
 617 +               if (olpc_rev_before(OLPC_REV_PRE_B3)) {
 618 +#endif
 619                 if (state.event == PM_EVENT_SUSPEND)
 620                         i8042_controller_reset();
 621 +#ifdef CONFIG_OLPC
 622 +               }
 623 +#endif
 624
 625                 dev->dev.power.power_state = state;
 626         }
 627 @@ -902,9 +914,15 @@ static int i8042_resume(struct platform_
 628         if (dev->dev.power.power_state.event == PM_EVENT_ON)
 629                 return 0;
 630
 631 +#ifdef CONFIG_OLPC
 632 +       if (olpc_rev_before(OLPC_REV_PRE_B3)) {
 633 +#endif
 634         error = i8042_controller_check();
 635         if (error)
 636                 return error;
 637 +#ifdef CONFIG_OLPC
 638 +       }
 639 +#endif
 640
 641         error = i8042_controller_selftest();
 642         if (error)
 643 Index: linux-2.6.23.17/drivers/input/serio/serio.c
 644 ===================================================================
 645 --- linux-2.6.23.17.orig/drivers/input/serio/serio.c
 646 +++ linux-2.6.23.17/drivers/input/serio/serio.c
 647 @@ -916,11 +916,22 @@ static int serio_uevent(struct device *d
 648  #endif /* CONFIG_HOTPLUG */
 649
 650  #ifdef CONFIG_PM
 651 +
 652 +#ifdef CONFIG_OLPC
 653 +#include <asm/olpc.h>
 654 +#endif
 655 +
 656  static int serio_suspend(struct device *dev, pm_message_t state)
 657  {
 658         if (dev->power.power_state.event != state.event) {
 659 +#ifdef CONFIG_OLPC
 660 +               if (olpc_rev_before(OLPC_REV_PRE_B3)) {
 661 +#endif
 662                 if (state.event == PM_EVENT_SUSPEND)
 663                         serio_cleanup(to_serio_port(dev));
 664 +#ifdef CONFIG_OLPC
 665 +               }
 666 +#endif
 667
 668                 dev->power.power_state = state;
 669         }
 670 Index: linux-2.6.23.17/drivers/media/video/cafe_ccic.c
 671 ===================================================================
 672 --- linux-2.6.23.17.orig/drivers/media/video/cafe_ccic.c
 673 +++ linux-2.6.23.17/drivers/media/video/cafe_ccic.c
 674 @@ -63,13 +63,13 @@ MODULE_SUPPORTED_DEVICE("Video");
 675   */
 676
 677  #define MAX_DMA_BUFS 3
 678 -static int alloc_bufs_at_load = 0;
 679 -module_param(alloc_bufs_at_load, bool, 0444);
 680 -MODULE_PARM_DESC(alloc_bufs_at_load,
 681 -               "Non-zero value causes DMA buffers to be allocated at module "
 682 -               "load time.  This increases the chances of successfully getting "
 683 -               "those buffers, but at the cost of nailing down the memory from "
 684 -               "the outset.");
 685 +static int alloc_bufs_at_read = 0;
 686 +module_param(alloc_bufs_at_read, bool, 0444);
 687 +MODULE_PARM_DESC(alloc_bufs_at_read,
 688 +               "Non-zero value causes DMA buffers to be allocated when the "
 689 +               "video capture device is read, rather than at module load "
 690 +               "time.  This saves memory, but decreases the chances of "
 691 +               "successfully getting those buffers.");
 692
 693  static int n_dma_bufs = 3;
 694  module_param(n_dma_bufs, uint, 0644);
 695 @@ -370,6 +370,10 @@ static int cafe_smbus_write_data(struct
 696         rval = value | ((command << TWSIC1_ADDR_SHIFT) & TWSIC1_ADDR);
 697         cafe_reg_write(cam, REG_TWSIC1, rval);
 698         spin_unlock_irqrestore(&cam->dev_lock, flags);
 699 +       mdelay(2); /* It'll probably take about 900µs anyway, and the
 700 +                     CAFÉ is apparently quite sensitive to being poked
 701 +                     at this point. If we can work out precisely what's
 702 +                     going on and reduce this delay, it would be nice. */
 703
 704         /*
 705          * Time to wait for the write to complete.  THIS IS A RACY
 706 @@ -1503,7 +1507,7 @@ static int cafe_v4l_release(struct inode
 707         }
 708         if (cam->users == 0) {
 709                 cafe_ctlr_power_down(cam);
 710 -               if (! alloc_bufs_at_load)
 711 +               if (alloc_bufs_at_read)
 712                         cafe_free_dma_bufs(cam);
 713         }
 714         mutex_unlock(&cam->s_mutex);
 715 @@ -2162,7 +2166,7 @@ static int cafe_pci_probe(struct pci_dev
 716         /*
 717          * If so requested, try to get our DMA buffers now.
 718          */
 719 -       if (alloc_bufs_at_load) {
 720 +       if (!alloc_bufs_at_read) {
 721                 if (cafe_alloc_dma_bufs(cam, 1))
 722                         cam_warn(cam, "Unable to alloc DMA buffers at load"
 723                                         " will try again later.");
 724 Index: linux-2.6.23.17/drivers/misc/Kconfig
 725 ===================================================================
 726 --- linux-2.6.23.17.orig/drivers/misc/Kconfig
 727 +++ linux-2.6.23.17/drivers/misc/Kconfig
 728 @@ -202,5 +202,10 @@ config THINKPAD_ACPI_BAY
 729
 730           If you are not sure, say Y here.
 731
 732 +config EEPROM_93CX6
 733 +       tristate "EEPROM 93CX6 support"
 734 +       ---help---
 735 +         This is a driver for the EEPROM chipsets 93c46 and 93c66.
 736 +         The driver supports both read as well as write commands.
 737
 738  endif # MISC_DEVICES
 739 Index: linux-2.6.23.17/drivers/mmc/host/sdhci.c
 740 ===================================================================
 741 --- linux-2.6.23.17.orig/drivers/mmc/host/sdhci.c
 742 +++ linux-2.6.23.17/drivers/mmc/host/sdhci.c
 743 @@ -411,6 +411,12 @@ static void sdhci_prepare_data(struct sd
 744                         break;
 745         }
 746
 747 +       /*
 748 +        * There's an off-by-one error in the hw that we need to
 749 +        * compensate for.
 750 +        */
 751 +       count++;
 752 +
 753         if (count >= 0xF) {
 754                 printk(KERN_WARNING "%s: Too large timeout requested!\n",
 755                         mmc_hostname(host->mmc));
 756 @@ -676,19 +682,17 @@ static void sdhci_set_power(struct sdhci
 757         if (!(host->chip->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
 758                 writeb(0, host->ioaddr + SDHCI_POWER_CONTROL);
 759
 760 -       pwr = SDHCI_POWER_ON;
 761 -
 762         switch (1 << power) {
 763         case MMC_VDD_165_195:
 764 -               pwr |= SDHCI_POWER_180;
 765 +               pwr = SDHCI_POWER_180;
 766                 break;
 767         case MMC_VDD_29_30:
 768         case MMC_VDD_30_31:
 769 -               pwr |= SDHCI_POWER_300;
 770 +               pwr = SDHCI_POWER_300;
 771                 break;
 772         case MMC_VDD_32_33:
 773         case MMC_VDD_33_34:
 774 -               pwr |= SDHCI_POWER_330;
 775 +               pwr = SDHCI_POWER_330;
 776                 break;
 777         default:
 778                 BUG();
 779 @@ -696,6 +700,10 @@ static void sdhci_set_power(struct sdhci
 780
 781         writeb(pwr, host->ioaddr + SDHCI_POWER_CONTROL);
 782
 783 +       pwr |= SDHCI_POWER_ON;
 784 +
 785 +       writeb(pwr, host->ioaddr + SDHCI_POWER_CONTROL);
 786 +
 787  out:
 788         host->power = power;
 789  }
 790 Index: linux-2.6.23.17/drivers/mtd/Kconfig
 791 ===================================================================
 792 --- linux-2.6.23.17.orig/drivers/mtd/Kconfig
 793 +++ linux-2.6.23.17/drivers/mtd/Kconfig
 794 @@ -288,6 +288,14 @@ config SSFDC
 795           This enables read only access to SmartMedia formatted NAND
 796           flash. You can mount it with FAT file system.
 797
 798 +config MTD_OOPS
 799 +       tristate "Log panic/oops to an MTD buffer"
 800 +       depends on MTD
 801 +       help
 802 +         This enables panic and oops messages to be logged to a circular
 803 +         buffer in a flash partition where it can be read back at some
 804 +         later point.
 805 +
 806  source "drivers/mtd/chips/Kconfig"
 807
 808  source "drivers/mtd/maps/Kconfig"
 809 Index: linux-2.6.23.17/drivers/mtd/Makefile
 810 ===================================================================
 811 --- linux-2.6.23.17.orig/drivers/mtd/Makefile
 812 +++ linux-2.6.23.17/drivers/mtd/Makefile
 813 @@ -22,6 +22,7 @@ obj-$(CONFIG_NFTL)            += nftl.o
 814  obj-$(CONFIG_INFTL)            += inftl.o
 815  obj-$(CONFIG_RFD_FTL)          += rfd_ftl.o
 816  obj-$(CONFIG_SSFDC)            += ssfdc.o
 817 +obj-$(CONFIG_MTD_OOPS)         += mtdoops.o
 818
 819  nftl-objs              := nftlcore.o nftlmount.o
 820  inftl-objs             := inftlcore.o inftlmount.o
 821 Index: linux-2.6.23.17/drivers/mtd/chips/cfi_cmdset_0001.c
 822 ===================================================================
 823 --- linux-2.6.23.17.orig/drivers/mtd/chips/cfi_cmdset_0001.c
 824 +++ linux-2.6.23.17/drivers/mtd/chips/cfi_cmdset_0001.c
 825 @@ -526,7 +526,7 @@ static int cfi_intelext_partition_fixup(
 826         struct cfi_pri_intelext *extp = cfi->cmdset_priv;
 827
 828         /*
 829 -        * Probing of multi-partition flash ships.
 830 +        * Probing of multi-partition flash chips.
 831          *
 832          * To support multiple partitions when available, we simply arrange
 833          * for each of them to have their own flchip structure even if they
 834 @@ -1781,7 +1781,7 @@ static int __xipram do_erase_oneblock(st
 835         return ret;
 836  }
 837
 838 -int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
 839 +static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
 840  {
 841         unsigned long ofs, len;
 842         int ret;
 843 @@ -1931,7 +1931,7 @@ static int cfi_intelext_lock(struct mtd_
 844         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
 845                __FUNCTION__, ofs, len);
 846         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
 847 -               ofs, len, 0);
 848 +               ofs, len, NULL);
 849  #endif
 850
 851         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
 852 @@ -1941,7 +1941,7 @@ static int cfi_intelext_lock(struct mtd_
 853         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
 854                __FUNCTION__, ret);
 855         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
 856 -               ofs, len, 0);
 857 +               ofs, len, NULL);
 858  #endif
 859
 860         return ret;
 861 @@ -1955,7 +1955,7 @@ static int cfi_intelext_unlock(struct mt
 862         printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
 863                __FUNCTION__, ofs, len);
 864         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
 865 -               ofs, len, 0);
 866 +               ofs, len, NULL);
 867  #endif
 868
 869         ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
 870 @@ -1965,7 +1965,7 @@ static int cfi_intelext_unlock(struct mt
 871         printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
 872                __FUNCTION__, ret);
 873         cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
 874 -               ofs, len, 0);
 875 +               ofs, len, NULL);
 876  #endif
 877
 878         return ret;
 879 @@ -2256,7 +2256,7 @@ static void cfi_intelext_save_locks(stru
 880                         adr = region->offset + block * len;
 881
 882                         status = cfi_varsize_frob(mtd,
 883 -                                       do_getlockstatus_oneblock, adr, len, 0);
 884 +                                       do_getlockstatus_oneblock, adr, len, NULL);
 885                         if (status)
 886                                 set_bit(block, region->lockmap);
 887                         else
 888 Index: linux-2.6.23.17/drivers/mtd/chips/cfi_cmdset_0002.c
 889 ===================================================================
 890 --- linux-2.6.23.17.orig/drivers/mtd/chips/cfi_cmdset_0002.c
 891 +++ linux-2.6.23.17/drivers/mtd/chips/cfi_cmdset_0002.c
 892 @@ -1617,7 +1617,7 @@ static int __xipram do_erase_oneblock(st
 893  }
 894
 895
 896 -int cfi_amdstd_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
 897 +static int cfi_amdstd_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
 898  {
 899         unsigned long ofs, len;
 900         int ret;
 901 Index: linux-2.6.23.17/drivers/mtd/chips/jedec_probe.c
 902 ===================================================================
 903 --- linux-2.6.23.17.orig/drivers/mtd/chips/jedec_probe.c
 904 +++ linux-2.6.23.17/drivers/mtd/chips/jedec_probe.c
 905 @@ -70,6 +70,7 @@
 906
 907  /* Fujitsu */
 908  #define MBM29F040C     0x00A4
 909 +#define MBM29F800BA    0x2258
 910  #define MBM29LV650UE   0x22D7
 911  #define MBM29LV320TE   0x22F6
 912  #define MBM29LV320BE   0x22F9
 913 @@ -129,6 +130,7 @@
 914  #define LH28F640BF     0x00b0
 915
 916  /* ST - www.st.com */
 917 +#define M29F800AB      0x0058
 918  #define M29W800DT      0x00D7
 919  #define M29W800DB      0x005B
 920  #define M29W160DT      0x22C4
 921 @@ -646,6 +648,23 @@ static const struct amd_flash_info jedec
 922                 }
 923         }, {
 924                 .mfr_id         = MANUFACTURER_FUJITSU,
 925 +               .dev_id         = MBM29F800BA,
 926 +               .name           = "Fujitsu MBM29F800BA",
 927 +               .uaddr          = {
 928 +                       [0] = MTD_UADDR_0x0AAA_0x0555,  /* x8 */
 929 +                       [1] = MTD_UADDR_0x0555_0x02AA,  /* x16 */
 930 +               },
 931 +               .DevSize        = SIZE_1MiB,
 932 +               .CmdSet         = P_ID_AMD_STD,
 933 +               .NumEraseRegions= 4,
 934 +               .regions        = {
 935 +                       ERASEINFO(0x04000,1),
 936 +                       ERASEINFO(0x02000,2),
 937 +                       ERASEINFO(0x08000,1),
 938 +                       ERASEINFO(0x10000,15),
 939 +               }
 940 +       }, {
 941 +               .mfr_id         = MANUFACTURER_FUJITSU,
 942                 .dev_id         = MBM29LV650UE,
 943                 .name           = "Fujitsu MBM29LV650UE",
 944                 .uaddr          = {
 945 @@ -1510,6 +1529,23 @@ static const struct amd_flash_info jedec
 946                         ERASEINFO(0x1000,256)
 947                 }
 948
 949 +       }, {
 950 +               .mfr_id         = MANUFACTURER_ST,
 951 +               .dev_id         = M29F800AB,
 952 +               .name           = "ST M29F800AB",
 953 +               .uaddr          = {
 954 +                       [0] = MTD_UADDR_0x0AAA_0x0555,  /* x8 */
 955 +                       [1] = MTD_UADDR_0x0555_0x02AA,  /* x16 */
 956 +               },
 957 +               .DevSize        = SIZE_1MiB,
 958 +               .CmdSet         = P_ID_AMD_STD,
 959 +               .NumEraseRegions= 4,
 960 +               .regions        = {
 961 +                       ERASEINFO(0x04000,1),
 962 +                       ERASEINFO(0x02000,2),
 963 +                       ERASEINFO(0x08000,1),
 964 +                       ERASEINFO(0x10000,15),
 965 +               }
 966         }, {
 967                 .mfr_id         = MANUFACTURER_ST,      /* FIXME - CFI device? */
 968                 .dev_id         = M29W800DT,
 969 Index: linux-2.6.23.17/drivers/mtd/devices/Kconfig
 970 ===================================================================
 971 --- linux-2.6.23.17.orig/drivers/mtd/devices/Kconfig
 972 +++ linux-2.6.23.17/drivers/mtd/devices/Kconfig
 973 @@ -69,12 +69,21 @@ config MTD_DATAFLASH26
 974           If you have such a board and such a DataFlash, say 'Y'.
 975
 976  config MTD_M25P80
 977 -       tristate "Support for M25 SPI Flash"
 978 +       tristate "Support most SPI Flash chips (AT26DF, M25P, W25X, ...)"
 979         depends on SPI_MASTER && EXPERIMENTAL
 980         help
 981 -         This enables access to ST M25P80 and similar SPI flash chips,
 982 -         used for program and data storage.  Set up your spi devices
 983 -         with the right board-specific platform data.
 984 +         This enables access to most modern SPI flash chips, used for
 985 +         program and data storage.   Series supported include Atmel AT26DF,
 986 +         Spansion S25SL, SST 25VF, ST M25P, and Winbond W25X.  Other chips
 987 +         are supported as well.  See the driver source for the current list,
 988 +         or to add other chips.
 989 +
 990 +         Note that the original DataFlash chips (AT45 series, not AT26DF),
 991 +         need an entirely different driver.
 992 +
 993 +         Set up your spi devices with the right board-specific platform data,
 994 +         if you want to specify device partitioning or to use a device which
 995 +         doesn't support the JEDEC ID instruction.
 996
 997  config MTD_SLRAM
 998         tristate "Uncached system RAM"
 999 Index: linux-2.6.23.17/drivers/mtd/devices/m25p80.c
1000 ===================================================================
1001 --- linux-2.6.23.17.orig/drivers/mtd/devices/m25p80.c
1002 +++ linux-2.6.23.17/drivers/mtd/devices/m25p80.c
1003 @@ -1,5 +1,5 @@
1004  /*
1005 - * MTD SPI driver for ST M25Pxx flash chips
1006 + * MTD SPI driver for ST M25Pxx (and similar) serial flash chips
1007   *
1008   * Author: Mike Lavender, mike@steroidmicros.com
1009   *
1010 @@ -19,33 +19,32 @@
1011  #include <linux/module.h>
1012  #include <linux/device.h>
1013  #include <linux/interrupt.h>
1014 -#include <linux/interrupt.h>
1015 +#include <linux/mutex.h>
1016 +
1017  #include <linux/mtd/mtd.h>
1018  #include <linux/mtd/partitions.h>
1019 +
1020  #include <linux/spi/spi.h>
1021  #include <linux/spi/flash.h>
1022
1023 -#include <asm/semaphore.h>
1024 -
1025 -
1026 -/* NOTE: AT 25F and SST 25LF series are very similar,
1027 - * but commands for sector erase and chip id differ...
1028 - */
1029
1030  #define FLASH_PAGESIZE         256
1031
1032  /* Flash opcodes. */
1033 -#define        OPCODE_WREN             6       /* Write enable */
1034 -#define        OPCODE_RDSR             5       /* Read status register */
1035 -#define        OPCODE_READ             3       /* Read data bytes */
1036 -#define        OPCODE_PP               2       /* Page program */
1037 -#define        OPCODE_SE               0xd8    /* Sector erase */
1038 -#define        OPCODE_RES              0xab    /* Read Electronic Signature */
1039 +#define        OPCODE_WREN             0x06    /* Write enable */
1040 +#define        OPCODE_RDSR             0x05    /* Read status register */
1041 +#define        OPCODE_READ             0x03    /* Read data bytes (low frequency) */
1042 +#define        OPCODE_FAST_READ        0x0b    /* Read data bytes (high frequency) */
1043 +#define        OPCODE_PP               0x02    /* Page program (up to 256 bytes) */
1044 +#define        OPCODE_BE_4K            0x20    /* Erase 4KiB block */
1045 +#define        OPCODE_BE_32K           0x52    /* Erase 32KiB block */
1046 +#define        OPCODE_SE               0xd8    /* Sector erase (usually 64KiB) */
1047  #define        OPCODE_RDID             0x9f    /* Read JEDEC ID */
1048
1049  /* Status Register bits. */
1050  #define        SR_WIP                  1       /* Write in progress */
1051  #define        SR_WEL                  2       /* Write enable latch */
1052 +/* meaning of other SR_* bits may differ between vendors */
1053  #define        SR_BP0                  4       /* Block protect 0 */
1054  #define        SR_BP1                  8       /* Block protect 1 */
1055  #define        SR_BP2                  0x10    /* Block protect 2 */
1056 @@ -65,9 +64,10 @@
1057
1058  struct m25p {
1059         struct spi_device       *spi;
1060 -       struct semaphore        lock;
1061 +       struct mutex            lock;
1062         struct mtd_info         mtd;
1063 -       unsigned                partitioned;
1064 +       unsigned                partitioned:1;
1065 +       u8                      erase_opcode;
1066         u8                      command[4];
1067  };
1068
1069 @@ -150,8 +150,9 @@ static int wait_till_ready(struct m25p *
1070   */
1071  static int erase_sector(struct m25p *flash, u32 offset)
1072  {
1073 -       DEBUG(MTD_DEBUG_LEVEL3, "%s: %s at 0x%08x\n", flash->spi->dev.bus_id,
1074 -                       __FUNCTION__, offset);
1075 +       DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %dKiB at 0x%08x\n",
1076 +                       flash->spi->dev.bus_id, __FUNCTION__,
1077 +                       flash->mtd.erasesize / 1024, offset);
1078
1079         /* Wait until finished previous write command. */
1080         if (wait_till_ready(flash))
1081 @@ -161,7 +162,7 @@ static int erase_sector(struct m25p *fla
1082         write_enable(flash);
1083
1084         /* Set up command buffer. */
1085 -       flash->command[0] = OPCODE_SE;
1086 +       flash->command[0] = flash->erase_opcode;
1087         flash->command[1] = offset >> 16;
1088         flash->command[2] = offset >> 8;
1089         flash->command[3] = offset;
1090 @@ -201,13 +202,17 @@ static int m25p80_erase(struct mtd_info
1091         addr = instr->addr;
1092         len = instr->len;
1093
1094 -       down(&flash->lock);
1095 +       mutex_lock(&flash->lock);
1096 +
1097 +       /* REVISIT in some cases we could speed up erasing large regions
1098 +        * by using OPCODE_SE instead of OPCODE_BE_4K
1099 +        */
1100
1101         /* now erase those sectors */
1102         while (len) {
1103                 if (erase_sector(flash, addr)) {
1104                         instr->state = MTD_ERASE_FAILED;
1105 -                       up(&flash->lock);
1106 +                       mutex_unlock(&flash->lock);
1107                         return -EIO;
1108                 }
1109
1110 @@ -215,7 +220,7 @@ static int m25p80_erase(struct mtd_info
1111                 len -= mtd->erasesize;
1112         }
1113
1114 -       up(&flash->lock);
1115 +       mutex_unlock(&flash->lock);
1116
1117         instr->state = MTD_ERASE_DONE;
1118         mtd_erase_callback(instr);
1119 @@ -260,16 +265,19 @@ static int m25p80_read(struct mtd_info *
1120         if (retlen)
1121                 *retlen = 0;
1122
1123 -       down(&flash->lock);
1124 +       mutex_lock(&flash->lock);
1125
1126         /* Wait till previous write/erase is done. */
1127         if (wait_till_ready(flash)) {
1128                 /* REVISIT status return?? */
1129 -               up(&flash->lock);
1130 +               mutex_unlock(&flash->lock);
1131                 return 1;
1132         }
1133
1134 -       /* NOTE:  OPCODE_FAST_READ (if available) is faster... */
1135 +       /* FIXME switch to OPCODE_FAST_READ.  It's required for higher
1136 +        * clocks; and at this writing, every chip this driver handles
1137 +        * supports that opcode.
1138 +        */
1139
1140         /* Set up the write data buffer. */
1141         flash->command[0] = OPCODE_READ;
1142 @@ -281,7 +289,7 @@ static int m25p80_read(struct mtd_info *
1143
1144         *retlen = m.actual_length - sizeof(flash->command);
1145
1146 -       up(&flash->lock);
1147 +       mutex_unlock(&flash->lock);
1148
1149         return 0;
1150  }
1151 @@ -323,7 +331,7 @@ static int m25p80_write(struct mtd_info
1152         t[1].tx_buf = buf;
1153         spi_message_add_tail(&t[1], &m);
1154
1155 -       down(&flash->lock);
1156 +       mutex_lock(&flash->lock);
1157
1158         /* Wait until finished previous write command. */
1159         if (wait_till_ready(flash))
1160 @@ -381,10 +389,10 @@ static int m25p80_write(struct mtd_info
1161                         if (retlen)
1162                                 *retlen += m.actual_length
1163                                         - sizeof(flash->command);
1164 -               }
1165 -       }
1166 +               }
1167 +       }
1168
1169 -       up(&flash->lock);
1170 +       mutex_unlock(&flash->lock);
1171
1172         return 0;
1173  }
1174 @@ -398,24 +406,118 @@ static int m25p80_write(struct mtd_info
1175
1176  struct flash_info {
1177         char            *name;
1178 -       u8              id;
1179 -       u16             jedec_id;
1180 +
1181 +       /* JEDEC id zero means "no ID" (most older chips); otherwise it has
1182 +        * a high byte of zero plus three data bytes: the manufacturer id,
1183 +        * then a two byte device id.
1184 +        */
1185 +       u32             jedec_id;
1186 +
1187 +       /* The size listed here is what works with OPCODE_SE, which isn't
1188 +        * necessarily called a "sector" by the vendor.
1189 +        */
1190         unsigned        sector_size;
1191 -       unsigned        n_sectors;
1192 +       u16             n_sectors;
1193 +
1194 +       u16             flags;
1195 +#define        SECT_4K         0x01            /* OPCODE_BE_4K works uniformly */
1196  };
1197
1198 +
1199 +/* NOTE: double check command sets and memory organization when you add
1200 + * more flash chips.  This current list focusses on newer chips, which
1201 + * have been converging on command sets which including JEDEC ID.
1202 + */
1203  static struct flash_info __devinitdata m25p_data [] = {
1204 -       /* REVISIT: fill in JEDEC ids, for parts that have them */
1205 -       { "m25p05", 0x05, 0x2010, 32 * 1024, 2 },
1206 -       { "m25p10", 0x10, 0x2011, 32 * 1024, 4 },
1207 -       { "m25p20", 0x11, 0x2012, 64 * 1024, 4 },
1208 -       { "m25p40", 0x12, 0x2013, 64 * 1024, 8 },
1209 -       { "m25p80", 0x13, 0x0000, 64 * 1024, 16 },
1210 -       { "m25p16", 0x14, 0x2015, 64 * 1024, 32 },
1211 -       { "m25p32", 0x15, 0x2016, 64 * 1024, 64 },
1212 -       { "m25p64", 0x16, 0x2017, 64 * 1024, 128 },
1213 +
1214 +       /* Atmel -- some are (confusingly) marketed as "DataFlash" */
1215 +       { "at25fs010",  0x1f6601, 32 * 1024, 4, SECT_4K, },
1216 +       { "at25fs040",  0x1f6604, 64 * 1024, 8, SECT_4K, },
1217 +
1218 +       { "at25df041a", 0x1f4401, 64 * 1024, 8, SECT_4K, },
1219 +
1220 +       { "at26f004",   0x1f0400, 64 * 1024, 8, SECT_4K, },
1221 +       { "at26df081a", 0x1f4501, 64 * 1024, 16, SECT_4K, },
1222 +       { "at26df161a", 0x1f4601, 64 * 1024, 32, SECT_4K, },
1223 +       { "at26df321",  0x1f4701, 64 * 1024, 64, SECT_4K, },
1224 +
1225 +       /* Spansion -- single (large) sector size only, at least
1226 +        * for the chips listed here (without boot sectors).
1227 +        */
1228 +       { "s25sl004a", 0x010212, 64 * 1024, 8, },
1229 +       { "s25sl008a", 0x010213, 64 * 1024, 16, },
1230 +       { "s25sl016a", 0x010214, 64 * 1024, 32, },
1231 +       { "s25sl032a", 0x010215, 64 * 1024, 64, },
1232 +       { "s25sl064a", 0x010216, 64 * 1024, 128, },
1233 +
1234 +       /* SST -- large erase sizes are "overlays", "sectors" are 4K */
1235 +       { "sst25vf040b", 0xbf258d, 64 * 1024, 8, SECT_4K, },
1236 +       { "sst25vf080b", 0xbf258e, 64 * 1024, 16, SECT_4K, },
1237 +       { "sst25vf016b", 0xbf2541, 64 * 1024, 32, SECT_4K, },
1238 +       { "sst25vf032b", 0xbf254a, 64 * 1024, 64, SECT_4K, },
1239 +
1240 +       /* ST Microelectronics -- newer production may have feature updates */
1241 +       { "m25p05",  0x202010,  32 * 1024, 2, },
1242 +       { "m25p10",  0x202011,  32 * 1024, 4, },
1243 +       { "m25p20",  0x202012,  64 * 1024, 4, },
1244 +       { "m25p40",  0x202013,  64 * 1024, 8, },
1245 +       { "m25p80",         0,  64 * 1024, 16, },
1246 +       { "m25p16",  0x202015,  64 * 1024, 32, },
1247 +       { "m25p32",  0x202016,  64 * 1024, 64, },
1248 +       { "m25p64",  0x202017,  64 * 1024, 128, },
1249 +       { "m25p128", 0x202018, 256 * 1024, 64, },
1250 +
1251 +       { "m45pe80", 0x204014,  64 * 1024, 16, },
1252 +       { "m45pe16", 0x204015,  64 * 1024, 32, },
1253 +
1254 +       { "m25pe80", 0x208014,  64 * 1024, 16, },
1255 +       { "m25pe16", 0x208015,  64 * 1024, 32, SECT_4K, },
1256 +
1257 +       /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
1258 +       { "w25x10", 0xef3011, 64 * 1024, 2, SECT_4K, },
1259 +       { "w25x20", 0xef3012, 64 * 1024, 4, SECT_4K, },
1260 +       { "w25x40", 0xef3013, 64 * 1024, 8, SECT_4K, },
1261 +       { "w25x80", 0xef3014, 64 * 1024, 16, SECT_4K, },
1262 +       { "w25x16", 0xef3015, 64 * 1024, 32, SECT_4K, },
1263 +       { "w25x32", 0xef3016, 64 * 1024, 64, SECT_4K, },
1264 +       { "w25x64", 0xef3017, 64 * 1024, 128, SECT_4K, },
1265  };
1266
1267 +static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
1268 +{
1269 +       int                     tmp;
1270 +       u8                      code = OPCODE_RDID;
1271 +       u8                      id[3];
1272 +       u32                     jedec;
1273 +       struct flash_info       *info;
1274 +
1275 +       /* JEDEC also defines an optional "extended device information"
1276 +        * string for after vendor-specific data, after the three bytes
1277 +        * we use here.  Supporting some chips might require using it.
1278 +        */
1279 +       tmp = spi_write_then_read(spi, &code, 1, id, 3);
1280 +       if (tmp < 0) {
1281 +               DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
1282 +                       spi->dev.bus_id, tmp);
1283 +               return NULL;
1284 +       }
1285 +       jedec = id[0];
1286 +       jedec = jedec << 8;
1287 +       jedec |= id[1];
1288 +       jedec = jedec << 8;
1289 +       jedec |= id[2];
1290 +
1291 +       for (tmp = 0, info = m25p_data;
1292 +                       tmp < ARRAY_SIZE(m25p_data);
1293 +                       tmp++, info++) {
1294 +               if (info->jedec_id == jedec)
1295 +                       return info;
1296 +       }
1297 +       dev_err(&spi->dev, "unrecognized JEDEC id %06x\n", jedec);
1298 +       return NULL;
1299 +}
1300 +
1301 +
1302  /*
1303   * board specific setup should have ensured the SPI clock used here
1304   * matches what the READ command supports, at least until this driver
1305 @@ -429,37 +531,51 @@ static int __devinit m25p_probe(struct s
1306         unsigned                        i;
1307
1308         /* Platform data helps sort out which chip type we have, as
1309 -        * well as how this board partitions it.
1310 +        * well as how this board partitions it.  If we don't have
1311 +        * a chip ID, try the JEDEC id commands; they'll work for most
1312 +        * newer chips, even if we don't recognize the particular chip.
1313          */
1314         data = spi->dev.platform_data;
1315 -       if (!data || !data->type) {
1316 -               /* FIXME some chips can identify themselves with RES
1317 -                * or JEDEC get-id commands.  Try them ...
1318 -                */
1319 -               DEBUG(MTD_DEBUG_LEVEL1, "%s: no chip id\n",
1320 -                               spi->dev.bus_id);
1321 -               return -ENODEV;
1322 -       }
1323 +       if (data && data->type) {
1324 +               for (i = 0, info = m25p_data;
1325 +                               i < ARRAY_SIZE(m25p_data);
1326 +                               i++, info++) {
1327 +                       if (strcmp(data->type, info->name) == 0)
1328 +                               break;
1329 +               }
1330
1331 -       for (i = 0, info = m25p_data; i < ARRAY_SIZE(m25p_data); i++, info++) {
1332 -               if (strcmp(data->type, info->name) == 0)
1333 -                       break;
1334 -       }
1335 -       if (i == ARRAY_SIZE(m25p_data)) {
1336 -               DEBUG(MTD_DEBUG_LEVEL1, "%s: unrecognized id %s\n",
1337 -                               spi->dev.bus_id, data->type);
1338 +               /* unrecognized chip? */
1339 +               if (i == ARRAY_SIZE(m25p_data)) {
1340 +                       DEBUG(MTD_DEBUG_LEVEL0, "%s: unrecognized id %s\n",
1341 +                                       spi->dev.bus_id, data->type);
1342 +                       info = NULL;
1343 +
1344 +               /* recognized; is that chip really what's there? */
1345 +               } else if (info->jedec_id) {
1346 +                       struct flash_info       *chip = jedec_probe(spi);
1347 +
1348 +                       if (!chip || chip != info) {
1349 +                               dev_warn(&spi->dev, "found %s, expected %s\n",
1350 +                                               chip ? chip->name : "UNKNOWN",
1351 +                                               info->name);
1352 +                               info = NULL;
1353 +                       }
1354 +               }
1355 +       } else
1356 +               info = jedec_probe(spi);
1357 +
1358 +       if (!info)
1359                 return -ENODEV;
1360 -       }
1361
1362         flash = kzalloc(sizeof *flash, GFP_KERNEL);
1363         if (!flash)
1364                 return -ENOMEM;
1365
1366         flash->spi = spi;
1367 -       init_MUTEX(&flash->lock);
1368 +       mutex_init(&flash->lock);
1369         dev_set_drvdata(&spi->dev, flash);
1370
1371 -       if (data->name)
1372 +       if (data && data->name)
1373                 flash->mtd.name = data->name;
1374         else
1375                 flash->mtd.name = spi->dev.bus_id;
1376 @@ -468,17 +584,25 @@ static int __devinit m25p_probe(struct s
1377         flash->mtd.writesize = 1;
1378         flash->mtd.flags = MTD_CAP_NORFLASH;
1379         flash->mtd.size = info->sector_size * info->n_sectors;
1380 -       flash->mtd.erasesize = info->sector_size;
1381         flash->mtd.erase = m25p80_erase;
1382         flash->mtd.read = m25p80_read;
1383         flash->mtd.write = m25p80_write;
1384
1385 +       /* prefer "small sector" erase if possible */
1386 +       if (info->flags & SECT_4K) {
1387 +               flash->erase_opcode = OPCODE_BE_4K;
1388 +               flash->mtd.erasesize = 4096;
1389 +       } else {
1390 +               flash->erase_opcode = OPCODE_SE;
1391 +               flash->mtd.erasesize = info->sector_size;
1392 +       }
1393 +
1394         dev_info(&spi->dev, "%s (%d Kbytes)\n", info->name,
1395                         flash->mtd.size / 1024);
1396
1397         DEBUG(MTD_DEBUG_LEVEL2,
1398 -               "mtd .name = %s, .size = 0x%.8x (%uM) "
1399 -                       ".erasesize = 0x%.8x (%uK) .numeraseregions = %d\n",
1400 +               "mtd .name = %s, .size = 0x%.8x (%uMiB) "
1401 +                       ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
1402                 flash->mtd.name,
1403                 flash->mtd.size, flash->mtd.size / (1024*1024),
1404                 flash->mtd.erasesize, flash->mtd.erasesize / 1024,
1405 @@ -488,7 +612,7 @@ static int __devinit m25p_probe(struct s
1406                 for (i = 0; i < flash->mtd.numeraseregions; i++)
1407                         DEBUG(MTD_DEBUG_LEVEL2,
1408                                 "mtd.eraseregions[%d] = { .offset = 0x%.8x, "
1409 -                               ".erasesize = 0x%.8x (%uK), "
1410 +                               ".erasesize = 0x%.8x (%uKiB), "
1411                                 ".numblocks = %d }\n",
1412                                 i, flash->mtd.eraseregions[i].offset,
1413                                 flash->mtd.eraseregions[i].erasesize,
1414 @@ -516,14 +640,14 @@ static int __devinit m25p_probe(struct s
1415                 }
1416
1417                 if (nr_parts > 0) {
1418 -                       for (i = 0; i < data->nr_parts; i++) {
1419 +                       for (i = 0; i < nr_parts; i++) {
1420                                 DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
1421                                         "{.name = %s, .offset = 0x%.8x, "
1422 -                                               ".size = 0x%.8x (%uK) }\n",
1423 -                                       i, data->parts[i].name,
1424 -                                       data->parts[i].offset,
1425 -                                       data->parts[i].size,
1426 -                                       data->parts[i].size / 1024);
1427 +                                               ".size = 0x%.8x (%uKiB) }\n",
1428 +                                       i, parts[i].name,
1429 +                                       parts[i].offset,
1430 +                                       parts[i].size,
1431 +                                       parts[i].size / 1024);
1432                         }
1433                         flash->partitioned = 1;
1434                         return add_mtd_partitions(&flash->mtd, parts, nr_parts);
1435 @@ -560,6 +684,11 @@ static struct spi_driver m25p80_driver =
1436         },
1437         .probe  = m25p_probe,
1438         .remove = __devexit_p(m25p_remove),
1439 +
1440 +       /* REVISIT: many of these chips have deep power-down modes, which
1441 +        * should clearly be entered on suspend() to minimize power use.
1442 +        * And also when they're otherwise idle...
1443 +        */
1444  };
1445
1446
1447 Index: linux-2.6.23.17/drivers/mtd/devices/mtd_dataflash.c
1448 ===================================================================
1449 --- linux-2.6.23.17.orig/drivers/mtd/devices/mtd_dataflash.c
1450 +++ linux-2.6.23.17/drivers/mtd/devices/mtd_dataflash.c
1451 @@ -14,6 +14,7 @@
1452  #include <linux/slab.h>
1453  #include <linux/delay.h>
1454  #include <linux/device.h>
1455 +#include <linux/mutex.h>
1456  #include <linux/spi/spi.h>
1457  #include <linux/spi/flash.h>
1458
1459 @@ -89,7 +90,7 @@ struct dataflash {
1460         unsigned short          page_offset;    /* offset in flash address */
1461         unsigned int            page_size;      /* of bytes per page */
1462
1463 -       struct semaphore        lock;
1464 +       struct mutex            lock;
1465         struct spi_device       *spi;
1466
1467         struct mtd_info         mtd;
1468 @@ -167,7 +168,7 @@ static int dataflash_erase(struct mtd_in
1469         x.len = 4;
1470         spi_message_add_tail(&x, &msg);
1471
1472 -       down(&priv->lock);
1473 +       mutex_lock(&priv->lock);
1474         while (instr->len > 0) {
1475                 unsigned int    pageaddr;
1476                 int             status;
1477 @@ -210,7 +211,7 @@ static int dataflash_erase(struct mtd_in
1478                         instr->len -= priv->page_size;
1479                 }
1480         }
1481 -       up(&priv->lock);
1482 +       mutex_unlock(&priv->lock);
1483
1484         /* Inform MTD subsystem that erase is complete */
1485         instr->state = MTD_ERASE_DONE;
1486 @@ -266,7 +267,7 @@ static int dataflash_read(struct mtd_inf
1487         x[1].len = len;
1488         spi_message_add_tail(&x[1], &msg);
1489
1490 -       down(&priv->lock);
1491 +       mutex_lock(&priv->lock);
1492
1493         /* Continuous read, max clock = f(car) which may be less than
1494          * the peak rate available.  Some chips support commands with
1495 @@ -279,7 +280,7 @@ static int dataflash_read(struct mtd_inf
1496         /* plus 4 "don't care" bytes */
1497
1498         status = spi_sync(priv->spi, &msg);
1499 -       up(&priv->lock);
1500 +       mutex_unlock(&priv->lock);
1501
1502         if (status >= 0) {
1503                 *retlen = msg.actual_length - 8;
1504 @@ -336,7 +337,7 @@ static int dataflash_write(struct mtd_in
1505         else
1506                 writelen = len;
1507
1508 -       down(&priv->lock);
1509 +       mutex_lock(&priv->lock);
1510         while (remaining > 0) {
1511                 DEBUG(MTD_DEBUG_LEVEL3, "write @ %i:%i len=%i\n",
1512                         pageaddr, offset, writelen);
1513 @@ -441,7 +442,7 @@ static int dataflash_write(struct mtd_in
1514                 else
1515                         writelen = remaining;
1516         }
1517 -       up(&priv->lock);
1518 +       mutex_unlock(&priv->lock);
1519
1520         return status;
1521  }
1522 @@ -463,7 +464,7 @@ add_dataflash(struct spi_device *spi, ch
1523         if (!priv)
1524                 return -ENOMEM;
1525
1526 -       init_MUTEX(&priv->lock);
1527 +       mutex_init(&priv->lock);
1528         priv->spi = spi;
1529         priv->page_size = pagesize;
1530         priv->page_offset = pageoffset;
1531 Index: linux-2.6.23.17/drivers/mtd/devices/pmc551.c
1532 ===================================================================
1533 --- linux-2.6.23.17.orig/drivers/mtd/devices/pmc551.c
1534 +++ linux-2.6.23.17/drivers/mtd/devices/pmc551.c
1535 @@ -30,8 +30,8 @@
1536   *
1537   * Notes:
1538   *     Due to what I assume is more buggy SROM, the 64M PMC551 I
1539 - *     have available claims that all 4 of it's DRAM banks have 64M
1540 - *     of ram configured (making a grand total of 256M onboard).
1541 + *     have available claims that all 4 of its DRAM banks have 64MiB
1542 + *     of ram configured (making a grand total of 256MiB onboard).
1543   *     This is slightly annoying since the BAR0 size reflects the
1544   *     aperture size, not the dram size, and the V370PDC supplies no
1545   *     other method for memory size discovery.  This problem is
1546 @@ -70,7 +70,7 @@
1547   *      made the memory unusable, added a fix to code to touch up
1548   *      the DRAM some.
1549   *
1550 - * Bugs/FIXME's:
1551 + * Bugs/FIXMEs:
1552   *     * MUST fix the init function to not spin on a register
1553   *     waiting for it to set .. this does not safely handle busted
1554   *     devices that never reset the register correctly which will
1555 @@ -562,10 +562,10 @@ static u32 fixup_pmc551(struct pci_dev *
1556         /*
1557          * Some screen fun
1558          */
1559 -       printk(KERN_DEBUG "pmc551: %d%c (0x%x) of %sprefetchable memory at "
1560 +       printk(KERN_DEBUG "pmc551: %d%sB (0x%x) of %sprefetchable memory at "
1561                 "0x%llx\n", (size < 1024) ? size : (size < 1048576) ?
1562                 size >> 10 : size >> 20,
1563 -               (size < 1024) ? 'B' : (size < 1048576) ? 'K' : 'M', size,
1564 +               (size < 1024) ? "" : (size < 1048576) ? "Ki" : "Mi", size,
1565                 ((dcmd & (0x1 << 3)) == 0) ? "non-" : "",
1566                 (unsigned long long)pci_resource_start(dev, 0));
1567
1568 @@ -649,14 +649,10 @@ MODULE_DESCRIPTION(PMC551_VERSION);
1569   * Stuff these outside the ifdef so as to not bust compiled in driver support
1570   */
1571  static int msize = 0;
1572 -#if defined(CONFIG_MTD_PMC551_APERTURE_SIZE)
1573 -static int asize = CONFIG_MTD_PMC551_APERTURE_SIZE;
1574 -#else
1575  static int asize = 0;
1576 -#endif
1577
1578  module_param(msize, int, 0);
1579 -MODULE_PARM_DESC(msize, "memory size in Megabytes [1 - 1024]");
1580 +MODULE_PARM_DESC(msize, "memory size in MiB [1 - 1024]");
1581  module_param(asize, int, 0);
1582  MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]");
1583
1584 @@ -799,8 +795,7 @@ static int __init init_pmc551(void)
1585                 mtd->owner = THIS_MODULE;
1586
1587                 if (add_mtd_device(mtd)) {
1588 -                       printk(KERN_NOTICE "pmc551: Failed to register new "
1589 -                               "device\n");
1590 +                       printk(KERN_NOTICE "pmc551: Failed to register new device\n");
1591                         pci_iounmap(PCI_Device, priv->start);
1592                         kfree(mtd->priv);
1593                         kfree(mtd);
1594 @@ -811,13 +806,13 @@ static int __init init_pmc551(void)
1595                 pci_dev_get(PCI_Device);
1596
1597                 printk(KERN_NOTICE "Registered pmc551 memory device.\n");
1598 -               printk(KERN_NOTICE "Mapped %dM of memory from 0x%p to 0x%p\n",
1599 +               printk(KERN_NOTICE "Mapped %dMiB of memory from 0x%p to 0x%p\n",
1600                         priv->asize >> 20,
1601                         priv->start, priv->start + priv->asize);
1602 -               printk(KERN_NOTICE "Total memory is %d%c\n",
1603 +               printk(KERN_NOTICE "Total memory is %d%sB\n",
1604                         (length < 1024) ? length :
1605                         (length < 1048576) ? length >> 10 : length >> 20,
1606 -                       (length < 1024) ? 'B' : (length < 1048576) ? 'K' : 'M');
1607 +                       (length < 1024) ? "" : (length < 1048576) ? "Ki" : "Mi");
1608                 priv->nextpmc551 = pmc551list;
1609                 pmc551list = mtd;
1610                 found++;
1611 @@ -850,7 +845,7 @@ static void __exit cleanup_pmc551(void)
1612                 pmc551list = priv->nextpmc551;
1613
1614                 if (priv->start) {
1615 -                       printk(KERN_DEBUG "pmc551: unmapping %dM starting at "
1616 +                       printk(KERN_DEBUG "pmc551: unmapping %dMiB starting at "
1617                                 "0x%p\n", priv->asize >> 20, priv->start);
1618                         pci_iounmap(priv->dev, priv->start);
1619                 }
1620 Index: linux-2.6.23.17/drivers/mtd/maps/nettel.c
1621 ===================================================================
1622 --- linux-2.6.23.17.orig/drivers/mtd/maps/nettel.c
1623 +++ linux-2.6.23.17/drivers/mtd/maps/nettel.c
1624 @@ -158,68 +158,11 @@ static struct notifier_block nettel_noti
1625         nettel_reboot_notifier, NULL, 0
1626  };
1627
1628 -/*
1629 - *     Erase the configuration file system.
1630 - *     Used to support the software reset button.
1631 - */
1632 -static void nettel_erasecallback(struct erase_info *done)
1633 -{
1634 -       wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
1635 -       wake_up(wait_q);
1636 -}
1637 -
1638 -static struct erase_info nettel_erase;
1639 -
1640 -int nettel_eraseconfig(void)
1641 -{
1642 -       struct mtd_info *mtd;
1643 -       DECLARE_WAITQUEUE(wait, current);
1644 -       wait_queue_head_t wait_q;
1645 -       int ret;
1646 -
1647 -       init_waitqueue_head(&wait_q);
1648 -       mtd = get_mtd_device(NULL, 2);
1649 -       if (!IS_ERR(mtd)) {
1650 -               nettel_erase.mtd = mtd;
1651 -               nettel_erase.callback = nettel_erasecallback;
1652 -               nettel_erase.callback = NULL;
1653 -               nettel_erase.addr = 0;
1654 -               nettel_erase.len = mtd->size;
1655 -               nettel_erase.priv = (u_long) &wait_q;
1656 -               nettel_erase.priv = 0;
1657 -
1658 -               set_current_state(TASK_INTERRUPTIBLE);
1659 -               add_wait_queue(&wait_q, &wait);
1660 -
1661 -               ret = mtd->erase(mtd, &nettel_erase);
1662 -               if (ret) {
1663 -                       set_current_state(TASK_RUNNING);
1664 -                       remove_wait_queue(&wait_q, &wait);
1665 -                       put_mtd_device(mtd);
1666 -                       return(ret);
1667 -               }
1668 -
1669 -               schedule();  /* Wait for erase to finish. */
1670 -               remove_wait_queue(&wait_q, &wait);
1671 -
1672 -               put_mtd_device(mtd);
1673 -       }
1674 -
1675 -       return(0);
1676 -}
1677 -
1678 -#else
1679 -
1680 -int nettel_eraseconfig(void)
1681 -{
1682 -       return(0);
1683 -}
1684 -
1685  #endif
1686
1687  /****************************************************************************/
1688
1689 -int __init nettel_init(void)
1690 +static int __init nettel_init(void)
1691  {
1692         volatile unsigned long *amdpar;
1693         unsigned long amdaddr, maxsize;
1694 @@ -421,10 +364,6 @@ int __init nettel_init(void)
1695
1696         intel_mtd->owner = THIS_MODULE;
1697
1698 -#ifndef CONFIG_BLK_DEV_INITRD
1699 -       ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, 1);
1700 -#endif
1701 -
1702         num_intel_partitions = sizeof(nettel_intel_partitions) /
1703                 sizeof(nettel_intel_partitions[0]);
1704
1705 @@ -477,7 +416,7 @@ out_unmap2:
1706
1707  /****************************************************************************/
1708
1709 -void __exit nettel_cleanup(void)
1710 +static void __exit nettel_cleanup(void)
1711  {
1712  #ifdef CONFIG_MTD_CFI_INTELEXT
1713         unregister_reboot_notifier(&nettel_notifier_block);
1714 Index: linux-2.6.23.17/drivers/mtd/maps/pmcmsp-ramroot.c
1715 ===================================================================
1716 --- linux-2.6.23.17.orig/drivers/mtd/maps/pmcmsp-ramroot.c
1717 +++ linux-2.6.23.17/drivers/mtd/maps/pmcmsp-ramroot.c
1718 @@ -79,7 +79,6 @@ static int __init init_rrmap(void)
1719                 rr_mtd->owner = THIS_MODULE;
1720
1721                 add_mtd_device(rr_mtd);
1722 -               ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, rr_mtd->index);
1723
1724                 return 0;
1725         }
1726 Index: linux-2.6.23.17/drivers/mtd/mtd_blkdevs.c
1727 ===================================================================
1728 --- linux-2.6.23.17.orig/drivers/mtd/mtd_blkdevs.c
1729 +++ linux-2.6.23.17/drivers/mtd/mtd_blkdevs.c
1730 @@ -24,10 +24,9 @@
1731  #include <linux/kthread.h>
1732  #include <asm/uaccess.h>
1733
1734 -static LIST_HEAD(blktrans_majors);
1735 +#include "mtdcore.h"
1736
1737 -extern struct mutex mtd_table_mutex;
1738 -extern struct mtd_info *mtd_table[];
1739 +static LIST_HEAD(blktrans_majors);
1740
1741  struct mtd_blkcore_priv {
1742         struct task_struct *thread;
1743 @@ -202,7 +201,7 @@ static int blktrans_ioctl(struct inode *
1744         }
1745  }
1746
1747 -struct block_device_operations mtd_blktrans_ops = {
1748 +static struct block_device_operations mtd_blktrans_ops = {
1749         .owner          = THIS_MODULE,
1750         .open           = blktrans_open,
1751         .release        = blktrans_release,
1752 Index: linux-2.6.23.17/drivers/mtd/mtdchar.c
1753 ===================================================================
1754 --- linux-2.6.23.17.orig/drivers/mtd/mtdchar.c
1755 +++ linux-2.6.23.17/drivers/mtd/mtdchar.c
1756 @@ -137,7 +137,8 @@ static int mtd_close(struct inode *inode
1757
1758         DEBUG(MTD_DEBUG_LEVEL0, "MTD_close\n");
1759
1760 -       if (mtd->sync)
1761 +       /* Only sync if opened RW */
1762 +       if ((file->f_mode & 2) && mtd->sync)
1763                 mtd->sync(mtd);
1764
1765         put_mtd_device(mtd);
1766 Index: linux-2.6.23.17/drivers/mtd/mtdcore.c
1767 ===================================================================
1768 --- linux-2.6.23.17.orig/drivers/mtd/mtdcore.c
1769 +++ linux-2.6.23.17/drivers/mtd/mtdcore.c
1770 @@ -22,6 +22,8 @@
1771
1772  #include <linux/mtd/mtd.h>
1773
1774 +#include "mtdcore.h"
1775 +
1776  /* These are exported solely for the purpose of mtd_blkdevs.c. You
1777     should not use them for _anything_ else */
1778  DEFINE_MUTEX(mtd_table_mutex);
1779 Index: linux-2.6.23.17/drivers/mtd/nand/Kconfig
1780 ===================================================================
1781 --- linux-2.6.23.17.orig/drivers/mtd/nand/Kconfig
1782 +++ linux-2.6.23.17/drivers/mtd/nand/Kconfig
1783 @@ -134,10 +134,10 @@ config MTD_NAND_S3C2410_HWECC
1784
1785  config MTD_NAND_NDFC
1786         tristate "NDFC NanD Flash Controller"
1787 -       depends on 44x
1788 +       depends on 4xx
1789         select MTD_NAND_ECC_SMC
1790         help
1791 -        NDFC Nand Flash Controllers are integrated in EP44x SoCs
1792 +        NDFC Nand Flash Controllers are integrated in IBM/AMCC's 4xx SoCs
1793
1794  config MTD_NAND_S3C2410_CLKSTOP
1795         bool "S3C2410 NAND IDLE clock stop"
1796 @@ -237,7 +237,7 @@ config MTD_NAND_CAFE
1797         select REED_SOLOMON
1798         select REED_SOLOMON_DEC16
1799         help
1800 -         Use NAND flash attached to the CAFÉ chip designed for the $100
1801 +         Use NAND flash attached to the CAFÉ chip designed for the OLPC
1802           laptop.
1803
1804  config MTD_NAND_CS553X
1805 Index: linux-2.6.23.17/drivers/mtd/nand/cafe_nand.c
1806 ===================================================================
1807 --- linux-2.6.23.17.orig/drivers/mtd/nand/cafe_nand.c
1808 +++ linux-2.6.23.17/drivers/mtd/nand/cafe_nand.c
1809 @@ -822,14 +822,53 @@ static struct pci_device_id cafe_nand_tb
1810
1811  MODULE_DEVICE_TABLE(pci, cafe_nand_tbl);
1812
1813 +static int cafe_nand_resume(struct pci_dev *pdev)
1814 +{
1815 +       uint32_t timing1, timing2, timing3;
1816 +       uint32_t ctrl;
1817 +       struct mtd_info *mtd = pci_get_drvdata(pdev);
1818 +       struct cafe_priv *cafe = mtd->priv;
1819 +
1820 +       timing1 = timing2 = timing3 = 0xffffffff;
1821 +       /* Start off by resetting the NAND controller completely */
1822 +       cafe_writel(cafe, 1, NAND_RESET);
1823 +       cafe_writel(cafe, 0, NAND_RESET);
1824 +       cafe_writel(cafe, timing1, NAND_TIMING1);
1825 +       cafe_writel(cafe, timing2, NAND_TIMING2);
1826 +       cafe_writel(cafe, timing3, NAND_TIMING3);
1827 +       cafe_writel(cafe, 0xffffffff, NAND_IRQ_MASK);
1828 +
1829 +        /* Disable master reset, enable NAND clock */
1830 +       ctrl = cafe_readl(cafe, GLOBAL_CTRL);
1831 +       ctrl &= 0xffffeff0;
1832 +       ctrl |= 0x00007000;
1833 +       cafe_writel(cafe, ctrl | 0x05, GLOBAL_CTRL);
1834 +       cafe_writel(cafe, ctrl | 0x0a, GLOBAL_CTRL);
1835 +       cafe_writel(cafe, 0, NAND_DMA_CTRL);
1836 +       cafe_writel(cafe, 0x7006, GLOBAL_CTRL);
1837 +       cafe_writel(cafe, 0x700a, GLOBAL_CTRL);
1838 +
1839 +       /* Set up DMA address */
1840 +       cafe_writel(cafe, cafe->dmaaddr & 0xffffffff, NAND_DMA_ADDR0);
1841 +       if (sizeof(cafe->dmaaddr) > 4)
1842 +       /* Shift in two parts to shut the compiler up */
1843 +               cafe_writel(cafe, (cafe->dmaaddr >> 16) >> 16, NAND_DMA_ADDR1);
1844 +       else
1845 +               cafe_writel(cafe, 0, NAND_DMA_ADDR1);
1846 +
1847 +       /* Enable NAND IRQ in global IRQ mask register */
1848 +       cafe_writel(cafe, 0x80000007, GLOBAL_IRQ_MASK);
1849 +       return 0;
1850 +}
1851 +
1852  static struct pci_driver cafe_nand_pci_driver = {
1853         .name = "CAFÉ NAND",
1854         .id_table = cafe_nand_tbl,
1855         .probe = cafe_nand_probe,
1856         .remove = __devexit_p(cafe_nand_remove),
1857 +       .resume = cafe_nand_resume,
1858  #ifdef CONFIG_PMx
1859         .suspend = cafe_nand_suspend,
1860 -       .resume = cafe_nand_resume,
1861  #endif
1862  };
1863
1864 Index: linux-2.6.23.17/drivers/mtd/nand/ndfc.c
1865 ===================================================================
1866 --- linux-2.6.23.17.orig/drivers/mtd/nand/ndfc.c
1867 +++ linux-2.6.23.17/drivers/mtd/nand/ndfc.c
1868 @@ -24,7 +24,11 @@
1869  #include <linux/platform_device.h>
1870
1871  #include <asm/io.h>
1872 +#ifdef CONFIG_40x
1873 +#include <asm/ibm405.h>
1874 +#else
1875  #include <asm/ibm44x.h>
1876 +#endif
1877
1878  struct ndfc_nand_mtd {
1879         struct mtd_info                 mtd;
1880 @@ -230,7 +234,11 @@ static int ndfc_nand_probe(struct platfo
1881         struct ndfc_controller *ndfc = &ndfc_ctrl;
1882         unsigned long long phys = settings->ndfc_erpn | res->start;
1883
1884 +#ifndef CONFIG_PHYS_64BIT
1885 +       ndfc->ndfcbase = ioremap((phys_addr_t)phys, res->end - res->start + 1);
1886 +#else
1887         ndfc->ndfcbase = ioremap64(phys, res->end - res->start + 1);
1888 +#endif
1889         if (!ndfc->ndfcbase) {
1890                 printk(KERN_ERR "NDFC: ioremap failed\n");
1891                 return -EIO;
1892 Index: linux-2.6.23.17/drivers/mtd/onenand/Kconfig
1893 ===================================================================
1894 --- linux-2.6.23.17.orig/drivers/mtd/onenand/Kconfig
1895 +++ linux-2.6.23.17/drivers/mtd/onenand/Kconfig
1896 @@ -40,4 +40,27 @@ config MTD_ONENAND_OTP
1897
1898           OTP block is fully-guaranteed to be a valid block.
1899
1900 +config MTD_ONENAND_2X_PROGRAM
1901 +       bool "OneNAND 2X program support"
1902 +       help
1903 +         The 2X Program is an extension of Program Operation.
1904 +         Since the device is equipped with two DataRAMs, and two-plane NAND
1905 +         Flash memory array, these two component enables simultaneous program
1906 +         of 4KiB. Plane1 has only even blocks such as block0, block2, block4
1907 +         while Plane2 has only odd blocks such as block1, block3, block5.
1908 +         So MTD regards it as 4KiB page size and 256KiB block size
1909 +
1910 +         Now the following chips support it. (KFXXX16Q2M)
1911 +           Demux: KFG2G16Q2M, KFH4G16Q2M, KFW8G16Q2M,
1912 +           Mux:   KFM2G16Q2M, KFN4G16Q2M,
1913 +
1914 +         And more recent chips
1915 +
1916 +config MTD_ONENAND_SIM
1917 +       tristate "OneNAND simulator support"
1918 +       depends on MTD_PARTITIONS
1919 +       help
1920 +         The simulator may simulate various OneNAND flash chips for the
1921 +         OneNAND MTD layer.
1922 +
1923  endif # MTD_ONENAND
1924 Index: linux-2.6.23.17/drivers/mtd/onenand/Makefile
1925 ===================================================================
1926 --- linux-2.6.23.17.orig/drivers/mtd/onenand/Makefile
1927 +++ linux-2.6.23.17/drivers/mtd/onenand/Makefile
1928 @@ -8,4 +8,7 @@ obj-$(CONFIG_MTD_ONENAND)               += onenand.o
1929  # Board specific.
1930  obj-$(CONFIG_MTD_ONENAND_GENERIC)      += generic.o
1931
1932 +# Simulator
1933 +obj-$(CONFIG_MTD_ONENAND_SIM)          += onenand_sim.o
1934 +
1935  onenand-objs = onenand_base.o onenand_bbt.o
1936 Index: linux-2.6.23.17/drivers/mtd/onenand/onenand_base.c
1937 ===================================================================
1938 --- linux-2.6.23.17.orig/drivers/mtd/onenand/onenand_base.c
1939 +++ linux-2.6.23.17/drivers/mtd/onenand/onenand_base.c
1940 @@ -206,6 +206,15 @@ static int onenand_command(struct mtd_in
1941         default:
1942                 block = (int) (addr >> this->erase_shift);
1943                 page = (int) (addr >> this->page_shift);
1944 +
1945 +               if (ONENAND_IS_2PLANE(this)) {
1946 +                       /* Make the even block number */
1947 +                       block &= ~1;
1948 +                       /* Is it the odd plane? */
1949 +                       if (addr & this->writesize)
1950 +                               block++;
1951 +                       page >>= 1;
1952 +               }
1953                 page &= this->page_mask;
1954                 break;
1955         }
1956 @@ -216,8 +225,12 @@ static int onenand_command(struct mtd_in
1957                 value = onenand_bufferram_address(this, block);
1958                 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
1959
1960 -               /* Switch to the next data buffer */
1961 -               ONENAND_SET_NEXT_BUFFERRAM(this);
1962 +               if (ONENAND_IS_2PLANE(this))
1963 +                       /* It is always BufferRAM0 */
1964 +                       ONENAND_SET_BUFFERRAM0(this);
1965 +               else
1966 +                       /* Switch to the next data buffer */
1967 +                       ONENAND_SET_NEXT_BUFFERRAM(this);
1968
1969                 return 0;
1970         }
1971 @@ -247,6 +260,8 @@ static int onenand_command(struct mtd_in
1972                         break;
1973
1974                 default:
1975 +                       if (ONENAND_IS_2PLANE(this) && cmd == ONENAND_CMD_PROG)
1976 +                               cmd = ONENAND_CMD_2X_PROG;
1977                         dataram = ONENAND_CURRENT_BUFFERRAM(this);
1978                         break;
1979                 }
1980 @@ -445,8 +460,9 @@ static inline int onenand_bufferram_offs
1981         struct onenand_chip *this = mtd->priv;
1982
1983         if (ONENAND_CURRENT_BUFFERRAM(this)) {
1984 +               /* Note: the 'this->writesize' is a real page size */
1985                 if (area == ONENAND_DATARAM)
1986 -                       return mtd->writesize;
1987 +                       return this->writesize;
1988                 if (area == ONENAND_SPARERAM)
1989                         return mtd->oobsize;
1990         }
1991 @@ -572,6 +588,30 @@ static int onenand_write_bufferram(struc
1992  }
1993
1994  /**
1995 + * onenand_get_2x_blockpage - [GENERIC] Get blockpage at 2x program mode
1996 + * @param mtd          MTD data structure
1997 + * @param addr         address to check
1998 + * @return             blockpage address
1999 + *
2000 + * Get blockpage address at 2x program mode
2001 + */
2002 +static int onenand_get_2x_blockpage(struct mtd_info *mtd, loff_t addr)
2003 +{
2004 +       struct onenand_chip *this = mtd->priv;
2005 +       int blockpage, block, page;
2006 +
2007 +       /* Calculate the even block number */
2008 +       block = (int) (addr >> this->erase_shift) & ~1;
2009 +       /* Is it the odd plane? */
2010 +       if (addr & this->writesize)
2011 +               block++;
2012 +       page = (int) (addr >> (this->page_shift + 1)) & this->page_mask;
2013 +       blockpage = (block << 7) | page;
2014 +
2015 +       return blockpage;
2016 +}
2017 +
2018 +/**
2019   * onenand_check_bufferram - [GENERIC] Check BufferRAM information
2020   * @param mtd          MTD data structure
2021   * @param addr         address to check
2022 @@ -585,7 +625,10 @@ static int onenand_check_bufferram(struc
2023         int blockpage, found = 0;
2024         unsigned int i;
2025
2026 -       blockpage = (int) (addr >> this->page_shift);
2027 +       if (ONENAND_IS_2PLANE(this))
2028 +               blockpage = onenand_get_2x_blockpage(mtd, addr);
2029 +       else
2030 +               blockpage = (int) (addr >> this->page_shift);
2031
2032         /* Is there valid data? */
2033         i = ONENAND_CURRENT_BUFFERRAM(this);
2034 @@ -625,7 +668,10 @@ static void onenand_update_bufferram(str
2035         int blockpage;
2036         unsigned int i;
2037
2038 -       blockpage = (int) (addr >> this->page_shift);
2039 +       if (ONENAND_IS_2PLANE(this))
2040 +               blockpage = onenand_get_2x_blockpage(mtd, addr);
2041 +       else
2042 +               blockpage = (int) (addr >> this->page_shift);
2043
2044         /* Invalidate another BufferRAM */
2045         i = ONENAND_NEXT_BUFFERRAM(this);
2046 @@ -734,6 +780,7 @@ static int onenand_read(struct mtd_info
2047         int read = 0, column;
2048         int thislen;
2049         int ret = 0, boundary = 0;
2050 +       int writesize = this->writesize;
2051
2052         DEBUG(MTD_DEBUG_LEVEL3, "onenand_read: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
2053
2054 @@ -754,22 +801,22 @@ static int onenand_read(struct mtd_info
2055         /* Do first load to bufferRAM */
2056         if (read < len) {
2057                 if (!onenand_check_bufferram(mtd, from)) {
2058 -                       this->command(mtd, ONENAND_CMD_READ, from, mtd->writesize);
2059 +                       this->command(mtd, ONENAND_CMD_READ, from, writesize);
2060                         ret = this->wait(mtd, FL_READING);
2061                         onenand_update_bufferram(mtd, from, !ret);
2062                 }
2063         }
2064
2065 -       thislen = min_t(int, mtd->writesize, len - read);
2066 -       column = from & (mtd->writesize - 1);
2067 -       if (column + thislen > mtd->writesize)
2068 -               thislen = mtd->writesize - column;
2069 +       thislen = min_t(int, writesize, len - read);
2070 +       column = from & (writesize - 1);
2071 +       if (column + thislen > writesize)
2072 +               thislen = writesize - column;
2073
2074         while (!ret) {
2075                 /* If there is more to load then start next load */
2076                 from += thislen;
2077                 if (read + thislen < len) {
2078 -                       this->command(mtd, ONENAND_CMD_READ, from, mtd->writesize);
2079 +                       this->command(mtd, ONENAND_CMD_READ, from, writesize);
2080                         /*
2081                          * Chip boundary handling in DDP
2082                          * Now we issued chip 1 read and pointed chip 1
2083 @@ -794,7 +841,7 @@ static int onenand_read(struct mtd_info
2084                         this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2);
2085                 ONENAND_SET_NEXT_BUFFERRAM(this);
2086                 buf += thislen;
2087 -               thislen = min_t(int, mtd->writesize, len - read);
2088 +               thislen = min_t(int, writesize, len - read);
2089                 column = 0;
2090                 cond_resched();
2091                 /* Now wait for load */
2092 @@ -1079,7 +1126,7 @@ int onenand_bbt_read_oob(struct mtd_info
2093                 /* Read more? */
2094                 if (read < len) {
2095                         /* Update Page size */
2096 -                       from += mtd->writesize;
2097 +                       from += this->writesize;
2098                         column = 0;
2099                 }
2100         }
2101 @@ -1135,12 +1182,12 @@ static int onenand_verify(struct mtd_inf
2102         int thislen, column;
2103
2104         while (len != 0) {
2105 -               thislen = min_t(int, mtd->writesize, len);
2106 -               column = addr & (mtd->writesize - 1);
2107 -               if (column + thislen > mtd->writesize)
2108 -                       thislen = mtd->writesize - column;
2109 +               thislen = min_t(int, this->writesize, len);
2110 +               column = addr & (this->writesize - 1);
2111 +               if (column + thislen > this->writesize)
2112 +                       thislen = this->writesize - column;
2113
2114 -               this->command(mtd, ONENAND_CMD_READ, addr, mtd->writesize);
2115 +               this->command(mtd, ONENAND_CMD_READ, addr, this->writesize);
2116
2117                 onenand_update_bufferram(mtd, addr, 0);
2118
2119 @@ -1236,6 +1283,10 @@ static int onenand_write(struct mtd_info
2120
2121                 /* In partial page write we don't update bufferram */
2122                 onenand_update_bufferram(mtd, to, !ret && !subpage);
2123 +               if (ONENAND_IS_2PLANE(this)) {
2124 +                       ONENAND_SET_BUFFERRAM1(this);
2125 +                       onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
2126 +               }
2127
2128                 if (ret) {
2129                         printk(KERN_ERR "onenand_write: write filaed %d\n", ret);
2130 @@ -1384,6 +1435,10 @@ static int onenand_do_write_oob(struct m
2131                 this->command(mtd, ONENAND_CMD_PROGOOB, to, mtd->oobsize);
2132
2133                 onenand_update_bufferram(mtd, to, 0);
2134 +               if (ONENAND_IS_2PLANE(this)) {
2135 +                       ONENAND_SET_BUFFERRAM1(this);
2136 +                       onenand_update_bufferram(mtd, to + this->writesize, 0);
2137 +               }
2138
2139                 ret = this->wait(mtd, FL_WRITING);
2140                 if (ret) {
2141 @@ -2107,6 +2162,7 @@ static int onenand_lock_user_prot_reg(st
2142   *
2143   * Check and set OneNAND features
2144   * - lock scheme
2145 + * - two plane
2146   */
2147  static void onenand_check_features(struct mtd_info *mtd)
2148  {
2149 @@ -2118,19 +2174,35 @@ static void onenand_check_features(struc
2150         process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT;
2151
2152         /* Lock scheme */
2153 -       if (density >= ONENAND_DEVICE_DENSITY_1Gb) {
2154 +       switch (density) {
2155 +       case ONENAND_DEVICE_DENSITY_4Gb:
2156 +               this->options |= ONENAND_HAS_2PLANE;
2157 +
2158 +       case ONENAND_DEVICE_DENSITY_2Gb:
2159 +               /* 2Gb DDP don't have 2 plane */
2160 +               if (!ONENAND_IS_DDP(this))
2161 +                       this->options |= ONENAND_HAS_2PLANE;
2162 +               this->options |= ONENAND_HAS_UNLOCK_ALL;
2163 +
2164 +       case ONENAND_DEVICE_DENSITY_1Gb:
2165                 /* A-Die has all block unlock */
2166 -               if (process) {
2167 -                       printk(KERN_DEBUG "Chip support all block unlock\n");
2168 +               if (process)
2169                         this->options |= ONENAND_HAS_UNLOCK_ALL;
2170 -               }
2171 -       } else {
2172 -               /* Some OneNAND has continues lock scheme */
2173 -               if (!process) {
2174 -                       printk(KERN_DEBUG "Lock scheme is Continues Lock\n");
2175 +               break;
2176 +
2177 +       default:
2178 +               /* Some OneNAND has continuous lock scheme */
2179 +               if (!process)
2180                         this->options |= ONENAND_HAS_CONT_LOCK;
2181 -               }
2182 +               break;
2183         }
2184 +
2185 +       if (this->options & ONENAND_HAS_CONT_LOCK)
2186 +               printk(KERN_DEBUG "Lock scheme is Continuous Lock\n");
2187 +       if (this->options & ONENAND_HAS_UNLOCK_ALL)
2188 +               printk(KERN_DEBUG "Chip support all block unlock\n");
2189 +       if (this->options & ONENAND_HAS_2PLANE)
2190 +               printk(KERN_DEBUG "Chip has 2 plane\n");
2191  }
2192
2193  /**
2194 @@ -2257,6 +2329,8 @@ static int onenand_probe(struct mtd_info
2195         this->erase_shift = ffs(mtd->erasesize) - 1;
2196         this->page_shift = ffs(mtd->writesize) - 1;
2197         this->page_mask = (1 << (this->erase_shift - this->page_shift)) - 1;
2198 +       /* It's real page size */
2199 +       this->writesize = mtd->writesize;
2200
2201         /* REVIST: Multichip handling */
2202
2203 @@ -2265,6 +2339,17 @@ static int onenand_probe(struct mtd_info
2204         /* Check OneNAND features */
2205         onenand_check_features(mtd);
2206
2207 +       /*
2208 +        * We emulate the 4KiB page and 256KiB erase block size
2209 +        * But oobsize is still 64 bytes.
2210 +        * It is only valid if you turn on 2X program support,
2211 +        * Otherwise it will be ignored by compiler.
2212 +        */
2213 +       if (ONENAND_IS_2PLANE(this)) {
2214 +               mtd->writesize <<= 1;
2215 +               mtd->erasesize <<= 1;
2216 +       }
2217 +
2218         return 0;
2219  }
2220
2221 Index: linux-2.6.23.17/drivers/pci/quirks.c
2222 ===================================================================
2223 --- linux-2.6.23.17.orig/drivers/pci/quirks.c
2224 +++ linux-2.6.23.17/drivers/pci/quirks.c
2225 @@ -1396,6 +1396,17 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_IN
2226  DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,   0x260b, quirk_intel_pcie_pm);
2227
2228  /*
2229 + * According to Tom Sylla, the Geode does not support PCI power management
2230 + * transition, so we shouldn't need the D3hot delay.
2231 + */
2232 +static void __init quirk_geode_pci_pm(struct pci_dev *dev)
2233 +{
2234 +       pci_pm_d3_delay = 0;
2235 +}
2236 +DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_LEGACY, quirk_geode_pci_pm);
2237 +DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA, quirk_geode_pci_pm);
2238 +
2239 +/*
2240   * Toshiba TC86C001 IDE controller reports the standard 8-byte BAR0 size
2241   * but the PIO transfers won't work if BAR0 falls at the odd 8 bytes.
2242   * Re-allocate the region if needed...
2243 Index: linux-2.6.23.17/drivers/video/Kconfig
2244 ===================================================================
2245 --- linux-2.6.23.17.orig/drivers/video/Kconfig
2246 +++ linux-2.6.23.17/drivers/video/Kconfig
2247 @@ -594,7 +594,7 @@ config FB_TGA
2248
2249  config FB_VESA
2250         bool "VESA VGA graphics support"
2251 -       depends on (FB = y) && X86
2252 +       depends on (FB = y) && X86 && !VGA_NOPROBE
2253         select FB_CFB_FILLRECT
2254         select FB_CFB_COPYAREA
2255         select FB_CFB_IMAGEBLIT
2256 @@ -1028,7 +1028,7 @@ config FB_CARILLO_RANCH
2257
2258  config FB_INTEL
2259         tristate "Intel 830M/845G/852GM/855GM/865G/915G/945G support (EXPERIMENTAL)"
2260 -       depends on FB && EXPERIMENTAL && PCI && X86
2261 +       depends on FB && EXPERIMENTAL && PCI && X86 && !VGA_NOPROBE
2262         select AGP
2263         select AGP_INTEL
2264         select FB_MODE_HELPERS
2265 @@ -1383,7 +1383,7 @@ config FB_SAVAGE_ACCEL
2266
2267  config FB_SIS
2268         tristate "SiS/XGI display support"
2269 -       depends on FB && PCI
2270 +       depends on FB && PCI && !VGA_NOPROBE
2271         select FB_CFB_FILLRECT
2272         select FB_CFB_COPYAREA
2273         select FB_CFB_IMAGEBLIT
2274 @@ -1822,6 +1822,15 @@ config FB_PS3_DEFAULT_SIZE_M
2275           The default value can be overridden on the kernel command line
2276           using the "ps3fb" option (e.g. "ps3fb=9M");
2277
2278 +config FB_OLPC_DCON
2279 +       tristate "One Laptop Per Child Display CONtroller support"
2280 +       depends on OLPC
2281 +       select I2C
2282 +       ---help---
2283 +         Add support for the OLPC DCON controller.  This controller is only
2284 +         available on OLPC platforms.   Unless you have one of these
2285 +         platforms, you will want to say 'N'.
2286 +
2287  config FB_XILINX
2288         tristate "Xilinx frame buffer support"
2289         depends on FB && XILINX_VIRTEX
2290 Index: linux-2.6.23.17/drivers/video/Makefile
2291 ===================================================================
2292 --- linux-2.6.23.17.orig/drivers/video/Makefile
2293 +++ linux-2.6.23.17/drivers/video/Makefile
2294 @@ -111,6 +111,7 @@ obj-$(CONFIG_FB_PNX4008_DUM_RGB)  += pnx
2295  obj-$(CONFIG_FB_IBM_GXT4500)     += gxt4500.o
2296  obj-$(CONFIG_FB_PS3)             += ps3fb.o
2297  obj-$(CONFIG_FB_SM501)            += sm501fb.o
2298 +obj-$(CONFIG_FB_OLPC_DCON)       += olpc_dcon.o
2299  obj-$(CONFIG_FB_XILINX)           += xilinxfb.o
2300  obj-$(CONFIG_FB_OMAP)             += omap/
2301
2302 Index: linux-2.6.23.17/drivers/video/fbmem.c
2303 ===================================================================
2304 --- linux-2.6.23.17.orig/drivers/video/fbmem.c
2305 +++ linux-2.6.23.17/drivers/video/fbmem.c
2306 @@ -820,6 +820,53 @@ static void try_to_load(int fb)
2307  #endif /* CONFIG_KMOD */
2308
2309  int
2310 +fb_powerup(struct fb_info *info)
2311 +{
2312 +       int ret = 0;
2313 +
2314 +       if (!info || info->state == FBINFO_STATE_RUNNING)
2315 +               return 0;
2316 +
2317 +       if (info->fbops->fb_powerup)
2318 +               ret = info->fbops->fb_powerup(info);
2319 +
2320 +       if (!ret) {
2321 +               acquire_console_sem();
2322 +               fb_set_suspend(info, 0);
2323 +               release_console_sem();
2324 +       }
2325 +
2326 +       return ret;
2327 +}
2328 +
2329 +int
2330 +fb_powerdown(struct fb_info *info)
2331 +{
2332 +       int ret = 0;
2333 +
2334 +       if (!info || info->state == FBINFO_STATE_SUSPENDED)
2335 +               return 0;
2336 +
2337 +       /* Tell everybody that the fbdev is going down */
2338 +       acquire_console_sem();
2339 +       fb_set_suspend(info, 1);
2340 +       release_console_sem();
2341 +
2342 +       if (info->fbops->fb_powerdown)
2343 +               ret = info->fbops->fb_powerdown(info);
2344 +
2345 +       /* If the power down failed, then un-notify */
2346 +
2347 +       if (ret) {
2348 +               acquire_console_sem();
2349 +               fb_set_suspend(info, 0);
2350 +               release_console_sem();
2351 +       }
2352 +
2353 +       return ret;
2354 +}
2355 +
2356 +int
2357  fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
2358  {
2359         struct fb_fix_screeninfo *fix = &info->fix;
2360 Index: linux-2.6.23.17/drivers/video/geode/Makefile
2361 ===================================================================
2362 --- linux-2.6.23.17.orig/drivers/video/geode/Makefile
2363 +++ linux-2.6.23.17/drivers/video/geode/Makefile
2364 @@ -5,5 +5,5 @@ obj-$(CONFIG_FB_GEODE_GX)  += gxfb.o
2365  obj-$(CONFIG_FB_GEODE_LX)  += lxfb.o
2366
2367  gx1fb-objs := gx1fb_core.o display_gx1.o video_cs5530.o
2368 -gxfb-objs  := gxfb_core.o display_gx.o video_gx.o
2369 +gxfb-objs  := gxfb_core.o display_gx.o video_gx.o suspend_gx.o
2370  lxfb-objs  := lxfb_core.o lxfb_ops.o
2371 Index: linux-2.6.23.17/drivers/video/geode/display_gx.c
2372 ===================================================================
2373 --- linux-2.6.23.17.orig/drivers/video/geode/display_gx.c
2374 +++ linux-2.6.23.17/drivers/video/geode/display_gx.c
2375 @@ -11,26 +11,44 @@
2376   *   Free Software Foundation; either version 2 of the License, or * (at your
2377   *   option) any later version.
2378   */
2379 +
2380 +#include <linux/kernel.h>
2381  #include <linux/spinlock.h>
2382  #include <linux/fb.h>
2383  #include <linux/delay.h>
2384  #include <asm/io.h>
2385  #include <asm/div64.h>
2386  #include <asm/delay.h>
2387 +#include <asm/olpc.h>
2388
2389  #include "geodefb.h"
2390  #include "display_gx.h"
2391
2392 -#ifdef CONFIG_FB_GEODE_GX_SET_FBSIZE
2393 -unsigned int gx_frame_buffer_size(void)
2394 +static inline void rmwl(u32 val, u32 *reg)
2395  {
2396 -       return CONFIG_FB_GEODE_GX_FBSIZE;
2397 +       u32 in = readl(reg);
2398 +       if (in != val)
2399 +               writel(val, reg);
2400  }
2401 -#else
2402 +
2403  unsigned int gx_frame_buffer_size(void)
2404  {
2405         unsigned int val;
2406
2407 +#ifdef CONFIG_OLPC
2408 +       if (machine_is_olpc() && !olpc_has_vsa()) {
2409 +               u32 hi,lo;
2410 +               rdmsr(GLIU0_P2D_RO0, lo, hi);
2411 +
2412 +               /* Top page number */
2413 +               val = ((hi & 0xff) << 12) | ((lo & 0xfff00000) >> 20);
2414 +
2415 +               val -= (lo & 0x000fffff); /* Subtract bottom page number */
2416 +               val += 1;                 /* Adjust page count */
2417 +               return (val << 12);
2418 +       }
2419 +#endif
2420 +
2421         /* FB size is reported by a virtual register */
2422         /* Virtual register class = 0x02 */
2423         /* VG_MEM_SIZE(512Kb units) = 0x00 */
2424 @@ -41,7 +59,6 @@ unsigned int gx_frame_buffer_size(void)
2425         val = (unsigned int)(inw(0xAC1E)) & 0xFFl;
2426         return (val << 19);
2427  }
2428 -#endif
2429
2430  int gx_line_delta(int xres, int bpp)
2431  {
2432 @@ -63,23 +80,23 @@ static void gx_set_mode(struct fb_info *
2433         gcfg = readl(par->dc_regs + DC_GENERAL_CFG);
2434         dcfg = readl(par->dc_regs + DC_DISPLAY_CFG);
2435
2436 -       /* Disable the timing generator. */
2437 -       dcfg &= ~(DC_DCFG_TGEN);
2438 -       writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
2439 -
2440 -       /* Wait for pending memory requests before disabling the FIFO load. */
2441 -       udelay(100);
2442 -
2443 -       /* Disable FIFO load and compression. */
2444 -       gcfg &= ~(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
2445 -       writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
2446 -
2447 -       /* Setup DCLK and its divisor. */
2448 -       par->vid_ops->set_dclk(info);
2449 -
2450 -       /*
2451 -        * Setup new mode.
2452 -        */
2453 +       /* Programming the clock is costly and ugly, so avoid if if we can */
2454 +
2455 +       if (par->curdclk != info->var.pixclock) {
2456 +               /* Disable the timing generator. */
2457 +               dcfg &= ~(DC_DCFG_TGEN);
2458 +               writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
2459 +
2460 +               /* Wait for pending memory requests before disabling the FIFO load. */
2461 +               udelay(100);
2462 +
2463 +               /* Disable FIFO load and compression. */
2464 +               gcfg &= ~(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
2465 +               writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
2466 +
2467 +               /* Setup DCLK and its divisor. */
2468 +               par->vid_ops->set_dclk(info);
2469 +       }
2470
2471         /* Clear all unused feature bits. */
2472         gcfg &= DC_GCFG_YUVM | DC_GCFG_VDSE;
2473 @@ -90,12 +107,13 @@ static void gx_set_mode(struct fb_info *
2474         gcfg |= (6 << DC_GCFG_DFHPEL_POS) | (5 << DC_GCFG_DFHPSL_POS) | DC_GCFG_DFLE;
2475
2476         /* Framebuffer start offset. */
2477 -       writel(0, par->dc_regs + DC_FB_ST_OFFSET);
2478 +       rmwl(0, par->dc_regs + DC_FB_ST_OFFSET);
2479
2480         /* Line delta and line buffer length. */
2481 -       writel(info->fix.line_length >> 3, par->dc_regs + DC_GFX_PITCH);
2482 -       writel(((info->var.xres * info->var.bits_per_pixel/8) >> 3) + 2,
2483 -              par->dc_regs + DC_LINE_SIZE);
2484 +       rmwl(info->fix.line_length >> 3, par->dc_regs + DC_GFX_PITCH);
2485 +
2486 +       rmwl(((info->var.xres * info->var.bits_per_pixel/8) >> 3) + 2,
2487 +            par->dc_regs + DC_LINE_SIZE);
2488
2489
2490         /* Enable graphics and video data and unmask address lines. */
2491 @@ -134,17 +152,16 @@ static void gx_set_mode(struct fb_info *
2492         vblankend = vsyncend + info->var.upper_margin;
2493         vtotal = vblankend;
2494
2495 -       writel((hactive - 1)     | ((htotal - 1) << 16),    par->dc_regs + DC_H_ACTIVE_TIMING);
2496 -       writel((hblankstart - 1) | ((hblankend - 1) << 16), par->dc_regs + DC_H_BLANK_TIMING);
2497 -       writel((hsyncstart - 1)  | ((hsyncend - 1) << 16),  par->dc_regs + DC_H_SYNC_TIMING);
2498 -
2499 -       writel((vactive - 1)     | ((vtotal - 1) << 16),    par->dc_regs + DC_V_ACTIVE_TIMING);
2500 -       writel((vblankstart - 1) | ((vblankend - 1) << 16), par->dc_regs + DC_V_BLANK_TIMING);
2501 -       writel((vsyncstart - 1)  | ((vsyncend - 1) << 16),  par->dc_regs + DC_V_SYNC_TIMING);
2502 +       rmwl((hactive - 1)     | ((htotal - 1) << 16),    par->dc_regs + DC_H_ACTIVE_TIMING);
2503 +       rmwl((hblankstart - 1) | ((hblankend - 1) << 16), par->dc_regs + DC_H_BLANK_TIMING);
2504 +       rmwl((hsyncstart - 1)  | ((hsyncend - 1) << 16),  par->dc_regs + DC_H_SYNC_TIMING);
2505 +       rmwl((vactive - 1)     | ((vtotal - 1) << 16),    par->dc_regs + DC_V_ACTIVE_TIMING);
2506 +       rmwl((vblankstart - 1) | ((vblankend - 1) << 16), par->dc_regs + DC_V_BLANK_TIMING);
2507 +       rmwl((vsyncstart - 1)  | ((vsyncend - 1) << 16),  par->dc_regs + DC_V_SYNC_TIMING);
2508
2509         /* Write final register values. */
2510 -       writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
2511 -       writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
2512 +       rmwl(dcfg, par->dc_regs + DC_DISPLAY_CFG);
2513 +       rmwl(gcfg, par->dc_regs + DC_GENERAL_CFG);
2514
2515         par->vid_ops->configure_display(info);
2516
2517 Index: linux-2.6.23.17/drivers/video/geode/display_gx.h
2518 ===================================================================
2519 --- linux-2.6.23.17.orig/drivers/video/geode/display_gx.h
2520 +++ linux-2.6.23.17/drivers/video/geode/display_gx.h
2521 @@ -20,6 +20,9 @@ extern struct geode_dc_ops gx_dc_ops;
2522  #define GLD_MSR_CONFIG   0xC0002001
2523  #define GLD_MSR_CONFIG_DM_FP 0x40
2524
2525 +/* Used for memory dection on the OLPC */
2526 +#define GLIU0_P2D_RO0 0x10000029
2527 +
2528  /* Display controller registers */
2529
2530  #define DC_UNLOCK 0x00
2531 Index: linux-2.6.23.17/drivers/video/geode/geodefb.h
2532 ===================================================================
2533 --- linux-2.6.23.17.orig/drivers/video/geode/geodefb.h
2534 +++ linux-2.6.23.17/drivers/video/geode/geodefb.h
2535 @@ -12,6 +12,10 @@
2536  #ifndef __GEODEFB_H__
2537  #define __GEODEFB_H__
2538
2539 +#define FB_POWER_STATE_OFF      0
2540 +#define FB_POWER_STATE_SUSPEND  1
2541 +#define FB_POWER_STATE_ON       2
2542 +
2543  struct geodefb_info;
2544
2545  struct geode_dc_ops {
2546 @@ -21,18 +25,24 @@ struct geode_dc_ops {
2547
2548  struct geode_vid_ops {
2549         void (*set_dclk)(struct fb_info *);
2550 +       unsigned int (*get_dclk)(struct fb_info *);
2551         void (*configure_display)(struct fb_info *);
2552         int  (*blank_display)(struct fb_info *, int blank_mode);
2553  };
2554
2555  struct geodefb_par {
2556         int enable_crt;
2557 +       int fbactive;  /* True if the current console is in KD_GRAPHICS mode */
2558         int panel_x; /* dimensions of an attached flat panel, non-zero => enable panel */
2559         int panel_y;
2560 +       unsigned int curdclk;  /* Used by GX to avoid unnessesary clock switching */
2561         void __iomem *dc_regs;
2562         void __iomem *vid_regs;
2563 +       void __iomem *gp_regs;
2564         struct geode_dc_ops  *dc_ops;
2565         struct geode_vid_ops *vid_ops;
2566 +
2567 +       int state;
2568  };
2569
2570  #endif /* !__GEODEFB_H__ */
2571 Index: linux-2.6.23.17/drivers/video/geode/gxfb_core.c
2572 ===================================================================
2573 --- linux-2.6.23.17.orig/drivers/video/geode/gxfb_core.c
2574 +++ linux-2.6.23.17/drivers/video/geode/gxfb_core.c
2575 @@ -30,12 +30,31 @@
2576  #include <linux/fb.h>
2577  #include <linux/init.h>
2578  #include <linux/pci.h>
2579 +#include <linux/notifier.h>
2580 +#include <linux/vt_kern.h>
2581 +#include <linux/console.h>
2582 +#include <asm/uaccess.h>
2583 +#include <asm/olpc.h>
2584
2585  #include "geodefb.h"
2586  #include "display_gx.h"
2587  #include "video_gx.h"
2588
2589 +#define FBIOSGAMMA             _IOW('F', 0x20, void *)
2590 +#define FBIOGGAMMA             _IOW('F', 0x21, void *)
2591 +
2592 +#ifdef DEBUG
2593 +
2594 +#define FBIODUMPGP             _IOW('F', 0x22, void *)
2595 +#define FBIODUMPDC             _IOW('F', 0x23, void *)
2596 +#define FBIODUMPVP             _IOW('F', 0x24, void *)
2597 +#define FBIODUMPFP             _IOW('F', 0x25, void *)
2598 +
2599 +#endif
2600 +
2601  static char *mode_option;
2602 +static int noclear;
2603 +struct fb_info *gxfb_info;
2604
2605  /* Modes relevant to the GX (taken from modedb.c) */
2606  static const struct fb_videomode gx_modedb[] __initdata = {
2607 @@ -103,8 +122,20 @@ static const struct fb_videomode gx_mode
2608         { NULL, 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3,
2609           FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
2610           FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
2611 +       /* 1200x900-75 - CRT timings for the OLPC mode */
2612 +       { NULL, 75, 1200, 900, 8049, 104, 240, 29, 54, 136, 3,
2613 +         0, FB_VMODE_NONINTERLACED, 0 }
2614  };
2615
2616 +#ifdef CONFIG_OLPC
2617 +static const struct fb_videomode gx_dcon_modedb[] __initdata = {
2618 +       /* The only mode the DCON has is 1200x900 */
2619 +       { NULL, 50, 1200, 900, 17460, 24, 8, 4, 5, 8, 3,
2620 +         0, FB_VMODE_NONINTERLACED, 0 }
2621 +};
2622 +#endif
2623 +
2624 +
2625  static int gxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
2626  {
2627         if (var->xres > 1600 || var->yres > 1200)
2628 @@ -137,7 +168,7 @@ static int gxfb_check_var(struct fb_var_
2629         return 0;
2630  }
2631
2632 -static int gxfb_set_par(struct fb_info *info)
2633 +int gxfb_set_par(struct fb_info *info)
2634  {
2635         struct geodefb_par *par = info->par;
2636
2637 @@ -204,16 +235,26 @@ static int gxfb_blank(int blank_mode, st
2638         return par->vid_ops->blank_display(info, blank_mode);
2639  }
2640
2641 +static int fbsize;
2642 +
2643  static int __init gxfb_map_video_memory(struct fb_info *info, struct pci_dev *dev)
2644  {
2645         struct geodefb_par *par = info->par;
2646 -       int fb_len;
2647         int ret;
2648
2649         ret = pci_enable_device(dev);
2650         if (ret < 0)
2651                 return ret;
2652
2653 +       ret = pci_request_region(dev, 1, "gxfb (graphics processor)");
2654 +       if (ret < 0)
2655 +               return ret;
2656 +
2657 +       par->gp_regs = ioremap(pci_resource_start(dev, 1),
2658 +                               pci_resource_len(dev, 1));
2659 +       if (!par->gp_regs)
2660 +               return -ENOMEM;
2661 +
2662         ret = pci_request_region(dev, 3, "gxfb (video processor)");
2663         if (ret < 0)
2664                 return ret;
2665 @@ -232,36 +273,118 @@ static int __init gxfb_map_video_memory(
2666         ret = pci_request_region(dev, 0, "gxfb (framebuffer)");
2667         if (ret < 0)
2668                 return ret;
2669 -       if ((fb_len = gx_frame_buffer_size()) < 0)
2670 -               return -ENOMEM;
2671 +
2672 +       /* If the fbsize wasn't specified then try to probe it */
2673 +
2674 +       if (!fbsize) {
2675 +               fbsize = gx_frame_buffer_size();
2676 +               if (fbsize == 0)
2677 +                       return -ENOMEM;
2678 +       }
2679 +
2680         info->fix.smem_start = pci_resource_start(dev, 0);
2681 -       info->fix.smem_len = fb_len;
2682 +       info->fix.smem_len = fbsize;
2683         info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
2684         if (!info->screen_base)
2685                 return -ENOMEM;
2686
2687 -       /* Set the 16MB aligned base address of the graphics memory region
2688 +       /* Set the 16MiB aligned base address of the graphics memory region
2689          * in the display controller */
2690
2691         writel(info->fix.smem_start & 0xFF000000,
2692                         par->dc_regs + DC_GLIU0_MEM_OFFSET);
2693
2694 -       dev_info(&dev->dev, "%d Kibyte of video memory at 0x%lx\n",
2695 +       dev_info(&dev->dev, "%d KiB of video memory at 0x%lx\n",
2696                  info->fix.smem_len / 1024, info->fix.smem_start);
2697
2698         return 0;
2699  }
2700
2701 +static int gxfb_ioctl( struct fb_info *info, unsigned int cmd,
2702 +                      unsigned long arg)
2703 +{
2704 +       unsigned int gamma[GXFB_GAMMA_DWORDS];
2705 +       int ret = -EINVAL;
2706 +       struct geodefb_par *par = info->par;
2707 +       int i;
2708 +
2709 +       switch(cmd) {
2710 +       case FBIOSGAMMA:
2711 +               /* Read the gamma information from the user - 256 dwords */
2712 +
2713 +               if (copy_from_user(gamma, (void * __user) arg, GXFB_GAMMA_SIZE))
2714 +                       return -EFAULT;
2715 +
2716 +               writel(0, par->vid_regs + GX_GAR);
2717 +
2718 +               /* Sequential writes to the data register will increment the
2719 +                  address automatically  */
2720 +
2721 +               for(i = 0; i < GXFB_GAMMA_DWORDS; i++)
2722 +                       writel(gamma[i] & 0xFFFFFF, par->vid_regs + GX_GDR);
2723 +
2724 +               writel(readl(par->vid_regs + GX_MISC) & ~GX_MISC_GAM_EN,
2725 +                      par->vid_regs + GX_MISC);
2726 +
2727 +               ret = 0;
2728 +               break;
2729 +
2730 +       case FBIOGGAMMA:
2731 +               if (readl(par->vid_regs + GX_MISC) & GX_MISC_GAM_EN)
2732 +                       return -EINVAL;
2733 +
2734 +               memset(gamma, 0, GXFB_GAMMA_SIZE);
2735 +               writel(0, par->vid_regs + GX_GAR);
2736 +
2737 +               for(i = 0; i < GXFB_GAMMA_DWORDS;i++)
2738 +                       gamma[i] = readl(par->vid_regs + GX_GDR);
2739 +
2740 +               if (copy_to_user((void * __user) arg, gamma, GXFB_GAMMA_SIZE))
2741 +                       ret = -EFAULT;
2742 +               else
2743 +                       ret = 0;
2744 +
2745 +               break;
2746 +
2747 +#ifdef DEBUG
2748 +       case FBIODUMPGP:
2749 +               ret = 0;
2750 +               dump_regs(info, 0);
2751 +               break;
2752 +
2753 +       case FBIODUMPDC:
2754 +               ret = 0;
2755 +               dump_regs(info, 1);
2756 +               break;
2757 +
2758 +       case FBIODUMPVP:
2759 +               ret = 0;
2760 +               dump_regs(info, 2);
2761 +               break;
2762 +
2763 +       case FBIODUMPFP:
2764 +               ret = 0;
2765 +               dump_regs(info, 3);
2766 +               break;
2767 +#endif
2768 +       }
2769 +
2770 +       return ret;
2771 +}
2772 +
2773  static struct fb_ops gxfb_ops = {
2774         .owner          = THIS_MODULE,
2775         .fb_check_var   = gxfb_check_var,
2776         .fb_set_par     = gxfb_set_par,
2777         .fb_setcolreg   = gxfb_setcolreg,
2778         .fb_blank       = gxfb_blank,
2779 +       .fb_ioctl       = gxfb_ioctl,
2780         /* No HW acceleration for now. */
2781         .fb_fillrect    = cfb_fillrect,
2782         .fb_copyarea    = cfb_copyarea,
2783         .fb_imageblit   = cfb_imageblit,
2784 +       .fb_powerdown   = gxfb_powerdown,
2785 +       .fb_powerup     = gxfb_powerup,
2786  };
2787
2788  static struct fb_info * __init gxfb_init_fbinfo(struct device *dev)
2789 @@ -303,23 +426,86 @@ static struct fb_info * __init gxfb_init
2790         return info;
2791  }
2792
2793 -static int __init gxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2794 +static int gxfb_console_notify(struct notifier_block *self,
2795 +                               unsigned long action, void *data)
2796 +{
2797 +       if (gxfb_info != NULL) {
2798 +               struct geodefb_par *par = gxfb_info->par;
2799 +               par->fbactive = (action == CONSOLE_EVENT_SWITCH_TEXT) ? 0 : 1;
2800 +       }
2801 +
2802 +       return NOTIFY_OK;
2803 +}
2804 +
2805 +static struct notifier_block gxfb_console_notifier = {
2806 +       .notifier_call = gxfb_console_notify
2807 +};
2808 +
2809 +#ifdef CONFIG_PM
2810 +
2811 +static int gxfb_suspend(struct pci_dev *pdev,  pm_message_t state)
2812 +{
2813 +       struct fb_info *info = pci_get_drvdata(pdev);
2814 +       struct geodefb_par *par = info->par;
2815 +
2816 +       if (pdev->dev.power.power_state.event == state.event)
2817 +               return 0;
2818 +
2819 +       if (state.event == PM_EVENT_SUSPEND) {
2820 +
2821 +               acquire_console_sem();
2822 +               gxfb_powerdown(info);
2823 +
2824 +               par->state = FB_POWER_STATE_OFF;
2825 +               fb_set_suspend(info, 1);
2826 +
2827 +               release_console_sem();
2828 +       }
2829 +
2830 +       pdev->dev.power.power_state = state;
2831 +       return 0;
2832 +}
2833 +
2834 +static int gxfb_resume(struct pci_dev *pdev)
2835 +{
2836 +       struct fb_info *info = pci_get_drvdata(pdev);
2837 +
2838 +       acquire_console_sem();
2839 +
2840 +       /* Turn the engine completely on */
2841 +
2842 +       if (gxfb_powerup(info))
2843 +         printk(KERN_ERR "gxfb:  Powerup failed\n");
2844 +
2845 +       fb_set_suspend(info, 0);
2846 +       release_console_sem();
2847 +
2848 +       pdev->dev.power.power_state = PMSG_ON;
2849 +        return 0;
2850 +}
2851 +#endif
2852 +
2853 +static int __init gxfb_probe(struct pci_dev *pdev,
2854 +                            const struct pci_device_id *id)
2855  {
2856         struct geodefb_par *par;
2857 -       struct fb_info *info;
2858         int ret;
2859         unsigned long val;
2860
2861 -       info = gxfb_init_fbinfo(&pdev->dev);
2862 -       if (!info)
2863 +       struct fb_videomode *modedb_ptr;
2864 +       int modedb_size;
2865 +
2866 +       gxfb_info = gxfb_init_fbinfo(&pdev->dev);
2867 +       if (gxfb_info == NULL)
2868                 return -ENOMEM;
2869 -       par = info->par;
2870 +
2871 +       par = gxfb_info->par;
2872
2873         /* GX display controller and GX video device. */
2874         par->dc_ops  = &gx_dc_ops;
2875         par->vid_ops = &gx_vid_ops;
2876
2877 -       if ((ret = gxfb_map_video_memory(info, pdev)) < 0) {
2878 +       if ((ret = gxfb_map_video_memory(gxfb_info, pdev)) < 0) {
2879                 dev_err(&pdev->dev, "failed to map frame buffer or controller registers\n");
2880                 goto err;
2881         }
2882 @@ -333,32 +519,60 @@ static int __init gxfb_probe(struct pci_
2883         else
2884                 par->enable_crt = 1;
2885
2886 -       ret = fb_find_mode(&info->var, info, mode_option,
2887 -                          gx_modedb, ARRAY_SIZE(gx_modedb), NULL, 16);
2888 +       /* Get the current dotclock */
2889 +
2890 +       par->curdclk = (par->vid_ops->get_dclk) ? par->vid_ops->get_dclk(gxfb_info) : 0;
2891 +
2892 +       /* We need to determine a display mode right now, so we will
2893 +        * check to see if the DCON was previously detected by the BIOS
2894 +        * and use that to make our mode database decision.
2895 +        */
2896 +
2897 +       modedb_ptr = (struct fb_videomode *) gx_modedb;
2898 +       modedb_size = ARRAY_SIZE(gx_modedb);
2899 +
2900 +#ifdef CONFIG_OLPC
2901 +       if (olpc_has_dcon()) {
2902 +               modedb_ptr = (struct fb_videomode *) gx_dcon_modedb;
2903 +               modedb_size = ARRAY_SIZE(gx_dcon_modedb);
2904 +       }
2905 +#endif
2906 +
2907 +       ret = fb_find_mode(&gxfb_info->var, gxfb_info, mode_option,
2908 +                          modedb_ptr, modedb_size, NULL, 16);
2909 +
2910         if (ret == 0 || ret == 4) {
2911                 dev_err(&pdev->dev, "could not find valid video mode\n");
2912                 ret = -EINVAL;
2913                 goto err;
2914         }
2915
2916 +       /* Clear the screen of garbage, unless noclear was specified,
2917 +        * in which case we assume the user knows what he is doing */
2918 +
2919 +       if (!noclear)
2920 +               memset_io(gxfb_info->screen_base, 0, gxfb_info->fix.smem_len);
2921 +
2922 +       gxfb_check_var(&gxfb_info->var, gxfb_info);
2923 +       gxfb_set_par(gxfb_info);
2924 +
2925 +       /* We are powered up */
2926 +       par->state = FB_POWER_STATE_ON;
2927
2928 -       /* Clear the frame buffer of garbage. */
2929 -        memset_io(info->screen_base, 0, info->fix.smem_len);
2930
2931 -       gxfb_check_var(&info->var, info);
2932 -       gxfb_set_par(info);
2933 +       console_event_register(&gxfb_console_notifier);
2934
2935 -       if (register_framebuffer(info) < 0) {
2936 +       if (register_framebuffer(gxfb_info) < 0) {
2937                 ret = -EINVAL;
2938                 goto err;
2939         }
2940 -       pci_set_drvdata(pdev, info);
2941 -       printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
2942 +       pci_set_drvdata(pdev, gxfb_info);
2943 +       printk(KERN_INFO "fb%d: %s frame buffer device\n", gxfb_info->node, gxfb_info->fix.id);
2944         return 0;
2945
2946    err:
2947 -       if (info->screen_base) {
2948 -               iounmap(info->screen_base);
2949 +       if (gxfb_info->screen_base) {
2950 +               iounmap(gxfb_info->screen_base);
2951                 pci_release_region(pdev, 0);
2952         }
2953         if (par->vid_regs) {
2954 @@ -370,8 +584,9 @@ static int __init gxfb_probe(struct pci_
2955                 pci_release_region(pdev, 2);
2956         }
2957
2958 -       if (info)
2959 -               framebuffer_release(info);
2960 +       if (gxfb_info)
2961 +               framebuffer_release(gxfb_info);
2962 +
2963         return ret;
2964  }
2965
2966 @@ -397,9 +612,7 @@ static void gxfb_remove(struct pci_dev *
2967  }
2968
2969  static struct pci_device_id gxfb_id_table[] = {
2970 -       { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_GX_VIDEO,
2971 -         PCI_ANY_ID, PCI_ANY_ID, PCI_BASE_CLASS_DISPLAY << 16,
2972 -         0xff0000, 0 },
2973 +       { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_GX_VIDEO) },
2974         { 0, }
2975  };
2976
2977 @@ -410,22 +623,30 @@ static struct pci_driver gxfb_driver = {
2978         .id_table       = gxfb_id_table,
2979         .probe          = gxfb_probe,
2980         .remove         = gxfb_remove,
2981 +#ifdef CONFIG_PM
2982 +       .suspend        = gxfb_suspend,
2983 +       .resume         = gxfb_resume
2984 +#endif
2985  };
2986
2987  #ifndef MODULE
2988 -static int __init gxfb_setup(char *options)
2989 -{
2990 +static int __init gxfb_setup(char *options) {
2991
2992         char *opt;
2993
2994         if (!options || !*options)
2995                 return 0;
2996
2997 -       while ((opt = strsep(&options, ",")) != NULL) {
2998 +       while((opt = strsep(&options, ",")) != NULL) {
2999                 if (!*opt)
3000                         continue;
3001
3002 -               mode_option = opt;
3003 +               if (!strncmp(opt, "fbsize:", 7))
3004 +                       fbsize = simple_strtoul(opt+7, NULL, 0);
3005 +               else if (!strcmp(opt, "noclear"))
3006 +                       noclear = 1;
3007 +               else
3008 +                       mode_option = opt;
3009         }
3010
3011         return 0;
3012 @@ -444,7 +665,6 @@ static int __init gxfb_init(void)
3013  #endif
3014         return pci_register_driver(&gxfb_driver);
3015  }
3016 -
3017  static void __exit gxfb_cleanup(void)
3018  {
3019         pci_unregister_driver(&gxfb_driver);
3020 @@ -456,5 +676,8 @@ module_exit(gxfb_cleanup);
3021  module_param(mode_option, charp, 0);
3022  MODULE_PARM_DESC(mode_option, "video mode (<x>x<y>[-<bpp>][@<refr>])");
3023
3024 +module_param(fbsize, int, 0);
3025 +MODULE_PARM_DESC(fbsize, "video memory size");
3026 +
3027  MODULE_DESCRIPTION("Framebuffer driver for the AMD Geode GX");
3028  MODULE_LICENSE("GPL");
3029 Index: linux-2.6.23.17/drivers/video/geode/lxfb.h
3030 ===================================================================
3031 --- linux-2.6.23.17.orig/drivers/video/geode/lxfb.h
3032 +++ linux-2.6.23.17/drivers/video/geode/lxfb.h
3033 @@ -25,10 +25,23 @@ void lx_set_mode(struct fb_info *);
3034  void lx_get_gamma(struct fb_info *, unsigned int *, int);
3035  void lx_set_gamma(struct fb_info *, unsigned int *, int);
3036  unsigned int lx_framebuffer_size(void);
3037 +int lx_shutdown(struct fb_info *);
3038 +int lx_powerup(struct fb_info *);
3039  int lx_blank_display(struct fb_info *, int);
3040  void lx_set_palette_reg(struct fb_info *, unsigned int, unsigned int,
3041                         unsigned int, unsigned int);
3042
3043 +
3044 +
3045 +/* ioctl() defines */
3046 +
3047 +#define FBIOSGAMMA              _IOW('F', 0x20, void *)
3048 +#define FBIOGGAMMA              _IOW('F', 0x21, void *)
3049 +
3050 +/* General definitions */
3051 +#define LXFB_GAMMA_DWORDS 256 /* number of dwords in the gamma ram */
3052 +#define LXFB_GAMMA_SIZE (LXFB_GAMMA_DWORDS * sizeof(unsigned int))
3053 +
3054  /* MSRS */
3055
3056  #define MSR_LX_GLD_CONFIG    0x48002001
3057 Index: linux-2.6.23.17/drivers/video/geode/lxfb_core.c
3058 ===================================================================
3059 --- linux-2.6.23.17.orig/drivers/video/geode/lxfb_core.c
3060 +++ linux-2.6.23.17/drivers/video/geode/lxfb_core.c
3061 @@ -22,6 +22,7 @@
3062  #include <linux/init.h>
3063  #include <linux/pci.h>
3064  #include <linux/uaccess.h>
3065 +#include <asm/olpc.h>
3066
3067  #include "lxfb.h"
3068
3069 @@ -35,186 +36,84 @@ static int fbsize;
3070   */
3071
3072  const struct fb_videomode geode_modedb[] __initdata = {
3073 -       /* 640x480-60 */
3074 -       { NULL, 60, 640, 480, 39682, 48, 8, 25, 2, 88, 2,
3075 +       /* 640x480-60 VESA */
3076 +       { NULL, 60, 640, 480, 39682,  48, 16, 33, 10, 96, 2,
3077 +         0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3078 +       /* 640x480-75 VESA */
3079 +       { NULL, 75, 640, 480, 31746, 120, 16, 16, 01, 64, 3,
3080 +         0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3081 +       /* 640x480-85 VESA */
3082 +       { NULL, 85, 640, 480, 27777, 80, 56, 25, 01, 56, 3,
3083 +         0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3084 +       /* 800x600-60 VESA */
3085 +       { NULL, 60, 800, 600, 25000, 88, 40, 23, 01, 128, 4,
3086 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3087 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3088 +       /* 800x600-75 VESA */
3089 +       { NULL, 75, 800, 600, 20202, 160, 16, 21, 01, 80, 3,
3090 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3091 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3092 +       /* 800x600-85 VESA */
3093 +       { NULL, 85, 800, 600, 17761, 152, 32, 27, 01, 64, 3,
3094 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3095 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3096 +       /* 1024x768-60 VESA */
3097 +       { NULL, 60, 1024, 768, 15384, 160, 24, 29, 3, 136, 6,
3098 +         0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3099 +       /* 1024x768-75 VESA */
3100 +       { NULL, 75, 1024, 768, 12690, 176, 16, 28, 1, 96, 3,
3101 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3102 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3103 +       /* 1024x768-85 VESA */
3104 +       { NULL, 85, 1024, 768, 10582, 208, 48, 36, 1, 96, 3,
3105 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3106 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3107 +       /* 1280x960-60 VESA */
3108 +       { NULL, 60, 1280, 960, 9259, 312, 96, 36, 1, 112, 3,
3109 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3110 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3111 +       /* 1280x960-85 VESA */
3112 +       { NULL, 85, 1280, 960, 6734, 224, 64, 47, 1, 160, 3,
3113 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3114 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3115 +       /* 1280x1024-60 VESA */
3116 +       { NULL, 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3,
3117 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3118 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3119 +       /* 1280x1024-75 VESA */
3120 +       { NULL, 75, 1280, 1024, 7407, 248, 16, 38, 1, 144, 3,
3121 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3122 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3123 +       /* 1280x1024-85 VESA */
3124 +       { NULL, 85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3,
3125           FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3126 -         FB_VMODE_NONINTERLACED, 0 },
3127 -       /* 640x400-70 */
3128 -       { NULL, 70, 640, 400, 39770, 40, 8, 28, 5, 96, 2,
3129 -         FB_SYNC_HOR_HIGH_ACT,
3130 -         FB_VMODE_NONINTERLACED, 0 },
3131 -       /* 640x480-70 */
3132 -       { NULL, 70, 640, 480, 35014, 88, 24, 15, 2, 64, 3,
3133 -         0, FB_VMODE_NONINTERLACED, 0 },
3134 -       /* 640x480-72 */
3135 -       { NULL, 72, 640, 480, 32102, 120, 16, 20, 1, 40, 3,
3136 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3137 -         FB_VMODE_NONINTERLACED, 0 },
3138 -       /* 640x480-75 */
3139 -       { NULL, 75, 640, 480, 31746, 120, 16, 16, 1, 64, 3,
3140 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3141 -         FB_VMODE_NONINTERLACED, 0 },
3142 -       /* 640x480-85 */
3143 -       { NULL, 85, 640, 480, 27780, 80, 56, 25, 1, 56, 3,
3144 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3145 -         FB_VMODE_NONINTERLACED, 0 },
3146 -       /* 640x480-90 */
3147 -       { NULL, 90, 640, 480, 26392, 96, 32, 22, 1, 64, 3,
3148 -         0, FB_VMODE_NONINTERLACED, 0 },
3149 -       /* 640x480-100 */
3150 -       { NULL, 100, 640, 480, 23167, 104, 40, 25, 1, 64, 3,
3151 -         0, FB_VMODE_NONINTERLACED, 0 },
3152 -       /* 640x480-60 */
3153 -       { NULL, 60, 640, 480, 39682, 48, 16, 25, 10, 88, 2,
3154 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3155 -         FB_VMODE_NONINTERLACED, 0 },
3156 -       /* 800x600-56 */
3157 -       { NULL, 56, 800, 600, 27901, 128, 24, 22, 1, 72, 2,
3158 -         0, FB_VMODE_NONINTERLACED, 0 },
3159 -       /* 800x600-60 */
3160 -       { NULL, 60, 800, 600, 25131, 72, 32, 23, 1, 136, 4,
3161 -         0, FB_VMODE_NONINTERLACED, 0 },
3162 -       /* 800x600-70 */
3163 -       { NULL, 70, 800, 600, 21873, 120, 40, 21, 4, 80, 3,
3164 -         0, FB_VMODE_NONINTERLACED, 0 },
3165 -       /* 800x600-72 */
3166 -       { NULL, 72, 800, 600, 20052, 64, 56, 23, 37, 120, 6,
3167 -         0, FB_VMODE_NONINTERLACED, 0 },
3168 -       /* 800x600-75 */
3169 -       { NULL, 75, 800, 600, 20202, 160, 16, 21, 1, 80, 3,
3170 -         0, FB_VMODE_NONINTERLACED, 0 },
3171 -       /* 800x600-85 */
3172 -       { NULL, 85, 800, 600, 17790, 152, 32, 27, 1, 64, 3,
3173 -         0, FB_VMODE_NONINTERLACED, 0 },
3174 -       /* 800x600-90 */
3175 -       { NULL, 90, 800, 600, 16648, 128, 40, 28, 1, 88, 3,
3176 -         0, FB_VMODE_NONINTERLACED, 0 },
3177 -       /* 800x600-100 */
3178 -       { NULL, 100, 800, 600, 14667, 136, 48, 27, 1, 88, 3,
3179 -         0, FB_VMODE_NONINTERLACED, 0 },
3180 -       /* 800x600-60 */
3181 -       { NULL, 60, 800, 600, 25131, 88, 40, 23, 1, 128, 4,
3182 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3183 -         FB_VMODE_NONINTERLACED, 0 },
3184 -       /* 1024x768-60 */
3185 -       { NULL, 60, 1024, 768, 15385, 160, 24, 29, 3, 136, 6,
3186 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3187 -         FB_VMODE_NONINTERLACED, 0 },
3188 -       /* 1024x768-70 */
3189 -       { NULL, 70, 1024, 768, 13346, 144, 24, 29, 3, 136, 6,
3190 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3191 -         FB_VMODE_NONINTERLACED, 0 },
3192 -       /* 1024x768-72 */
3193 -       { NULL, 72, 1024, 768, 12702, 168, 56, 29, 4, 112, 3,
3194 -         0, FB_VMODE_NONINTERLACED, 0 },
3195 -       /* 1024x768-75 */
3196 -       { NULL, 75, 1024, 768, 12703, 176, 16, 28, 1, 96, 3,
3197 -         0, FB_VMODE_NONINTERLACED, 0 },
3198 -       /* 1024x768-85 */
3199 -       { NULL, 85, 1024, 768, 10581, 208, 48, 36, 1, 96, 3,
3200 -         0, FB_VMODE_NONINTERLACED, 0 },
3201 -       /* 1024x768-90 */
3202 -       { NULL, 90, 1024, 768, 9981, 176, 64, 37, 1, 112, 3,
3203 -         0, FB_VMODE_NONINTERLACED, 0 },
3204 -       /* 1024x768-100 */
3205 -       { NULL, 100, 1024, 768, 8825, 184, 72, 42, 1, 112, 3,
3206 -         0, FB_VMODE_NONINTERLACED, 0 },
3207 -       /* 1024x768-60 */
3208 -       { NULL, 60, 1024, 768, 15385, 160, 24, 29, 3, 136, 6,
3209 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3210 -         FB_VMODE_NONINTERLACED, 0 },
3211 -       /* 1152x864-60 */
3212 -       { NULL, 60, 1152, 864, 12251, 184, 64, 27, 1, 120, 3,
3213 -         0, FB_VMODE_NONINTERLACED, 0 },
3214 -       /* 1152x864-70 */
3215 -       { NULL, 70, 1152, 864, 10254, 192, 72, 32, 8, 120, 3,
3216 -         0, FB_VMODE_NONINTERLACED, 0 },
3217 -       /* 1152x864-72 */
3218 -       { NULL, 72, 1152, 864, 9866, 200, 72, 33, 7, 128, 3,
3219 -         0, FB_VMODE_NONINTERLACED, 0 },
3220 -       /* 1152x864-75 */
3221 -       { NULL, 75, 1152, 864, 9259, 256, 64, 32, 1, 128, 3,
3222 -         0, FB_VMODE_NONINTERLACED, 0 },
3223 -       /* 1152x864-85 */
3224 -       { NULL, 85, 1152, 864, 8357, 200, 72, 37, 3, 128, 3,
3225 -         0, FB_VMODE_NONINTERLACED, 0 },
3226 -       /* 1152x864-90 */
3227 -       { NULL, 90, 1152, 864, 7719, 208, 80, 42, 9, 128, 3,
3228 -         0, FB_VMODE_NONINTERLACED, 0 },
3229 -       /* 1152x864-100 */
3230 -       { NULL, 100, 1152, 864, 6947, 208, 80, 48, 3, 128, 3,
3231 -         0, FB_VMODE_NONINTERLACED, 0 },
3232 -       /* 1152x864-60 */
3233 -       { NULL, 60, 1152, 864, 12251, 184, 64, 27, 1, 120, 3,
3234 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3235 -         FB_VMODE_NONINTERLACED, 0 },
3236 -       /* 1280x1024-60 */
3237 -       { NULL, 60, 1280, 1024, 9262, 248, 48, 38, 1, 112, 3,
3238 -         0, FB_VMODE_NONINTERLACED, 0 },
3239 -       /* 1280x1024-70 */
3240 -       { NULL, 70, 1280, 1024, 7719, 224, 88, 38, 6, 136, 3,
3241 -         0, FB_VMODE_NONINTERLACED, 0 },
3242 -       /* 1280x1024-72 */
3243 -       { NULL, 72, 1280, 1024, 7490, 224, 88, 39, 7, 136, 3,
3244 -         0, FB_VMODE_NONINTERLACED, 0 },
3245 -       /* 1280x1024-75 */
3246 -       { NULL, 75, 1280, 1024, 7409, 248, 16, 38, 1, 144, 3,
3247 -         0, FB_VMODE_NONINTERLACED, 0 },
3248 -       /* 1280x1024-85 */
3249 -       { NULL, 85, 1280, 1024, 6351, 224, 64, 44, 1, 160, 3,
3250 -         0, FB_VMODE_NONINTERLACED, 0 },
3251 -       /* 1280x1024-90 */
3252 -       { NULL, 90, 1280, 1024, 5791, 240, 96, 51, 12, 144, 3,
3253 -         0, FB_VMODE_NONINTERLACED, 0 },
3254 -       /* 1280x1024-100 */
3255 -       { NULL, 100, 1280, 1024, 5212, 240, 96, 57, 6, 144, 3,
3256 -         0, FB_VMODE_NONINTERLACED, 0 },
3257 -       /* 1280x1024-60 */
3258 -       { NULL, 60, 1280, 1024, 9262, 248, 48, 38, 1, 112, 3,
3259 -         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3260 -         FB_VMODE_NONINTERLACED, 0 },
3261 -       /* 1600x1200-60 */
3262 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3263 +       /* 1600x1200-60 VESA */
3264         { NULL, 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
3265 -         0, FB_VMODE_NONINTERLACED, 0 },
3266 -       /* 1600x1200-70 */
3267 -       { NULL, 70, 1600, 1200, 5291, 304, 64, 46, 1, 192, 3,
3268 -         0, FB_VMODE_NONINTERLACED, 0 },
3269 -       /* 1600x1200-72 */
3270 -       { NULL, 72, 1600, 1200, 5053, 288, 112, 47, 13, 176, 3,
3271 -         0, FB_VMODE_NONINTERLACED, 0 },
3272 -       /* 1600x1200-75 */
3273 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3274 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3275 +       /* 1600x1200-75 VESA */
3276         { NULL, 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
3277 -         0, FB_VMODE_NONINTERLACED, 0 },
3278 -       /* 1600x1200-85 */
3279 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3280 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3281 +       /* 1600x1200-85 VESA */
3282         { NULL, 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3,
3283 -         0, FB_VMODE_NONINTERLACED, 0 },
3284 -       /* 1600x1200-90 */
3285 -       { NULL, 90, 1600, 1200, 3981, 304, 128, 60, 1, 176, 3,
3286 -         0, FB_VMODE_NONINTERLACED, 0 },
3287 -       /* 1600x1200-100 */
3288 -       { NULL, 100, 1600, 1200, 3563, 304, 128, 67, 1, 176, 3,
3289 -         0, FB_VMODE_NONINTERLACED, 0 },
3290 -       /* 1600x1200-60 */
3291 -       { NULL, 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
3292           FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3293 -         FB_VMODE_NONINTERLACED, 0 },
3294 -       /* 1920x1440-60 */
3295 -       { NULL, 60, 1920, 1440, 4273, 344, 128, 56, 1, 208, 3,
3296 -         0, FB_VMODE_NONINTERLACED, 0 },
3297 -       /* 1920x1440-70 */
3298 -       { NULL, 70, 1920, 1440, 3593, 360, 152, 55, 8, 208, 3,
3299 -         0, FB_VMODE_NONINTERLACED, 0 },
3300 -       /* 1920x1440-72 */
3301 -       { NULL, 72, 1920, 1440, 3472, 360, 152, 68, 4, 208, 3,
3302 -         0, FB_VMODE_NONINTERLACED, 0 },
3303 -       /* 1920x1440-75 */
3304 -       { NULL, 75, 1920, 1440, 3367, 352, 144, 56, 1, 224, 3,
3305 -         0, FB_VMODE_NONINTERLACED, 0 },
3306 -       /* 1920x1440-85 */
3307 -       { NULL, 85, 1920, 1440, 2929, 368, 152, 68, 1, 216, 3,
3308 -         0, FB_VMODE_NONINTERLACED, 0 },
3309 +         FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
3310 +       /* 1200x900-75 - CRT timings for the OLPC mode */
3311 +       { NULL, 75, 1200, 900, 8049, 104, 240, 29, 54, 136, 3,
3312 +         0, FB_VMODE_NONINTERLACED, 0 }
3313  };
3314
3315 +#ifdef CONFIG_OLPC
3316 +const struct fb_videomode olpc_dcon_modedb[] __initdata = {
3317 +       /* The only mode the DCON has is 1200x900 */
3318 +       { NULL, 50, 1200, 900, 17460, 24, 8, 4, 5, 8, 3,
3319 +         FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
3320 +         FB_VMODE_NONINTERLACED, 0 }
3321 +};
3322 +#endif
3323 +
3324  static int lxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
3325  {
3326         if (var->xres > 1920 || var->yres > 1440)
3327 @@ -379,16 +278,55 @@ static int __init lxfb_map_video_memory(
3328         return 0;
3329  }
3330
3331 +static int lxfb_set_gamma(struct fb_info *info, void * __user data)
3332 +{
3333 +       unsigned int gamma[LXFB_GAMMA_DWORDS];
3334 +
3335 +       if (copy_from_user(gamma, data, LXFB_GAMMA_SIZE))
3336 +               return -EFAULT;
3337 +
3338 +       lx_set_gamma(info, gamma, LXFB_GAMMA_SIZE);
3339 +       return 0;
3340 +}
3341 +
3342 +static int lxfb_get_gamma(struct fb_info *info, void * __user data)
3343 +{
3344 +       unsigned int gamma[LXFB_GAMMA_DWORDS];
3345 +       memset(gamma, 0, sizeof(gamma));
3346 +
3347 +       lx_get_gamma(info, gamma, LXFB_GAMMA_DWORDS);
3348 +
3349 +       return copy_to_user(data, gamma, LXFB_GAMMA_SIZE) ?
3350 +               -EFAULT : 0;
3351 +}
3352 +
3353 +static int lxfb_ioctl( struct fb_info *info, unsigned int cmd,
3354 +                      unsigned long arg)
3355 +{
3356 +       switch(cmd) {
3357 +       case FBIOSGAMMA:
3358 +               return lxfb_set_gamma(info, (void * __user) arg);
3359 +
3360 +       case FBIOGGAMMA:
3361 +               return lxfb_get_gamma(info, (void * __user) arg);
3362 +       }
3363 +
3364 +       return -ENOTTY;
3365 +}
3366 +
3367  static struct fb_ops lxfb_ops = {
3368         .owner          = THIS_MODULE,
3369         .fb_check_var   = lxfb_check_var,
3370         .fb_set_par     = lxfb_set_par,
3371         .fb_setcolreg   = lxfb_setcolreg,
3372         .fb_blank       = lxfb_blank,
3373 +       .fb_ioctl       = lxfb_ioctl,
3374         /* No HW acceleration for now. */
3375         .fb_fillrect    = cfb_fillrect,
3376         .fb_copyarea    = cfb_copyarea,
3377         .fb_imageblit   = cfb_imageblit,
3378 +       .fb_powerdown   = lx_shutdown,
3379 +       .fb_powerup     = lx_powerup,
3380  };
3381
3382  static struct fb_info * __init lxfb_init_fbinfo(struct device *dev)
3383 @@ -431,6 +369,45 @@ static struct fb_info * __init lxfb_init
3384         return info;
3385  }
3386
3387 +#ifdef CONFIG_PM
3388 +
3389 +static int lxfb_suspend(struct pci_dev *pdev,  pm_message_t state)
3390 +{
3391 +       struct fb_info *info = pci_get_drvdata(pdev);
3392 +
3393 +       if (pdev->dev.power.power_state.event == state.event)
3394 +               return 0;
3395 +
3396 +       if (state.event == PM_EVENT_SUSPEND) {
3397 +
3398 +               acquire_console_sem();
3399 +               lx_shutdown(info);
3400 +               fb_set_suspend(info, 1);
3401 +               release_console_sem();
3402 +       }
3403 +
3404 +       pdev->dev.power.power_state = state;
3405 +       return 0;
3406 +}
3407 +
3408 +static int lxfb_resume(struct pci_dev *pdev)
3409 +{
3410 +       struct fb_info *info = pci_get_drvdata(pdev);
3411 +
3412 +       acquire_console_sem();
3413 +
3414 +       /* Turn the engine completely on */
3415 +
3416 +       lx_powerup(info);
3417 +       fb_set_suspend(info, 0);
3418 +       release_console_sem();
3419 +
3420 +       pdev->dev.power.power_state = PMSG_ON;
3421 +        return 0;
3422 +}
3423 +
3424 +#endif
3425 +
3426  static int __init lxfb_probe(struct pci_dev *pdev,
3427                              const struct pci_device_id *id)
3428  {
3429 @@ -467,6 +444,13 @@ static int __init lxfb_probe(struct pci_
3430         modedb_ptr = (struct fb_videomode *) geode_modedb;
3431         modedb_size = ARRAY_SIZE(geode_modedb);
3432
3433 +#ifdef CONFIG_OLPC
3434 +       if (olpc_has_dcon()) {
3435 +               modedb_ptr = (struct fb_videomode *) olpc_dcon_modedb;
3436 +               modedb_size = ARRAY_SIZE(olpc_dcon_modedb);
3437 +       }
3438 +#endif
3439 +
3440         ret = fb_find_mode(&info->var, info, mode_option,
3441                            modedb_ptr, modedb_size, NULL, 16);
3442
3443 @@ -556,6 +540,10 @@ static struct pci_driver lxfb_driver = {
3444         .id_table       = lxfb_id_table,
3445         .probe          = lxfb_probe,
3446         .remove         = lxfb_remove,
3447 +#ifdef CONFIG_PM
3448 +       .suspend        = lxfb_suspend,
3449 +       .resume         = lxfb_resume
3450 +#endif
3451  };
3452
3453  #ifndef MODULE
3454 Index: linux-2.6.23.17/drivers/video/geode/lxfb_ops.c
3455 ===================================================================
3456 --- linux-2.6.23.17.orig/drivers/video/geode/lxfb_ops.c
3457 +++ linux-2.6.23.17/drivers/video/geode/lxfb_ops.c
3458 @@ -13,9 +13,13 @@
3459  #include <linux/fb.h>
3460  #include <linux/uaccess.h>
3461  #include <linux/delay.h>
3462 +#include <asm/olpc.h>
3463
3464  #include "lxfb.h"
3465
3466 +#define _GEODELX_
3467 +#include "geode_regs.h"
3468 +
3469  /* TODO
3470   * Support panel scaling
3471   * Add acceleration
3472 @@ -290,6 +294,19 @@ unsigned int lx_framebuffer_size(void)
3473  {
3474         unsigned int val;
3475
3476 +#ifdef CONFIG_OLPC
3477 +        if (machine_is_olpc() && !olpc_has_vsa()) {
3478 +               u32 hi,lo;
3479 +               rdmsr(MSR_LX_GLIU0_P2D_RO0, lo, hi);
3480 +
3481 +               /* Top page number */
3482 +               val = ((hi & 0xff) << 12) | ((lo & 0xfff00000) >> 20);
3483 +               val -= (lo & 0x000fffff); /* Subtract bottom page number */
3484 +               val += 1;                 /* Adjust page count */
3485 +               return (val << 12);
3486 +       }
3487 +#endif
3488 +
3489         /* The frame buffer size is reported by a VSM in VSA II */
3490         /* Virtual Register Class    = 0x02                     */
3491         /* VG_MEM_SIZE (1MB units)   = 0x00                     */
3492 @@ -301,6 +318,34 @@ unsigned int lx_framebuffer_size(void)
3493         return (val << 20);
3494  }
3495
3496 +void lx_set_gamma(struct fb_info *info, unsigned int *gamma, int len)
3497 +{
3498 +       int i;
3499 +       struct lxfb_par *par = info->par;
3500 +
3501 +       writel(0, par->df_regs + DF_PAR);
3502 +
3503 +       /* Sequential writes to the data register will increment the
3504 +          address automatically  */
3505 +
3506 +       for(i = 0; i < len; i++)
3507 +               writel(gamma[i] & 0xFFFFFF, par->df_regs + DF_PDR);
3508 +
3509 +       writel(readl(par->df_regs + DF_MISC) & ~DF_MISC_GAM_BYPASS,
3510 +              par->df_regs + DF_MISC);
3511 +}
3512 +
3513 +void lx_get_gamma(struct fb_info *info, unsigned int *gamma, int len)
3514 +{
3515 +       int i;
3516 +       struct lxfb_par *par = info->par;
3517 +
3518 +       writel(0, par->df_regs + DF_PAR);
3519 +
3520 +       for(i = 0; i < len;i++)
3521 +               gamma[i] = readl(par->df_regs + DF_PDR);
3522 +}
3523 +
3524  void lx_set_mode(struct fb_info *info)
3525  {
3526         struct lxfb_par *par = info->par;
3527 @@ -313,6 +358,7 @@ void lx_set_mode(struct fb_info *info)
3528         int vactive, vblankstart, vsyncstart, vsyncend, vblankend, vtotal;
3529
3530         /* Unlock the DC registers */
3531 +       readl(par->dc_regs + DC_UNLOCK);
3532         writel(DC_UNLOCK_CODE, par->dc_regs + DC_UNLOCK);
3533
3534         lx_graphics_disable(info);
3535 @@ -534,3 +580,285 @@ int lx_blank_display(struct fb_info *inf
3536
3537         return 0;
3538  }
3539 +
3540 +static struct geoderegs saved_regs;
3541 +
3542 +static void lx_save_regs(struct fb_info *info, struct geoderegs *regs)
3543 +{
3544 +       struct lxfb_par *par = info->par;
3545 +       int i;
3546 +
3547 +       /* Wait for the command buffer to empty */
3548 +       while(!(readl(par->gp_regs + 0x44) & (1 << 4)));
3549 +
3550 +       rdmsrl(MSR_LX_DF_PADSEL, regs->msr.padsel);
3551 +       rdmsrl(MSR_LX_GLCP_DOTPLL, regs->msr.dotpll);
3552 +       rdmsrl(MSR_LX_DF_GLCONFIG, regs->msr.dfglcfg);
3553 +       rdmsrl(MSR_LX_DC_SPARE, regs->msr.dcspare);
3554 +
3555 +       writel(0x4758, par->dc_regs + 0x00);
3556 +
3557 +       memcpy(regs->gp.b, par->gp_regs, GP_REG_SIZE);
3558 +       memcpy(regs->dc.b, par->dc_regs, DC_REG_SIZE);
3559 +       memcpy(regs->vp.b, par->df_regs, VP_REG_SIZE);
3560 +       memcpy(regs->fp.b, par->df_regs + VP_FP_START, FP_REG_SIZE);
3561 +
3562 +       /* Save the palettes */
3563 +       writel(0, par->dc_regs + 0x70);
3564 +
3565 +       for(i = 0; i < DC_PAL_SIZE; i++)
3566 +               regs->pal[i] = readl(par->dc_regs + 0x74);
3567 +
3568 +       writel(0, par->df_regs + 0x38);
3569 +
3570 +       for(i = 0; i <= 0xFF; i++)
3571 +               regs->gamma[i] = readl(par->df_regs + 0x40);
3572 +}
3573 +
3574 +static void lx_restore_regs(struct fb_info *info, struct geoderegs *regs)
3575 +{
3576 +       struct lxfb_par *par = info->par;
3577 +       u32 val, i;
3578 +
3579 +       /* == DOTPLL == */
3580 +
3581 +       lx_set_dotpll((u32) (regs->msr.dotpll >> 32));
3582 +
3583 +       /* MSRs */
3584 +
3585 +       wrmsrl(MSR_LX_DF_GLCONFIG, regs->msr.dfglcfg);
3586 +
3587 +       /* == GP == */
3588 +
3589 +       writel(regs->gp.r.dst_offset, par->gp_regs + 0x00);
3590 +       writel(regs->gp.r.src_offset, par->gp_regs + 0x04);
3591 +       writel(regs->gp.r.stride, par->gp_regs + 0x08);
3592 +       writel(regs->gp.r.wid_height, par->gp_regs + 0x0C);
3593 +       writel(regs->gp.r.src_color_fg, par->gp_regs + 0x10);
3594 +       writel(regs->gp.r.src_color_bg, par->gp_regs + 0x14);
3595 +       writel(regs->gp.r.pat_color_0, par->gp_regs + 0x18);
3596 +       writel(regs->gp.r.pat_color_1, par->gp_regs + 0x1C);
3597 +       writel(regs->gp.r.pat_color_2, par->gp_regs + 0x20);
3598 +       writel(regs->gp.r.pat_color_3, par->gp_regs + 0x24);
3599 +       writel(regs->gp.r.pat_color_4, par->gp_regs + 0x28);
3600 +       writel(regs->gp.r.pat_color_5, par->gp_regs + 0x2C);
3601 +       writel(regs->gp.r.pat_data_0, par->gp_regs + 0x30);
3602 +       writel(regs->gp.r.pat_data_1, par->gp_regs + 0x34);
3603 +
3604 +       /* Writing to these registers would cause a blt to happen */
3605 +       /* 0x38, 0x3c, 0x40 */
3606 +
3607 +       /* Status register (0x44) is read only */
3608 +
3609 +       writel(regs->gp.r.hst_src, par->gp_regs + 0x48);
3610 +       writel(regs->gp.r.base_offset, par->gp_regs + 0x4c);
3611 +       writel(regs->gp.r.cmd_top, par->gp_regs + 0x50);
3612 +       writel(regs->gp.r.cmd_bot, par->gp_regs + 0x54);
3613 +       writel(regs->gp.r.cmd_read, par->gp_regs + 0x58);
3614 +       writel(regs->gp.r.cmd_write, par->gp_regs + 0x5C);
3615 +       writel(regs->gp.r.ch3_offset, par->gp_regs + 0x60);
3616 +       writel(regs->gp.r.ch3_mode_str, par->gp_regs + 0x64);
3617 +       writel(regs->gp.r.ch3_width, par->gp_regs + 0x6C);
3618 +       writel(regs->gp.r.ch3_hsrc, par->gp_regs + 0x70);
3619 +
3620 +       /* FIXME:  Restore the LUT data here */
3621 +
3622 +       writel(regs->gp.r.int_cntrl, par->gp_regs + 0x70);
3623 +
3624 +       /* == DC == */
3625 +
3626 +       /* Write the unlock value */
3627 +       writel(0x4758, par->dc_regs + 0x00);
3628 +
3629 +       /* Write the palette data first */
3630 +
3631 +       writel(0, par->dc_regs + 0x70);
3632 +
3633 +       for(i = 0; i < DC_PAL_SIZE; i++)
3634 +               writel(regs->pal[i], par->dc_regs + 0x74);
3635 +
3636 +       /* MSRs */
3637 +       wrmsrl(MSR_LX_DC_SPARE, regs->msr.dcspare);
3638 +
3639 +       /* Write the gcfg register without the enables */
3640 +       writel(regs->dc.r.gcfg & ~0x0F, par->dc_regs + 0x04);
3641 +
3642 +       /* Write the vcfg register without the enables */
3643 +       writel(regs->dc.r.dcfg & ~0x19, par->dc_regs + 0x08);
3644 +
3645 +       /* Write the rest of the active registers */
3646 +       writel(regs->dc.r.arb, par->dc_regs + 0x0C);
3647 +       writel(regs->dc.r.fb_st_offset, par->dc_regs + 0x10);
3648 +       writel(regs->dc.r.cb_st_offset, par->dc_regs + 0x14);
3649 +       writel(regs->dc.r.curs_st_offset, par->dc_regs + 0x18);
3650 +       writel(regs->dc.r.icon_st_offset, par->dc_regs + 0x1C);
3651 +       writel(regs->dc.r.vid_y_st_offset, par->dc_regs + 0x20);
3652 +       writel(regs->dc.r.vid_u_st_offset, par->dc_regs + 0x24);
3653 +       writel(regs->dc.r.vid_v_st_offset, par->dc_regs + 0x28);
3654 +       writel(regs->dc.r.dctop, par->dc_regs + 0x2c);
3655 +       writel(regs->dc.r.line_size, par->dc_regs + 0x30);
3656 +       writel(regs->dc.r.gfx_pitch, par->dc_regs + 0x34);
3657 +       writel(regs->dc.r.vid_yuv_pitch, par->dc_regs + 0x38);
3658 +       writel(regs->dc.r.h_active_timing, par->dc_regs + 0x40);
3659 +       writel(regs->dc.r.h_blank_timing, par->dc_regs + 0x44);
3660 +       writel(regs->dc.r.h_sync_timing, par->dc_regs + 0x48);
3661 +       writel(regs->dc.r.v_active_timing, par->dc_regs + 0x50);
3662 +       writel(regs->dc.r.v_blank_timing, par->dc_regs + 0x54);
3663 +       writel(regs->dc.r.v_sync_timing, par->dc_regs + 0x58);
3664 +       writel(regs->dc.r.fbactive, par->dc_regs + 0x5c);
3665 +       writel(regs->dc.r.dc_cursor_x, par->dc_regs + 0x60);
3666 +       writel(regs->dc.r.dc_cursor_y, par->dc_regs + 0x64);
3667 +       writel(regs->dc.r.dc_icon_x, par->dc_regs + 0x68);
3668 +
3669 +       /* Skip register 0x6C (line_cnt), 0x70/0x74 (palette),
3670 +          0x78 (diagnostic), and 0x7c (diagnostic)
3671 +       */
3672 +
3673 +       writel(regs->dc.r.dc_vid_ds_delta, par->dc_regs + 0x80);
3674 +       writel(regs->dc.r.gliu0_mem_offset, par->dc_regs + 0x84);
3675 +       writel(regs->dc.r.dv_ctl, par->dc_regs + 0x88);
3676 +       writel(regs->dc.r.dv_acc, par->dc_regs + 0x8C);
3677 +
3678 +       writel(regs->dc.r.gfx_scale, par->dc_regs + 0x90);
3679 +       writel(regs->dc.r.irq_filt_ctl, par->dc_regs + 0x94);
3680 +       writel(regs->dc.r.filt_coeff1, par->dc_regs + 0x98);
3681 +       writel(regs->dc.r.filt_coeff2, par->dc_regs + 0x9C);
3682 +       writel(regs->dc.r.vbi_event_ctl, par->dc_regs + 0xA0);
3683 +
3684 +       writel(regs->dc.r.vbi_odd_ctl, par->dc_regs + 0xA4);
3685 +       writel(regs->dc.r.vbi_hor, par->dc_regs + 0xA8);
3686 +       writel(regs->dc.r.vbi_ln_odd, par->dc_regs + 0xAC);
3687 +       writel(regs->dc.r.vbi_ln_event, par->dc_regs + 0xB0);
3688 +       writel(regs->dc.r.vbi_pitch, par->dc_regs + 0xB4);
3689 +       writel(regs->dc.r.clr_key, par->dc_regs + 0xB8);
3690 +       writel(regs->dc.r.clr_key_mask, par->dc_regs + 0xBC);
3691 +
3692 +       writel(regs->dc.r.clr_key_x, par->dc_regs + 0xC0);
3693 +       writel(regs->dc.r.clr_key_y, par->dc_regs + 0xC4);
3694 +       writel(regs->dc.r.irq, par->dc_regs + 0xC8);
3695 +       writel(regs->dc.r.genlk_ctrl, par->dc_regs + 0xD4);
3696 +
3697 +       writel(regs->dc.r.vid_even_y_st_offset, par->dc_regs + 0xD8);
3698 +       writel(regs->dc.r.vid_even_u_st_offset, par->dc_regs + 0xDC);
3699 +       writel(regs->dc.r.vid_even_v_st_offset, par->dc_regs + 0xE0);
3700 +
3701 +       writel(regs->dc.r.v_active_even_timing, par->dc_regs + 0xE4);
3702 +       writel(regs->dc.r.v_blank_even_timing, par->dc_regs + 0xE8);
3703 +       writel(regs->dc.r.v_sync_even_timing, par->dc_regs + 0xEC);
3704 +
3705 +       /* == VP == */
3706 +
3707 +       /* MSR */
3708 +       wrmsrl(MSR_LX_DF_PADSEL, regs->msr.padsel);
3709 +
3710 +       /* Write gamma information first */
3711 +
3712 +       writel(0, par->df_regs + 0x38);
3713 +
3714 +       for(i = 0; i <= 0xFF; i++)
3715 +               writel((u32) regs->gamma[i], par->df_regs + 0x40);
3716 +
3717 +       /* Don't enable video yet */
3718 +       writel((u32) regs->vp.r.vcfg & ~0x01, par->df_regs + 0x00);
3719 +
3720 +       /* Don't enable the CRT yet */
3721 +       writel((u32) regs->vp.r.dcfg & ~0x0F, par->df_regs + 0x08);
3722 +
3723 +       /* Write the rest of the VP registers */
3724 +
3725 +       writel((u32) regs->vp.r.vx, par->df_regs + 0x10);
3726 +       writel((u32) regs->vp.r.vy, par->df_regs + 0x18);
3727 +       writel((u32) regs->vp.r.vs, par->df_regs + 0x20);
3728 +       writel((u32) regs->vp.r.vck, par->df_regs + 0x28);
3729 +       writel((u32) regs->vp.r.vcm, par->df_regs + 0x30);
3730 +       writel((u32) regs->vp.r.misc, par->df_regs + 0x50);
3731 +       writel((u32) regs->vp.r.ccs, par->df_regs + 0x58);
3732 +       writel((u32) regs->vp.r.vdc, par->df_regs + 0x78);
3733 +       writel((u32) regs->vp.r.vco, par->df_regs + 0x80);
3734 +       writel((u32) regs->vp.r.crc, par->df_regs + 0x88);
3735 +       writel((u32) regs->vp.r.vde, par->df_regs + 0x98);
3736 +       writel((u32) regs->vp.r.cck, par->df_regs + 0xA0);
3737 +       writel((u32) regs->vp.r.ccm, par->df_regs + 0xA8);
3738 +       writel((u32) regs->vp.r.cc1, par->df_regs + 0xB0);
3739 +       writel((u32) regs->vp.r.cc2, par->df_regs + 0xB8);
3740 +       writel((u32) regs->vp.r.a1x, par->df_regs + 0xC0);
3741 +       writel((u32) regs->vp.r.a1y, par->df_regs + 0xC8);
3742 +       writel((u32) regs->vp.r.a1c, par->df_regs + 0xD0);
3743 +       writel((u32) regs->vp.r.a1t, par->df_regs + 0xD8);
3744 +       writel((u32) regs->vp.r.a2x, par->df_regs + 0xE0);
3745 +       writel((u32) regs->vp.r.a2y, par->df_regs + 0xE8);
3746 +       writel((u32) regs->vp.r.a2c, par->df_regs + 0xF0);
3747 +       writel((u32) regs->vp.r.a2t, par->df_regs + 0xF8);
3748 +       writel((u32) regs->vp.r.a3x, par->df_regs + 0x100);
3749 +       writel((u32) regs->vp.r.a3y, par->df_regs + 0x108);
3750 +       writel((u32) regs->vp.r.a3c, par->df_regs + 0x110);
3751 +       writel((u32) regs->vp.r.a3t, par->df_regs + 0x118);
3752 +       writel((u32) regs->vp.r.vrr, par->df_regs + 0x120);
3753 +
3754 +       writel((u32) regs->vp.r.vye, par->df_regs + 0x138);
3755 +       writel((u32) regs->vp.r.a1ye, par->df_regs + 0x140);
3756 +       writel((u32) regs->vp.r.a2ye, par->df_regs + 0x148);
3757 +       writel((u32) regs->vp.r.a3ye, par->df_regs + 0x150);
3758 +
3759 +       /* == FP == */
3760 +
3761 +       writel((u32) regs->fp.r.pt1, par->df_regs + 0x400);
3762 +       writel((u32) regs->fp.r.pt2, par->df_regs + 0x408);
3763 +       writel((u32) regs->fp.r.dfc, par->df_regs + 0x418);
3764 +       writel(regs->fp.r.dca, par->df_regs + 0x448);
3765 +       writel(regs->fp.r.dmd, par->df_regs + 0x450);
3766 +       writel(regs->fp.r.crc, par->df_regs + 0x458);
3767 +
3768 +       /* Final enables */
3769 +
3770 +       val = readl(par->df_regs + 0x410);
3771 +
3772 +       /* Control the panel */
3773 +       if (regs->fp.r.pm & (1 << 24)) {
3774 +
3775 +               if (!(val & 0x09))
3776 +                       writel(regs->fp.r.pm, par->df_regs + 0x410);
3777 +       }
3778 +       else {
3779 +               if (!(val & 0x05))
3780 +                       writel(regs->fp.r.pm, par->df_regs + 0x410);
3781 +       }
3782 +
3783 +       /* Turn everything on */
3784 +
3785 +       writel(regs->dc.r.gcfg, par->dc_regs + 0x04);
3786 +       writel((u32) regs->vp.r.vcfg, par->df_regs + 0x00);
3787 +       writel((u32) regs->vp.r.dcfg, par->df_regs + 0x08);
3788 +       writel(regs->dc.r.dcfg, par->dc_regs + 0x08);
3789 +}
3790 +
3791 +static int lx_power_on = 1;
3792 +
3793 +int lx_shutdown(struct fb_info *info)
3794 +{
3795 +       struct lxfb_par *par = info->par;
3796 +
3797 +       if (lx_power_on == 0)
3798 +               return 0;
3799 +
3800 +       writel(DC_UNLOCK_CODE, par->dc_regs + DC_UNLOCK);
3801 +       lx_save_regs(info, &saved_regs);
3802 +       lx_graphics_disable(info);
3803 +
3804 +       lx_power_on = 0;
3805 +       return 0;
3806 +}
3807 +
3808 +int lx_powerup(struct fb_info *info)
3809 +{
3810 +       struct lxfb_par *par = info->par;
3811 +
3812 +       if (lx_power_on == 1)
3813 +               return 0;
3814 +
3815 +       lx_restore_regs(info, &saved_regs);
3816 +       writel(0, par->dc_regs + DC_UNLOCK);
3817 +
3818 +       lx_power_on = 1;
3819 +       return 0;
3820 +}
3821 Index: linux-2.6.23.17/drivers/video/geode/video_gx.c
3822 ===================================================================
3823 --- linux-2.6.23.17.orig/drivers/video/geode/video_gx.c
3824 +++ linux-2.6.23.17/drivers/video/geode/video_gx.c
3825 @@ -16,10 +16,14 @@
3826  #include <asm/io.h>
3827  #include <asm/delay.h>
3828  #include <asm/msr.h>
3829 +#include <asm/olpc.h>
3830
3831  #include "geodefb.h"
3832  #include "video_gx.h"
3833 +#include "display_gx.h"
3834
3835 +/* This structure is used to store the saved registers during suspend */
3836 +static struct geoderegs gx_saved_regs;
3837
3838  /*
3839   * Tables of register settings for various DOTCLKs.
3840 @@ -58,7 +62,7 @@ static const struct gx_pll_entry gx_pll_
3841         { 13888, POSTDIV3,          0x000007E1 },       /*  72.0000 */
3842         { 13426, PREMULT2,          0x00000F4A },       /*  74.4810 */
3843         { 13333, 0,                 0x00000052 },       /*  75.0000 */
3844 -       { 12698, 0,                 0x00000056 },       /*  78.7500 */
3845 +       { 12698, 0,                 0x00000056 },       /*  78.7500 */
3846         { 12500, POSTDIV3|PREMULT2, 0x00000709 },       /*  80.0000 */
3847         { 11135, PREMULT2,          0x00000262 },       /*  89.8000 */
3848         { 10582, 0,                 0x000002D2 },       /*  94.5000 */
3849 @@ -117,8 +121,9 @@ static const struct gx_pll_entry gx_pll_
3850         {  4357, 0, 0x0000057D },       /* 229.5000 */
3851  };
3852
3853 -static void gx_set_dclk_frequency(struct fb_info *info)
3854 +void gx_set_dclk_frequency(struct fb_info *info)
3855  {
3856 +       struct geodefb_par *par = info->par;
3857         const struct gx_pll_entry *pll_table;
3858         int pll_table_len;
3859         int i, best_i;
3860 @@ -173,115 +178,169 @@ static void gx_set_dclk_frequency(struct
3861         do {
3862                 rdmsrl(MSR_GLCP_DOTPLL, dotpll);
3863         } while (timeout-- && !(dotpll & MSR_GLCP_DOTPLL_LOCK));
3864 +
3865 +       par->curdclk = pll_table[best_i].dotpll_value;
3866  }
3867
3868 -static void
3869 -gx_configure_tft(struct fb_info *info)
3870 +/* Find out the current clock - we will use this information to avoid
3871 +   re-programming it if we don't need to */
3872 +
3873 +unsigned int gx_get_dclk(struct fb_info *info)
3874  {
3875 -       struct geodefb_par *par = info->par;
3876 -       unsigned long val;
3877 -       unsigned long fp;
3878 +       const struct gx_pll_entry *pll_table;
3879 +       int pll_table_len;
3880 +       u64 dotpll;
3881 +       int i;
3882
3883 -       /* Set up the DF pad select MSR */
3884 +       if (cpu_data->x86_mask == 1) {
3885 +               pll_table = gx_pll_table_14MHz;
3886 +               pll_table_len = ARRAY_SIZE(gx_pll_table_14MHz);
3887 +       } else {
3888 +               pll_table = gx_pll_table_48MHz;
3889 +               pll_table_len = ARRAY_SIZE(gx_pll_table_48MHz);
3890 +       }
3891
3892 -       rdmsrl(GX_VP_MSR_PAD_SELECT, val);
3893 -       val &= ~GX_VP_PAD_SELECT_MASK;
3894 -       val |= GX_VP_PAD_SELECT_TFT;
3895 -       wrmsrl(GX_VP_MSR_PAD_SELECT, val);
3896 +       rdmsrl(MSR_GLCP_DOTPLL, dotpll);
3897
3898 -       /* Turn off the panel */
3899 +       for(i = 0; i < pll_table_len; i++) {
3900 +               if (pll_table[i].dotpll_value == (u32) (dotpll >> 32))
3901 +                       break;
3902 +       }
3903 +
3904 +       return (i == pll_table_len) ? 0 : pll_table[i].pixclock;
3905 +}
3906
3907 -       fp = readl(par->vid_regs + GX_FP_PM);
3908 -       fp &= ~GX_FP_PM_P;
3909 -       writel(fp, par->vid_regs + GX_FP_PM);
3910
3911 -       /* Set timing 1 */
3912 +#define CMP(val, mask, res) (((val) & (mask)) == (res))
3913
3914 -       fp = readl(par->vid_regs + GX_FP_PT1);
3915 -       fp &= GX_FP_PT1_VSIZE_MASK;
3916 -       fp |= info->var.yres << GX_FP_PT1_VSIZE_SHIFT;
3917 -       writel(fp, par->vid_regs + GX_FP_PT1);
3918 +static void
3919 +gx_configure_tft(struct fb_info *info) {
3920
3921 -       /* Timing 2 */
3922 -       /* Set bits that are always on for TFT */
3923 +       struct geodefb_par *par = info->par;
3924 +       u32 val, fp = 0, fp1, fp2, sync = 0;
3925
3926 -       fp = 0x0F100000;
3927 +       /* Set up the DF pad select MSR */
3928
3929 -       /* Add sync polarity */
3930 +       rdmsrl(GX_VP_MSR_PAD_SELECT, val);
3931 +
3932 +       if ((val & GX_VP_PAD_SELECT_MASK) != GX_VP_PAD_SELECT_TFT) {
3933 +               val &= ~GX_VP_PAD_SELECT_MASK;
3934 +               val |= GX_VP_PAD_SELECT_TFT;
3935 +               wrmsrl(GX_VP_MSR_PAD_SELECT, val);
3936 +       }
3937
3938         if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT))
3939 -               fp |= GX_FP_PT2_VSP;
3940 +               sync |= GX_FP_PT2_VSP;
3941
3942         if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT))
3943 -               fp |= GX_FP_PT2_HSP;
3944 +               sync |= GX_FP_PT2_HSP;
3945
3946 -       writel(fp, par->vid_regs + GX_FP_PT2);
3947 +       /* We only need to turn off the panel if something changed */
3948
3949 -       /*  Set the dither control */
3950 -       writel(0x70, par->vid_regs + GX_FP_DFC);
3951 +       fp1 = readl(par->vid_regs + GX_FP_PT1);
3952 +       fp2 = readl(par->vid_regs + GX_FP_PT2);
3953 +
3954 +       if (!CMP(fp1, GX_FP_PT1_VSIZE_MASK, info->var.yres << GX_FP_PT1_VSIZE_SHIFT) ||
3955 +           (fp2 != (0x0F100000 | sync))) {
3956 +
3957 +               /* Turn off the panel */
3958 +
3959 +#ifdef NOTUSED
3960 +               /* Do we really need to turn off the panel? */
3961 +               /* Possibly - we have a glitch somewhere */
3962
3963 -       /* Enable the FP data and power (in case the BIOS didn't) */
3964 +               fp = readl(par->vid_regs + GX_FP_PM);
3965 +               fp &= ~GX_FP_PM_P;
3966 +               writel(fp, par->vid_regs + GX_FP_PM);
3967 +#endif
3968
3969 -       fp = readl(par->vid_regs + GX_DCFG);
3970 -       fp |= GX_DCFG_FP_PWR_EN | GX_DCFG_FP_DATA_EN;
3971 -       writel(fp, par->vid_regs + GX_DCFG);
3972 +               /* Timing 1 */
3973 +               fp1 &= GX_FP_PT1_VSIZE_MASK;
3974 +               fp1 |= info->var.yres << GX_FP_PT1_VSIZE_SHIFT;
3975 +               writel(fp, par->vid_regs + GX_FP_PT1);
3976
3977 -       /* Unblank the panel */
3978 +               /* Timing 2 */
3979 +               writel(0x0F100000 | sync, par->vid_regs + GX_FP_PT2);
3980 +       }
3981 +
3982 +       /*  Set the dither control */
3983 +       if (readl(par->vid_regs + GX_FP_DFC) != 0x70) {
3984 +               writel(0x70, par->vid_regs + GX_FP_DFC);
3985 +       }
3986 +
3987 +       /* Turn on the panel */
3988
3989         fp = readl(par->vid_regs + GX_FP_PM);
3990 -       fp |= GX_FP_PM_P;
3991 -       writel(fp, par->vid_regs + GX_FP_PM);
3992 +
3993 +       if (!(fp & 0x09))
3994 +               writel(fp | GX_FP_PM_P, par->vid_regs + GX_FP_PM);
3995  }
3996
3997 +#define DCFG_DEFAULT_VAL GX_DCFG_CRT_SYNC_SKW_DFLT | GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN | \
3998 +GX_DCFG_CRT_EN | GX_DCFG_DAC_BL_EN
3999 +
4000  static void gx_configure_display(struct fb_info *info)
4001  {
4002         struct geodefb_par *par = info->par;
4003 -       u32 dcfg, misc;
4004 +       u32 dcfg, misc, sync = 0;
4005
4006         /* Set up the MISC register */
4007 -
4008         misc = readl(par->vid_regs + GX_MISC);
4009
4010 -       /* Power up the DAC */
4011 -       misc &= ~(GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN);
4012 +       /* We leave gamma enabled if it was already enabled.
4013 +          Although the hardware enables it without setting
4014 +          up the gamma table, the BIOS or bootloader ought
4015 +          to have either disabled it or loaded a table by now */
4016
4017 -       /* Disable gamma correction */
4018 -       misc |= GX_MISC_GAM_EN;
4019
4020 -       writel(misc, par->vid_regs + GX_MISC);
4021
4022 -       /* Write the display configuration */
4023 -       dcfg = readl(par->vid_regs + GX_DCFG);
4024 +       if (par->enable_crt) {
4025 +               /* Power up the CRT DACs */
4026 +               if (misc & ( GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN)) {
4027 +                       misc &= ~(GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN);
4028 +                       writel(misc, par->vid_regs + GX_MISC);
4029 +               }
4030
4031 -       /* Disable hsync and vsync */
4032 -       dcfg &= ~(GX_DCFG_VSYNC_EN | GX_DCFG_HSYNC_EN);
4033 -       writel(dcfg, par->vid_regs + GX_DCFG);
4034 +               if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT))
4035 +                       sync |= GX_DCFG_CRT_HSYNC_POL;
4036
4037 -       /* Clear bits from existing mode. */
4038 -       dcfg &= ~(GX_DCFG_CRT_SYNC_SKW_MASK
4039 -                 | GX_DCFG_CRT_HSYNC_POL   | GX_DCFG_CRT_VSYNC_POL
4040 -                 | GX_DCFG_VSYNC_EN        | GX_DCFG_HSYNC_EN);
4041 +               if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT))
4042 +                       sync |= GX_DCFG_CRT_VSYNC_POL;
4043 +       }
4044 +       else {
4045 +               /* Turn off the CRT DACs in FP mode - we don't need them */
4046 +               if ((misc & (GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN))) {
4047 +                       misc |= (GX_MISC_A_PWRDN | GX_MISC_DAC_PWRDN);
4048 +                       writel(misc, par->vid_regs + GX_MISC);
4049 +               }
4050 +       }
4051
4052 -       /* Set default sync skew.  */
4053 -       dcfg |= GX_DCFG_CRT_SYNC_SKW_DFLT;
4054 +       /* Write the display configuration */
4055 +       dcfg = readl(par->vid_regs + GX_DCFG);
4056
4057 -       /* Enable hsync and vsync. */
4058 -       dcfg |= GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN;
4059 +       if (!CMP(dcfg, DCFG_DEFAULT_VAL | GX_DCFG_CRT_HSYNC_POL | GX_DCFG_CRT_VSYNC_POL,
4060 +                DCFG_DEFAULT_VAL | sync)) {
4061
4062 -       /* Sync polarities. */
4063 -       if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
4064 -               dcfg |= GX_DCFG_CRT_HSYNC_POL;
4065 -       if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
4066 -               dcfg |= GX_DCFG_CRT_VSYNC_POL;
4067 +               /* Disable hsync and vsync */
4068 +               dcfg &= ~(GX_DCFG_VSYNC_EN | GX_DCFG_HSYNC_EN);
4069 +               writel(dcfg, par->vid_regs + GX_DCFG);
4070
4071 -       /* Enable the display logic */
4072 -       /* Set up the DACS to blank normally */
4073 +               /* Clear bits from existing mode. */
4074 +               dcfg &= ~(GX_DCFG_CRT_SYNC_SKW_MASK
4075 +                         | GX_DCFG_CRT_HSYNC_POL   | GX_DCFG_CRT_VSYNC_POL
4076 +                         | GX_DCFG_VSYNC_EN        | GX_DCFG_HSYNC_EN);
4077
4078 -       dcfg |= GX_DCFG_CRT_EN | GX_DCFG_DAC_BL_EN;
4079 +               /* Set default sync skew.  */
4080 +               dcfg |= GX_DCFG_CRT_SYNC_SKW_DFLT;
4081
4082 -       /* Enable the external DAC VREF? */
4083 +               /* Enable hsync and vsync. */
4084 +               dcfg |= GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN;
4085
4086 -       writel(dcfg, par->vid_regs + GX_DCFG);
4087 +               /* Enable the display logic */
4088 +               dcfg |= GX_DCFG_CRT_EN | GX_DCFG_DAC_BL_EN;
4089 +
4090 +               writel(dcfg, par->vid_regs + GX_DCFG);
4091 +       }
4092
4093         /* Set up the flat panel (if it is enabled) */
4094
4095 @@ -289,6 +348,100 @@ static void gx_configure_display(struct
4096                 gx_configure_tft(info);
4097  }
4098
4099 +int gxfb_powerdown(struct fb_info *info)
4100 +{
4101 +       struct geodefb_par *par = info->par;
4102 +
4103 +       /* We're already suspended */
4104 +
4105 +       if (par->state != FB_POWER_STATE_ON)
4106 +               return 0;
4107 +
4108 +       /* Save the registers */
4109 +       gx_save_regs(info, &gx_saved_regs);
4110 +
4111 +       /* Shut down the engine */
4112 +
4113 +       writel(gx_saved_regs.vp.r.vcfg & ~0x01, par->vid_regs + GX_VCFG);
4114 +       writel(gx_saved_regs.vp.r.dcfg & ~0x0F, par->vid_regs + GX_DCFG);
4115 +
4116 +       /* Turn off the flat panel unless we are attached to a DCON */
4117 +       if (!olpc_has_dcon())
4118 +               writel(gx_saved_regs.fp.r.pm & ~GX_FP_PM_P, par->vid_regs + GX_FP_PM);
4119 +
4120 +       writel(0x4758, par->dc_regs + DC_UNLOCK);
4121 +
4122 +       writel(gx_saved_regs.dc.r.gcfg & ~0x0F,
4123 +              par->dc_regs + DC_GENERAL_CFG);
4124 +
4125 +       writel(gx_saved_regs.dc.r.dcfg & ~0x19,
4126 +              par->dc_regs + DC_DISPLAY_CFG);
4127 +
4128 +       par->state = FB_POWER_STATE_SUSPEND;
4129 +
4130 +       return 0;
4131 +}
4132 +
4133 +int gxfb_powerup(struct fb_info *info)
4134 +{
4135 +       struct geodefb_par *par = info->par;
4136 +       u32 val;
4137 +
4138 +       if (par->state == FB_POWER_STATE_SUSPEND) {
4139 +
4140 +               writel(gx_saved_regs.dc.r.dcfg,
4141 +                      par->dc_regs + DC_DISPLAY_CFG);
4142 +
4143 +               writel(gx_saved_regs.vp.r.vcfg, par->vid_regs + GX_VCFG);
4144 +               writel(gx_saved_regs.vp.r.dcfg, par->vid_regs + GX_DCFG);
4145 +
4146 +               val = readl(par->vid_regs + GX_FP_PM);
4147 +
4148 +               /* power up the panel if it needs it; we don't always power it down */
4149 +               if (!(val & 0x09)) {
4150 +                       writel(gx_saved_regs.fp.r.pm, par->vid_regs + GX_FP_PM);
4151 +                       mdelay(64);
4152 +               }
4153 +       }
4154 +
4155 +       /* If the panel is currently on its way up, then wait up to 100ms
4156 +          for it */
4157 +
4158 +       if (readl(par->vid_regs + GX_FP_PM) & 0x08) {
4159 +               int i;
4160 +
4161 +               for(i = 0; i < 10; i++) {
4162 +                       if (readl(par->vid_regs + GX_FP_PM) & 0x01)
4163 +                               break;
4164 +
4165 +                       mdelay(10);
4166 +               }
4167 +
4168 +               if (i == 10)
4169 +                       printk(KERN_ERR "gxfb:  Panel power up timed out\n");
4170 +       }
4171 +
4172 +       if (par->state == FB_POWER_STATE_ON)
4173 +               return 0;
4174 +
4175 +       switch(par->state) {
4176 +       case FB_POWER_STATE_OFF:
4177 +               gx_restore_regs(info, &gx_saved_regs);
4178 +               break;
4179 +
4180 +       case FB_POWER_STATE_SUSPEND:
4181 +               /* Do this because it will turn on the FIFO which will
4182 +                  start the line count */
4183 +               writel(gx_saved_regs.dc.r.gcfg,
4184 +                      par->dc_regs + DC_GENERAL_CFG);
4185 +               writel(0x0, par->dc_regs + DC_UNLOCK);
4186 +               break;
4187 +       }
4188 +
4189 +       par->state = FB_POWER_STATE_ON;
4190 +       return 0;
4191 +}
4192 +
4193  static int gx_blank_display(struct fb_info *info, int blank_mode)
4194  {
4195         struct geodefb_par *par = info->par;
4196 @@ -315,6 +468,7 @@ static int gx_blank_display(struct fb_in
4197         default:
4198                 return -EINVAL;
4199         }
4200 +
4201         dcfg = readl(par->vid_regs + GX_DCFG);
4202         dcfg &= ~(GX_DCFG_DAC_BL_EN
4203                   | GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN);
4204 @@ -326,7 +480,7 @@ static int gx_blank_display(struct fb_in
4205                 dcfg |= GX_DCFG_VSYNC_EN;
4206         writel(dcfg, par->vid_regs + GX_DCFG);
4207
4208 -       /* Power on/off flat panel. */
4209 +       /* Power on/off flat panel */
4210
4211         if (par->enable_crt == 0) {
4212                 fp_pm = readl(par->vid_regs + GX_FP_PM);
4213 @@ -340,8 +494,37 @@ static int gx_blank_display(struct fb_in
4214         return 0;
4215  }
4216
4217 +extern struct fb_info *gxfb_info;
4218 +
4219 +/* This function controls the flatpanel power sequencing - this is used
4220 +   by the OLPC power management engine to enable the FP sequencing much
4221 +   earlier in the resume process
4222 +*/
4223 +
4224 +void gxfb_flatpanel_control(int state)
4225 +{
4226 +       struct geodefb_par *par = gxfb_info->par;
4227 +       u32 val, fp = readl(par->vid_regs + GX_FP_PM);
4228 +       val  = fp;
4229 +
4230 +       /* Turn on the panel if it isn't aleady */
4231 +
4232 +       if (state) {
4233 +               if (!(val & 0x01))
4234 +                       val |= GX_FP_PM_P;
4235 +       }
4236 +       else {
4237 +               if (!(val & 0x02))
4238 +                       val &= ~GX_FP_PM_P;
4239 +       }
4240 +
4241 +       if (val != fp)
4242 +               writel(val, par->vid_regs + GX_FP_PM);
4243 +}
4244 +
4245  struct geode_vid_ops gx_vid_ops = {
4246         .set_dclk          = gx_set_dclk_frequency,
4247 +       .get_dclk          = gx_get_dclk,
4248         .configure_display = gx_configure_display,
4249         .blank_display     = gx_blank_display,
4250  };
4251 Index: linux-2.6.23.17/drivers/video/geode/video_gx.h
4252 ===================================================================
4253 --- linux-2.6.23.17.orig/drivers/video/geode/video_gx.h
4254 +++ linux-2.6.23.17/drivers/video/geode/video_gx.h
4255 @@ -11,6 +11,8 @@
4256  #ifndef __VIDEO_GX_H__
4257  #define __VIDEO_GX_H__
4258
4259 +#include "geode_regs.h"
4260 +
4261  extern struct geode_vid_ops gx_vid_ops;
4262
4263  /* GX Flatpanel control MSR */
4264 @@ -20,6 +22,8 @@ extern struct geode_vid_ops gx_vid_ops;
4265
4266  /* Geode GX video processor registers */
4267
4268 +#define GX_VCFG         0x0000
4269 +
4270  #define GX_DCFG                0x0008
4271  #  define GX_DCFG_CRT_EN               0x00000001
4272  #  define GX_DCFG_HSYNC_EN             0x00000002
4273 @@ -42,6 +46,14 @@ extern struct geode_vid_ops gx_vid_ops;
4274  #define GX_MISC_DAC_PWRDN  0x00000400
4275  #define GX_MISC_A_PWRDN    0x00000800
4276
4277 +/* Gamma correction RAM - address and data registers */
4278 +
4279 +#define GX_GAR 0x038
4280 +#define GX_GDR 0x040
4281 +
4282 +#define GXFB_GAMMA_DWORDS 256 /* number of dwords in the gamma ram */
4283 +#define GXFB_GAMMA_SIZE (GXFB_GAMMA_DWORDS * sizeof(unsigned int))
4284 +
4285  /* Geode GX flat panel display control registers */
4286
4287  #define GX_FP_PT1 0x0400
4288 @@ -69,4 +81,13 @@ extern struct geode_vid_ops gx_vid_ops;
4289  #  define MSR_GLCP_DOTPLL_BYPASS               (0x0000000000008000ull)
4290  #  define MSR_GLCP_DOTPLL_LOCK                 (0x0000000002000000ull)
4291
4292 +int gxfb_powerdown(struct fb_info *info);
4293 +int gxfb_powerup(struct fb_info *info);
4294 +
4295 +void gx_set_dclk_frequency(struct fb_info *info);
4296 +unsigned int gx_get_dclk(struct fb_info *info);
4297 +
4298 +void gx_save_regs(struct fb_info *info, struct geoderegs *regs);
4299 +void gx_restore_regs(struct fb_info *info, struct geoderegs *regs);
4300 +
4301  #endif /* !__VIDEO_GX_H__ */
4302 Index: linux-2.6.23.17/drivers/video/modedb.c
4303 ===================================================================
4304 --- linux-2.6.23.17.orig/drivers/video/modedb.c
4305 +++ linux-2.6.23.17/drivers/video/modedb.c
4306 @@ -33,6 +33,8 @@ const char *global_mode_option;
4307       *  Standard video mode definitions (taken from XFree86)
4308       */
4309
4310 +#define DEFAULT_MODEDB_INDEX   0
4311 +
4312  static const struct fb_videomode modedb[] = {
4313      {
4314         /* 640x400 @ 70 Hz, 31.5 kHz hsync */
4315 @@ -504,7 +506,8 @@ int fb_find_mode(struct fb_var_screeninf
4316      }
4317
4318      if (!default_mode)
4319 -       default_mode = &db[0];
4320 +           default_mode = (db == modedb) ?
4321 +                   &modedb[DEFAULT_MODEDB_INDEX] : &db[0];
4322
4323      if (!default_bpp)
4324         default_bpp = 8;
4325 Index: linux-2.6.23.17/fs/Kconfig
4326 ===================================================================
4327 --- linux-2.6.23.17.orig/fs/Kconfig
4328 +++ linux-2.6.23.17/fs/Kconfig
4329 @@ -1003,6 +1003,23 @@ config HUGETLBFS
4330  config HUGETLB_PAGE
4331         def_bool HUGETLBFS
4332
4333 +config PROMFS_FS
4334 +       tristate "PromFS IEEE 1275 file system support"
4335 +       depends on SPARC || PPC || OLPC
4336 +       help
4337 +         PromFS is a file system interface to various IEEE-1275 compatible
4338 +         firmwares.  If you have such a firmware (Sparc64, PowerPC, and
4339 +         some other architectures and embedded systems have such firmwares,
4340 +         with names like "OpenBoot (tm)" and "OpenFirmware"), say Y here
4341 +         to be able to access the firmware's device-tree from Linux.
4342 +
4343 +         The firmware device-tree is available as a virtual file system,
4344 +         can be mounted under /prom with the command "mount -t promfs
4345 +         none /prom".
4346 +
4347 +         To compile PromFS support as a module, choose M here; the module
4348 +         will be called promfs.  If unsure, choose M.
4349 +
4350  config RAMFS
4351         bool
4352         default y
4353 @@ -1229,6 +1246,14 @@ config JFFS2_FS_WRITEBUFFER
4354             - NOR flash with transparent ECC
4355             - DataFlash
4356
4357 +config JFFS2_FS_WBUF_VERIFY
4358 +       bool "Verify JFFS2 write-buffer reads"
4359 +       depends on JFFS2_FS_WRITEBUFFER
4360 +       default n
4361 +       help
4362 +         This causes JFFS2 to read back every page written through the
4363 +         write-buffer, and check for errors.
4364 +
4365  config JFFS2_SUMMARY
4366         bool "JFFS2 summary support (EXPERIMENTAL)"
4367         depends on JFFS2_FS && EXPERIMENTAL
4368 @@ -1299,52 +1324,52 @@ config JFFS2_ZLIB
4369         select ZLIB_DEFLATE
4370         depends on JFFS2_FS
4371         default y
4372 -        help
4373 -          Zlib is designed to be a free, general-purpose, legally unencumbered,
4374 -          lossless data-compression library for use on virtually any computer
4375 -          hardware and operating system. See <http://www.gzip.org/zlib/> for
4376 -          further information.
4377 +       help
4378 +         Zlib is designed to be a free, general-purpose, legally unencumbered,
4379 +         lossless data-compression library for use on virtually any computer
4380 +         hardware and operating system. See <http://www.gzip.org/zlib/> for
4381 +         further information.
4382
4383 -          Say 'Y' if unsure.
4384 +         Say 'Y' if unsure.
4385
4386  config JFFS2_RTIME
4387         bool "JFFS2 RTIME compression support" if JFFS2_COMPRESSION_OPTIONS
4388         depends on JFFS2_FS
4389         default y
4390 -        help
4391 -          Rtime does manage to recompress already-compressed data. Say 'Y' if unsure.
4392 +       help
4393 +         Rtime does manage to recompress already-compressed data. Say 'Y' if unsure.
4394
4395  config JFFS2_RUBIN
4396         bool "JFFS2 RUBIN compression support" if JFFS2_COMPRESSION_OPTIONS
4397         depends on JFFS2_FS
4398         default n
4399 -        help
4400 -          RUBINMIPS and DYNRUBIN compressors. Say 'N' if unsure.
4401 +       help
4402 +         RUBINMIPS and DYNRUBIN compressors. Say 'N' if unsure.
4403
4404  choice
4405 -        prompt "JFFS2 default compression mode" if JFFS2_COMPRESSION_OPTIONS
4406 -        default JFFS2_CMODE_PRIORITY
4407 -        depends on JFFS2_FS
4408 -        help
4409 -          You can set here the default compression mode of JFFS2 from
4410 -          the available compression modes. Don't touch if unsure.
4411 +       prompt "JFFS2 default compression mode" if JFFS2_COMPRESSION_OPTIONS
4412 +       default JFFS2_CMODE_PRIORITY
4413 +       depends on JFFS2_FS
4414 +       help
4415 +         You can set here the default compression mode of JFFS2 from
4416 +         the available compression modes. Don't touch if unsure.
4417
4418  config JFFS2_CMODE_NONE
4419 -        bool "no compression"
4420 -        help
4421 -          Uses no compression.
4422 +       bool "no compression"
4423 +       help
4424 +         Uses no compression.
4425
4426  config JFFS2_CMODE_PRIORITY
4427 -        bool "priority"
4428 -        help
4429 -          Tries the compressors in a predefined order and chooses the first
4430 -          successful one.
4431 +       bool "priority"
4432 +       help
4433 +         Tries the compressors in a predefined order and chooses the first
4434 +         successful one.
4435
4436  config JFFS2_CMODE_SIZE
4437 -        bool "size (EXPERIMENTAL)"
4438 -        help
4439 -          Tries all compressors and chooses the one which has the smallest
4440 -          result.
4441 +       bool "size (EXPERIMENTAL)"
4442 +       help
4443 +         Tries all compressors and chooses the one which has the smallest
4444 +         result.
4445
4446  endchoice
4447
4448 Index: linux-2.6.23.17/fs/Makefile
4449 ===================================================================
4450 --- linux-2.6.23.17.orig/fs/Makefile
4451 +++ linux-2.6.23.17/fs/Makefile
4452 @@ -110,6 +110,7 @@ obj-$(CONFIG_ADFS_FS)               += adfs/
4453  obj-$(CONFIG_FUSE_FS)          += fuse/
4454  obj-$(CONFIG_UDF_FS)           += udf/
4455  obj-$(CONFIG_SUN_OPENPROMFS)   += openpromfs/
4456 +obj-$(CONFIG_PROMFS_FS)                += promfs/
4457  obj-$(CONFIG_JFS_FS)           += jfs/
4458  obj-$(CONFIG_XFS_FS)           += xfs/
4459  obj-$(CONFIG_9P_FS)            += 9p/
4460 Index: linux-2.6.23.17/fs/jffs2/background.c
4461 ===================================================================
4462 --- linux-2.6.23.17.orig/fs/jffs2/background.c
4463 +++ linux-2.6.23.17/fs/jffs2/background.c
4464 @@ -23,8 +23,8 @@ static int jffs2_garbage_collect_thread(
4465  void jffs2_garbage_collect_trigger(struct jffs2_sb_info *c)
4466  {
4467         spin_lock(&c->erase_completion_lock);
4468 -        if (c->gc_task && jffs2_thread_should_wake(c))
4469 -                send_sig(SIGHUP, c->gc_task, 1);
4470 +       if (c->gc_task && jffs2_thread_should_wake(c))
4471 +               send_sig(SIGHUP, c->gc_task, 1);
4472         spin_unlock(&c->erase_completion_lock);
4473  }
4474
4475 Index: linux-2.6.23.17/fs/jffs2/compr.c
4476 ===================================================================
4477 --- linux-2.6.23.17.orig/fs/jffs2/compr.c
4478 +++ linux-2.6.23.17/fs/jffs2/compr.c
4479 @@ -5,7 +5,7 @@
4480   * Created by Arjan van de Ven <arjanv@redhat.com>
4481   *
4482   * Copyright © 2004 Ferenc Havasi <havasi@inf.u-szeged.hu>,
4483 - *                    University of Szeged, Hungary
4484 + *                 University of Szeged, Hungary
4485   *
4486   * For licensing information, see the file 'LICENCE' in this directory.
4487   *
4488 @@ -43,121 +43,122 @@ static uint32_t none_stat_compr_blocks=0
4489   * *datalen accordingly to show the amount of data which were compressed.
4490   */
4491  uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
4492 -                            unsigned char *data_in, unsigned char **cpage_out,
4493 -                            uint32_t *datalen, uint32_t *cdatalen)
4494 +                       unsigned char *data_in, unsigned char **cpage_out,
4495 +                       uint32_t *datalen, uint32_t *cdatalen)
4496  {
4497         int ret = JFFS2_COMPR_NONE;
4498 -        int compr_ret;
4499 -        struct jffs2_compressor *this, *best=NULL;
4500 -        unsigned char *output_buf = NULL, *tmp_buf;
4501 -        uint32_t orig_slen, orig_dlen;
4502 -        uint32_t best_slen=0, best_dlen=0;
4503 -
4504 -        switch (jffs2_compression_mode) {
4505 -        case JFFS2_COMPR_MODE_NONE:
4506 -                break;
4507 -        case JFFS2_COMPR_MODE_PRIORITY:
4508 -                output_buf = kmalloc(*cdatalen,GFP_KERNEL);
4509 -                if (!output_buf) {
4510 -                        printk(KERN_WARNING "JFFS2: No memory for compressor allocation. Compression failed.\n");
4511 -                        goto out;
4512 -                }
4513 -                orig_slen = *datalen;
4514 -                orig_dlen = *cdatalen;
4515 -                spin_lock(&jffs2_compressor_list_lock);
4516 -                list_for_each_entry(this, &jffs2_compressor_list, list) {
4517 -                        /* Skip decompress-only backwards-compatibility and disabled modules */
4518 -                        if ((!this->compress)||(this->disabled))
4519 -                                continue;
4520 -
4521 -                        this->usecount++;
4522 -                        spin_unlock(&jffs2_compressor_list_lock);
4523 -                        *datalen  = orig_slen;
4524 -                        *cdatalen = orig_dlen;
4525 -                        compr_ret = this->compress(data_in, output_buf, datalen, cdatalen, NULL);
4526 -                        spin_lock(&jffs2_compressor_list_lock);
4527 -                        this->usecount--;
4528 -                        if (!compr_ret) {
4529 -                                ret = this->compr;
4530 -                                this->stat_compr_blocks++;
4531 -                                this->stat_compr_orig_size += *datalen;
4532 -                                this->stat_compr_new_size  += *cdatalen;
4533 -                                break;
4534 -                        }
4535 -                }
4536 -                spin_unlock(&jffs2_compressor_list_lock);
4537 -                if (ret == JFFS2_COMPR_NONE) kfree(output_buf);
4538 -                break;
4539 -        case JFFS2_COMPR_MODE_SIZE:
4540 -                orig_slen = *datalen;
4541 -                orig_dlen = *cdatalen;
4542 -                spin_lock(&jffs2_compressor_list_lock);
4543 -                list_for_each_entry(this, &jffs2_compressor_list, list) {
4544 -                        /* Skip decompress-only backwards-compatibility and disabled modules */
4545 -                        if ((!this->compress)||(this->disabled))
4546 -                                continue;
4547 -                        /* Allocating memory for output buffer if necessary */
4548 -                        if ((this->compr_buf_size<orig_dlen)&&(this->compr_buf)) {
4549 -                                spin_unlock(&jffs2_compressor_list_lock);
4550 -                                kfree(this->compr_buf);
4551 -                                spin_lock(&jffs2_compressor_list_lock);
4552 -                                this->compr_buf_size=0;
4553 -                                this->compr_buf=NULL;
4554 -                        }
4555 -                        if (!this->compr_buf) {
4556 -                                spin_unlock(&jffs2_compressor_list_lock);
4557 -                                tmp_buf = kmalloc(orig_dlen,GFP_KERNEL);
4558 -                                spin_lock(&jffs2_compressor_list_lock);
4559 -                                if (!tmp_buf) {
4560 -                                        printk(KERN_WARNING "JFFS2: No memory for compressor allocation. (%d bytes)\n",orig_dlen);
4561 -                                        continue;
4562 -                                }
4563 -                                else {
4564 -                                        this->compr_buf = tmp_buf;
4565 -                                        this->compr_buf_size = orig_dlen;
4566 -                                }
4567 -                        }
4568 -                        this->usecount++;
4569 -                        spin_unlock(&jffs2_compressor_list_lock);
4570 -                        *datalen  = orig_slen;
4571 -                        *cdatalen = orig_dlen;
4572 -                        compr_ret = this->compress(data_in, this->compr_buf, datalen, cdatalen, NULL);
4573 -                        spin_lock(&jffs2_compressor_list_lock);
4574 -                        this->usecount--;
4575 -                        if (!compr_ret) {
4576 -                                if ((!best_dlen)||(best_dlen>*cdatalen)) {
4577 -                                        best_dlen = *cdatalen;
4578 -                                        best_slen = *datalen;
4579 -                                        best = this;
4580 -                                }
4581 -                        }
4582 -                }
4583 -                if (best_dlen) {
4584 -                        *cdatalen = best_dlen;
4585 -                        *datalen  = best_slen;
4586 -                        output_buf = best->compr_buf;
4587 -                        best->compr_buf = NULL;
4588 -                        best->compr_buf_size = 0;
4589 -                        best->stat_compr_blocks++;
4590 -                        best->stat_compr_orig_size += best_slen;
4591 -                        best->stat_compr_new_size  += best_dlen;
4592 -                        ret = best->compr;
4593 -                }
4594 -                spin_unlock(&jffs2_compressor_list_lock);
4595 -                break;
4596 -        default:
4597 -                printk(KERN_ERR "JFFS2: unknow compression mode.\n");
4598 -        }
4599 +       int compr_ret;
4600 +       struct jffs2_compressor *this, *best=NULL;
4601 +       unsigned char *output_buf = NULL, *tmp_buf;
4602 +       uint32_t orig_slen, orig_dlen;
4603 +       uint32_t best_slen=0, best_dlen=0;
4604 +
4605 +       switch (jffs2_compression_mode) {
4606 +       case JFFS2_COMPR_MODE_NONE:
4607 +               break;
4608 +       case JFFS2_COMPR_MODE_PRIORITY:
4609 +               output_buf = kmalloc(*cdatalen,GFP_KERNEL);
4610 +               if (!output_buf) {
4611 +                       printk(KERN_WARNING "JFFS2: No memory for compressor allocation. Compression failed.\n");
4612 +                       goto out;
4613 +               }
4614 +               orig_slen = *datalen;
4615 +               orig_dlen = *cdatalen;
4616 +               spin_lock(&jffs2_compressor_list_lock);
4617 +               list_for_each_entry(this, &jffs2_compressor_list, list) {
4618 +                       /* Skip decompress-only backwards-compatibility and disabled modules */
4619 +                       if ((!this->compress)||(this->disabled))
4620 +                               continue;
4621 +
4622 +                       this->usecount++;
4623 +                       spin_unlock(&jffs2_compressor_list_lock);
4624 +                       *datalen  = orig_slen;
4625 +                       *cdatalen = orig_dlen;
4626 +                       compr_ret = this->compress(data_in, output_buf, datalen, cdatalen, NULL);
4627 +                       spin_lock(&jffs2_compressor_list_lock);
4628 +                       this->usecount--;
4629 +                       if (!compr_ret) {
4630 +                               ret = this->compr;
4631 +                               this->stat_compr_blocks++;
4632 +                               this->stat_compr_orig_size += *datalen;
4633 +                               this->stat_compr_new_size  += *cdatalen;
4634 +                               break;
4635 +                       }
4636 +               }
4637 +               spin_unlock(&jffs2_compressor_list_lock);
4638 +               if (ret == JFFS2_COMPR_NONE)
4639 +                       kfree(output_buf);
4640 +               break;
4641 +       case JFFS2_COMPR_MODE_SIZE:
4642 +               orig_slen = *datalen;
4643 +               orig_dlen = *cdatalen;
4644 +               spin_lock(&jffs2_compressor_list_lock);
4645 +               list_for_each_entry(this, &jffs2_compressor_list, list) {
4646 +                       /* Skip decompress-only backwards-compatibility and disabled modules */
4647 +                       if ((!this->compress)||(this->disabled))
4648 +                               continue;
4649 +                       /* Allocating memory for output buffer if necessary */
4650 +                       if ((this->compr_buf_size<orig_dlen)&&(this->compr_buf)) {
4651 +                               spin_unlock(&jffs2_compressor_list_lock);
4652 +                               kfree(this->compr_buf);
4653 +                               spin_lock(&jffs2_compressor_list_lock);
4654 +                               this->compr_buf_size=0;
4655 +                               this->compr_buf=NULL;
4656 +                       }
4657 +                       if (!this->compr_buf) {
4658 +                               spin_unlock(&jffs2_compressor_list_lock);
4659 +                               tmp_buf = kmalloc(orig_dlen,GFP_KERNEL);
4660 +                               spin_lock(&jffs2_compressor_list_lock);
4661 +                               if (!tmp_buf) {
4662 +                                       printk(KERN_WARNING "JFFS2: No memory for compressor allocation. (%d bytes)\n",orig_dlen);
4663 +                                       continue;
4664 +                               }
4665 +                               else {
4666 +                                       this->compr_buf = tmp_buf;
4667 +                                       this->compr_buf_size = orig_dlen;
4668 +                               }
4669 +                       }
4670 +                       this->usecount++;
4671 +                       spin_unlock(&jffs2_compressor_list_lock);
4672 +                       *datalen  = orig_slen;
4673 +                       *cdatalen = orig_dlen;
4674 +                       compr_ret = this->compress(data_in, this->compr_buf, datalen, cdatalen, NULL);
4675 +                       spin_lock(&jffs2_compressor_list_lock);
4676 +                       this->usecount--;
4677 +                       if (!compr_ret) {
4678 +                               if ((!best_dlen)||(best_dlen>*cdatalen)) {
4679 +                                       best_dlen = *cdatalen;
4680 +                                       best_slen = *datalen;
4681 +                                       best = this;
4682 +                               }
4683 +                       }
4684 +               }
4685 +               if (best_dlen) {
4686 +                       *cdatalen = best_dlen;
4687 +                       *datalen  = best_slen;
4688 +                       output_buf = best->compr_buf;
4689 +                       best->compr_buf = NULL;
4690 +                       best->compr_buf_size = 0;
4691 +                       best->stat_compr_blocks++;
4692 +                       best->stat_compr_orig_size += best_slen;
4693 +                       best->stat_compr_new_size  += best_dlen;
4694 +                       ret = best->compr;
4695 +               }
4696 +               spin_unlock(&jffs2_compressor_list_lock);
4697 +               break;
4698 +       default:
4699 +               printk(KERN_ERR "JFFS2: unknow compression mode.\n");
4700 +       }
4701   out:
4702 -        if (ret == JFFS2_COMPR_NONE) {
4703 -               *cpage_out = data_in;
4704 -               *datalen = *cdatalen;
4705 -                none_stat_compr_blocks++;
4706 -                none_stat_compr_size += *datalen;
4707 -        }
4708 -        else {
4709 -                *cpage_out = output_buf;
4710 -        }
4711 +       if (ret == JFFS2_COMPR_NONE) {
4712 +               *cpage_out = data_in;
4713 +               *datalen = *cdatalen;
4714 +               none_stat_compr_blocks++;
4715 +               none_stat_compr_size += *datalen;
4716 +       }
4717 +       else {
4718 +               *cpage_out = output_buf;
4719 +       }
4720         return ret;
4721  }
4722
4723 @@ -165,8 +166,8 @@ int jffs2_decompress(struct jffs2_sb_inf
4724                      uint16_t comprtype, unsigned char *cdata_in,
4725                      unsigned char *data_out, uint32_t cdatalen, uint32_t datalen)
4726  {
4727 -        struct jffs2_compressor *this;
4728 -        int ret;
4729 +       struct jffs2_compressor *this;
4730 +       int ret;
4731
4732         /* Older code had a bug where it would write non-zero 'usercompr'
4733            fields. Deal with it. */
4734 @@ -177,32 +178,32 @@ int jffs2_decompress(struct jffs2_sb_inf
4735         case JFFS2_COMPR_NONE:
4736                 /* This should be special-cased elsewhere, but we might as well deal with it */
4737                 memcpy(data_out, cdata_in, datalen);
4738 -                none_stat_decompr_blocks++;
4739 +               none_stat_decompr_blocks++;
4740                 break;
4741         case JFFS2_COMPR_ZERO:
4742                 memset(data_out, 0, datalen);
4743                 break;
4744         default:
4745 -                spin_lock(&jffs2_compressor_list_lock);
4746 -                list_for_each_entry(this, &jffs2_compressor_list, list) {
4747 -                        if (comprtype == this->compr) {
4748 -                                this->usecount++;
4749 -                                spin_unlock(&jffs2_compressor_list_lock);
4750 -                                ret = this->decompress(cdata_in, data_out, cdatalen, datalen, NULL);
4751 -                                spin_lock(&jffs2_compressor_list_lock);
4752 -                                if (ret) {
4753 -                                        printk(KERN_WARNING "Decompressor \"%s\" returned %d\n", this->name, ret);
4754 -                                }
4755 -                                else {
4756 -                                        this->stat_decompr_blocks++;
4757 -                                }
4758 -                                this->usecount--;
4759 -                                spin_unlock(&jffs2_compressor_list_lock);
4760 -                                return ret;
4761 -                        }
4762 -                }
4763 +               spin_lock(&jffs2_compressor_list_lock);
4764 +               list_for_each_entry(this, &jffs2_compressor_list, list) {
4765 +                       if (comprtype == this->compr) {
4766 +                               this->usecount++;
4767 +                               spin_unlock(&jffs2_compressor_list_lock);
4768 +                               ret = this->decompress(cdata_in, data_out, cdatalen, datalen, NULL);
4769 +                               spin_lock(&jffs2_compressor_list_lock);
4770 +                               if (ret) {
4771 +                                       printk(KERN_WARNING "Decompressor \"%s\" returned %d\n", this->name, ret);
4772 +                               }
4773 +                               else {
4774 +                                       this->stat_decompr_blocks++;
4775 +                               }
4776 +                               this->usecount--;
4777 +                               spin_unlock(&jffs2_compressor_list_lock);
4778 +                               return ret;
4779 +                       }
4780 +               }
4781                 printk(KERN_WARNING "JFFS2 compression type 0x%02x not available.\n", comprtype);
4782 -                spin_unlock(&jffs2_compressor_list_lock);
4783 +               spin_unlock(&jffs2_compressor_list_lock);
4784                 return -EIO;
4785         }
4786         return 0;
4787 @@ -210,108 +211,108 @@ int jffs2_decompress(struct jffs2_sb_inf
4788
4789  int jffs2_register_compressor(struct jffs2_compressor *comp)
4790  {
4791 -        struct jffs2_compressor *this;
4792 +       struct jffs2_compressor *this;
4793
4794 -        if (!comp->name) {
4795 -                printk(KERN_WARNING "NULL compressor name at registering JFFS2 compressor. Failed.\n");
4796 -                return -1;
4797 -        }
4798 -        comp->compr_buf_size=0;
4799 -        comp->compr_buf=NULL;
4800 -        comp->usecount=0;
4801 -        comp->stat_compr_orig_size=0;
4802 -        comp->stat_compr_new_size=0;
4803 -        comp->stat_compr_blocks=0;
4804 -        comp->stat_decompr_blocks=0;
4805 -        D1(printk(KERN_DEBUG "Registering JFFS2 compressor \"%s\"\n", comp->name));
4806 -
4807 -        spin_lock(&jffs2_compressor_list_lock);
4808 -
4809 -        list_for_each_entry(this, &jffs2_compressor_list, list) {
4810 -                if (this->priority < comp->priority) {
4811 -                        list_add(&comp->list, this->list.prev);
4812 -                        goto out;
4813 -                }
4814 -        }
4815 -        list_add_tail(&comp->list, &jffs2_compressor_list);
4816 +       if (!comp->name) {
4817 +               printk(KERN_WARNING "NULL compressor name at registering JFFS2 compressor. Failed.\n");
4818 +               return -1;
4819 +       }
4820 +       comp->compr_buf_size=0;
4821 +       comp->compr_buf=NULL;
4822 +       comp->usecount=0;
4823 +       comp->stat_compr_orig_size=0;
4824 +       comp->stat_compr_new_size=0;
4825 +       comp->stat_compr_blocks=0;
4826 +       comp->stat_decompr_blocks=0;
4827 +       D1(printk(KERN_DEBUG "Registering JFFS2 compressor \"%s\"\n", comp->name));
4828 +
4829 +       spin_lock(&jffs2_compressor_list_lock);
4830 +
4831 +       list_for_each_entry(this, &jffs2_compressor_list, list) {
4832 +               if (this->priority < comp->priority) {
4833 +                       list_add(&comp->list, this->list.prev);
4834 +                       goto out;
4835 +               }
4836 +       }
4837 +       list_add_tail(&comp->list, &jffs2_compressor_list);
4838  out:
4839 -        D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
4840 -                printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
4841 -        })
4842 +       D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
4843 +               printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
4844 +       })
4845
4846 -        spin_unlock(&jffs2_compressor_list_lock);
4847 +       spin_unlock(&jffs2_compressor_list_lock);
4848
4849 -        return 0;
4850 +       return 0;
4851  }
4852
4853  int jffs2_unregister_compressor(struct jffs2_compressor *comp)
4854  {
4855 -        D2(struct jffs2_compressor *this;)
4856 +       D2(struct jffs2_compressor *this;)
4857 +
4858 +       D1(printk(KERN_DEBUG "Unregistering JFFS2 compressor \"%s\"\n", comp->name));
4859
4860 -        D1(printk(KERN_DEBUG "Unregistering JFFS2 compressor \"%s\"\n", comp->name));
4861 +       spin_lock(&jffs2_compressor_list_lock);
4862
4863 -        spin_lock(&jffs2_compressor_list_lock);
4864 +       if (comp->usecount) {
4865 +               spin_unlock(&jffs2_compressor_list_lock);
4866 +               printk(KERN_WARNING "JFFS2: Compressor modul is in use. Unregister failed.\n");
4867 +               return -1;
4868 +       }
4869 +       list_del(&comp->list);
4870
4871 -        if (comp->usecount) {
4872 -                spin_unlock(&jffs2_compressor_list_lock);
4873 -                printk(KERN_WARNING "JFFS2: Compressor modul is in use. Unregister failed.\n");
4874 -                return -1;
4875 -        }
4876 -        list_del(&comp->list);
4877 -
4878 -        D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
4879 -                printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
4880 -        })
4881 -        spin_unlock(&jffs2_compressor_list_lock);
4882 -        return 0;
4883 +       D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
4884 +               printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
4885 +       })
4886 +       spin_unlock(&jffs2_compressor_list_lock);
4887 +       return 0;
4888  }
4889
4890  void jffs2_free_comprbuf(unsigned char *comprbuf, unsigned char *orig)
4891  {
4892 -        if (orig != comprbuf)
4893 -                kfree(comprbuf);
4894 +       if (orig != comprbuf)
4895 +               kfree(comprbuf);
4896  }
4897
4898  int __init jffs2_compressors_init(void)
4899  {
4900  /* Registering compressors */
4901  #ifdef CONFIG_JFFS2_ZLIB
4902 -        jffs2_zlib_init();
4903 +       jffs2_zlib_init();
4904  #endif
4905  #ifdef CONFIG_JFFS2_RTIME
4906 -        jffs2_rtime_init();
4907 +       jffs2_rtime_init();
4908  #endif
4909  #ifdef CONFIG_JFFS2_RUBIN
4910 -        jffs2_rubinmips_init();
4911 -        jffs2_dynrubin_init();
4912 +       jffs2_rubinmips_init();
4913 +       jffs2_dynrubin_init();
4914  #endif
4915  /* Setting default compression mode */
4916  #ifdef CONFIG_JFFS2_CMODE_NONE
4917 -        jffs2_compression_mode = JFFS2_COMPR_MODE_NONE;
4918 -        D1(printk(KERN_INFO "JFFS2: default compression mode: none\n");)
4919 +       jffs2_compression_mode = JFFS2_COMPR_MODE_NONE;
4920 +       D1(printk(KERN_INFO "JFFS2: default compression mode: none\n");)
4921  #else
4922  #ifdef CONFIG_JFFS2_CMODE_SIZE
4923 -        jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE;
4924 -        D1(printk(KERN_INFO "JFFS2: default compression mode: size\n");)
4925 +       jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE;
4926 +       D1(printk(KERN_INFO "JFFS2: default compression mode: size\n");)
4927  #else
4928 -        D1(printk(KERN_INFO "JFFS2: default compression mode: priority\n");)
4929 +       D1(printk(KERN_INFO "JFFS2: default compression mode: priority\n");)
4930  #endif
4931  #endif
4932 -        return 0;
4933 +       return 0;
4934  }
4935
4936  int jffs2_compressors_exit(void)
4937  {
4938  /* Unregistering compressors */
4939  #ifdef CONFIG_JFFS2_RUBIN
4940 -        jffs2_dynrubin_exit();
4941 -        jffs2_rubinmips_exit();
4942 +       jffs2_dynrubin_exit();
4943 +       jffs2_rubinmips_exit();
4944  #endif
4945  #ifdef CONFIG_JFFS2_RTIME
4946 -        jffs2_rtime_exit();
4947 +       jffs2_rtime_exit();
4948  #endif
4949  #ifdef CONFIG_JFFS2_ZLIB
4950 -        jffs2_zlib_exit();
4951 +       jffs2_zlib_exit();
4952  #endif
4953 -        return 0;
4954 +       return 0;
4955  }
4956 Index: linux-2.6.23.17/fs/jffs2/compr.h
4957 ===================================================================
4958 --- linux-2.6.23.17.orig/fs/jffs2/compr.h
4959 +++ linux-2.6.23.17/fs/jffs2/compr.h
4960 @@ -2,7 +2,7 @@
4961   * JFFS2 -- Journalling Flash File System, Version 2.
4962   *
4963   * Copyright © 2004   Ferenc Havasi <havasi@inf.u-szeged.hu>,
4964 - *                    University of Szeged, Hungary
4965 + *                   University of Szeged, Hungary
4966   *
4967   * For licensing information, see the file 'LICENCE' in this directory.
4968   *
4969 @@ -32,29 +32,29 @@
4970  #define JFFS2_ZLIB_PRIORITY      60
4971
4972  #define JFFS2_RUBINMIPS_DISABLED /* RUBINs will be used only */
4973 -#define JFFS2_DYNRUBIN_DISABLED  /*        for decompression */
4974 +#define JFFS2_DYNRUBIN_DISABLED  /*       for decompression */
4975
4976  #define JFFS2_COMPR_MODE_NONE       0
4977  #define JFFS2_COMPR_MODE_PRIORITY   1
4978  #define JFFS2_COMPR_MODE_SIZE       2
4979
4980  struct jffs2_compressor {
4981 -        struct list_head list;
4982 -        int priority;              /* used by prirority comr. mode */
4983 -        char *name;
4984 -        char compr;                /* JFFS2_COMPR_XXX */
4985 -        int (*compress)(unsigned char *data_in, unsigned char *cpage_out,
4986 -                        uint32_t *srclen, uint32_t *destlen, void *model);
4987 -        int (*decompress)(unsigned char *cdata_in, unsigned char *data_out,
4988 -                        uint32_t cdatalen, uint32_t datalen, void *model);
4989 -        int usecount;
4990 -        int disabled;              /* if seted the compressor won't compress */
4991 -        unsigned char *compr_buf;  /* used by size compr. mode */
4992 -        uint32_t compr_buf_size;   /* used by size compr. mode */
4993 -        uint32_t stat_compr_orig_size;
4994 -        uint32_t stat_compr_new_size;
4995 -        uint32_t stat_compr_blocks;
4996 -        uint32_t stat_decompr_blocks;
4997 +       struct list_head list;
4998 +       int priority;                   /* used by prirority comr. mode */
4999 +       char *name;
5000 +       char compr;                     /* JFFS2_COMPR_XXX */
5001 +       int (*compress)(unsigned char *data_in, unsigned char *cpage_out,
5002 +                       uint32_t *srclen, uint32_t *destlen, void *model);
5003 +       int (*decompress)(unsigned char *cdata_in, unsigned char *data_out,
5004 +                         uint32_t cdatalen, uint32_t datalen, void *model);
5005 +       int usecount;
5006 +       int disabled;           /* if set the compressor won't compress */
5007 +       unsigned char *compr_buf;       /* used by size compr. mode */
5008 +       uint32_t compr_buf_size;        /* used by size compr. mode */
5009 +       uint32_t stat_compr_orig_size;
5010 +       uint32_t stat_compr_new_size;
5011 +       uint32_t stat_compr_blocks;
5012 +       uint32_t stat_decompr_blocks;
5013  };
5014
5015  int jffs2_register_compressor(struct jffs2_compressor *comp);
5016 @@ -64,12 +64,12 @@ int jffs2_compressors_init(void);
5017  int jffs2_compressors_exit(void);
5018
5019  uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
5020 -                             unsigned char *data_in, unsigned char **cpage_out,
5021 -                             uint32_t *datalen, uint32_t *cdatalen);
5022 +                       unsigned char *data_in, unsigned char **cpage_out,
5023 +                       uint32_t *datalen, uint32_t *cdatalen);
5024
5025  int jffs2_decompress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
5026 -                     uint16_t comprtype, unsigned char *cdata_in,
5027 -                     unsigned char *data_out, uint32_t cdatalen, uint32_t datalen);
5028 +                    uint16_t comprtype, unsigned char *cdata_in,
5029 +                    unsigned char *data_out, uint32_t cdatalen, uint32_t datalen);
5030
5031  void jffs2_free_comprbuf(unsigned char *comprbuf, unsigned char *orig);
5032
5033 Index: linux-2.6.23.17/fs/jffs2/compr_rtime.c
5034 ===================================================================
5035 --- linux-2.6.23.17.orig/fs/jffs2/compr_rtime.c
5036 +++ linux-2.6.23.17/fs/jffs2/compr_rtime.c
5037 @@ -104,7 +104,7 @@ static int jffs2_rtime_decompress(unsign
5038                         }
5039                 }
5040         }
5041 -        return 0;
5042 +       return 0;
5043  }
5044
5045  static struct jffs2_compressor jffs2_rtime_comp = {
5046 Index: linux-2.6.23.17/fs/jffs2/compr_rubin.c
5047 ===================================================================
5048 --- linux-2.6.23.17.orig/fs/jffs2/compr_rubin.c
5049 +++ linux-2.6.23.17/fs/jffs2/compr_rubin.c
5050 @@ -384,7 +384,7 @@ static int jffs2_rubinmips_decompress(un
5051                                       void *model)
5052  {
5053         rubin_do_decompress(BIT_DIVIDER_MIPS, bits_mips, data_in, cpage_out, sourcelen, dstlen);
5054 -        return 0;
5055 +       return 0;
5056  }
5057
5058  static int jffs2_dynrubin_decompress(unsigned char *data_in,
5059 @@ -399,7 +399,7 @@ static int jffs2_dynrubin_decompress(uns
5060                 bits[c] = data_in[c];
5061
5062         rubin_do_decompress(256, bits, data_in+8, cpage_out, sourcelen-8, dstlen);
5063 -        return 0;
5064 +       return 0;
5065  }
5066
5067  static struct jffs2_compressor jffs2_rubinmips_comp = {
5068 Index: linux-2.6.23.17/fs/jffs2/compr_zlib.c
5069 ===================================================================
5070 --- linux-2.6.23.17.orig/fs/jffs2/compr_zlib.c
5071 +++ linux-2.6.23.17/fs/jffs2/compr_zlib.c
5072 @@ -181,7 +181,7 @@ static int jffs2_zlib_decompress(unsigne
5073         }
5074         zlib_inflateEnd(&inf_strm);
5075         mutex_unlock(&inflate_mutex);
5076 -        return 0;
5077 +       return 0;
5078  }
5079
5080  static struct jffs2_compressor jffs2_zlib_comp = {
5081 @@ -203,11 +203,11 @@ int __init jffs2_zlib_init(void)
5082
5083      ret = alloc_workspaces();
5084      if (ret)
5085 -        return ret;
5086 +           return ret;
5087
5088      ret = jffs2_register_compressor(&jffs2_zlib_comp);
5089      if (ret)
5090 -        free_workspaces();
5091 +           free_workspaces();
5092
5093      return ret;
5094  }
5095 Index: linux-2.6.23.17/fs/jffs2/dir.c
5096 ===================================================================
5097 --- linux-2.6.23.17.orig/fs/jffs2/dir.c
5098 +++ linux-2.6.23.17/fs/jffs2/dir.c
5099 @@ -32,7 +32,7 @@ static int jffs2_mkdir (struct inode *,s
5100  static int jffs2_rmdir (struct inode *,struct dentry *);
5101  static int jffs2_mknod (struct inode *,struct dentry *,int,dev_t);
5102  static int jffs2_rename (struct inode *, struct dentry *,
5103 -                        struct inode *, struct dentry *);
5104 +                        struct inode *, struct dentry *);
5105
5106  const struct file_operations jffs2_dir_operations =
5107  {
5108 @@ -770,7 +770,7 @@ static int jffs2_mknod (struct inode *di
5109  }
5110
5111  static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
5112 -                        struct inode *new_dir_i, struct dentry *new_dentry)
5113 +                        struct inode *new_dir_i, struct dentry *new_dentry)
5114  {
5115         int ret;
5116         struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
5117 Index: linux-2.6.23.17/fs/jffs2/erase.c
5118 ===================================================================
5119 --- linux-2.6.23.17.orig/fs/jffs2/erase.c
5120 +++ linux-2.6.23.17/fs/jffs2/erase.c
5121 @@ -38,8 +38,8 @@ static void jffs2_erase_block(struct jff
5122  #ifdef __ECOS
5123         ret = jffs2_flash_erase(c, jeb);
5124         if (!ret) {
5125 -               jffs2_erase_succeeded(c, jeb);
5126 -               return;
5127 +              jffs2_erase_succeeded(c, jeb);
5128 +              return;
5129         }
5130         bad_offset = jeb->offset;
5131  #else /* Linux */
5132 @@ -50,12 +50,14 @@ static void jffs2_erase_block(struct jff
5133         instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL);
5134         if (!instr) {
5135                 printk(KERN_WARNING "kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n");
5136 +               down(&c->erase_free_sem);
5137                 spin_lock(&c->erase_completion_lock);
5138                 list_move(&jeb->list, &c->erase_pending_list);
5139                 c->erasing_size -= c->sector_size;
5140                 c->dirty_size += c->sector_size;
5141                 jeb->dirty_size = c->sector_size;
5142                 spin_unlock(&c->erase_completion_lock);
5143 +               up(&c->erase_free_sem);
5144                 return;
5145         }
5146
5147 @@ -82,12 +84,14 @@ static void jffs2_erase_block(struct jff
5148         if (ret == -ENOMEM || ret == -EAGAIN) {
5149                 /* Erase failed immediately. Refile it on the list */
5150                 D1(printk(KERN_DEBUG "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n", jeb->offset, ret));
5151 +               down(&c->erase_free_sem);
5152                 spin_lock(&c->erase_completion_lock);
5153                 list_move(&jeb->list, &c->erase_pending_list);
5154                 c->erasing_size -= c->sector_size;
5155                 c->dirty_size += c->sector_size;
5156                 jeb->dirty_size = c->sector_size;
5157                 spin_unlock(&c->erase_completion_lock);
5158 +               up(&c->erase_free_sem);
5159                 return;
5160         }
5161
5162 @@ -114,6 +118,7 @@ void jffs2_erase_pending_blocks(struct j
5163                         jeb = list_entry(c->erase_complete_list.next, struct jffs2_eraseblock, list);
5164                         list_del(&jeb->list);
5165                         spin_unlock(&c->erase_completion_lock);
5166 +                       up(&c->erase_free_sem);
5167                         jffs2_mark_erased_block(c, jeb);
5168
5169                         if (!--count) {
5170 @@ -134,6 +139,7 @@ void jffs2_erase_pending_blocks(struct j
5171                         jffs2_free_jeb_node_refs(c, jeb);
5172                         list_add(&jeb->list, &c->erasing_list);
5173                         spin_unlock(&c->erase_completion_lock);
5174 +                       up(&c->erase_free_sem);
5175
5176                         jffs2_erase_block(c, jeb);
5177
5178 @@ -142,23 +148,25 @@ void jffs2_erase_pending_blocks(struct j
5179                 }
5180
5181                 /* Be nice */
5182 -               cond_resched();
5183 +               yield();
5184 +               down(&c->erase_free_sem);
5185                 spin_lock(&c->erase_completion_lock);
5186         }
5187
5188         spin_unlock(&c->erase_completion_lock);
5189 +       up(&c->erase_free_sem);
5190   done:
5191         D1(printk(KERN_DEBUG "jffs2_erase_pending_blocks completed\n"));
5192 -
5193 -       up(&c->erase_free_sem);
5194  }
5195
5196  static void jffs2_erase_succeeded(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
5197  {
5198         D1(printk(KERN_DEBUG "Erase completed successfully at 0x%08x\n", jeb->offset));
5199 +       down(&c->erase_free_sem);
5200         spin_lock(&c->erase_completion_lock);
5201         list_move_tail(&jeb->list, &c->erase_complete_list);
5202         spin_unlock(&c->erase_completion_lock);
5203 +       up(&c->erase_free_sem);
5204         /* Ensure that kupdated calls us again to mark them clean */
5205         jffs2_erase_pending_trigger(c);
5206  }
5207 @@ -172,22 +180,26 @@ static void jffs2_erase_failed(struct jf
5208                    failed too many times. */
5209                 if (!jffs2_write_nand_badblock(c, jeb, bad_offset)) {
5210                         /* We'd like to give this block another try. */
5211 +                       down(&c->erase_free_sem);
5212                         spin_lock(&c->erase_completion_lock);
5213                         list_move(&jeb->list, &c->erase_pending_list);
5214                         c->erasing_size -= c->sector_size;
5215                         c->dirty_size += c->sector_size;
5216                         jeb->dirty_size = c->sector_size;
5217                         spin_unlock(&c->erase_completion_lock);
5218 +                       up(&c->erase_free_sem);
5219                         return;
5220                 }
5221         }
5222
5223 +       down(&c->erase_free_sem);
5224         spin_lock(&c->erase_completion_lock);
5225         c->erasing_size -= c->sector_size;
5226         c->bad_size += c->sector_size;
5227         list_move(&jeb->list, &c->bad_list);
5228         c->nr_erasing_blocks--;
5229         spin_unlock(&c->erase_completion_lock);
5230 +       up(&c->erase_free_sem);
5231         wake_up(&c->erase_wait);
5232  }
5233
5234 @@ -317,6 +329,33 @@ static int jffs2_block_check_erase(struc
5235         size_t retlen;
5236         int ret = -EIO;
5237
5238 +       if (c->mtd->point) {
5239 +               unsigned long *wordebuf;
5240 +
5241 +               ret = c->mtd->point(c->mtd, jeb->offset, c->sector_size, &retlen, (unsigned char **)&ebuf);
5242 +               if (ret) {
5243 +                       D1(printk(KERN_DEBUG "MTD point failed %d\n", ret));
5244 +                       goto do_flash_read;
5245 +               }
5246 +               if (retlen < c->sector_size) {
5247 +                       /* Don't muck about if it won't let us point to the whole erase sector */
5248 +                       D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", retlen));
5249 +                       c->mtd->unpoint(c->mtd, ebuf, jeb->offset, c->sector_size);
5250 +                       goto do_flash_read;
5251 +               }
5252 +               wordebuf = ebuf-sizeof(*wordebuf);
5253 +               retlen /= sizeof(*wordebuf);
5254 +               do {
5255 +                  if (*++wordebuf != ~0)
5256 +                          break;
5257 +               } while(--retlen);
5258 +               c->mtd->unpoint(c->mtd, ebuf, jeb->offset, c->sector_size);
5259 +               if (retlen)
5260 +                       printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08x\n",
5261 +                              *wordebuf, jeb->offset + c->sector_size-retlen*sizeof(*wordebuf));
5262 +               return 0;
5263 +       }
5264 + do_flash_read:
5265         ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
5266         if (!ebuf) {
5267                 printk(KERN_WARNING "Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", jeb->offset);
5268 @@ -417,6 +456,7 @@ static void jffs2_mark_erased_block(stru
5269                 jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL);
5270         }
5271
5272 +       down(&c->erase_free_sem);
5273         spin_lock(&c->erase_completion_lock);
5274         c->erasing_size -= c->sector_size;
5275         c->free_size += jeb->free_size;
5276 @@ -429,23 +469,28 @@ static void jffs2_mark_erased_block(stru
5277         c->nr_erasing_blocks--;
5278         c->nr_free_blocks++;
5279         spin_unlock(&c->erase_completion_lock);
5280 +       up(&c->erase_free_sem);
5281         wake_up(&c->erase_wait);
5282         return;
5283
5284  filebad:
5285 +       down(&c->erase_free_sem);
5286         spin_lock(&c->erase_completion_lock);
5287         /* Stick it on a list (any list) so erase_failed can take it
5288            right off again.  Silly, but shouldn't happen often. */
5289         list_add(&jeb->list, &c->erasing_list);
5290         spin_unlock(&c->erase_completion_lock);
5291 +       up(&c->erase_free_sem);
5292         jffs2_erase_failed(c, jeb, bad_offset);
5293         return;
5294
5295  refile:
5296         /* Stick it back on the list from whence it came and come back later */
5297         jffs2_erase_pending_trigger(c);
5298 +       down(&c->erase_free_sem);
5299         spin_lock(&c->erase_completion_lock);
5300         list_add(&jeb->list, &c->erase_complete_list);
5301         spin_unlock(&c->erase_completion_lock);
5302 +       up(&c->erase_free_sem);
5303         return;
5304  }
5305 Index: linux-2.6.23.17/fs/jffs2/gc.c
5306 ===================================================================
5307 --- linux-2.6.23.17.orig/fs/jffs2/gc.c
5308 +++ linux-2.6.23.17/fs/jffs2/gc.c
5309 @@ -556,7 +556,7 @@ static int jffs2_garbage_collect_pristin
5310
5311         node = kmalloc(rawlen, GFP_KERNEL);
5312         if (!node)
5313 -               return -ENOMEM;
5314 +               return -ENOMEM;
5315
5316         ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)node);
5317         if (!ret && retlen != rawlen)
5318 @@ -624,7 +624,7 @@ static int jffs2_garbage_collect_pristin
5319
5320         if (ret || (retlen != rawlen)) {
5321                 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n",
5322 -                       rawlen, phys_ofs, ret, retlen);
5323 +                      rawlen, phys_ofs, ret, retlen);
5324                 if (retlen) {
5325                         jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, rawlen, NULL);
5326                 } else {
5327 Index: linux-2.6.23.17/fs/jffs2/jffs2_fs_sb.h
5328 ===================================================================
5329 --- linux-2.6.23.17.orig/fs/jffs2/jffs2_fs_sb.h
5330 +++ linux-2.6.23.17/fs/jffs2/jffs2_fs_sb.h
5331 @@ -106,6 +106,9 @@ struct jffs2_sb_info {
5332
5333         uint32_t wbuf_pagesize; /* 0 for NOR and other flashes with no wbuf */
5334
5335 +#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
5336 +       unsigned char *wbuf_verify; /* read-back buffer for verification */
5337 +#endif
5338  #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
5339         unsigned char *wbuf; /* Write-behind buffer for NAND flash */
5340         uint32_t wbuf_ofs;
5341 Index: linux-2.6.23.17/fs/jffs2/nodelist.h
5342 ===================================================================
5343 --- linux-2.6.23.17.orig/fs/jffs2/nodelist.h
5344 +++ linux-2.6.23.17/fs/jffs2/nodelist.h
5345 @@ -127,7 +127,7 @@ static inline struct jffs2_inode_cache *
5346         return ((struct jffs2_inode_cache *)raw);
5347  }
5348
5349 -        /* flash_offset & 3 always has to be zero, because nodes are
5350 +       /* flash_offset & 3 always has to be zero, because nodes are
5351            always aligned at 4 bytes. So we have a couple of extra bits
5352            to play with, which indicate the node's status; see below: */
5353  #define REF_UNCHECKED  0       /* We haven't yet checked the CRC or built its inode */
5354 @@ -197,7 +197,7 @@ struct jffs2_inode_cache {
5355  #define RAWNODE_CLASS_XATTR_DATUM      1
5356  #define RAWNODE_CLASS_XATTR_REF                2
5357
5358 -#define INOCACHE_HASHSIZE 128
5359 +#define INOCACHE_HASHSIZE 1024
5360
5361  #define write_ofs(c) ((c)->nextblock->offset + (c)->sector_size - (c)->nextblock->free_size)
5362
5363 Index: linux-2.6.23.17/fs/jffs2/nodemgmt.c
5364 ===================================================================
5365 --- linux-2.6.23.17.orig/fs/jffs2/nodemgmt.c
5366 +++ linux-2.6.23.17/fs/jffs2/nodemgmt.c
5367 @@ -154,7 +154,7 @@ int jffs2_reserve_space_gc(struct jffs2_
5368         while(ret == -EAGAIN) {
5369                 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
5370                 if (ret) {
5371 -                       D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
5372 +                       D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
5373                 }
5374         }
5375         spin_unlock(&c->erase_completion_lock);
5376 @@ -423,7 +423,12 @@ struct jffs2_raw_node_ref *jffs2_add_phy
5377            even after refiling c->nextblock */
5378         if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
5379             && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
5380 -               printk(KERN_WARNING "argh. node added in wrong place\n");
5381 +               printk(KERN_WARNING "argh. node added in wrong place at 0x%08x(%d)\n", ofs & ~3, ofs & 3);
5382 +               if (c->nextblock)
5383 +                       printk(KERN_WARNING "nextblock 0x%08x", c->nextblock->offset);
5384 +               else
5385 +                       printk(KERN_WARNING "No nextblock");
5386 +               printk(", expected at %08x\n", jeb->offset + (c->sector_size - jeb->free_size));
5387                 return ERR_PTR(-EINVAL);
5388         }
5389  #endif
5390 Index: linux-2.6.23.17/fs/jffs2/readinode.c
5391 ===================================================================
5392 --- linux-2.6.23.17.orig/fs/jffs2/readinode.c
5393 +++ linux-2.6.23.17/fs/jffs2/readinode.c
5394 @@ -211,7 +211,7 @@ static void jffs2_kill_tn(struct jffs2_s
5395   * ordering.
5396   *
5397   * Returns 0 if the node was handled (including marking it obsolete)
5398 - *         < 0 an if error occurred
5399 + *      < 0 an if error occurred
5400   */
5401  static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c,
5402                                 struct jffs2_readinode_info *rii,
5403 @@ -862,8 +862,8 @@ static inline int read_unknown(struct jf
5404                 JFFS2_ERROR("REF_UNCHECKED but unknown node at %#08x\n",
5405                             ref_offset(ref));
5406                 JFFS2_ERROR("Node is {%04x,%04x,%08x,%08x}. Please report this error.\n",
5407 -                            je16_to_cpu(un->magic), je16_to_cpu(un->nodetype),
5408 -                            je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc));
5409 +                           je16_to_cpu(un->magic), je16_to_cpu(un->nodetype),
5410 +                           je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc));
5411                 jffs2_mark_node_obsolete(c, ref);
5412                 return 0;
5413         }
5414 Index: linux-2.6.23.17/fs/jffs2/scan.c
5415 ===================================================================
5416 --- linux-2.6.23.17.orig/fs/jffs2/scan.c
5417 +++ linux-2.6.23.17/fs/jffs2/scan.c
5418 @@ -877,7 +877,7 @@ scan_more:
5419                         switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
5420                         case JFFS2_FEATURE_ROCOMPAT:
5421                                 printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs);
5422 -                               c->flags |= JFFS2_SB_FLAG_RO;
5423 +                               c->flags |= JFFS2_SB_FLAG_RO;
5424                                 if (!(jffs2_is_readonly(c)))
5425                                         return -EROFS;
5426                                 if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
5427 Index: linux-2.6.23.17/fs/jffs2/security.c
5428 ===================================================================
5429 --- linux-2.6.23.17.orig/fs/jffs2/security.c
5430 +++ linux-2.6.23.17/fs/jffs2/security.c
5431 @@ -38,9 +38,9 @@ int jffs2_init_security(struct inode *in
5432         }
5433         rc = do_jffs2_setxattr(inode, JFFS2_XPREFIX_SECURITY, name, value, len, 0);
5434
5435 -        kfree(name);
5436 -        kfree(value);
5437 -        return rc;
5438 +       kfree(name);
5439 +       kfree(value);
5440 +       return rc;
5441  }
5442
5443  /* ---- XATTR Handler for "security.*" ----------------- */
5444 Index: linux-2.6.23.17/fs/jffs2/summary.c
5445 ===================================================================
5446 --- linux-2.6.23.17.orig/fs/jffs2/summary.c
5447 +++ linux-2.6.23.17/fs/jffs2/summary.c
5448 @@ -2,10 +2,10 @@
5449   * JFFS2 -- Journalling Flash File System, Version 2.
5450   *
5451   * Copyright © 2004  Ferenc Havasi <havasi@inf.u-szeged.hu>,
5452 - *                   Zoltan Sogor <weth@inf.u-szeged.hu>,
5453 - *                   Patrik Kluba <pajko@halom.u-szeged.hu>,
5454 - *                   University of Szeged, Hungary
5455 - *             2006  KaiGai Kohei <kaigai@ak.jp.nec.com>
5456 + *                  Zoltan Sogor <weth@inf.u-szeged.hu>,
5457 + *                  Patrik Kluba <pajko@halom.u-szeged.hu>,
5458 + *                  University of Szeged, Hungary
5459 + *            2006  KaiGai Kohei <kaigai@ak.jp.nec.com>
5460   *
5461   * For licensing information, see the file 'LICENCE' in this directory.
5462   *
5463 Index: linux-2.6.23.17/fs/jffs2/summary.h
5464 ===================================================================
5465 --- linux-2.6.23.17.orig/fs/jffs2/summary.h
5466 +++ linux-2.6.23.17/fs/jffs2/summary.h
5467 @@ -2,9 +2,9 @@
5468   * JFFS2 -- Journalling Flash File System, Version 2.
5469   *
5470   * Copyright © 2004  Ferenc Havasi <havasi@inf.u-szeged.hu>,
5471 - *                   Zoltan Sogor <weth@inf.u-szeged.hu>,
5472 - *                   Patrik Kluba <pajko@halom.u-szeged.hu>,
5473 - *                   University of Szeged, Hungary
5474 + *                  Zoltan Sogor <weth@inf.u-szeged.hu>,
5475 + *                  Patrik Kluba <pajko@halom.u-szeged.hu>,
5476 + *                  University of Szeged, Hungary
5477   *
5478   * For licensing information, see the file 'LICENCE' in this directory.
5479   *
5480 Index: linux-2.6.23.17/fs/jffs2/wbuf.c
5481 ===================================================================
5482 --- linux-2.6.23.17.orig/fs/jffs2/wbuf.c
5483 +++ linux-2.6.23.17/fs/jffs2/wbuf.c
5484 @@ -220,6 +220,47 @@ static struct jffs2_raw_node_ref **jffs2
5485         return NULL;
5486  }
5487
5488 +#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
5489 +static int jffs2_verify_write(struct jffs2_sb_info *c, unsigned char *buf,
5490 +                             uint32_t ofs)
5491 +{
5492 +       int ret;
5493 +       size_t retlen;
5494 +       char *eccstr;
5495 +
5496 +       ret = c->mtd->read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify);
5497 +       if (ret && ret != -EUCLEAN && ret != -EBADMSG) {
5498 +               printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x failed: %d\n", c->wbuf_ofs, ret);
5499 +               return ret;
5500 +       } else if (retlen != c->wbuf_pagesize) {
5501 +               printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x gave short read: %zd not %d.\n", ofs, retlen, c->wbuf_pagesize);
5502 +               return -EIO;
5503 +       }
5504 +       if (!memcmp(buf, c->wbuf_verify, c->wbuf_pagesize))
5505 +               return 0;
5506 +
5507 +       if (ret == -EUCLEAN)
5508 +               eccstr = "corrected";
5509 +       else if (ret == -EBADMSG)
5510 +               eccstr = "correction failed";
5511 +       else
5512 +               eccstr = "OK or unused";
5513 +
5514 +       printk(KERN_WARNING "Write verify error (ECC %s) at %08x. Wrote:\n",
5515 +              eccstr, c->wbuf_ofs);
5516 +       print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
5517 +                      c->wbuf, c->wbuf_pagesize, 0);
5518 +
5519 +       printk(KERN_WARNING "Read back:\n");
5520 +       print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
5521 +                      c->wbuf_verify, c->wbuf_pagesize, 0);
5522 +
5523 +       return -EIO;
5524 +}
5525 +#else
5526 +#define jffs2_verify_write(c,b,o) (0)
5527 +#endif
5528 +
5529  /* Recover from failure to write wbuf. Recover the nodes up to the
5530   * wbuf, not the one which we were starting to try to write. */
5531
5532 @@ -380,7 +421,7 @@ static void jffs2_wbuf_recover(struct jf
5533                         ret = c->mtd->write(c->mtd, ofs, towrite, &retlen,
5534                                             rewrite_buf);
5535
5536 -               if (ret || retlen != towrite) {
5537 +               if (ret || retlen != towrite || jffs2_verify_write(c, rewrite_buf, ofs)) {
5538                         /* Argh. We tried. Really we did. */
5539                         printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
5540                         kfree(buf);
5541 @@ -587,15 +628,16 @@ static int __jffs2_flush_wbuf(struct jff
5542
5543                 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
5544
5545 -       if (ret || retlen != c->wbuf_pagesize) {
5546 -               if (ret)
5547 -                       printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
5548 -               else {
5549 -                       printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
5550 -                               retlen, c->wbuf_pagesize);
5551 -                       ret = -EIO;
5552 -               }
5553 -
5554 +       if (ret) {
5555 +               printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n", ret);
5556 +               goto wfail;
5557 +       } else if (retlen != c->wbuf_pagesize) {
5558 +               printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
5559 +                      retlen, c->wbuf_pagesize);
5560 +               ret = -EIO;
5561 +               goto wfail;
5562 +       } else if ((ret = jffs2_verify_write(c, c->wbuf, c->wbuf_ofs))) {
5563 +       wfail:
5564                 jffs2_wbuf_recover(c);
5565
5566                 return ret;
5567 @@ -966,8 +1008,8 @@ exit:
5568
5569  #define NR_OOB_SCAN_PAGES 4
5570
5571 -/* For historical reasons we use only 12 bytes for OOB clean marker */
5572 -#define OOB_CM_SIZE 12
5573 +/* For historical reasons we use only 8 bytes for OOB clean marker */
5574 +#define OOB_CM_SIZE 8
5575
5576  static const struct jffs2_unknown_node oob_cleanmarker =
5577  {
5578 @@ -1021,8 +1063,8 @@ int jffs2_check_oob_empty(struct jffs2_s
5579  /*
5580   * Check for a valid cleanmarker.
5581   * Returns: 0 if a valid cleanmarker was found
5582 - *          1 if no cleanmarker was found
5583 - *          negative error code if an error occurred
5584 + *         1 if no cleanmarker was found
5585 + *         negative error code if an error occurred
5586   */
5587  int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
5588                                  struct jffs2_eraseblock *jeb)
5589 @@ -1138,11 +1180,22 @@ int jffs2_nand_flash_setup(struct jffs2_
5590                 return -ENOMEM;
5591         }
5592
5593 +#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
5594 +       c->wbuf_verify = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
5595 +       if (!c->wbuf_verify) {
5596 +               kfree(c->oobbuf);
5597 +               kfree(c->wbuf);
5598 +               return -ENOMEM;
5599 +       }
5600 +#endif
5601         return 0;
5602  }
5603
5604  void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
5605  {
5606 +#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
5607 +       kfree(c->wbuf_verify);
5608 +#endif
5609         kfree(c->wbuf);
5610         kfree(c->oobbuf);
5611  }
5612 Index: linux-2.6.23.17/fs/jffs2/xattr.h
5613 ===================================================================
5614 --- linux-2.6.23.17.orig/fs/jffs2/xattr.h
5615 +++ linux-2.6.23.17/fs/jffs2/xattr.h
5616 @@ -75,7 +75,7 @@ extern void jffs2_build_xattr_subsystem(
5617  extern void jffs2_clear_xattr_subsystem(struct jffs2_sb_info *c);
5618
5619  extern struct jffs2_xattr_datum *jffs2_setup_xattr_datum(struct jffs2_sb_info *c,
5620 -                                                  uint32_t xid, uint32_t version);
5621 +                                                        uint32_t xid, uint32_t version);
5622
5623  extern void jffs2_xattr_delete_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic);
5624  extern void jffs2_xattr_free_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic);
5625 Index: linux-2.6.23.17/fs/jffs2/xattr_user.c
5626 ===================================================================
5627 --- linux-2.6.23.17.orig/fs/jffs2/xattr_user.c
5628 +++ linux-2.6.23.17/fs/jffs2/xattr_user.c
5629 @@ -17,7 +17,7 @@
5630  #include "nodelist.h"
5631
5632  static int jffs2_user_getxattr(struct inode *inode, const char *name,
5633 -                               void *buffer, size_t size)
5634 +                              void *buffer, size_t size)
5635  {
5636         if (!strcmp(name, ""))
5637                 return -EINVAL;
5638 @@ -25,7 +25,7 @@ static int jffs2_user_getxattr(struct in
5639  }
5640
5641  static int jffs2_user_setxattr(struct inode *inode, const char *name, const void *buffer,
5642 -                               size_t size, int flags)
5643 +                              size_t size, int flags)
5644  {
5645         if (!strcmp(name, ""))
5646                 return -EINVAL;
5647 Index: linux-2.6.23.17/include/asm-i386/geode.h
5648 ===================================================================
5649 --- linux-2.6.23.17.orig/include/asm-i386/geode.h
5650 +++ linux-2.6.23.17/include/asm-i386/geode.h
5651 @@ -135,6 +135,55 @@ static inline void geode_gpio_event_pme(
5652         geode_gpio_setup_event(gpio, pair, 1);
5653  }
5654
5655 +/* MFGPT */
5656 +
5657 +#define MFGPT_TIMER_ANY -1
5658 +
5659 +#define MFGPT_DOMAIN_WORKING 1
5660 +#define MFGPT_DOMAIN_STANDBY 2
5661 +#define MFGPT_DOMAIN_ANY (MFGPT_DOMAIN_WORKING | MFGPT_DOMAIN_STANDBY)
5662 +
5663 +#define MFGPT_CMP1 0
5664 +#define MFGPT_CMP2 1
5665 +
5666 +#define MFGPT_EVENT_IRQ   0
5667 +#define MFGPT_EVENT_NMI   1
5668 +#define MFGPT_EVENT_RESET 3
5669 +
5670 +#define MFGPT_REG_CMP1    0
5671 +#define MFGPT_REG_CMP2    2
5672 +#define MFGPT_REG_COUNTER 4
5673 +#define MFGPT_REG_SETUP   6
5674 +
5675 +#define MFGPT_SETUP_CNTEN  (1 << 15)
5676 +#define MFGPT_SETUP_CMP2   (1 << 14)
5677 +#define MFGPT_SETUP_CMP1   (1 << 13)
5678 +#define MFGPT_SETUP_SETUP  (1 << 12)
5679 +#define MFGPT_SETUP_STOPEN (1 << 11)
5680 +#define MFGPT_SETUP_EXTEN  (1 << 10)
5681 +#define MFGPT_SETUP_REVEN  (1 << 5)
5682 +#define MFGPT_SETUP_CLKSEL (1 << 4)
5683 +
5684 +static inline void geode_mfgpt_write(int timer, u16 reg, u16 value)
5685 +{
5686 +       u32 base = geode_get_dev_base(GEODE_DEV_MFGPT);
5687 +       outw(value, base + reg + (timer * 8));
5688 +}
5689 +
5690 +static inline u16 geode_mfgpt_read(int timer, u16 reg)
5691 +{
5692 +       u32 base = geode_get_dev_base(GEODE_DEV_MFGPT);
5693 +       return inw(base + reg + (timer * 8));
5694 +}
5695 +
5696 +extern int __init geode_mfgpt_detect(void);
5697 +extern int geode_mfgpt_toggle_event(int timer, int cmp, int event, int enable);
5698 +extern int geode_mfgpt_set_irq(int timer, int cmp, int irq, int enable);
5699 +extern int geode_mfgpt_alloc_timer(int timer, int domain, struct module *owner);
5700 +
5701 +#define geode_mfgpt_setup_irq(t,c,i) geode_mfgpt_set_irq((t),(c),(i),1)
5702 +#define geode_mfgpt_release_irq(t,c,i) geode_mfgpt_set_irq((t),(c),(i),0)
5703 +
5704  /* Specific geode tests */
5705
5706  static inline int is_geode_gx(void)
5707 Index: linux-2.6.23.17/include/asm-i386/setup.h
5708 ===================================================================
5709 --- linux-2.6.23.17.orig/include/asm-i386/setup.h
5710 +++ linux-2.6.23.17/include/asm-i386/setup.h
5711 @@ -24,6 +24,7 @@
5712  #define OLD_CL_BASE_ADDR       0x90000
5713  #define OLD_CL_OFFSET          0x90022
5714  #define NEW_CL_POINTER         0x228   /* Relative to real mode data */
5715 +#define OFW_INFO_OFFSET                0xb0    /* Relative to real mode data */
5716
5717  #ifndef __ASSEMBLY__
5718
5719 Index: linux-2.6.23.17/include/linux/console.h
5720 ===================================================================
5721 --- linux-2.6.23.17.orig/include/linux/console.h
5722 +++ linux-2.6.23.17/include/linux/console.h
5723 @@ -121,14 +121,11 @@ extern void console_stop(struct console
5724  extern void console_start(struct console *);
5725  extern int is_console_locked(void);
5726
5727 -#ifndef CONFIG_DISABLE_CONSOLE_SUSPEND
5728 +extern int serial_console_suspend_enabled;
5729 +
5730  /* Suspend and resume console messages over PM events */
5731  extern void suspend_console(void);
5732  extern void resume_console(void);
5733 -#else
5734 -static inline void suspend_console(void) {}
5735 -static inline void resume_console(void) {}
5736 -#endif /* CONFIG_DISABLE_CONSOLE_SUSPEND */
5737
5738  int mda_console_init(void);
5739  void prom_con_init(void);
5740 Index: linux-2.6.23.17/include/linux/fb.h
5741 ===================================================================
5742 --- linux-2.6.23.17.orig/include/linux/fb.h
5743 +++ linux-2.6.23.17/include/linux/fb.h
5744 @@ -664,6 +664,12 @@ struct fb_ops {
5745         /* restore saved state */
5746         void (*fb_restore_state)(struct fb_info *info);
5747
5748 +       /* Shut down the graphics engine to save power */
5749 +       int (*fb_powerdown)(struct fb_info *info);
5750 +
5751 +       /* Power it back up */
5752 +       int (*fb_powerup)(struct fb_info *info);
5753 +
5754         /* get capability given var */
5755         void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
5756                             struct fb_var_screeninfo *var);
5757 @@ -943,6 +949,9 @@ extern int fb_get_color_depth(struct fb_
5758  extern int fb_get_options(char *name, char **option);
5759  extern int fb_new_modelist(struct fb_info *info);
5760
5761 +extern int fb_powerdown(struct fb_info *info);
5762 +extern int fb_powerup(struct fb_info *info);
5763 +
5764  extern struct fb_info *registered_fb[FB_MAX];
5765  extern int num_registered_fb;
5766  extern struct class *fb_class;
5767 Index: linux-2.6.23.17/include/linux/mtd/onenand.h
5768 ===================================================================
5769 --- linux-2.6.23.17.orig/include/linux/mtd/onenand.h
5770 +++ linux-2.6.23.17/include/linux/mtd/onenand.h
5771 @@ -60,6 +60,7 @@ struct onenand_bufferram {
5772   * @erase_shift:       [INTERN] number of address bits in a block
5773   * @page_shift:                [INTERN] number of address bits in a page
5774   * @page_mask:         [INTERN] a page per block mask
5775 + * @writesize:         [INTERN] a real page size
5776   * @bufferram_index:   [INTERN] BufferRAM index
5777   * @bufferram:         [INTERN] BufferRAM info
5778   * @readw:             [REPLACEABLE] hardware specific function for read short
5779 @@ -100,6 +101,7 @@ struct onenand_chip {
5780         unsigned int            erase_shift;
5781         unsigned int            page_shift;
5782         unsigned int            page_mask;
5783 +       unsigned int            writesize;
5784
5785         unsigned int            bufferram_index;
5786         struct onenand_bufferram        bufferram[MAX_BUFFERRAM];
5787 @@ -140,6 +142,8 @@ struct onenand_chip {
5788  #define ONENAND_NEXT_BUFFERRAM(this)           (this->bufferram_index ^ 1)
5789  #define ONENAND_SET_NEXT_BUFFERRAM(this)       (this->bufferram_index ^= 1)
5790  #define ONENAND_SET_PREV_BUFFERRAM(this)       (this->bufferram_index ^= 1)
5791 +#define ONENAND_SET_BUFFERRAM0(this)           (this->bufferram_index = 0)
5792 +#define ONENAND_SET_BUFFERRAM1(this)           (this->bufferram_index = 1)
5793
5794  #define ONENAND_GET_SYS_CFG1(this)                                     \
5795         (this->read_word(this->base + ONENAND_REG_SYS_CFG1))
5796 @@ -149,6 +153,13 @@ struct onenand_chip {
5797  #define ONENAND_IS_DDP(this)                                           \
5798         (this->device_id & ONENAND_DEVICE_IS_DDP)
5799
5800 +#ifdef CONFIG_MTD_ONENAND_2X_PROGRAM
5801 +#define ONENAND_IS_2PLANE(this)                                                \
5802 +       (this->options & ONENAND_HAS_2PLANE)
5803 +#else
5804 +#define ONENAND_IS_2PLANE(this)                        (0)
5805 +#endif
5806 +
5807  /* Check byte access in OneNAND */
5808  #define ONENAND_CHECK_BYTE_ACCESS(addr)                (addr & 0x1)
5809
5810 @@ -157,6 +168,7 @@ struct onenand_chip {
5811   */
5812  #define ONENAND_HAS_CONT_LOCK          (0x0001)
5813  #define ONENAND_HAS_UNLOCK_ALL         (0x0002)
5814 +#define ONENAND_HAS_2PLANE             (0x0004)
5815  #define ONENAND_PAGEBUF_ALLOC          (0x1000)
5816  #define ONENAND_OOBBUF_ALLOC           (0x2000)
5817
5818 Index: linux-2.6.23.17/include/linux/mtd/onenand_regs.h
5819 ===================================================================
5820 --- linux-2.6.23.17.orig/include/linux/mtd/onenand_regs.h
5821 +++ linux-2.6.23.17/include/linux/mtd/onenand_regs.h
5822 @@ -74,6 +74,8 @@
5823
5824  #define ONENAND_DEVICE_DENSITY_512Mb   (0x002)
5825  #define ONENAND_DEVICE_DENSITY_1Gb     (0x003)
5826 +#define ONENAND_DEVICE_DENSITY_2Gb     (0x004)
5827 +#define ONENAND_DEVICE_DENSITY_4Gb     (0x005)
5828
5829  /*
5830   * Version ID Register F002h (R)
5831 @@ -111,6 +113,8 @@
5832  #define ONENAND_CMD_READOOB            (0x13)
5833  #define ONENAND_CMD_PROG               (0x80)
5834  #define ONENAND_CMD_PROGOOB            (0x1A)
5835 +#define ONENAND_CMD_2X_PROG            (0x7D)
5836 +#define ONENAND_CMD_2X_CACHE_PROG      (0x7F)
5837  #define ONENAND_CMD_UNLOCK             (0x23)
5838  #define ONENAND_CMD_LOCK               (0x2A)
5839  #define ONENAND_CMD_LOCK_TIGHT         (0x2C)
5840 Index: linux-2.6.23.17/include/linux/vt_kern.h
5841 ===================================================================
5842 --- linux-2.6.23.17.orig/include/linux/vt_kern.h
5843 +++ linux-2.6.23.17/include/linux/vt_kern.h
5844 @@ -95,4 +95,23 @@ struct vt_spawn_console {
5845  };
5846  extern struct vt_spawn_console vt_spawn_con;
5847
5848 +/* A notifier list for console events  */
5849 +extern struct raw_notifier_head console_notifier_list;
5850 +
5851 +/* Called when the FG console switches to KD_TEXT mode */
5852 +#define CONSOLE_EVENT_SWITCH_TEXT 0x01
5853 +
5854 +/* Called when the FG console switches to KD_GRAPHICS mode */
5855 +#define CONSOLE_EVENT_SWITCH_GRAPHICS 0x02
5856 +
5857 +static inline int console_event_register(struct notifier_block *n)
5858 +{
5859 +       return raw_notifier_chain_register(&console_notifier_list, n);
5860 +}
5861 +
5862 +static inline int console_event_unregister(struct notifier_block *n)
5863 +{
5864 +       return raw_notifier_chain_unregister(&console_notifier_list, n);
5865 +}
5866 +
5867  #endif /* _VT_KERN_H */
5868 Index: linux-2.6.23.17/kernel/power/console.c
5869 ===================================================================
5870 --- linux-2.6.23.17.orig/kernel/power/console.c
5871 +++ linux-2.6.23.17/kernel/power/console.c
5872 @@ -9,7 +9,7 @@
5873  #include <linux/console.h>
5874  #include "power.h"
5875
5876 -#if defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE)
5877 +#if defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE) && !defined(CONFIG_DISABLE_SUSPEND_VT_SWITCH)
5878  #define SUSPEND_CONSOLE        (MAX_NR_CONSOLES-1)
5879
5880  static int orig_fgconsole, orig_kmsg;