linux-moblin: Add 2.6.27 moblin kernel

This will be the default moblin kernel.
We also moved the 2.6.27-rc* kernels to meta-moblin.

meta-moblin/packages/linux/linux-moblin-2.6.27/0001-drm-remove-define-for-non-linux-systems.patch

@@ -0,0 +1,48 @@
+commit 2e6ec7cdc09f36be1cbe9aeaccfc45f307fc0060
+Author: Carlos R. Mafra <crmafra2@gmail.com>
+Date:   Wed Jul 30 12:29:37 2008 -0700
+
+    drm: remove #define's for non-linux systems
+    
+    There is no point in considering FreeBSD et al.  in the linux kernel
+    source code.
+    
+    Signed-off-by: Carlos R. Mafra <crmafra@gmail.com>
+    Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+    Signed-off-by: Dave Airlie <airlied@redhat.com>
+
+diff --git a/include/drm/drm.h b/include/drm/drm.h
+index 38d3c6b..0864c69 100644
+--- a/include/drm/drm.h
++++ b/include/drm/drm.h
+@@ -36,7 +36,6 @@
+ #ifndef _DRM_H_
+ #define _DRM_H_
+ 
+-#if defined(__linux__)
+ #if defined(__KERNEL__)
+ #endif
+ #include <asm/ioctl.h>		/* For _IO* macros */
+@@ -46,22 +45,6 @@
+ #define DRM_IOC_WRITE		_IOC_WRITE
+ #define DRM_IOC_READWRITE	_IOC_READ|_IOC_WRITE
+ #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+-#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+-#if defined(__FreeBSD__) && defined(IN_MODULE)
+-/* Prevent name collision when including sys/ioccom.h */
+-#undef ioctl
+-#include <sys/ioccom.h>
+-#define ioctl(a,b,c)		xf86ioctl(a,b,c)
+-#else
+-#include <sys/ioccom.h>
+-#endif				/* __FreeBSD__ && xf86ioctl */
+-#define DRM_IOCTL_NR(n)		((n) & 0xff)
+-#define DRM_IOC_VOID		IOC_VOID
+-#define DRM_IOC_READ		IOC_OUT
+-#define DRM_IOC_WRITE		IOC_IN
+-#define DRM_IOC_READWRITE	IOC_INOUT
+-#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+-#endif
+ 
+ #define DRM_MAJOR       226
+ #define DRM_MAX_MINOR   15

meta-moblin/packages/linux/linux-moblin-2.6.27/0002-i915-remove-settable-use_mi_batchbuffer_start.patch

@@ -0,0 +1,60 @@
+commit 91019197abbfde388d0b71b0fc8979a936c23fe3
+Author: Keith Packard <keithp@keithp.com>
+Date:   Wed Jul 30 12:28:47 2008 -0700
+
+    i915: remove settable use_mi_batchbuffer_start
+    
+    The driver can know what hardware requires MI_BATCH_BUFFER vs
+    MI_BATCH_BUFFER_START; there's no reason to let user mode configure this.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+    Signed-off-by: Dave Airlie <airlied@redhat.com>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 8897434..24adbde 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -159,13 +159,6 @@ static int i915_initialize(struct drm_device * dev, drm_i915_init_t * init)
+ 	dev_priv->current_page = 0;
+ 	dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
+ 
+-	/* We are using separate values as placeholders for mechanisms for
+-	 * private backbuffer/depthbuffer usage.
+-	 */
+-	dev_priv->use_mi_batchbuffer_start = 0;
+-	if (IS_I965G(dev)) /* 965 doesn't support older method */
+-		dev_priv->use_mi_batchbuffer_start = 1;
+-
+ 	/* Allow hardware batchbuffers unless told otherwise.
+ 	 */
+ 	dev_priv->allow_batchbuffer = 1;
+@@ -486,7 +479,7 @@ static int i915_dispatch_batchbuffer(struct drm_device * dev,
+ 				return ret;
+ 		}
+ 
+-		if (dev_priv->use_mi_batchbuffer_start) {
++		if (!IS_I830(dev) && !IS_845G(dev)) {
+ 			BEGIN_LP_RING(2);
+ 			if (IS_I965G(dev)) {
+ 				OUT_RING(MI_BATCH_BUFFER_START | (2 << 6) | MI_BATCH_NON_SECURE_I965);
+@@ -697,8 +690,6 @@ static int i915_setparam(struct drm_device *dev, void *data,
+ 
+ 	switch (param->param) {
+ 	case I915_SETPARAM_USE_MI_BATCHBUFFER_START:
+-		if (!IS_I965G(dev))
+-			dev_priv->use_mi_batchbuffer_start = param->value;
+ 		break;
+ 	case I915_SETPARAM_TEX_LRU_LOG_GRANULARITY:
+ 		dev_priv->tex_lru_log_granularity = param->value;
+diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
+index d7326d9..2d441d3 100644
+--- a/drivers/gpu/drm/i915/i915_drv.h
++++ b/drivers/gpu/drm/i915/i915_drv.h
+@@ -99,7 +99,6 @@ typedef struct drm_i915_private {
+ 	int front_offset;
+ 	int current_page;
+ 	int page_flipping;
+-	int use_mi_batchbuffer_start;
+ 
+ 	wait_queue_head_t irq_queue;
+ 	atomic_t irq_received;

meta-moblin/packages/linux/linux-moblin-2.6.27/0003-i915-Ignore-X-server-provided-mmio-address.patch

@@ -0,0 +1,41 @@
+commit 20ae3cf7d4a9ae8d23bcffa67c9a34fc2640d217
+Author: Keith Packard <keithp@keithp.com>
+Date:   Wed Jul 30 12:36:08 2008 -0700
+
+    i915: Ignore X server provided mmio address
+    
+    It is already correctly detected by the kernel for use in suspend/resume.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+    Signed-off-by: Dave Airlie <airlied@redhat.com>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 24adbde..01a869b 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -121,13 +121,6 @@ static int i915_initialize(struct drm_device * dev, drm_i915_init_t * init)
+ 		return -EINVAL;
+ 	}
+ 
+-	dev_priv->mmio_map = drm_core_findmap(dev, init->mmio_offset);
+-	if (!dev_priv->mmio_map) {
+-		i915_dma_cleanup(dev);
+-		DRM_ERROR("can not find mmio map!\n");
+-		return -EINVAL;
+-	}
+-
+ 	dev_priv->sarea_priv = (drm_i915_sarea_t *)
+ 	    ((u8 *) dev_priv->sarea->handle + init->sarea_priv_offset);
+ 
+@@ -194,11 +187,6 @@ static int i915_dma_resume(struct drm_device * dev)
+ 		return -EINVAL;
+ 	}
+ 
+-	if (!dev_priv->mmio_map) {
+-		DRM_ERROR("can not find mmio map!\n");
+-		return -EINVAL;
+-	}
+-
+ 	if (dev_priv->ring.map.handle == NULL) {
+ 		DRM_ERROR("can not ioremap virtual address for"
+ 			  " ring buffer\n");

meta-moblin/packages/linux/linux-moblin-2.6.27/0005-i915-Add-support-for-MSI-and-interrupt-mitigation.patch

@@ -0,0 +1,424 @@
+commit 4f99970852559935b27bc634318f34c18c5fd143
+Author: Eric Anholt <eric@anholt.net>
+Date:   Tue Jul 29 12:10:39 2008 -0700
+
+    i915: Add support for MSI and interrupt mitigation.
+    
+    Previous attempts at interrupt mitigation had been foiled by i915_wait_irq's
+    failure to update the sarea seqno value when the status page indicated that
+    the seqno had already been passed.  MSI support has been seen to cut CPU
+    costs by up to 40% in some workloads by avoiding other expensive interrupt
+    handlers for frequent graphics interrupts.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+    Signed-off-by: Dave Airlie <airlied@redhat.com>
+
+diff --git a/drivers/gpu/drm/drm_irq.c b/drivers/gpu/drm/drm_irq.c
+index 53f0e5a..61ed515 100644
+--- a/drivers/gpu/drm/drm_irq.c
++++ b/drivers/gpu/drm/drm_irq.c
+@@ -63,7 +63,7 @@ int drm_irq_by_busid(struct drm_device *dev, void *data,
+ 	    p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn))
+ 		return -EINVAL;
+ 
+-	p->irq = dev->irq;
++	p->irq = dev->pdev->irq;
+ 
+ 	DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
+ 		  p->irq);
+@@ -89,7 +89,7 @@ static int drm_irq_install(struct drm_device * dev)
+ 	if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
+ 		return -EINVAL;
+ 
+-	if (dev->irq == 0)
++	if (dev->pdev->irq == 0)
+ 		return -EINVAL;
+ 
+ 	mutex_lock(&dev->struct_mutex);
+@@ -107,7 +107,7 @@ static int drm_irq_install(struct drm_device * dev)
+ 	dev->irq_enabled = 1;
+ 	mutex_unlock(&dev->struct_mutex);
+ 
+-	DRM_DEBUG("irq=%d\n", dev->irq);
++	DRM_DEBUG("irq=%d\n", dev->pdev->irq);
+ 
+ 	if (drm_core_check_feature(dev, DRIVER_IRQ_VBL)) {
+ 		init_waitqueue_head(&dev->vbl_queue);
+@@ -127,8 +127,12 @@ static int drm_irq_install(struct drm_device * dev)
+ 	if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
+ 		sh_flags = IRQF_SHARED;
+ 
+-	ret = request_irq(dev->irq, dev->driver->irq_handler,
++	ret = request_irq(dev->pdev->irq, dev->driver->irq_handler,
+ 			  sh_flags, dev->devname, dev);
++	/* Expose the device irq number to drivers that want to export it for
++	 * whatever reason.
++	 */
++	dev->irq = dev->pdev->irq;
+ 	if (ret < 0) {
+ 		mutex_lock(&dev->struct_mutex);
+ 		dev->irq_enabled = 0;
+@@ -164,11 +168,11 @@ int drm_irq_uninstall(struct drm_device * dev)
+ 	if (!irq_enabled)
+ 		return -EINVAL;
+ 
+-	DRM_DEBUG("irq=%d\n", dev->irq);
++	DRM_DEBUG("irq=%d\n", dev->pdev->irq);
+ 
+ 	dev->driver->irq_uninstall(dev);
+ 
+-	free_irq(dev->irq, dev);
++	free_irq(dev->pdev->irq, dev);
+ 
+ 	dev->locked_tasklet_func = NULL;
+ 
+@@ -201,7 +205,7 @@ int drm_control(struct drm_device *dev, void *data,
+ 		if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
+ 			return 0;
+ 		if (dev->if_version < DRM_IF_VERSION(1, 2) &&
+-		    ctl->irq != dev->irq)
++		    ctl->irq != dev->pdev->irq)
+ 			return -EINVAL;
+ 		return drm_irq_install(dev);
+ 	case DRM_UNINST_HANDLER:
+@@ -239,7 +243,7 @@ int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_pr
+ 	int ret = 0;
+ 	unsigned int flags, seq;
+ 
+-	if ((!dev->irq) || (!dev->irq_enabled))
++	if ((!dev->pdev->irq) || (!dev->irq_enabled))
+ 		return -EINVAL;
+ 
+ 	if (vblwait->request.type &
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 7be580b..10bfb0c 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -84,7 +84,7 @@ static int i915_dma_cleanup(struct drm_device * dev)
+ 	 * may not have been called from userspace and after dev_private
+ 	 * is freed, it's too late.
+ 	 */
+-	if (dev->irq)
++	if (dev->irq_enabled)
+ 		drm_irq_uninstall(dev);
+ 
+ 	if (dev_priv->ring.virtual_start) {
+@@ -644,7 +644,7 @@ static int i915_getparam(struct drm_device *dev, void *data,
+ 
+ 	switch (param->param) {
+ 	case I915_PARAM_IRQ_ACTIVE:
+-		value = dev->irq ? 1 : 0;
++		value = dev->irq_enabled;
+ 		break;
+ 	case I915_PARAM_ALLOW_BATCHBUFFER:
+ 		value = dev_priv->allow_batchbuffer ? 1 : 0;
+@@ -763,6 +763,20 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
+ 	ret = drm_addmap(dev, base, size, _DRM_REGISTERS,
+ 			 _DRM_KERNEL | _DRM_DRIVER,
+ 			 &dev_priv->mmio_map);
++
++
++	/* On the 945G/GM, the chipset reports the MSI capability on the
++	 * integrated graphics even though the support isn't actually there
++	 * according to the published specs.  It doesn't appear to function
++	 * correctly in testing on 945G.
++	 * This may be a side effect of MSI having been made available for PEG
++	 * and the registers being closely associated.
++	 */
++	if (!IS_I945G(dev) && !IS_I945GM(dev))
++		pci_enable_msi(dev->pdev);
++
++	spin_lock_init(&dev_priv->user_irq_lock);
++
+ 	return ret;
+ }
+ 
+@@ -770,6 +784,9 @@ int i915_driver_unload(struct drm_device *dev)
+ {
+ 	struct drm_i915_private *dev_priv = dev->dev_private;
+ 
++	if (dev->pdev->msi_enabled)
++		pci_disable_msi(dev->pdev);
++
+ 	if (dev_priv->mmio_map)
+ 		drm_rmmap(dev, dev_priv->mmio_map);
+ 
+diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
+index afb51a3..8daf0d8 100644
+--- a/drivers/gpu/drm/i915/i915_drv.h
++++ b/drivers/gpu/drm/i915/i915_drv.h
+@@ -105,6 +105,12 @@ typedef struct drm_i915_private {
+ 	wait_queue_head_t irq_queue;
+ 	atomic_t irq_received;
+ 	atomic_t irq_emitted;
++	/** Protects user_irq_refcount and irq_mask_reg */
++	spinlock_t user_irq_lock;
++	/** Refcount for i915_user_irq_get() versus i915_user_irq_put(). */
++	int user_irq_refcount;
++	/** Cached value of IMR to avoid reads in updating the bitfield */
++	u32 irq_mask_reg;
+ 
+ 	int tex_lru_log_granularity;
+ 	int allow_batchbuffer;
+diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
+index 4a2de78..24d11ed 100644
+--- a/drivers/gpu/drm/i915/i915_irq.c
++++ b/drivers/gpu/drm/i915/i915_irq.c
+@@ -33,6 +33,31 @@
+ 
+ #define MAX_NOPID ((u32)~0)
+ 
++/** These are the interrupts used by the driver */
++#define I915_INTERRUPT_ENABLE_MASK (I915_USER_INTERRUPT |		\
++				    I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT | \
++				    I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT)
++
++static inline void
++i915_enable_irq(drm_i915_private_t *dev_priv, u32 mask)
++{
++	if ((dev_priv->irq_mask_reg & mask) != 0) {
++		dev_priv->irq_mask_reg &= ~mask;
++		I915_WRITE(IMR, dev_priv->irq_mask_reg);
++		(void) I915_READ(IMR);
++	}
++}
++
++static inline void
++i915_disable_irq(drm_i915_private_t *dev_priv, u32 mask)
++{
++	if ((dev_priv->irq_mask_reg & mask) != mask) {
++		dev_priv->irq_mask_reg |= mask;
++		I915_WRITE(IMR, dev_priv->irq_mask_reg);
++		(void) I915_READ(IMR);
++	}
++}
++
+ /**
+  * Emit blits for scheduled buffer swaps.
+  *
+@@ -229,46 +254,50 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
+ {
+ 	struct drm_device *dev = (struct drm_device *) arg;
+ 	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+-	u16 temp;
+ 	u32 pipea_stats, pipeb_stats;
++	u32 iir;
+ 
+ 	pipea_stats = I915_READ(PIPEASTAT);
+ 	pipeb_stats = I915_READ(PIPEBSTAT);
+ 
+-	temp = I915_READ16(IIR);
+-
+-	temp &= (I915_USER_INTERRUPT |
+-		 I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT |
+-		 I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT);
++	if (dev->pdev->msi_enabled)
++		I915_WRITE(IMR, ~0);
++	iir = I915_READ(IIR);
+ 
+-	DRM_DEBUG("%s flag=%08x\n", __FUNCTION__, temp);
++	DRM_DEBUG("iir=%08x\n", iir);
+ 
+-	if (temp == 0)
++	if (iir == 0) {
++		if (dev->pdev->msi_enabled) {
++			I915_WRITE(IMR, dev_priv->irq_mask_reg);
++			(void) I915_READ(IMR);
++		}
+ 		return IRQ_NONE;
++	}
+ 
+-	I915_WRITE16(IIR, temp);
+-	(void) I915_READ16(IIR);
+-	DRM_READMEMORYBARRIER();
++	I915_WRITE(IIR, iir);
++	if (dev->pdev->msi_enabled)
++		I915_WRITE(IMR, dev_priv->irq_mask_reg);
++	(void) I915_READ(IIR); /* Flush posted writes */
+ 
+ 	dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
+ 
+-	if (temp & I915_USER_INTERRUPT)
++	if (iir & I915_USER_INTERRUPT)
+ 		DRM_WAKEUP(&dev_priv->irq_queue);
+ 
+-	if (temp & (I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT |
+-		    I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT)) {
++	if (iir & (I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT |
++		   I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT)) {
+ 		int vblank_pipe = dev_priv->vblank_pipe;
+ 
+ 		if ((vblank_pipe &
+ 		     (DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B))
+ 		    == (DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B)) {
+-			if (temp & I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT)
++			if (iir & I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT)
+ 				atomic_inc(&dev->vbl_received);
+-			if (temp & I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT)
++			if (iir & I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT)
+ 				atomic_inc(&dev->vbl_received2);
+-		} else if (((temp & I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT) &&
++		} else if (((iir & I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT) &&
+ 			    (vblank_pipe & DRM_I915_VBLANK_PIPE_A)) ||
+-			   ((temp & I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT) &&
++			   ((iir & I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT) &&
+ 			    (vblank_pipe & DRM_I915_VBLANK_PIPE_B)))
+ 			atomic_inc(&dev->vbl_received);
+ 
+@@ -314,6 +343,27 @@ static int i915_emit_irq(struct drm_device * dev)
+ 	return dev_priv->counter;
+ }
+ 
++static void i915_user_irq_get(struct drm_device *dev)
++{
++	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
++
++	spin_lock(&dev_priv->user_irq_lock);
++	if (dev->irq_enabled && (++dev_priv->user_irq_refcount == 1))
++		i915_enable_irq(dev_priv, I915_USER_INTERRUPT);
++	spin_unlock(&dev_priv->user_irq_lock);
++}
++
++static void i915_user_irq_put(struct drm_device *dev)
++{
++	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
++
++	spin_lock(&dev_priv->user_irq_lock);
++	BUG_ON(dev->irq_enabled && dev_priv->user_irq_refcount <= 0);
++	if (dev->irq_enabled && (--dev_priv->user_irq_refcount == 0))
++		i915_disable_irq(dev_priv, I915_USER_INTERRUPT);
++	spin_unlock(&dev_priv->user_irq_lock);
++}
++
+ static int i915_wait_irq(struct drm_device * dev, int irq_nr)
+ {
+ 	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+@@ -322,13 +372,17 @@ static int i915_wait_irq(struct drm_device * dev, int irq_nr)
+ 	DRM_DEBUG("irq_nr=%d breadcrumb=%d\n", irq_nr,
+ 		  READ_BREADCRUMB(dev_priv));
+ 
+-	if (READ_BREADCRUMB(dev_priv) >= irq_nr)
++	if (READ_BREADCRUMB(dev_priv) >= irq_nr) {
++		dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
+ 		return 0;
++	}
+ 
+ 	dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
+ 
++	i915_user_irq_get(dev);
+ 	DRM_WAIT_ON(ret, dev_priv->irq_queue, 3 * DRM_HZ,
+ 		    READ_BREADCRUMB(dev_priv) >= irq_nr);
++	i915_user_irq_put(dev);
+ 
+ 	if (ret == -EBUSY) {
+ 		DRM_ERROR("EBUSY -- rec: %d emitted: %d\n",
+@@ -413,20 +467,6 @@ int i915_irq_wait(struct drm_device *dev, void *data,
+ 	return i915_wait_irq(dev, irqwait->irq_seq);
+ }
+ 
+-static void i915_enable_interrupt (struct drm_device *dev)
+-{
+-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+-	u16 flag;
+-
+-	flag = 0;
+-	if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_A)
+-		flag |= I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT;
+-	if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
+-		flag |= I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT;
+-
+-	I915_WRITE16(IER, I915_USER_INTERRUPT | flag);
+-}
+-
+ /* Set the vblank monitor pipe
+  */
+ int i915_vblank_pipe_set(struct drm_device *dev, void *data,
+@@ -434,6 +474,7 @@ int i915_vblank_pipe_set(struct drm_device *dev, void *data,
+ {
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+ 	drm_i915_vblank_pipe_t *pipe = data;
++	u32 enable_mask = 0, disable_mask = 0;
+ 
+ 	if (!dev_priv) {
+ 		DRM_ERROR("called with no initialization\n");
+@@ -445,9 +486,20 @@ int i915_vblank_pipe_set(struct drm_device *dev, void *data,
+ 		return -EINVAL;
+ 	}
+ 
+-	dev_priv->vblank_pipe = pipe->pipe;
++	if (pipe->pipe & DRM_I915_VBLANK_PIPE_A)
++		enable_mask |= I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT;
++	else
++		disable_mask |= I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT;
++
++	if (pipe->pipe & DRM_I915_VBLANK_PIPE_B)
++		enable_mask |= I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT;
++	else
++		disable_mask |= I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT;
+ 
+-	i915_enable_interrupt (dev);
++	i915_enable_irq(dev_priv, enable_mask);
++	i915_disable_irq(dev_priv, disable_mask);
++
++	dev_priv->vblank_pipe = pipe->pipe;
+ 
+ 	return 0;
+ }
+@@ -464,7 +516,7 @@ int i915_vblank_pipe_get(struct drm_device *dev, void *data,
+ 		return -EINVAL;
+ 	}
+ 
+-	flag = I915_READ(IER);
++	flag = I915_READ(IMR);
+ 	pipe->pipe = 0;
+ 	if (flag & I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT)
+ 		pipe->pipe |= DRM_I915_VBLANK_PIPE_A;
+@@ -586,9 +638,9 @@ void i915_driver_irq_preinstall(struct drm_device * dev)
+ {
+ 	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+ 
+-	I915_WRITE16(HWSTAM, 0xfffe);
+-	I915_WRITE16(IMR, 0x0);
+-	I915_WRITE16(IER, 0x0);
++	I915_WRITE(HWSTAM, 0xfffe);
++	I915_WRITE(IMR, 0x0);
++	I915_WRITE(IER, 0x0);
+ }
+ 
+ void i915_driver_irq_postinstall(struct drm_device * dev)
+@@ -601,7 +653,18 @@ void i915_driver_irq_postinstall(struct drm_device * dev)
+ 
+ 	if (!dev_priv->vblank_pipe)
+ 		dev_priv->vblank_pipe = DRM_I915_VBLANK_PIPE_A;
+-	i915_enable_interrupt(dev);
++
++	/* Set initial unmasked IRQs to just the selected vblank pipes. */
++	dev_priv->irq_mask_reg = ~0;
++	if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_A)
++		dev_priv->irq_mask_reg &= ~I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT;
++	if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
++		dev_priv->irq_mask_reg &= ~I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT;
++
++	I915_WRITE(IMR, dev_priv->irq_mask_reg);
++	I915_WRITE(IER, I915_INTERRUPT_ENABLE_MASK);
++	(void) I915_READ(IER);
++
+ 	DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
+ }
+ 
+@@ -613,10 +676,10 @@ void i915_driver_irq_uninstall(struct drm_device * dev)
+ 	if (!dev_priv)
+ 		return;
+ 
+-	I915_WRITE16(HWSTAM, 0xffff);
+-	I915_WRITE16(IMR, 0xffff);
+-	I915_WRITE16(IER, 0x0);
++	I915_WRITE(HWSTAM, 0xffff);
++	I915_WRITE(IMR, 0xffff);
++	I915_WRITE(IER, 0x0);
+ 
+-	temp = I915_READ16(IIR);
+-	I915_WRITE16(IIR, temp);
++	temp = I915_READ(IIR);
++	I915_WRITE(IIR, temp);
+ }

meta-moblin/packages/linux/linux-moblin-2.6.27/0006-i915-Track-progress-inside-of-batchbuffers-for-dete.patch

@@ -0,0 +1,46 @@
+commit 1236e8610ab9c6f9f8297e60530bedb2640c7224
+Author: Keith Packard <keithp@keithp.com>
+Date:   Wed Jul 30 12:21:20 2008 -0700
+
+    i915: Track progress inside of batchbuffers for determining wedgedness.
+    
+    This avoids early termination for long-running commands.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+    Signed-off-by: Dave Airlie <airlied@redhat.com>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 10bfb0c..4c72a01 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -40,11 +40,15 @@ int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
+ {
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+ 	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
++	u32 acthd_reg = IS_I965G(dev) ? ACTHD_I965 : ACTHD;
++	u32 last_acthd = I915_READ(acthd_reg);
++	u32 acthd;
+ 	u32 last_head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
+ 	int i;
+ 
+-	for (i = 0; i < 10000; i++) {
++	for (i = 0; i < 100000; i++) {
+ 		ring->head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
++		acthd = I915_READ(acthd_reg);
+ 		ring->space = ring->head - (ring->tail + 8);
+ 		if (ring->space < 0)
+ 			ring->space += ring->Size;
+@@ -55,8 +59,13 @@ int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
+ 
+ 		if (ring->head != last_head)
+ 			i = 0;
++		if (acthd != last_acthd)
++			i = 0;
+ 
+ 		last_head = ring->head;
++		last_acthd = acthd;
++		msleep_interruptible(10);
++
+ 	}
+ 
+ 	return -EBUSY;

meta-moblin/packages/linux/linux-moblin-2.6.27/0007-i915-Initialize-hardware-status-page-at-device-load.patch

@@ -0,0 +1,137 @@
+commit 75fed4ae8454aa975c274b2585ec2287dd15773d
+Author: Keith Packard <keithp@keithp.com>
+Date:   Wed Jul 30 13:03:43 2008 -0700
+
+    i915: Initialize hardware status page at device load when possible.
+    
+    Some chips were unstable with repeated setup/teardown of the hardware status
+    page.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+    Signed-off-by: Dave Airlie <airlied@redhat.com>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 4c72a01..b3c4ac9 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -71,6 +71,52 @@ int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
+ 	return -EBUSY;
+ }
+ 
++/**
++ * Sets up the hardware status page for devices that need a physical address
++ * in the register.
++ */
++int i915_init_phys_hws(struct drm_device *dev)
++{
++	drm_i915_private_t *dev_priv = dev->dev_private;
++	/* Program Hardware Status Page */
++	dev_priv->status_page_dmah =
++		drm_pci_alloc(dev, PAGE_SIZE, PAGE_SIZE, 0xffffffff);
++
++	if (!dev_priv->status_page_dmah) {
++		DRM_ERROR("Can not allocate hardware status page\n");
++		return -ENOMEM;
++	}
++	dev_priv->hw_status_page = dev_priv->status_page_dmah->vaddr;
++	dev_priv->dma_status_page = dev_priv->status_page_dmah->busaddr;
++
++	memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
++
++	I915_WRITE(HWS_PGA, dev_priv->dma_status_page);
++	DRM_DEBUG("Enabled hardware status page\n");
++	return 0;
++}
++
++/**
++ * Frees the hardware status page, whether it's a physical address or a virtual
++ * address set up by the X Server.
++ */
++void i915_free_hws(struct drm_device *dev)
++{
++	drm_i915_private_t *dev_priv = dev->dev_private;
++	if (dev_priv->status_page_dmah) {
++		drm_pci_free(dev, dev_priv->status_page_dmah);
++		dev_priv->status_page_dmah = NULL;
++	}
++
++	if (dev_priv->status_gfx_addr) {
++		dev_priv->status_gfx_addr = 0;
++		drm_core_ioremapfree(&dev_priv->hws_map, dev);
++	}
++
++	/* Need to rewrite hardware status page */
++	I915_WRITE(HWS_PGA, 0x1ffff000);
++}
++
+ void i915_kernel_lost_context(struct drm_device * dev)
+ {
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+@@ -103,18 +149,9 @@ static int i915_dma_cleanup(struct drm_device * dev)
+ 		dev_priv->ring.map.size = 0;
+ 	}
+ 
+-	if (dev_priv->status_page_dmah) {
+-		drm_pci_free(dev, dev_priv->status_page_dmah);
+-		dev_priv->status_page_dmah = NULL;
+-		/* Need to rewrite hardware status page */
+-		I915_WRITE(HWS_PGA, 0x1ffff000);
+-	}
+-
+-	if (dev_priv->status_gfx_addr) {
+-		dev_priv->status_gfx_addr = 0;
+-		drm_core_ioremapfree(&dev_priv->hws_map, dev);
+-		I915_WRITE(HWS_PGA, 0x1ffff000);
+-	}
++	/* Clear the HWS virtual address at teardown */
++	if (I915_NEED_GFX_HWS(dev))
++		i915_free_hws(dev);
+ 
+ 	return 0;
+ }
+@@ -165,23 +202,6 @@ static int i915_initialize(struct drm_device * dev, drm_i915_init_t * init)
+ 	 */
+ 	dev_priv->allow_batchbuffer = 1;
+ 
+-	/* Program Hardware Status Page */
+-	if (!I915_NEED_GFX_HWS(dev)) {
+-		dev_priv->status_page_dmah =
+-			drm_pci_alloc(dev, PAGE_SIZE, PAGE_SIZE, 0xffffffff);
+-
+-		if (!dev_priv->status_page_dmah) {
+-			i915_dma_cleanup(dev);
+-			DRM_ERROR("Can not allocate hardware status page\n");
+-			return -ENOMEM;
+-		}
+-		dev_priv->hw_status_page = dev_priv->status_page_dmah->vaddr;
+-		dev_priv->dma_status_page = dev_priv->status_page_dmah->busaddr;
+-
+-		memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
+-		I915_WRITE(HWS_PGA, dev_priv->dma_status_page);
+-	}
+-	DRM_DEBUG("Enabled hardware status page\n");
+ 	return 0;
+ }
+ 
+@@ -773,6 +793,12 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
+ 			 _DRM_KERNEL | _DRM_DRIVER,
+ 			 &dev_priv->mmio_map);
+ 
++	/* Init HWS */
++	if (!I915_NEED_GFX_HWS(dev)) {
++		ret = i915_init_phys_hws(dev);
++		if (ret != 0)
++			return ret;
++	}
+ 
+ 	/* On the 945G/GM, the chipset reports the MSI capability on the
+ 	 * integrated graphics even though the support isn't actually there
+@@ -796,6 +822,8 @@ int i915_driver_unload(struct drm_device *dev)
+ 	if (dev->pdev->msi_enabled)
+ 		pci_disable_msi(dev->pdev);
+ 
++	i915_free_hws(dev);
++
+ 	if (dev_priv->mmio_map)
+ 		drm_rmmap(dev, dev_priv->mmio_map);
+ 

meta-moblin/packages/linux/linux-moblin-2.6.27/0008-Add-Intel-ACPI-IGD-OpRegion-support.patch

@@ -0,0 +1,572 @@
+commit 91c2ebb8e78aa64f4807399b506ec0090ae5f3d6
+Author: Matthew Garrett <mjg59@srcf.ucam.org>
+Date:   Tue Aug 5 19:37:25 2008 +0100
+
+    Add Intel ACPI IGD OpRegion support
+    
+    This adds the support necessary for allowing ACPI backlight control to
+    work on some newer Intel-based graphics systems. Tested on Thinkpad T61
+    and HP 2510p hardware.
+    
+    Signed-off-by: Matthew Garrett <mjg@redhat.com>
+    Signed-off-by: Dave Airlie <airlied@linux.ie>
+
+diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
+index a9e6046..b032808 100644
+--- a/drivers/gpu/drm/i915/Makefile
++++ b/drivers/gpu/drm/i915/Makefile
+@@ -3,7 +3,7 @@
+ # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
+ 
+ ccflags-y := -Iinclude/drm
+-i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o
++i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o i915_opregion.o
+ 
+ i915-$(CONFIG_COMPAT)   += i915_ioc32.o
+ 
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index b3c4ac9..cead62f 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -810,6 +810,8 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
+ 	if (!IS_I945G(dev) && !IS_I945GM(dev))
+ 		pci_enable_msi(dev->pdev);
+ 
++	intel_opregion_init(dev);
++
+ 	spin_lock_init(&dev_priv->user_irq_lock);
+ 
+ 	return ret;
+@@ -827,6 +829,8 @@ int i915_driver_unload(struct drm_device *dev)
+ 	if (dev_priv->mmio_map)
+ 		drm_rmmap(dev, dev_priv->mmio_map);
+ 
++	intel_opregion_free(dev);
++
+ 	drm_free(dev->dev_private, sizeof(drm_i915_private_t),
+ 		 DRM_MEM_DRIVER);
+ 
+diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
+index 6c99aab..d95eca2 100644
+--- a/drivers/gpu/drm/i915/i915_drv.c
++++ b/drivers/gpu/drm/i915/i915_drv.c
+@@ -371,6 +371,8 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state)
+ 
+ 	i915_save_vga(dev);
+ 
++	intel_opregion_free(dev);
++
+ 	if (state.event == PM_EVENT_SUSPEND) {
+ 		/* Shut down the device */
+ 		pci_disable_device(dev->pdev);
+@@ -532,6 +534,8 @@ static int i915_resume(struct drm_device *dev)
+ 
+ 	i915_restore_vga(dev);
+ 
++	intel_opregion_init(dev);
++
+ 	return 0;
+ }
+ 
+diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
+index 8daf0d8..e4bd01c 100644
+--- a/drivers/gpu/drm/i915/i915_drv.h
++++ b/drivers/gpu/drm/i915/i915_drv.h
+@@ -82,6 +82,14 @@ typedef struct _drm_i915_vbl_swap {
+ 	unsigned int sequence;
+ } drm_i915_vbl_swap_t;
+ 
++struct intel_opregion {
++	struct opregion_header *header;
++	struct opregion_acpi *acpi;
++	struct opregion_swsci *swsci;
++	struct opregion_asle *asle;
++	int enabled;
++};
++
+ typedef struct drm_i915_private {
+ 	drm_local_map_t *sarea;
+ 	drm_local_map_t *mmio_map;
+@@ -122,6 +130,8 @@ typedef struct drm_i915_private {
+ 	drm_i915_vbl_swap_t vbl_swaps;
+ 	unsigned int swaps_pending;
+ 
++	struct intel_opregion opregion;
++
+ 	/* Register state */
+ 	u8 saveLBB;
+ 	u32 saveDSPACNTR;
+@@ -244,6 +254,7 @@ extern int i915_vblank_pipe_get(struct drm_device *dev, void *data,
+ 				struct drm_file *file_priv);
+ extern int i915_vblank_swap(struct drm_device *dev, void *data,
+ 			    struct drm_file *file_priv);
++extern void i915_enable_irq(drm_i915_private_t *dev_priv, u32 mask);
+ 
+ /* i915_mem.c */
+ extern int i915_mem_alloc(struct drm_device *dev, void *data,
+@@ -258,6 +269,12 @@ extern void i915_mem_takedown(struct mem_block **heap);
+ extern void i915_mem_release(struct drm_device * dev,
+ 			     struct drm_file *file_priv, struct mem_block *heap);
+ 
++/* i915_opregion.c */
++extern int intel_opregion_init(struct drm_device *dev);
++extern void intel_opregion_free(struct drm_device *dev);
++extern void opregion_asle_intr(struct drm_device *dev);
++extern void opregion_enable_asle(struct drm_device *dev);
++
+ #define I915_READ(reg)          DRM_READ32(dev_priv->mmio_map, (reg))
+ #define I915_WRITE(reg,val)     DRM_WRITE32(dev_priv->mmio_map, (reg), (val))
+ #define I915_READ16(reg)	DRM_READ16(dev_priv->mmio_map, (reg))
+diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
+index 24d11ed..ae7d3a8 100644
+--- a/drivers/gpu/drm/i915/i915_irq.c
++++ b/drivers/gpu/drm/i915/i915_irq.c
+@@ -36,9 +36,11 @@
+ /** These are the interrupts used by the driver */
+ #define I915_INTERRUPT_ENABLE_MASK (I915_USER_INTERRUPT |		\
+ 				    I915_DISPLAY_PIPE_A_VBLANK_INTERRUPT | \
+-				    I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT)
++				    I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT | \
++				    I915_ASLE_INTERRUPT |		\
++				    I915_DISPLAY_PIPE_B_EVENT_INTERRUPT)
+ 
+-static inline void
++void
+ i915_enable_irq(drm_i915_private_t *dev_priv, u32 mask)
+ {
+ 	if ((dev_priv->irq_mask_reg & mask) != 0) {
+@@ -274,6 +276,9 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
+ 		return IRQ_NONE;
+ 	}
+ 
++	I915_WRITE(PIPEASTAT, pipea_stats);
++	I915_WRITE(PIPEBSTAT, pipeb_stats);
++
+ 	I915_WRITE(IIR, iir);
+ 	if (dev->pdev->msi_enabled)
+ 		I915_WRITE(IMR, dev_priv->irq_mask_reg);
+@@ -306,14 +311,14 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
+ 
+ 		if (dev_priv->swaps_pending > 0)
+ 			drm_locked_tasklet(dev, i915_vblank_tasklet);
+-		I915_WRITE(PIPEASTAT,
+-			pipea_stats|I915_VBLANK_INTERRUPT_ENABLE|
+-			PIPE_VBLANK_INTERRUPT_STATUS);
+-		I915_WRITE(PIPEBSTAT,
+-			pipeb_stats|I915_VBLANK_INTERRUPT_ENABLE|
+-			PIPE_VBLANK_INTERRUPT_STATUS);
+ 	}
+ 
++	if (iir & I915_ASLE_INTERRUPT)
++		opregion_asle_intr(dev);
++
++	if (iir & I915_DISPLAY_PIPE_B_EVENT_INTERRUPT)
++		opregion_asle_intr(dev);
++
+ 	return IRQ_HANDLED;
+ }
+ 
+@@ -661,10 +666,14 @@ void i915_driver_irq_postinstall(struct drm_device * dev)
+ 	if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
+ 		dev_priv->irq_mask_reg &= ~I915_DISPLAY_PIPE_B_VBLANK_INTERRUPT;
+ 
++	dev_priv->irq_mask_reg &= I915_INTERRUPT_ENABLE_MASK;
++
+ 	I915_WRITE(IMR, dev_priv->irq_mask_reg);
+ 	I915_WRITE(IER, I915_INTERRUPT_ENABLE_MASK);
+ 	(void) I915_READ(IER);
+ 
++	opregion_enable_asle(dev);
++
+ 	DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
+ }
+ 
+diff --git a/drivers/gpu/drm/i915/i915_opregion.c b/drivers/gpu/drm/i915/i915_opregion.c
+new file mode 100644
+index 0000000..1787a0c
+--- /dev/null
++++ b/drivers/gpu/drm/i915/i915_opregion.c
+@@ -0,0 +1,371 @@
++/*
++ * Copyright 2008 Intel Corporation <hong.liu@intel.com>
++ * Copyright 2008 Red Hat <mjg@redhat.com>
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial
++ * portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
++ * NON-INFRINGEMENT.  IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE
++ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ *
++ */
++
++#include <linux/acpi.h>
++
++#include "drmP.h"
++#include "i915_drm.h"
++#include "i915_drv.h"
++
++#define PCI_ASLE 0xe4
++#define PCI_LBPC 0xf4
++#define PCI_ASLS 0xfc
++
++#define OPREGION_SZ            (8*1024)
++#define OPREGION_HEADER_OFFSET 0
++#define OPREGION_ACPI_OFFSET   0x100
++#define OPREGION_SWSCI_OFFSET  0x200
++#define OPREGION_ASLE_OFFSET   0x300
++#define OPREGION_VBT_OFFSET    0x1000
++
++#define OPREGION_SIGNATURE "IntelGraphicsMem"
++#define MBOX_ACPI      (1<<0)
++#define MBOX_SWSCI     (1<<1)
++#define MBOX_ASLE      (1<<2)
++
++struct opregion_header {
++       u8 signature[16];
++       u32 size;
++       u32 opregion_ver;
++       u8 bios_ver[32];
++       u8 vbios_ver[16];
++       u8 driver_ver[16];
++       u32 mboxes;
++       u8 reserved[164];
++} __attribute__((packed));
++
++/* OpRegion mailbox #1: public ACPI methods */
++struct opregion_acpi {
++       u32 drdy;       /* driver readiness */
++       u32 csts;       /* notification status */
++       u32 cevt;       /* current event */
++       u8 rsvd1[20];
++       u32 didl[8];    /* supported display devices ID list */
++       u32 cpdl[8];    /* currently presented display list */
++       u32 cadl[8];    /* currently active display list */
++       u32 nadl[8];    /* next active devices list */
++       u32 aslp;       /* ASL sleep time-out */
++       u32 tidx;       /* toggle table index */
++       u32 chpd;       /* current hotplug enable indicator */
++       u32 clid;       /* current lid state*/
++       u32 cdck;       /* current docking state */
++       u32 sxsw;       /* Sx state resume */
++       u32 evts;       /* ASL supported events */
++       u32 cnot;       /* current OS notification */
++       u32 nrdy;       /* driver status */
++       u8 rsvd2[60];
++} __attribute__((packed));
++
++/* OpRegion mailbox #2: SWSCI */
++struct opregion_swsci {
++       u32 scic;       /* SWSCI command|status|data */
++       u32 parm;       /* command parameters */
++       u32 dslp;       /* driver sleep time-out */
++       u8 rsvd[244];
++} __attribute__((packed));
++
++/* OpRegion mailbox #3: ASLE */
++struct opregion_asle {
++       u32 ardy;       /* driver readiness */
++       u32 aslc;       /* ASLE interrupt command */
++       u32 tche;       /* technology enabled indicator */
++       u32 alsi;       /* current ALS illuminance reading */
++       u32 bclp;       /* backlight brightness to set */
++       u32 pfit;       /* panel fitting state */
++       u32 cblv;       /* current brightness level */
++       u16 bclm[20];   /* backlight level duty cycle mapping table */
++       u32 cpfm;       /* current panel fitting mode */
++       u32 epfm;       /* enabled panel fitting modes */
++       u8 plut[74];    /* panel LUT and identifier */
++       u32 pfmb;       /* PWM freq and min brightness */
++       u8 rsvd[102];
++} __attribute__((packed));
++
++/* ASLE irq request bits */
++#define ASLE_SET_ALS_ILLUM     (1 << 0)
++#define ASLE_SET_BACKLIGHT     (1 << 1)
++#define ASLE_SET_PFIT          (1 << 2)
++#define ASLE_SET_PWM_FREQ      (1 << 3)
++#define ASLE_REQ_MSK           0xf
++
++/* response bits of ASLE irq request */
++#define ASLE_ALS_ILLUM_FAIL    (2<<10)
++#define ASLE_BACKLIGHT_FAIL    (2<<12)
++#define ASLE_PFIT_FAIL         (2<<14)
++#define ASLE_PWM_FREQ_FAIL     (2<<16)
++
++/* ASLE backlight brightness to set */
++#define ASLE_BCLP_VALID                (1<<31)
++#define ASLE_BCLP_MSK          (~(1<<31))
++
++/* ASLE panel fitting request */
++#define ASLE_PFIT_VALID         (1<<31)
++#define ASLE_PFIT_CENTER (1<<0)
++#define ASLE_PFIT_STRETCH_TEXT (1<<1)
++#define ASLE_PFIT_STRETCH_GFX (1<<2)
++
++/* PWM frequency and minimum brightness */
++#define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
++#define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
++#define ASLE_PFMB_PWM_MASK (0x7ffffe00)
++#define ASLE_PFMB_PWM_VALID (1<<31)
++
++#define ASLE_CBLV_VALID         (1<<31)
++
++static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
++{
++	struct drm_i915_private *dev_priv = dev->dev_private;
++	struct opregion_asle *asle = dev_priv->opregion.asle;
++	u32 blc_pwm_ctl, blc_pwm_ctl2;
++
++	if (!(bclp & ASLE_BCLP_VALID))
++		return ASLE_BACKLIGHT_FAIL;
++
++	bclp &= ASLE_BCLP_MSK;
++	if (bclp < 0 || bclp > 255)
++		return ASLE_BACKLIGHT_FAIL;
++
++	blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
++	blc_pwm_ctl &= ~BACKLIGHT_DUTY_CYCLE_MASK;
++	blc_pwm_ctl2 = I915_READ(BLC_PWM_CTL2);
++
++	if (blc_pwm_ctl2 & BLM_COMBINATION_MODE)
++		pci_write_config_dword(dev->pdev, PCI_LBPC, bclp);
++	else
++		I915_WRITE(BLC_PWM_CTL, blc_pwm_ctl | ((bclp * 0x101)-1));
++
++	asle->cblv = (bclp*0x64)/0xff | ASLE_CBLV_VALID;
++
++	return 0;
++}
++
++static u32 asle_set_als_illum(struct drm_device *dev, u32 alsi)
++{
++	/* alsi is the current ALS reading in lux. 0 indicates below sensor
++	   range, 0xffff indicates above sensor range. 1-0xfffe are valid */
++	return 0;
++}
++
++static u32 asle_set_pwm_freq(struct drm_device *dev, u32 pfmb)
++{
++	struct drm_i915_private *dev_priv = dev->dev_private;
++	if (pfmb & ASLE_PFMB_PWM_VALID) {
++		u32 blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
++		u32 pwm = pfmb & ASLE_PFMB_PWM_MASK;
++		blc_pwm_ctl &= BACKLIGHT_DUTY_CYCLE_MASK;
++		pwm = pwm >> 9;
++		/* FIXME - what do we do with the PWM? */
++	}
++	return 0;
++}
++
++static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
++{
++	/* Panel fitting is currently controlled by the X code, so this is a
++	   noop until modesetting support works fully */
++	if (!(pfit & ASLE_PFIT_VALID))
++		return ASLE_PFIT_FAIL;
++	return 0;
++}
++
++void opregion_asle_intr(struct drm_device *dev)
++{
++	struct drm_i915_private *dev_priv = dev->dev_private;
++	struct opregion_asle *asle = dev_priv->opregion.asle;
++	u32 asle_stat = 0;
++	u32 asle_req;
++
++	if (!asle)
++		return;
++
++	asle_req = asle->aslc & ASLE_REQ_MSK;
++
++	if (!asle_req) {
++		DRM_DEBUG("non asle set request??\n");
++		return;
++	}
++
++	if (asle_req & ASLE_SET_ALS_ILLUM)
++		asle_stat |= asle_set_als_illum(dev, asle->alsi);
++
++	if (asle_req & ASLE_SET_BACKLIGHT)
++		asle_stat |= asle_set_backlight(dev, asle->bclp);
++
++	if (asle_req & ASLE_SET_PFIT)
++		asle_stat |= asle_set_pfit(dev, asle->pfit);
++
++	if (asle_req & ASLE_SET_PWM_FREQ)
++		asle_stat |= asle_set_pwm_freq(dev, asle->pfmb);
++
++	asle->aslc = asle_stat;
++}
++
++#define ASLE_ALS_EN    (1<<0)
++#define ASLE_BLC_EN    (1<<1)
++#define ASLE_PFIT_EN   (1<<2)
++#define ASLE_PFMB_EN   (1<<3)
++
++void opregion_enable_asle(struct drm_device *dev)
++{
++	struct drm_i915_private *dev_priv = dev->dev_private;
++	struct opregion_asle *asle = dev_priv->opregion.asle;
++
++	if (asle) {
++		u32 pipeb_stats = I915_READ(PIPEBSTAT);
++		if (IS_MOBILE(dev)) {
++			/* Many devices trigger events with a write to the
++			   legacy backlight controller, so we need to ensure
++			   that it's able to generate interrupts */
++			I915_WRITE(PIPEBSTAT, pipeb_stats |=
++				   I915_LEGACY_BLC_EVENT_ENABLE);
++			i915_enable_irq(dev_priv, I915_ASLE_INTERRUPT |
++					I915_DISPLAY_PIPE_B_EVENT_INTERRUPT);
++		} else
++			i915_enable_irq(dev_priv, I915_ASLE_INTERRUPT);
++
++		asle->tche = ASLE_ALS_EN | ASLE_BLC_EN | ASLE_PFIT_EN |
++			ASLE_PFMB_EN;
++		asle->ardy = 1;
++	}
++}
++
++#define ACPI_EV_DISPLAY_SWITCH (1<<0)
++#define ACPI_EV_LID            (1<<1)
++#define ACPI_EV_DOCK           (1<<2)
++
++static struct intel_opregion *system_opregion;
++
++int intel_opregion_video_event(struct notifier_block *nb, unsigned long val,
++			       void *data)
++{
++	/* The only video events relevant to opregion are 0x80. These indicate
++	   either a docking event, lid switch or display switch request. In
++	   Linux, these are handled by the dock, button and video drivers.
++	   We might want to fix the video driver to be opregion-aware in
++	   future, but right now we just indicate to the firmware that the
++	   request has been handled */
++
++	struct opregion_acpi *acpi;
++
++	if (!system_opregion)
++		return NOTIFY_DONE;
++
++	acpi = system_opregion->acpi;
++	acpi->csts = 0;
++
++	return NOTIFY_OK;
++}
++
++static struct notifier_block intel_opregion_notifier = {
++	.notifier_call = intel_opregion_video_event,
++};
++
++int intel_opregion_init(struct drm_device *dev)
++{
++	struct drm_i915_private *dev_priv = dev->dev_private;
++	struct intel_opregion *opregion = &dev_priv->opregion;
++	void *base;
++	u32 asls, mboxes;
++	int err = 0;
++
++	pci_read_config_dword(dev->pdev, PCI_ASLS, &asls);
++	DRM_DEBUG("graphic opregion physical addr: 0x%x\n", asls);
++	if (asls == 0) {
++		DRM_DEBUG("ACPI OpRegion not supported!\n");
++		return -ENOTSUPP;
++	}
++
++	base = ioremap(asls, OPREGION_SZ);
++	if (!base)
++		return -ENOMEM;
++
++	opregion->header = base;
++	if (memcmp(opregion->header->signature, OPREGION_SIGNATURE, 16)) {
++		DRM_DEBUG("opregion signature mismatch\n");
++		err = -EINVAL;
++		goto err_out;
++	}
++
++	mboxes = opregion->header->mboxes;
++	if (mboxes & MBOX_ACPI) {
++		DRM_DEBUG("Public ACPI methods supported\n");
++		opregion->acpi = base + OPREGION_ACPI_OFFSET;
++	} else {
++		DRM_DEBUG("Public ACPI methods not supported\n");
++		err = -ENOTSUPP;
++		goto err_out;
++	}
++	opregion->enabled = 1;
++
++	if (mboxes & MBOX_SWSCI) {
++		DRM_DEBUG("SWSCI supported\n");
++		opregion->swsci = base + OPREGION_SWSCI_OFFSET;
++	}
++	if (mboxes & MBOX_ASLE) {
++		DRM_DEBUG("ASLE supported\n");
++		opregion->asle = base + OPREGION_ASLE_OFFSET;
++	}
++
++	/* Notify BIOS we are ready to handle ACPI video ext notifs.
++	 * Right now, all the events are handled by the ACPI video module.
++	 * We don't actually need to do anything with them. */
++	opregion->acpi->csts = 0;
++	opregion->acpi->drdy = 1;
++
++	system_opregion = opregion;
++	register_acpi_notifier(&intel_opregion_notifier);
++
++	return 0;
++
++err_out:
++	iounmap(opregion->header);
++	opregion->header = NULL;
++	return err;
++}
++
++void intel_opregion_free(struct drm_device *dev)
++{
++	struct drm_i915_private *dev_priv = dev->dev_private;
++	struct intel_opregion *opregion = &dev_priv->opregion;
++
++	if (!opregion->enabled)
++		return;
++
++	opregion->acpi->drdy = 0;
++
++	system_opregion = NULL;
++	unregister_acpi_notifier(&intel_opregion_notifier);
++
++	/* just clear all opregion memory pointers now */
++	iounmap(opregion->header);
++	opregion->header = NULL;
++	opregion->acpi = NULL;
++	opregion->swsci = NULL;
++	opregion->asle = NULL;
++
++	opregion->enabled = 0;
++}
+diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
+index 477c64e..43ad2cb 100644
+--- a/drivers/gpu/drm/i915/i915_reg.h
++++ b/drivers/gpu/drm/i915/i915_reg.h
+@@ -740,6 +740,7 @@
+ #define BLC_PWM_CTL		0x61254
+ #define   BACKLIGHT_MODULATION_FREQ_SHIFT		(17)
+ #define BLC_PWM_CTL2		0x61250 /* 965+ only */
++#define   BLM_COMBINATION_MODE (1 << 30)
+ /*
+  * This is the most significant 15 bits of the number of backlight cycles in a
+  * complete cycle of the modulated backlight control.

meta-moblin/packages/linux/linux-moblin-2.6.27/0009-drm-fix-sysfs-error-path.patch

@@ -0,0 +1,23 @@
+commit 2e9c9eedfe0be777c051a2198dddf459adcc407b
+Author: Dave Airlie <airlied@redhat.com>
+Date:   Tue Sep 2 10:06:06 2008 +1000
+
+    drm: fix sysfs error path.
+    
+    Pointed out by Roel Kluin on dri-devel.
+    
+    Signed-off-by: Dave Airlie <airlied@redhat.com>
+
+diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
+index af211a0..1611b9b 100644
+--- a/drivers/gpu/drm/drm_sysfs.c
++++ b/drivers/gpu/drm/drm_sysfs.c
+@@ -184,7 +184,7 @@ int drm_sysfs_device_add(struct drm_minor *minor)
+ err_out_files:
+ 	if (i > 0)
+ 		for (j = 0; j < i; j++)
+-			device_remove_file(&minor->kdev, &device_attrs[i]);
++			device_remove_file(&minor->kdev, &device_attrs[j]);
+ 	device_unregister(&minor->kdev);
+ err_out:
+ 

meta-moblin/packages/linux/linux-moblin-2.6.27/0012-Export-shmem_file_setup-for-DRM-GEM.patch

@@ -0,0 +1,25 @@
+commit 48e13db26a25ebaf61f1fc28f612d6b35ddf1965
+Author: Keith Packard <keithp@keithp.com>
+Date:   Fri Jun 20 00:08:06 2008 -0700
+
+    Export shmem_file_setup for DRM-GEM
+    
+    GEM needs to create shmem files to back buffer objects.  Though currently
+    creation of files for objects could have been driven from userland, the
+    modesetting work will require allocation of buffer objects before userland
+    is running, for boot-time message display.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/mm/shmem.c b/mm/shmem.c
+index 04fb4f1..515909d 100644
+--- a/mm/shmem.c
++++ b/mm/shmem.c
+@@ -2582,6 +2582,7 @@ put_memory:
+ 	shmem_unacct_size(flags, size);
+ 	return ERR_PTR(error);
+ }
++EXPORT_SYMBOL(shmem_file_setup);
+ 
+ /**
+  * shmem_zero_setup - setup a shared anonymous mapping

meta-moblin/packages/linux/linux-moblin-2.6.27/0013-Export-kmap_atomic_pfn-for-DRM-GEM.patch

@@ -0,0 +1,24 @@
+commit 25eaa97fc74b225e13cf11ed8d770192ddc9355d
+Author: Eric Anholt <eric@anholt.net>
+Date:   Thu Aug 21 12:53:33 2008 -0700
+
+    Export kmap_atomic_pfn for DRM-GEM.
+    
+    The driver would like to map IO space directly for copying data in when
+    appropriate, to avoid CPU cache flushing for streaming writes.
+    kmap_atomic_pfn lets us avoid IPIs associated with ioremap for this process.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/arch/x86/mm/highmem_32.c b/arch/x86/mm/highmem_32.c
+index 165c871..d52e91d 100644
+--- a/arch/x86/mm/highmem_32.c
++++ b/arch/x86/mm/highmem_32.c
+@@ -137,6 +137,7 @@ void *kmap_atomic_pfn(unsigned long pfn, enum km_type type)
+ 
+ 	return (void*) vaddr;
+ }
++EXPORT_SYMBOL(kmap_atomic_pfn);
+ 
+ struct page *kmap_atomic_to_page(void *ptr)
+ {

meta-moblin/packages/linux/linux-moblin-2.6.27/0015-i915-Add-chip-set-ID-param.patch

@@ -0,0 +1,35 @@
+commit 26ead293ddf664f33dc0ba12b726887c40ce3957
+Author: Kristian Høgsberg <krh@redhat.com>
+Date:   Wed Aug 20 11:08:52 2008 -0400
+
+    i915: Add chip set ID param.
+    
+    Signed-off-by: Kristian Høgsberg <krh@redhat.com>
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 3b5aa74..205d21e 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -689,6 +689,9 @@ static int i915_getparam(struct drm_device *dev, void *data,
+ 	case I915_PARAM_LAST_DISPATCH:
+ 		value = READ_BREADCRUMB(dev_priv);
+ 		break;
++	case I915_PARAM_CHIPSET_ID:
++		value = dev->pci_device;
++		break;
+ 	case I915_PARAM_HAS_GEM:
+ 		value = 1;
+ 		break;
+diff --git a/include/drm/i915_drm.h b/include/drm/i915_drm.h
+index 59d08fc..eb4b350 100644
+--- a/include/drm/i915_drm.h
++++ b/include/drm/i915_drm.h
+@@ -230,6 +230,7 @@ typedef struct drm_i915_irq_wait {
+ #define I915_PARAM_IRQ_ACTIVE            1
+ #define I915_PARAM_ALLOW_BATCHBUFFER     2
+ #define I915_PARAM_LAST_DISPATCH         3
++#define I915_PARAM_CHIPSET_ID            4
+ #define I915_PARAM_HAS_GEM               5
+ 
+ typedef struct drm_i915_getparam {

meta-moblin/packages/linux/linux-moblin-2.6.27/0016-i915-Use-struct_mutex-to-protect-ring-in-GEM-mode.patch

@@ -0,0 +1,205 @@
+commit 8a524209fce67d3b6d2e831b5dad4eced796ce98
+Author: Eric Anholt <eric@anholt.net>
+Date:   Mon Sep 1 16:45:29 2008 -0700
+
+    i915: Use struct_mutex to protect ring in GEM mode.
+    
+    In the conversion for GEM, we had stopped using the hardware lock to protect
+    ring usage, since it was all internal to the DRM now.  However, some paths
+    weren't converted to using struct_mutex to prevent multiple threads from
+    concurrently working on the ring, in particular between the vblank swap handler
+    and ioctls.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 205d21e..25f59c1 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -588,9 +588,15 @@ static int i915_quiescent(struct drm_device * dev)
+ static int i915_flush_ioctl(struct drm_device *dev, void *data,
+ 			    struct drm_file *file_priv)
+ {
+-	LOCK_TEST_WITH_RETURN(dev, file_priv);
++	int ret;
++
++	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
+ 
+-	return i915_quiescent(dev);
++	mutex_lock(&dev->struct_mutex);
++	ret = i915_quiescent(dev);
++	mutex_unlock(&dev->struct_mutex);
++
++	return ret;
+ }
+ 
+ static int i915_batchbuffer(struct drm_device *dev, void *data,
+@@ -611,14 +617,16 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
+ 	DRM_DEBUG("i915 batchbuffer, start %x used %d cliprects %d\n",
+ 		  batch->start, batch->used, batch->num_cliprects);
+ 
+-	LOCK_TEST_WITH_RETURN(dev, file_priv);
++	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
+ 
+ 	if (batch->num_cliprects && DRM_VERIFYAREA_READ(batch->cliprects,
+ 						       batch->num_cliprects *
+ 						       sizeof(struct drm_clip_rect)))
+ 		return -EFAULT;
+ 
++	mutex_lock(&dev->struct_mutex);
+ 	ret = i915_dispatch_batchbuffer(dev, batch);
++	mutex_unlock(&dev->struct_mutex);
+ 
+ 	sarea_priv->last_dispatch = (int)hw_status[5];
+ 	return ret;
+@@ -637,7 +645,7 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
+ 	DRM_DEBUG("i915 cmdbuffer, buf %p sz %d cliprects %d\n",
+ 		  cmdbuf->buf, cmdbuf->sz, cmdbuf->num_cliprects);
+ 
+-	LOCK_TEST_WITH_RETURN(dev, file_priv);
++	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
+ 
+ 	if (cmdbuf->num_cliprects &&
+ 	    DRM_VERIFYAREA_READ(cmdbuf->cliprects,
+@@ -647,7 +655,9 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
+ 		return -EFAULT;
+ 	}
+ 
++	mutex_lock(&dev->struct_mutex);
+ 	ret = i915_dispatch_cmdbuffer(dev, cmdbuf);
++	mutex_unlock(&dev->struct_mutex);
+ 	if (ret) {
+ 		DRM_ERROR("i915_dispatch_cmdbuffer failed\n");
+ 		return ret;
+@@ -660,11 +670,17 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
+ static int i915_flip_bufs(struct drm_device *dev, void *data,
+ 			  struct drm_file *file_priv)
+ {
++	int ret;
++
+ 	DRM_DEBUG("%s\n", __FUNCTION__);
+ 
+-	LOCK_TEST_WITH_RETURN(dev, file_priv);
++	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
+ 
+-	return i915_dispatch_flip(dev);
++	mutex_lock(&dev->struct_mutex);
++	ret = i915_dispatch_flip(dev);
++	mutex_unlock(&dev->struct_mutex);
++
++	return ret;
+ }
+ 
+ static int i915_getparam(struct drm_device *dev, void *data,
+diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
+index 87b071a..8547f0a 100644
+--- a/drivers/gpu/drm/i915/i915_drv.h
++++ b/drivers/gpu/drm/i915/i915_drv.h
+@@ -285,6 +285,9 @@ typedef struct drm_i915_private {
+ 		 */
+ 		struct delayed_work retire_work;
+ 
++		/** Work task for vblank-related ring access */
++		struct work_struct vblank_work;
++
+ 		uint32_t next_gem_seqno;
+ 
+ 		/**
+@@ -435,6 +438,7 @@ extern int i915_irq_wait(struct drm_device *dev, void *data,
+ void i915_user_irq_get(struct drm_device *dev);
+ void i915_user_irq_put(struct drm_device *dev);
+ 
++extern void i915_gem_vblank_work_handler(struct work_struct *work);
+ extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
+ extern void i915_driver_irq_preinstall(struct drm_device * dev);
+ extern int i915_driver_irq_postinstall(struct drm_device *dev);
+@@ -538,6 +542,17 @@ extern void intel_opregion_free(struct drm_device *dev);
+ extern void opregion_asle_intr(struct drm_device *dev);
+ extern void opregion_enable_asle(struct drm_device *dev);
+ 
++/**
++ * Lock test for when it's just for synchronization of ring access.
++ *
++ * In that case, we don't need to do it when GEM is initialized as nobody else
++ * has access to the ring.
++ */
++#define RING_LOCK_TEST_WITH_RETURN(dev, file_priv) do {			\
++	if (((drm_i915_private_t *)dev->dev_private)->ring.ring_obj == NULL) \
++		LOCK_TEST_WITH_RETURN(dev, file_priv);			\
++} while (0)
++
+ #define I915_READ(reg)          DRM_READ32(dev_priv->mmio_map, (reg))
+ #define I915_WRITE(reg,val)     DRM_WRITE32(dev_priv->mmio_map, (reg), (val))
+ #define I915_READ16(reg)	DRM_READ16(dev_priv->mmio_map, (reg))
+diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
+index 90ae8a0..bb6e5a3 100644
+--- a/drivers/gpu/drm/i915/i915_gem.c
++++ b/drivers/gpu/drm/i915/i915_gem.c
+@@ -2491,6 +2491,8 @@ i915_gem_load(struct drm_device *dev)
+ 	INIT_LIST_HEAD(&dev_priv->mm.request_list);
+ 	INIT_DELAYED_WORK(&dev_priv->mm.retire_work,
+ 			  i915_gem_retire_work_handler);
++	INIT_WORK(&dev_priv->mm.vblank_work,
++		  i915_gem_vblank_work_handler);
+ 	dev_priv->mm.next_gem_seqno = 1;
+ 
+ 	i915_gem_detect_bit_6_swizzle(dev);
+diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
+index f295bdf..d04c526 100644
+--- a/drivers/gpu/drm/i915/i915_irq.c
++++ b/drivers/gpu/drm/i915/i915_irq.c
+@@ -349,6 +349,21 @@ u32 i915_get_vblank_counter(struct drm_device *dev, int plane)
+ 	return count;
+ }
+ 
++void
++i915_gem_vblank_work_handler(struct work_struct *work)
++{
++	drm_i915_private_t *dev_priv;
++	struct drm_device *dev;
++
++	dev_priv = container_of(work, drm_i915_private_t,
++				mm.vblank_work);
++	dev = dev_priv->dev;
++
++	mutex_lock(&dev->struct_mutex);
++	i915_vblank_tasklet(dev);
++	mutex_unlock(&dev->struct_mutex);
++}
++
+ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
+ {
+ 	struct drm_device *dev = (struct drm_device *) arg;
+@@ -422,8 +437,12 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
+ 	if (iir & I915_ASLE_INTERRUPT)
+ 		opregion_asle_intr(dev);
+ 
+-	if (vblank && dev_priv->swaps_pending > 0)
+-		drm_locked_tasklet(dev, i915_vblank_tasklet);
++	if (vblank && dev_priv->swaps_pending > 0) {
++		if (dev_priv->ring.ring_obj == NULL)
++			drm_locked_tasklet(dev, i915_vblank_tasklet);
++		else
++			schedule_work(&dev_priv->mm.vblank_work);
++	}
+ 
+ 	return IRQ_HANDLED;
+ }
+@@ -514,14 +533,15 @@ int i915_irq_emit(struct drm_device *dev, void *data,
+ 	drm_i915_irq_emit_t *emit = data;
+ 	int result;
+ 
+-	LOCK_TEST_WITH_RETURN(dev, file_priv);
++	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
+ 
+ 	if (!dev_priv) {
+ 		DRM_ERROR("called with no initialization\n");
+ 		return -EINVAL;
+ 	}
+-
++	mutex_lock(&dev->struct_mutex);
+ 	result = i915_emit_irq(dev);
++	mutex_unlock(&dev->struct_mutex);
+ 
+ 	if (DRM_COPY_TO_USER(emit->irq_seq, &result, sizeof(int))) {
+ 		DRM_ERROR("copy_to_user\n");

meta-moblin/packages/linux/linux-moblin-2.6.27/0017-i915-Make-use-of-sarea_priv-conditional.patch

@@ -0,0 +1,147 @@
+commit 69749cf99189a8a78de201ac24990c91ee111469
+Author: Kristian Høgsberg <krh@redhat.com>
+Date:   Wed Aug 20 11:20:13 2008 -0400
+
+    i915: Make use of sarea_priv conditional.
+    
+    We fail ioctls that depend on the sarea_priv with EINVAL.
+    
+    Signed-off-by: Kristian Høgsberg <krh@redhat.com>
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index 25f59c1..dbd3f49 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -55,7 +55,8 @@ int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
+ 		if (ring->space >= n)
+ 			return 0;
+ 
+-		dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
++		if (dev_priv->sarea_priv)
++			dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
+ 
+ 		if (ring->head != last_head)
+ 			i = 0;
+@@ -128,7 +129,7 @@ void i915_kernel_lost_context(struct drm_device * dev)
+ 	if (ring->space < 0)
+ 		ring->space += ring->Size;
+ 
+-	if (ring->head == ring->tail)
++	if (ring->head == ring->tail && dev_priv->sarea_priv)
+ 		dev_priv->sarea_priv->perf_boxes |= I915_BOX_RING_EMPTY;
+ }
+ 
+@@ -433,10 +434,11 @@ static void i915_emit_breadcrumb(struct drm_device *dev)
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+ 	RING_LOCALS;
+ 
+-	dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
+-
++	dev_priv->counter++;
+ 	if (dev_priv->counter > 0x7FFFFFFFUL)
+-		dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
++		dev_priv->counter = 0;
++	if (dev_priv->sarea_priv)
++		dev_priv->sarea_priv->last_enqueue = dev_priv->counter;
+ 
+ 	BEGIN_LP_RING(4);
+ 	OUT_RING(MI_STORE_DWORD_INDEX);
+@@ -534,6 +536,9 @@ static int i915_dispatch_flip(struct drm_device * dev)
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+ 	RING_LOCALS;
+ 
++	if (!dev_priv->sarea_priv)
++		return -EINVAL;
++
+ 	DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n",
+ 		  __FUNCTION__,
+ 		  dev_priv->current_page,
+@@ -628,7 +633,8 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
+ 	ret = i915_dispatch_batchbuffer(dev, batch);
+ 	mutex_unlock(&dev->struct_mutex);
+ 
+-	sarea_priv->last_dispatch = (int)hw_status[5];
++	if (sarea_priv)
++		sarea_priv->last_dispatch = (int)hw_status[5];
+ 	return ret;
+ }
+ 
+@@ -663,7 +669,8 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
+ 		return ret;
+ 	}
+ 
+-	sarea_priv->last_dispatch = (int)hw_status[5];
++	if (sarea_priv)
++		sarea_priv->last_dispatch = (int)hw_status[5];
+ 	return 0;
+ }
+ 
+diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
+index d04c526..ef03a59 100644
+--- a/drivers/gpu/drm/i915/i915_irq.c
++++ b/drivers/gpu/drm/i915/i915_irq.c
+@@ -427,7 +427,9 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
+ 		I915_WRITE(IMR, dev_priv->irq_mask_reg);
+ 	(void) I915_READ(IIR); /* Flush posted writes */
+ 
+-	dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
++	if (dev_priv->sarea_priv)
++		dev_priv->sarea_priv->last_dispatch =
++			READ_BREADCRUMB(dev_priv);
+ 
+ 	if (iir & I915_USER_INTERRUPT) {
+ 		dev_priv->mm.irq_gem_seqno = i915_get_gem_seqno(dev);
+@@ -456,10 +458,11 @@ static int i915_emit_irq(struct drm_device * dev)
+ 
+ 	DRM_DEBUG("\n");
+ 
+-	dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
+-
++	dev_priv->counter++;
+ 	if (dev_priv->counter > 0x7FFFFFFFUL)
+-		dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
++		dev_priv->counter = 1;
++	if (dev_priv->sarea_priv)
++		dev_priv->sarea_priv->last_enqueue = dev_priv->counter;
+ 
+ 	BEGIN_LP_RING(6);
+ 	OUT_RING(MI_STORE_DWORD_INDEX);
+@@ -503,11 +506,15 @@ static int i915_wait_irq(struct drm_device * dev, int irq_nr)
+ 		  READ_BREADCRUMB(dev_priv));
+ 
+ 	if (READ_BREADCRUMB(dev_priv) >= irq_nr) {
+-		dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
++		if (dev_priv->sarea_priv) {
++			dev_priv->sarea_priv->last_dispatch =
++				READ_BREADCRUMB(dev_priv);
++		}
+ 		return 0;
+ 	}
+ 
+-	dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
++	if (dev_priv->sarea_priv)
++		dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
+ 
+ 	i915_user_irq_get(dev);
+ 	DRM_WAIT_ON(ret, dev_priv->irq_queue, 3 * DRM_HZ,
+@@ -519,7 +526,9 @@ static int i915_wait_irq(struct drm_device * dev, int irq_nr)
+ 			  READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
+ 	}
+ 
+-	dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
++	if (dev_priv->sarea_priv)
++		dev_priv->sarea_priv->last_dispatch =
++			READ_BREADCRUMB(dev_priv);
+ 
+ 	return ret;
+ }
+@@ -682,7 +691,7 @@ int i915_vblank_swap(struct drm_device *dev, void *data,
+ 	struct list_head *list;
+ 	int ret;
+ 
+-	if (!dev_priv) {
++	if (!dev_priv || !dev_priv->sarea_priv) {
+ 		DRM_ERROR("%s called with no initialization\n", __func__);
+ 		return -EINVAL;
+ 	}

meta-moblin/packages/linux/linux-moblin-2.6.27/0018-i915-gem-install-and-uninstall-irq-handler-in-enter.patch

@@ -0,0 +1,44 @@
+commit 7ad6d5861b04bbb2cdc36d1dcf8989e16f86e659
+Author: Kristian Høgsberg <krh@redhat.com>
+Date:   Wed Aug 20 11:04:27 2008 -0400
+
+    i915 gem: install and uninstall irq handler in entervt and leavevt ioctls.
+    
+    Signed-off-by: Kristian Høgsberg <krh@redhat.com>
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
+index bb6e5a3..5fe5034 100644
+--- a/drivers/gpu/drm/i915/i915_gem.c
++++ b/drivers/gpu/drm/i915/i915_gem.c
+@@ -2443,6 +2443,9 @@ i915_gem_entervt_ioctl(struct drm_device *dev, void *data,
+ 	BUG_ON(!list_empty(&dev_priv->mm.request_list));
+ 	dev_priv->mm.suspended = 0;
+ 	mutex_unlock(&dev->struct_mutex);
++
++	drm_irq_install(dev);
++
+ 	return 0;
+ }
+ 
+@@ -2458,6 +2461,8 @@ i915_gem_leavevt_ioctl(struct drm_device *dev, void *data,
+ 		i915_gem_cleanup_ringbuffer(dev);
+ 	mutex_unlock(&dev->struct_mutex);
+ 
++	drm_irq_uninstall(dev);
++
+ 	return 0;
+ }
+ 
+diff --git a/include/drm/drmP.h b/include/drm/drmP.h
+index 1469a1b..51ee72c 100644
+--- a/include/drm/drmP.h
++++ b/include/drm/drmP.h
+@@ -1134,6 +1134,7 @@ extern void drm_core_reclaim_buffers(struct drm_device *dev,
+ extern int drm_control(struct drm_device *dev, void *data,
+ 		       struct drm_file *file_priv);
+ extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
++extern int drm_irq_install(struct drm_device *dev);
+ extern int drm_irq_uninstall(struct drm_device *dev);
+ extern void drm_driver_irq_preinstall(struct drm_device *dev);
+ extern void drm_driver_irq_postinstall(struct drm_device *dev);

meta-moblin/packages/linux/linux-moblin-2.6.27/0019-DRM-Return-EBADF-on-bad-object-in-flink-and-retur.patch

@@ -0,0 +1,32 @@
+commit c3de45b0488762a9161e9b9e8bf419f63c100c47
+Author: Eric Anholt <eric@anholt.net>
+Date:   Tue Sep 9 11:40:34 2008 -0700
+
+    DRM: Return -EBADF on bad object in flink, and return curent name if it exists.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
+index 434155b..ccd1afd 100644
+--- a/drivers/gpu/drm/drm_gem.c
++++ b/drivers/gpu/drm/drm_gem.c
+@@ -251,7 +251,7 @@ drm_gem_flink_ioctl(struct drm_device *dev, void *data,
+ 
+ 	obj = drm_gem_object_lookup(dev, file_priv, args->handle);
+ 	if (obj == NULL)
+-		return -EINVAL;
++		return -EBADF;
+ 
+ again:
+ 	if (idr_pre_get(&dev->object_name_idr, GFP_KERNEL) == 0)
+@@ -259,8 +259,9 @@ again:
+ 
+ 	spin_lock(&dev->object_name_lock);
+ 	if (obj->name) {
++		args->name = obj->name;
+ 		spin_unlock(&dev->object_name_lock);
+-		return -EEXIST;
++		return 0;
+ 	}
+ 	ret = idr_get_new_above(&dev->object_name_idr, obj, 1,
+ 				 &obj->name);

meta-moblin/packages/linux/linux-moblin-2.6.27/0020-drm-Avoid-oops-in-GEM-execbuffers-with-bad-argument.patch

@@ -0,0 +1,23 @@
+commit 880db7a8dbed226d638b3a48aa1a3996f8624911
+Author: Eric Anholt <eric@anholt.net>
+Date:   Wed Sep 10 14:22:49 2008 -0700
+
+    drm: Avoid oops in GEM execbuffers with bad arguments.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
+index 5fe5034..29d9d21 100644
+--- a/drivers/gpu/drm/i915/i915_gem.c
++++ b/drivers/gpu/drm/i915/i915_gem.c
+@@ -1763,6 +1763,10 @@ i915_gem_execbuffer(struct drm_device *dev, void *data,
+ 		  (int) args->buffers_ptr, args->buffer_count, args->batch_len);
+ #endif
+ 
++	if (args->buffer_count < 1) {
++		DRM_ERROR("execbuf with %d buffers\n", args->buffer_count);
++		return -EINVAL;
++	}
+ 	/* Copy in the exec list from userland */
+ 	exec_list = drm_calloc(sizeof(*exec_list), args->buffer_count,
+ 			       DRM_MEM_DRIVER);

meta-moblin/packages/linux/linux-moblin-2.6.27/0021-drm-G33-class-hardware-has-a-newer-965-style-MCH-n.patch

@@ -0,0 +1,23 @@
+commit 930469634910fa87c21f0a7423c98b270d35d8c6
+Author: Eric Anholt <eric@anholt.net>
+Date:   Mon Sep 15 13:13:34 2008 -0700
+
+    drm: G33-class hardware has a newer 965-style MCH (no DCC register).
+    
+    Fixes bad software fallback rendering in Mesa in dual-channel configurations.
+    
+    d9a2470012588dc5313a5ac8bb2f03575af00e99
+
+diff --git a/drivers/gpu/drm/i915/i915_gem_tiling.c b/drivers/gpu/drm/i915/i915_gem_tiling.c
+index 0c1b3a0..6b3f1e4 100644
+--- a/drivers/gpu/drm/i915/i915_gem_tiling.c
++++ b/drivers/gpu/drm/i915/i915_gem_tiling.c
+@@ -96,7 +96,7 @@ i915_gem_detect_bit_6_swizzle(struct drm_device *dev)
+ 		 */
+ 		swizzle_x = I915_BIT_6_SWIZZLE_NONE;
+ 		swizzle_y = I915_BIT_6_SWIZZLE_NONE;
+-	} else if (!IS_I965G(dev) || IS_I965GM(dev)) {
++	} else if ((!IS_I965G(dev) && !IS_G33(dev)) || IS_I965GM(dev)) {
+ 		uint32_t dcc;
+ 
+ 		/* On 915-945 and GM965, channel interleave by the CPU is

meta-moblin/packages/linux/linux-moblin-2.6.27/0022-drm-use-ioremap_wc-in-i915-instead-of-ioremap.patch

@@ -0,0 +1,58 @@
+commit d9f2382adde582f8792ad96e9570716bcbea21a0
+Author: Eric Anholt <eric@anholt.net>
+Date:   Tue Sep 23 14:50:57 2008 -0700
+
+    drm: Use ioremap_wc in i915_driver instead of ioremap, since we always want WC.
+    
+    Fixes failure to map the ringbuffer when PAT tells us we don't get to do
+    uncached on something that's already mapped WC, or something along those lines.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
+index 29d9d21..6ecfd10 100644
+--- a/drivers/gpu/drm/i915/i915_gem.c
++++ b/drivers/gpu/drm/i915/i915_gem.c
+@@ -233,7 +233,7 @@ i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
+ 		if (unwritten)
+ #endif /* CONFIG_HIGHMEM */
+ 		{
+-			vaddr = ioremap(pfn << PAGE_SHIFT, PAGE_SIZE);
++			vaddr = ioremap_wc(pfn << PAGE_SHIFT, PAGE_SIZE);
+ #if WATCH_PWRITE
+ 			DRM_INFO("pwrite slow i %d o %d l %d "
+ 				 "pfn %ld vaddr %p\n",
+@@ -1612,9 +1612,10 @@ i915_gem_object_pin_and_relocate(struct drm_gem_object *obj,
+ 			if (reloc_page != NULL)
+ 				iounmap(reloc_page);
+ 
+-			reloc_page = ioremap(dev->agp->base +
+-					     (reloc_offset & ~(PAGE_SIZE - 1)),
+-					     PAGE_SIZE);
++			reloc_page = ioremap_wc(dev->agp->base +
++						(reloc_offset &
++						 ~(PAGE_SIZE - 1)),
++						PAGE_SIZE);
+ 			last_reloc_offset = reloc_offset;
+ 			if (reloc_page == NULL) {
+ 				drm_gem_object_unreference(target_obj);
+@@ -2318,7 +2319,9 @@ i915_gem_init_hws(struct drm_device *dev)
+ 	dev_priv->hws_map.flags = 0;
+ 	dev_priv->hws_map.mtrr = 0;
+ 
+-	drm_core_ioremap(&dev_priv->hws_map, dev);
++	/* Ioremapping here is the wrong thing to do.  We want cached access.
++	 */
++	drm_core_ioremap_wc(&dev_priv->hws_map, dev);
+ 	if (dev_priv->hws_map.handle == NULL) {
+ 		DRM_ERROR("Failed to map status page.\n");
+ 		memset(&dev_priv->hws_map, 0, sizeof(dev_priv->hws_map));
+@@ -2369,7 +2372,7 @@ i915_gem_init_ringbuffer(struct drm_device *dev)
+ 	dev_priv->ring.map.flags = 0;
+ 	dev_priv->ring.map.mtrr = 0;
+ 
+-	drm_core_ioremap(&dev_priv->ring.map, dev);
++	drm_core_ioremap_wc(&dev_priv->ring.map, dev);
+ 	if (dev_priv->ring.map.handle == NULL) {
+ 		DRM_ERROR("Failed to map ringbuffer.\n");
+ 		memset(&dev_priv->ring, 0, sizeof(dev_priv->ring));

meta-moblin/packages/linux/linux-moblin-2.6.27/0023-drm-clean-up-many-sparse-warnings-in-i915.patch

@@ -0,0 +1,192 @@
+commit 034994cfffbb2371b720e3f49378031ebc12645e
+Author: Eric Anholt <eric@anholt.net>
+Date:   Thu Oct 2 12:24:47 2008 -0700
+
+    drm: Clean up many sparse warnings in i915.
+    
+    Signed-off-by: Eric Anholt <eric@anholt.net>
+
+diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
+index dbd3f49..814cc12 100644
+--- a/drivers/gpu/drm/i915/i915_dma.c
++++ b/drivers/gpu/drm/i915/i915_dma.c
+@@ -76,7 +76,7 @@ int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
+  * Sets up the hardware status page for devices that need a physical address
+  * in the register.
+  */
+-int i915_init_phys_hws(struct drm_device *dev)
++static int i915_init_phys_hws(struct drm_device *dev)
+ {
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+ 	/* Program Hardware Status Page */
+@@ -101,7 +101,7 @@ int i915_init_phys_hws(struct drm_device *dev)
+  * Frees the hardware status page, whether it's a physical address or a virtual
+  * address set up by the X Server.
+  */
+-void i915_free_hws(struct drm_device *dev)
++static void i915_free_hws(struct drm_device *dev)
+ {
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+ 	if (dev_priv->status_page_dmah) {
+@@ -145,8 +145,8 @@ static int i915_dma_cleanup(struct drm_device * dev)
+ 
+ 	if (dev_priv->ring.virtual_start) {
+ 		drm_core_ioremapfree(&dev_priv->ring.map, dev);
+-		dev_priv->ring.virtual_start = 0;
+-		dev_priv->ring.map.handle = 0;
++		dev_priv->ring.virtual_start = NULL;
++		dev_priv->ring.map.handle = NULL;
+ 		dev_priv->ring.map.size = 0;
+ 	}
+ 
+@@ -827,9 +827,7 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
+ 	base = drm_get_resource_start(dev, mmio_bar);
+ 	size = drm_get_resource_len(dev, mmio_bar);
+ 
+-	ret = drm_addmap(dev, base, size, _DRM_REGISTERS,
+-			 _DRM_KERNEL | _DRM_DRIVER,
+-			 &dev_priv->mmio_map);
++	dev_priv->regs = ioremap(base, size);
+ 
+ 	i915_gem_load(dev);
+ 
+@@ -867,8 +865,8 @@ int i915_driver_unload(struct drm_device *dev)
+ 
+ 	i915_free_hws(dev);
+ 
+-	if (dev_priv->mmio_map)
+-		drm_rmmap(dev, dev_priv->mmio_map);
++	if (dev_priv->regs != NULL)
++		iounmap(dev_priv->regs);
+ 
+ 	intel_opregion_free(dev);
+ 
+diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
+index 8547f0a..b184d54 100644
+--- a/drivers/gpu/drm/i915/i915_drv.h
++++ b/drivers/gpu/drm/i915/i915_drv.h
+@@ -110,8 +110,8 @@ struct intel_opregion {
+ typedef struct drm_i915_private {
+ 	struct drm_device *dev;
+ 
++	void __iomem *regs;
+ 	drm_local_map_t *sarea;
+-	drm_local_map_t *mmio_map;
+ 
+ 	drm_i915_sarea_t *sarea_priv;
+ 	drm_i915_ring_buffer_t ring;
+@@ -553,12 +553,12 @@ extern void opregion_enable_asle(struct drm_device *dev);
+ 		LOCK_TEST_WITH_RETURN(dev, file_priv);			\
+ } while (0)
+ 
+-#define I915_READ(reg)          DRM_READ32(dev_priv->mmio_map, (reg))
+-#define I915_WRITE(reg,val)     DRM_WRITE32(dev_priv->mmio_map, (reg), (val))
+-#define I915_READ16(reg)	DRM_READ16(dev_priv->mmio_map, (reg))
+-#define I915_WRITE16(reg,val)	DRM_WRITE16(dev_priv->mmio_map, (reg), (val))
+-#define I915_READ8(reg)		DRM_READ8(dev_priv->mmio_map, (reg))
+-#define I915_WRITE8(reg,val)	DRM_WRITE8(dev_priv->mmio_map, (reg), (val))
++#define I915_READ(reg)          readl(dev_priv->regs + (reg))
++#define I915_WRITE(reg,val)     writel(val, dev_priv->regs + (reg))
++#define I915_READ16(reg)	readw(dev_priv->regs + (reg))
++#define I915_WRITE16(reg,val)	writel(val, dev_priv->regs + (reg))
++#define I915_READ8(reg)		readb(dev_priv->regs + (reg))
++#define I915_WRITE8(reg,val)	writeb(val, dev_priv->regs + (reg))
+ 
+ #define I915_VERBOSE 0
+ 
+diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
+index 6ecfd10..6a89449 100644
+--- a/drivers/gpu/drm/i915/i915_gem.c
++++ b/drivers/gpu/drm/i915/i915_gem.c
+@@ -176,7 +176,8 @@ i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
+ 	ssize_t remain;
+ 	loff_t offset;
+ 	char __user *user_data;
+-	char *vaddr;
++	char __iomem *vaddr;
++	char *vaddr_atomic;
+ 	int i, o, l;
+ 	int ret = 0;
+ 	unsigned long pfn;
+@@ -219,16 +220,20 @@ i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
+ 		pfn = (dev->agp->base >> PAGE_SHIFT) + i;
+ 
+ #ifdef CONFIG_HIGHMEM
+-		/* kmap_atomic can't map IO pages on non-HIGHMEM kernels
++		/* This is a workaround for the low performance of iounmap
++		 * (approximate 10% cpu cost on normal 3D workloads).
++		 * kmap_atomic on HIGHMEM kernels happens to let us map card
++		 * memory without taking IPIs.  When the vmap rework lands
++		 * we should be able to dump this hack.
+ 		 */
+-		vaddr = kmap_atomic_pfn(pfn, KM_USER0);
++		vaddr_atomic = kmap_atomic_pfn(pfn, KM_USER0);
+ #if WATCH_PWRITE
+ 		DRM_INFO("pwrite i %d o %d l %d pfn %ld vaddr %p\n",
+-			 i, o, l, pfn, vaddr);
++			 i, o, l, pfn, vaddr_atomic);
+ #endif
+-		unwritten = __copy_from_user_inatomic_nocache(vaddr + o,
++		unwritten = __copy_from_user_inatomic_nocache(vaddr_atomic + o,
+ 							      user_data, l);
+-		kunmap_atomic(vaddr, KM_USER0);
++		kunmap_atomic(vaddr_atomic, KM_USER0);
+ 
+ 		if (unwritten)
+ #endif /* CONFIG_HIGHMEM */
+@@ -271,7 +276,7 @@ fail:
+ 	return ret;
+ }
+ 
+-int
++static int
+ i915_gem_shmem_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
+ 		      struct drm_i915_gem_pwrite *args,
+ 		      struct drm_file *file_priv)
+@@ -587,7 +592,7 @@ i915_add_request(struct drm_device *dev, uint32_t flush_domains)
+  * Ensures that all commands in the ring are finished
+  * before signalling the CPU
+  */
+-uint32_t
++static uint32_t
+ i915_retire_commands(struct drm_device *dev)
+ {
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+@@ -734,7 +739,7 @@ i915_gem_retire_work_handler(struct work_struct *work)
+  * Waits for a sequence number to be signaled, and cleans up the
+  * request and object lists appropriately for that event.
+  */
+-int
++static int
+ i915_wait_request(struct drm_device *dev, uint32_t seqno)
+ {
+ 	drm_i915_private_t *dev_priv = dev->dev_private;
+@@ -1483,7 +1488,7 @@ i915_gem_object_pin_and_relocate(struct drm_gem_object *obj,
+ 	struct drm_i915_gem_object *obj_priv = obj->driver_private;
+ 	int i, ret;
+ 	uint32_t last_reloc_offset = -1;
+-	void *reloc_page = NULL;
++	void __iomem *reloc_page = NULL;
+ 
+ 	/* Choose the GTT offset for our buffer and put it there. */
+ 	ret = i915_gem_object_pin(obj, (uint32_t) entry->alignment);
+@@ -1500,8 +1505,8 @@ i915_gem_object_pin_and_relocate(struct drm_gem_object *obj,
+ 	for (i = 0; i < entry->relocation_count; i++) {
+ 		struct drm_gem_object *target_obj;
+ 		struct drm_i915_gem_object *target_obj_priv;
+-		uint32_t reloc_val, reloc_offset, *reloc_entry;
+-		int ret;
++		uint32_t reloc_val, reloc_offset;
++		uint32_t __iomem *reloc_entry;
+ 
+ 		ret = copy_from_user(&reloc, relocs + i, sizeof(reloc));
+ 		if (ret != 0) {
+@@ -1624,7 +1629,7 @@ i915_gem_object_pin_and_relocate(struct drm_gem_object *obj,
+ 			}
+ 		}
+ 
+-		reloc_entry = (uint32_t *)((char *)reloc_page +
++		reloc_entry = (uint32_t __iomem *)(reloc_page +
+ 					   (reloc_offset & (PAGE_SIZE - 1)));
+ 		reloc_val = target_obj_priv->gtt_offset + reloc.delta;
+ 

meta-moblin/packages/linux/linux-moblin-2.6.27/0024-fastboot-create-a-asynchronous-initlevel.patch

@@ -0,0 +1,133 @@
+From ac9103dd8e4dc65c110d6cba9a3380c6c617ffa7 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Fri, 18 Jul 2008 15:16:08 -0700
+Subject: [PATCH] fastboot: create a "asynchronous" initlevel
+
+This patch creates an asynchronous initlevel (6a) which is at the same
+level as the normal device initcalls, but with the difference that they
+are run asynchronous from all the other initcalls. The purpose of this
+*selective* level is that we can move long waiting inits that are not
+boot-critical to this level one at a time.
+
+To keep things not totally insane, the asynchronous initcalls are async
+to the other initcalls, but are still ordered to themselves; think of it
+as "bottom-half-not-softirq". This has the benefit that async drivers
+still have stable device ordering between them.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ include/asm-generic/vmlinux.lds.h |    3 +++
+ include/linux/init.h              |    6 ++++++
+ init/main.c                       |   35 ++++++++++++++++++++++++++++++++---
+ 3 files changed, 41 insertions(+), 3 deletions(-)
+
+Index: linux-2.6.27/include/asm-generic/vmlinux.lds.h
+===================================================================
+--- linux-2.6.27.orig/include/asm-generic/vmlinux.lds.h	2008-10-14 16:55:43.000000000 +0200
++++ linux-2.6.27/include/asm-generic/vmlinux.lds.h	2008-10-14 17:00:59.000000000 +0200
+@@ -376,6 +376,9 @@
+   	*(.initcall5.init)						\
+   	*(.initcall5s.init)						\
+ 	*(.initcallrootfs.init)						\
++	__async_initcall_start = .;					\
++	*(.initcall6a.init)						\
++	__async_initcall_end = .;					\
+   	*(.initcall6.init)						\
+   	*(.initcall6s.init)						\
+   	*(.initcall7.init)						\
+Index: linux-2.6.27/include/linux/init.h
+===================================================================
+--- linux-2.6.27.orig/include/linux/init.h	2008-10-14 16:55:45.000000000 +0200
++++ linux-2.6.27/include/linux/init.h	2008-10-14 17:00:59.000000000 +0200
+@@ -197,11 +197,13 @@ extern void (*late_time_init)(void);
+ #define fs_initcall_sync(fn)		__define_initcall("5s",fn,5s)
+ #define rootfs_initcall(fn)		__define_initcall("rootfs",fn,rootfs)
+ #define device_initcall(fn)		__define_initcall("6",fn,6)
++#define device_initcall_async(fn)	__define_initcall("6a", fn, 6a)
+ #define device_initcall_sync(fn)	__define_initcall("6s",fn,6s)
+ #define late_initcall(fn)		__define_initcall("7",fn,7)
+ #define late_initcall_sync(fn)		__define_initcall("7s",fn,7s)
+ 
+ #define __initcall(fn) device_initcall(fn)
++#define __initcall_async(fn) device_initcall_async(fn)
+ 
+ #define __exitcall(fn) \
+ 	static exitcall_t __exitcall_##fn __exit_call = fn
+@@ -257,6 +259,7 @@ void __init parse_early_param(void);
+  * be one per module.
+  */
+ #define module_init(x)	__initcall(x);
++#define module_init_async(x)	__initcall_async(x);
+ 
+ /**
+  * module_exit() - driver exit entry point
+@@ -279,10 +282,13 @@ void __init parse_early_param(void);
+ #define subsys_initcall(fn)		module_init(fn)
+ #define fs_initcall(fn)			module_init(fn)
+ #define device_initcall(fn)		module_init(fn)
++#define device_initcall_async(fn)	module_init(fn)
+ #define late_initcall(fn)		module_init(fn)
+ 
+ #define security_initcall(fn)		module_init(fn)
+ 
++#define module_init_async(fn)		module_init(fn)
++
+ /* Each module must use one module_init(). */
+ #define module_init(initfn)					\
+ 	static inline initcall_t __inittest(void)		\
+Index: linux-2.6.27/init/main.c
+===================================================================
+--- linux-2.6.27.orig/init/main.c	2008-10-14 16:55:47.000000000 +0200
++++ linux-2.6.27/init/main.c	2008-10-14 17:00:59.000000000 +0200
+@@ -745,18 +745,47 @@ int do_one_initcall(initcall_t fn)
+ 
+ 
+ extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
++extern initcall_t __async_initcall_start[], __async_initcall_end[];
+ 
+-static void __init do_initcalls(void)
++static void __init do_async_initcalls(struct work_struct *dummy)
+ {
+ 	initcall_t *call;
+ 
+-	for (call = __early_initcall_end; call < __initcall_end; call++)
++	for (call = __async_initcall_start; call < __async_initcall_end; call++)
+ 		do_one_initcall(*call);
++}
++
++static struct workqueue_struct *async_init_wq;
++
++static void __init do_initcalls(void)
++{
++	initcall_t *call;
++	static DECLARE_WORK(async_work, do_async_initcalls);
++	int phase = 0; /* 0 = levels 0 - 6, 1 = level 6a, 2 = after level 6a */
++
++	async_init_wq = create_singlethread_workqueue("kasyncinit");
++
++	for (call = __early_initcall_end; call < __initcall_end; call++) {
++		if (phase == 0 && call >= __async_initcall_start) {
++			phase = 1;
++			queue_work(async_init_wq, &async_work);
++		}
++		if (phase == 1 && call >= __async_initcall_end)
++			phase = 2;
++		if (phase != 1)
++			do_one_initcall(*call);
++	}
+ 
+-	/* Make sure there is no pending stuff from the initcall sequence */
++	/*
++ 	* Make sure there is no pending stuff from the initcall sequence,
++	* including the async initcalls
++	*/
+ 	flush_scheduled_work();
++	flush_workqueue(async_init_wq);
++	destroy_workqueue(async_init_wq);
+ }
+ 
++
+ /*
+  * Ok, the machine is now initialized. None of the devices
+  * have been touched yet, but the CPU subsystem is up and

meta-moblin/packages/linux/linux-moblin-2.6.27/0025-fastboot-turn-the-USB-hostcontroller-initcalls-into.patch

@@ -0,0 +1,59 @@
+From d1a26186ee222329a797bb0b2c8e2b5bc7d94d42 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Fri, 18 Jul 2008 15:16:53 -0700
+Subject: [PATCH] fastboot: turn the USB hostcontroller initcalls into async initcalls
+
+the USB host controller init calls take a long time, mostly due to a
+"minimally 100 msec" delay *per port* during initialization.
+These are prime candidates for going in parallel to everything else.
+
+The USB device ordering is not affected by this due to the
+serialized-within-eachother property of async initcalls.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ drivers/usb/host/ehci-hcd.c |    2 +-
+ drivers/usb/host/ohci-hcd.c |    2 +-
+ drivers/usb/host/uhci-hcd.c |    2 +-
+ 3 files changed, 3 insertions(+), 3 deletions(-)
+
+Index: linux-2.6.27/drivers/usb/host/ehci-hcd.c
+===================================================================
+--- linux-2.6.27.orig/drivers/usb/host/ehci-hcd.c	2008-10-14 16:55:35.000000000 +0200
++++ linux-2.6.27/drivers/usb/host/ehci-hcd.c	2008-10-14 17:01:27.000000000 +0200
+@@ -1107,7 +1107,7 @@ clean0:
+ #endif
+ 	return retval;
+ }
+-module_init(ehci_hcd_init);
++module_init_async(ehci_hcd_init);
+ 
+ static void __exit ehci_hcd_cleanup(void)
+ {
+Index: linux-2.6.27/drivers/usb/host/ohci-hcd.c
+===================================================================
+--- linux-2.6.27.orig/drivers/usb/host/ohci-hcd.c	2008-10-14 16:55:35.000000000 +0200
++++ linux-2.6.27/drivers/usb/host/ohci-hcd.c	2008-10-14 17:01:27.000000000 +0200
+@@ -1186,7 +1186,7 @@ static int __init ohci_hcd_mod_init(void
+ 
+ 	return retval;
+ }
+-module_init(ohci_hcd_mod_init);
++module_init_async(ohci_hcd_mod_init);
+ 
+ static void __exit ohci_hcd_mod_exit(void)
+ {
+Index: linux-2.6.27/drivers/usb/host/uhci-hcd.c
+===================================================================
+--- linux-2.6.27.orig/drivers/usb/host/uhci-hcd.c	2008-10-14 16:55:35.000000000 +0200
++++ linux-2.6.27/drivers/usb/host/uhci-hcd.c	2008-10-14 17:01:27.000000000 +0200
+@@ -999,7 +999,7 @@ static void __exit uhci_hcd_cleanup(void
+ 	kfree(errbuf);
+ }
+ 
+-module_init(uhci_hcd_init);
++module_init_async(uhci_hcd_init);
+ module_exit(uhci_hcd_cleanup);
+ 
+ MODULE_AUTHOR(DRIVER_AUTHOR);

meta-moblin/packages/linux/linux-moblin-2.6.27/0026-fastboot-convert-a-few-non-critical-ACPI-drivers-to.patch

@@ -0,0 +1,51 @@
+From 60ddc2e5c44b4b9f5fcb440065469eacbeabf5eb Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Fri, 18 Jul 2008 15:17:35 -0700
+Subject: [PATCH] fastboot: convert a few non-critical ACPI drivers to async initcalls
+
+This patch converts a few non-critical ACPI drivers to async initcalls;
+these initcalls (battery, button and thermal) tend to take quite a bit of
+time (100's of milliseconds) due to the hardware they need to talk to,
+but are otherwise clearly non-essential for the boot process.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ drivers/acpi/battery.c |    2 +-
+ drivers/acpi/button.c  |    2 +-
+ drivers/acpi/thermal.c |    2 +-
+ 3 files changed, 3 insertions(+), 3 deletions(-)
+
+Index: linux-2.6.27/drivers/acpi/battery.c
+===================================================================
+--- linux-2.6.27.orig/drivers/acpi/battery.c	2008-10-14 16:55:15.000000000 +0200
++++ linux-2.6.27/drivers/acpi/battery.c	2008-10-14 17:01:33.000000000 +0200
+@@ -904,5 +904,5 @@ static void __exit acpi_battery_exit(voi
+ #endif
+ }
+ 
+-module_init(acpi_battery_init);
++module_init_async(acpi_battery_init);
+ module_exit(acpi_battery_exit);
+Index: linux-2.6.27/drivers/acpi/button.c
+===================================================================
+--- linux-2.6.27.orig/drivers/acpi/button.c	2008-10-14 16:55:15.000000000 +0200
++++ linux-2.6.27/drivers/acpi/button.c	2008-10-14 17:01:33.000000000 +0200
+@@ -545,5 +545,5 @@ static void __exit acpi_button_exit(void
+ 	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
+ }
+ 
+-module_init(acpi_button_init);
++module_init_async(acpi_button_init);
+ module_exit(acpi_button_exit);
+Index: linux-2.6.27/drivers/acpi/thermal.c
+===================================================================
+--- linux-2.6.27.orig/drivers/acpi/thermal.c	2008-10-14 16:55:15.000000000 +0200
++++ linux-2.6.27/drivers/acpi/thermal.c	2008-10-14 17:01:33.000000000 +0200
+@@ -1876,5 +1876,5 @@ static void __exit acpi_thermal_exit(voi
+ 	return;
+ }
+ 
+-module_init(acpi_thermal_init);
++module_init_async(acpi_thermal_init);
+ module_exit(acpi_thermal_exit);

meta-moblin/packages/linux/linux-moblin-2.6.27/0027-fastboot-hold-the-BKL-over-the-async-init-call-sequ.patch

@@ -0,0 +1,37 @@
+From 3e6558b693dd1e69e3177bc248977f067a769f14 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 20 Jul 2008 08:59:24 -0700
+Subject: [PATCH] fastboot: hold the BKL over the async init call sequence
+
+Regular init calls are called with the BKL held; make sure
+the async init calls are also called with the BKL held.
+While this reduces parallelism a little, it does provide
+lock-for-lock compatibility. The hit to prallelism isn't too
+bad, most of the init calls are done immediately or actually
+block for their delays.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ init/main.c |    6 ++++++
+ 1 file changed, 6 insertions(+)
+
+Index: linux-2.6.27/init/main.c
+===================================================================
+--- linux-2.6.27.orig/init/main.c	2008-10-14 17:00:59.000000000 +0200
++++ linux-2.6.27/init/main.c	2008-10-14 17:01:38.000000000 +0200
+@@ -751,8 +751,14 @@ static void __init do_async_initcalls(st
+ {
+ 	initcall_t *call;
+ 
++	/*
++	 * For compatibility with normal init calls... take the BKL
++	 * not pretty, not desirable, but compatibility first
++	 */
++	lock_kernel();
+ 	for (call = __async_initcall_start; call < __async_initcall_end; call++)
+ 		do_one_initcall(*call);
++	unlock_kernel();
+ }
+ 
+ static struct workqueue_struct *async_init_wq;

meta-moblin/packages/linux/linux-moblin-2.6.27/0028-fastboot-sync-the-async-execution-before-late_initc.patch

@@ -0,0 +1,92 @@
+From 660625fb93f2fc0e633da9cb71d13d895b385f64 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 20 Jul 2008 09:00:41 -0700
+Subject: [PATCH] fastboot: sync the async execution before late_initcall and move level 6s (sync) first
+
+Rene Herman points out several cases where it's basically needed to have
+all level 6/6a/6s calls done before the level 7 (late_initcall) code
+runs. This patch adds a sync point in the transition from the 6's to the
+7's.
+
+Second, this patch makes sure that level 6s (sync) happens before the
+async code starts, and puts a user in driver/pci in this category that
+needs to happen before device init.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ drivers/pci/pci.c                 |    2 +-
+ include/asm-generic/vmlinux.lds.h |    3 ++-
+ init/main.c                       |   14 +++++++++++++-
+ 3 files changed, 16 insertions(+), 3 deletions(-)
+
+Index: linux-2.6.27/drivers/pci/pci.c
+===================================================================
+--- linux-2.6.27.orig/drivers/pci/pci.c	2008-10-14 16:55:30.000000000 +0200
++++ linux-2.6.27/drivers/pci/pci.c	2008-10-14 17:01:42.000000000 +0200
+@@ -1909,7 +1909,7 @@ static int __devinit pci_setup(char *str
+ }
+ early_param("pci", pci_setup);
+ 
+-device_initcall(pci_init);
++device_initcall_sync(pci_init);
+ 
+ EXPORT_SYMBOL(pci_reenable_device);
+ EXPORT_SYMBOL(pci_enable_device_io);
+Index: linux-2.6.27/include/asm-generic/vmlinux.lds.h
+===================================================================
+--- linux-2.6.27.orig/include/asm-generic/vmlinux.lds.h	2008-10-14 17:00:59.000000000 +0200
++++ linux-2.6.27/include/asm-generic/vmlinux.lds.h	2008-10-14 17:01:42.000000000 +0200
+@@ -376,11 +376,12 @@
+   	*(.initcall5.init)						\
+   	*(.initcall5s.init)						\
+ 	*(.initcallrootfs.init)						\
++	*(.initcall6s.init)						\
+ 	__async_initcall_start = .;					\
+ 	*(.initcall6a.init)						\
+ 	__async_initcall_end = .;					\
+   	*(.initcall6.init)						\
+-  	*(.initcall6s.init)						\
++	__device_initcall_end = .;					\
+   	*(.initcall7.init)						\
+   	*(.initcall7s.init)
+ 
+Index: linux-2.6.27/init/main.c
+===================================================================
+--- linux-2.6.27.orig/init/main.c	2008-10-14 17:01:38.000000000 +0200
++++ linux-2.6.27/init/main.c	2008-10-14 17:01:42.000000000 +0200
+@@ -746,6 +746,7 @@ int do_one_initcall(initcall_t fn)
+ 
+ extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
+ extern initcall_t __async_initcall_start[], __async_initcall_end[];
++extern initcall_t __device_initcall_end[];
+ 
+ static void __init do_async_initcalls(struct work_struct *dummy)
+ {
+@@ -767,7 +768,13 @@ static void __init do_initcalls(void)
+ {
+ 	initcall_t *call;
+ 	static DECLARE_WORK(async_work, do_async_initcalls);
+-	int phase = 0; /* 0 = levels 0 - 6, 1 = level 6a, 2 = after level 6a */
++	/*
++	 * 0 = levels 0 - 6,
++	 * 1 = level 6a,
++	 * 2 = after level 6a,
++	 * 3 = after level 6
++	 */
++	int phase = 0;
+ 
+ 	async_init_wq = create_singlethread_workqueue("kasyncinit");
+ 
+@@ -778,6 +785,11 @@ static void __init do_initcalls(void)
+ 		}
+ 		if (phase == 1 && call >= __async_initcall_end)
+ 			phase = 2;
++		if (phase == 2 && call >= __device_initcall_end) {
++			phase = 3;
++			/* make sure all async work is done before level 7 */
++			flush_workqueue(async_init_wq);
++		}
+ 		if (phase != 1)
+ 			do_one_initcall(*call);
+ 	}

meta-moblin/packages/linux/linux-moblin-2.6.27/0029-fastboot-make-fastboot-a-config-option.patch

@@ -0,0 +1,53 @@
+From 50b6962016b824dfac254b8f36fc6cac301c8a8d Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 20 Jul 2008 10:20:49 -0700
+Subject: [PATCH] fastboot: make fastboot a config option
+
+to mitigate the risks of async bootup, make fastboot a configuration
+option...
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ init/Kconfig |   11 +++++++++++
+ init/main.c  |    4 ++++
+ 2 files changed, 15 insertions(+)
+
+Index: linux-2.6.27/init/Kconfig
+===================================================================
+--- linux-2.6.27.orig/init/Kconfig	2008-10-14 16:55:47.000000000 +0200
++++ linux-2.6.27/init/Kconfig	2008-10-14 17:01:48.000000000 +0200
+@@ -524,6 +524,17 @@ config CC_OPTIMIZE_FOR_SIZE
+ 
+ 	  If unsure, say Y.
+ 
++config FASTBOOT
++	bool "Fast boot support"
++	help
++	  The fastboot option will cause the kernel to try to optimize
++	  for faster boot.
++
++	  This includes doing some of the device initialization asynchronous
++	  as well as opportunistically trying to mount the root fs early.
++
++	  If unsure, say N.
++
+ config SYSCTL
+ 	bool
+ 
+Index: linux-2.6.27/init/main.c
+===================================================================
+--- linux-2.6.27.orig/init/main.c	2008-10-14 17:01:42.000000000 +0200
++++ linux-2.6.27/init/main.c	2008-10-14 17:01:48.000000000 +0200
+@@ -781,7 +781,11 @@ static void __init do_initcalls(void)
+ 	for (call = __early_initcall_end; call < __initcall_end; call++) {
+ 		if (phase == 0 && call >= __async_initcall_start) {
+ 			phase = 1;
++#ifdef CONFIG_FASTBOOT
+ 			queue_work(async_init_wq, &async_work);
++#else
++			do_async_initcalls(NULL);
++#endif
+ 		}
+ 		if (phase == 1 && call >= __async_initcall_end)
+ 			phase = 2;

meta-moblin/packages/linux/linux-moblin-2.6.27/0030-fastboot-retry-mounting-the-root-fs-if-we-can-t-fin.patch

@@ -0,0 +1,64 @@
+From db62cd29f9b9142c19c574ca00916f66ff22ed4a Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 20 Jul 2008 13:01:28 -0700
+Subject: [PATCH] fastboot: retry mounting the root fs if we can't find init
+
+currently we wait until all device init is done before trying to mount
+the root fs, and to consequently execute init.
+
+In preparation for relaxing the first delay, this patch adds a retry
+attempt in case /sbin/init is not found. Before retrying, the code
+will wait for all device init to complete.
+
+While this patch by itself doesn't gain boot time yet (it needs follow on
+patches), the alternative already is to panic()...
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+---
+ init/main.c |   19 +++++++++++++++++++
+ 1 file changed, 19 insertions(+)
+
+Index: linux-2.6.27/init/main.c
+===================================================================
+--- linux-2.6.27.orig/init/main.c	2008-10-14 17:01:48.000000000 +0200
++++ linux-2.6.27/init/main.c	2008-10-14 17:02:42.000000000 +0200
+@@ -845,6 +845,7 @@ static void run_init_process(char *init_
+  */
+ static int noinline init_post(void)
+ {
++	int retry_count = 1;
+ 	free_initmem();
+ 	unlock_kernel();
+ 	mark_rodata_ro();
+@@ -865,6 +866,7 @@ static int noinline init_post(void)
+ 				ramdisk_execute_command);
+ 	}
+ 
++retry:
+ 	/*
+ 	 * We try each of these until one succeeds.
+ 	 *
+@@ -877,6 +879,23 @@ static int noinline init_post(void)
+ 					"defaults...\n", execute_command);
+ 	}
+ 	run_init_process("/sbin/init");
++
++	if (retry_count > 0) {
++		retry_count--;
++		/*
++		 * We haven't found init yet... potentially because the device
++		 * is still being probed. We need to
++		 * - flush keventd and friends
++		 * - wait for the known devices to complete their probing
++		 * - try to mount the root fs again
++		 */
++		flush_scheduled_work();
++		while (driver_probe_done() != 0)
++			msleep(100);
++		prepare_namespace();
++		goto retry;
++	}
++
+ 	run_init_process("/etc/init");
+ 	run_init_process("/bin/init");
+ 	run_init_process("/bin/sh");

meta-moblin/packages/linux/linux-moblin-2.6.27/0031-fastboot-make-the-raid-autodetect-code-wait-for-all.patch

@@ -0,0 +1,41 @@
+From b52c36a95ed8026b6925fe8595ebcab6921ae62d Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 20 Jul 2008 13:07:09 -0700
+Subject: [PATCH] fastboot: make the raid autodetect code wait for all devices to init
+
+The raid autodetect code really needs to have all devices probed before
+it can detect raid arrays; not doing so would give rather messy situations
+where arrays would get detected as degraded while they shouldn't be etc.
+
+This is in preparation of removing the "wait for everything to init"
+code that makes everyone pay, not just raid users.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+---
+ init/do_mounts_md.c |    7 +++++++
+ 1 files changed, 7 insertions(+), 0 deletions(-)
+
+diff --git a/init/do_mounts_md.c b/init/do_mounts_md.c
+index 693d246..c0412a9 100644
+--- a/init/do_mounts_md.c
++++ b/init/do_mounts_md.c
+@@ -267,9 +267,16 @@ __setup("md=", md_setup);
+ void __init md_run_setup(void)
+ {
+ 	create_dev("/dev/md0", MKDEV(MD_MAJOR, 0));
++
+ 	if (raid_noautodetect)
+ 		printk(KERN_INFO "md: Skipping autodetection of RAID arrays. (raid=noautodetect)\n");
+ 	else {
++		/* 
++		 * Since we don't want to detect and use half a raid array, we need to
++		 * wait for the known devices to complete their probing
++		 */
++		while (driver_probe_done() != 0)
++			msleep(100);
+ 		int fd = sys_open("/dev/md0", 0, 0);
+ 		if (fd >= 0) {
+ 			sys_ioctl(fd, RAID_AUTORUN, raid_autopart);
+-- 
+1.5.4.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0032-fastboot-remove-wait-for-all-devices-before-mounti.patch

@@ -0,0 +1,41 @@
+From 1b5a2bd0602010398cb473d1b821a9f1c1399caf Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 20 Jul 2008 13:12:16 -0700
+Subject: [PATCH] fastboot: remove "wait for all devices before mounting root" delay
+
+In the non-initrd case, we wait for all devices to finish their
+probing before we try to mount the rootfs.
+In practice, this means that we end up waiting 2 extra seconds for
+the PS/2 mouse probing even though the root holding device has been
+ready since a long time.
+
+The previous two patches in this series made the RAID autodetect code
+do it's own "wait for probing to be done" code, and added
+"wait and retry" functionality in case the root device isn't actually
+available.
+
+These two changes should make it safe to remove the delay itself,
+and this patch does this. On my test laptop, this reduces the boot time
+by 2 seconds (kernel time goes from 3.9 to 1.9 seconds).
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+---
+ init/do_mounts.c |    2 ++
+ 1 file changed, 2 insertions(+)
+
+Index: linux-2.6.27/init/do_mounts.c
+===================================================================
+--- linux-2.6.27.orig/init/do_mounts.c	2008-10-14 16:57:34.000000000 +0200
++++ linux-2.6.27/init/do_mounts.c	2008-10-14 17:02:51.000000000 +0200
+@@ -365,9 +365,11 @@ void __init prepare_namespace(void)
+ 		ssleep(root_delay);
+ 	}
+ 
++#ifndef CONFIG_FASTBOOT
+ 	/* wait for the known devices to complete their probing */
+ 	while (driver_probe_done() != 0)
+ 		msleep(100);
++#endif
+ 
+ 	md_run_setup();
+ 

meta-moblin/packages/linux/linux-moblin-2.6.27/0033-fastboot-make-the-RAID-autostart-code-print-a-messa.patch

@@ -0,0 +1,32 @@
+From 799d0da9e645258b9d1ae11d4aac73c9474906e3 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 20 Jul 2008 16:30:29 -0700
+Subject: [PATCH] fastboot: make the RAID autostart code print a message just before waiting
+
+As requested/suggested by Neil Brown: make the raid code print that it's
+about to wait for probing to be done as well as give a suggestion on how
+to disable the probing if the user doesn't use raid.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com
+---
+ init/do_mounts_md.c |    4 +++-
+ 1 files changed, 3 insertions(+), 1 deletions(-)
+
+diff --git a/init/do_mounts_md.c b/init/do_mounts_md.c
+index c0412a9..1ec5c41 100644
+--- a/init/do_mounts_md.c
++++ b/init/do_mounts_md.c
+@@ -275,7 +275,9 @@ void __init md_run_setup(void)
+ 		 * Since we don't want to detect and use half a raid array, we need to
+ 		 * wait for the known devices to complete their probing
+ 		 */
+-		while (driver_probe_done() != 0)
++		printk(KERN_INFO "md: Waiting for all devices to be available before autodetect\n");
++		printk(KERN_INFO "md: If you don't use raid, use raid=noautodetect\n");
++		while (driver_probe_done() < 0)
+ 			msleep(100);
+ 		int fd = sys_open("/dev/md0", 0, 0);
+ 		if (fd >= 0) {
+-- 
+1.5.4.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0034-fastboot-fix-typo-in-init-Kconfig-text.patch

@@ -0,0 +1,26 @@
+From 1a23ed42e1baf0481cc70c2f71d97b0bf0f1be70 Mon Sep 17 00:00:00 2001
+From: Ingo Molnar <mingo@elte.hu>
+Date: Thu, 31 Jul 2008 12:52:29 +0200
+Subject: [PATCH] fastboot: fix typo in init/Kconfig text
+
+noticed by Randy Dunlap.
+
+Reported-by: Randy Dunlap <randy.dunlap@oracle.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ init/Kconfig |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+Index: linux-2.6.27/init/Kconfig
+===================================================================
+--- linux-2.6.27.orig/init/Kconfig	2008-10-14 17:02:39.000000000 +0200
++++ linux-2.6.27/init/Kconfig	2008-10-14 17:02:56.000000000 +0200
+@@ -530,7 +530,7 @@ config FASTBOOT
+ 	  The fastboot option will cause the kernel to try to optimize
+ 	  for faster boot.
+ 
+-	  This includes doing some of the device initialization asynchronous
++	  This includes doing some of the device initialization asynchronously
+ 	  as well as opportunistically trying to mount the root fs early.
+ 
+ 	  If unsure, say N.

meta-moblin/packages/linux/linux-moblin-2.6.27/0035-fastboot-remove-duplicate-unpack_to_rootfs.patch

@@ -0,0 +1,161 @@
+From 8929dda869d51b953c8f300864da62297db8a74e Mon Sep 17 00:00:00 2001
+From: Li, Shaohua <shaohua.li@intel.com>
+Date: Wed, 13 Aug 2008 17:26:01 +0800
+Subject: [PATCH] fastboot: remove duplicate unpack_to_rootfs()
+
+we check if initrd is initramfs first and then do real unpack. The
+check isn't required, we can directly do unpack. If initrd isn't
+initramfs, we can remove garbage. In my laptop, this saves 0.1s boot
+time. This penalizes non-initramfs case, but now initramfs is mostly
+widely used.
+
+Signed-off-by: Shaohua Li <shaohua.li@intel.com>
+Acked-by: Arjan van de Ven <arjan@infradead.org>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ init/initramfs.c |   71 ++++++++++++++++++++++++++++++++++++++++++-----------
+ 1 files changed, 56 insertions(+), 15 deletions(-)
+
+diff --git a/init/initramfs.c b/init/initramfs.c
+index 644fc01..da8d030 100644
+--- a/init/initramfs.c
++++ b/init/initramfs.c
+@@ -5,6 +5,7 @@
+ #include <linux/fcntl.h>
+ #include <linux/delay.h>
+ #include <linux/string.h>
++#include <linux/dirent.h>
+ #include <linux/syscalls.h>
+ 
+ static __initdata char *message;
+@@ -121,8 +122,6 @@ static __initdata char *victim;
+ static __initdata unsigned count;
+ static __initdata loff_t this_header, next_header;
+ 
+-static __initdata int dry_run;
+-
+ static inline void __init eat(unsigned n)
+ {
+ 	victim += n;
+@@ -183,10 +182,6 @@ static int __init do_header(void)
+ 	parse_header(collected);
+ 	next_header = this_header + N_ALIGN(name_len) + body_len;
+ 	next_header = (next_header + 3) & ~3;
+-	if (dry_run) {
+-		read_into(name_buf, N_ALIGN(name_len), GotName);
+-		return 0;
+-	}
+ 	state = SkipIt;
+ 	if (name_len <= 0 || name_len > PATH_MAX)
+ 		return 0;
+@@ -257,8 +252,6 @@ static int __init do_name(void)
+ 		free_hash();
+ 		return 0;
+ 	}
+-	if (dry_run)
+-		return 0;
+ 	clean_path(collected, mode);
+ 	if (S_ISREG(mode)) {
+ 		int ml = maybe_link();
+@@ -423,10 +416,9 @@ static void __init flush_window(void)
+ 	outcnt = 0;
+ }
+ 
+-static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)
++static char * __init unpack_to_rootfs(char *buf, unsigned len)
+ {
+ 	int written;
+-	dry_run = check_only;
+ 	header_buf = kmalloc(110, GFP_KERNEL);
+ 	symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);
+ 	name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);
+@@ -520,10 +512,57 @@ skip:
+ 	initrd_end = 0;
+ }
+ 
++#define BUF_SIZE 1024
++static void __init clean_rootfs(void)
++{
++	int fd;
++	void *buf;
++	struct linux_dirent64 *dirp;
++	int count;
++
++	fd = sys_open("/", O_RDONLY, 0);
++	WARN_ON(fd < 0);
++	if (fd < 0)
++		return;
++	buf = kzalloc(BUF_SIZE, GFP_KERNEL);
++	WARN_ON(!buf);
++	if (!buf) {
++		sys_close(fd);
++		return;
++	}
++
++	dirp = buf;
++	count = sys_getdents64(fd, dirp, BUF_SIZE);
++	while (count > 0) {
++		while (count > 0) {
++			struct stat st;
++			int ret;
++
++			ret = sys_newlstat(dirp->d_name, &st);
++			WARN_ON_ONCE(ret);
++			if (!ret) {
++				if (S_ISDIR(st.st_mode))
++					sys_rmdir(dirp->d_name);
++				else
++					sys_unlink(dirp->d_name);
++			}
++
++			count -= dirp->d_reclen;
++			dirp = (void *)dirp + dirp->d_reclen;
++		}
++		dirp = buf;
++		memset(buf, 0, BUF_SIZE);
++		count = sys_getdents64(fd, dirp, BUF_SIZE);
++	}
++
++	sys_close(fd);
++	kfree(buf);
++}
++
+ static int __init populate_rootfs(void)
+ {
+ 	char *err = unpack_to_rootfs(__initramfs_start,
+-			 __initramfs_end - __initramfs_start, 0);
++			 __initramfs_end - __initramfs_start);
+ 	if (err)
+ 		panic(err);
+ 	if (initrd_start) {
+@@ -531,13 +570,15 @@ static int __init populate_rootfs(void)
+ 		int fd;
+ 		printk(KERN_INFO "checking if image is initramfs...");
+ 		err = unpack_to_rootfs((char *)initrd_start,
+-			initrd_end - initrd_start, 1);
++			initrd_end - initrd_start);
+ 		if (!err) {
+ 			printk(" it is\n");
+-			unpack_to_rootfs((char *)initrd_start,
+-				initrd_end - initrd_start, 0);
+ 			free_initrd();
+ 			return 0;
++		} else {
++			clean_rootfs();
++			unpack_to_rootfs(__initramfs_start,
++				 __initramfs_end - __initramfs_start);
+ 		}
+ 		printk("it isn't (%s); looks like an initrd\n", err);
+ 		fd = sys_open("/initrd.image", O_WRONLY|O_CREAT, 0700);
+@@ -550,7 +591,7 @@ static int __init populate_rootfs(void)
+ #else
+ 		printk(KERN_INFO "Unpacking initramfs...");
+ 		err = unpack_to_rootfs((char *)initrd_start,
+-			initrd_end - initrd_start, 0);
++			initrd_end - initrd_start);
+ 		if (err)
+ 			panic(err);
+ 		printk(" done\n");
+-- 
+1.5.4.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0036-warning-fix-init-do_mounts_md-c.patch

@@ -0,0 +1,82 @@
+From fa3038625d7df2a1244c5b753069e7fdf99af3b5 Mon Sep 17 00:00:00 2001
+From: Ingo Molnar <mingo@elte.hu>
+Date: Mon, 18 Aug 2008 12:54:00 +0200
+Subject: [PATCH] warning: fix init do_mounts_md c
+MIME-Version: 1.0
+Content-Type: text/plain; charset=utf-8
+Content-Transfer-Encoding: 8bit
+
+fix warning:
+
+  init/do_mounts_md.c: In function ‘md_run_setup’:
+  init/do_mounts_md.c:282: warning: ISO C90 forbids mixed declarations and code
+
+also, use the opportunity to put the RAID autodetection code
+into a separate function - this also solves a checkpatch style warning.
+
+No code changed:
+
+md5:
+   aa36a35faef371b05f1974ad583bdbbd  do_mounts_md.o.before.asm
+   aa36a35faef371b05f1974ad583bdbbd  do_mounts_md.o.after.asm
+
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ init/do_mounts_md.c |   36 +++++++++++++++++++++---------------
+ 1 files changed, 21 insertions(+), 15 deletions(-)
+
+diff --git a/init/do_mounts_md.c b/init/do_mounts_md.c
+index 1ec5c41..c0dfd3c 100644
+--- a/init/do_mounts_md.c
++++ b/init/do_mounts_md.c
+@@ -264,26 +264,32 @@ static int __init raid_setup(char *str)
+ __setup("raid=", raid_setup);
+ __setup("md=", md_setup);
+ 
++static void autodetect_raid(void)
++{
++	int fd;
++
++	/*
++	 * Since we don't want to detect and use half a raid array, we need to
++	 * wait for the known devices to complete their probing
++	 */
++	printk(KERN_INFO "md: Waiting for all devices to be available before autodetect\n");
++	printk(KERN_INFO "md: If you don't use raid, use raid=noautodetect\n");
++	while (driver_probe_done() < 0)
++		msleep(100);
++	fd = sys_open("/dev/md0", 0, 0);
++	if (fd >= 0) {
++		sys_ioctl(fd, RAID_AUTORUN, raid_autopart);
++		sys_close(fd);
++	}
++}
++
+ void __init md_run_setup(void)
+ {
+ 	create_dev("/dev/md0", MKDEV(MD_MAJOR, 0));
+ 
+ 	if (raid_noautodetect)
+ 		printk(KERN_INFO "md: Skipping autodetection of RAID arrays. (raid=noautodetect)\n");
+-	else {
+-		/* 
+-		 * Since we don't want to detect and use half a raid array, we need to
+-		 * wait for the known devices to complete their probing
+-		 */
+-		printk(KERN_INFO "md: Waiting for all devices to be available before autodetect\n");
+-		printk(KERN_INFO "md: If you don't use raid, use raid=noautodetect\n");
+-		while (driver_probe_done() < 0)
+-			msleep(100);
+-		int fd = sys_open("/dev/md0", 0, 0);
+-		if (fd >= 0) {
+-			sys_ioctl(fd, RAID_AUTORUN, raid_autopart);
+-			sys_close(fd);
+-		}
+-	}
++	else
++		autodetect_raid();
+ 	md_setup_drive();
+ }
+-- 
+1.5.4.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0037-init-initramfs.c-unused-function-when-compiling-wit.patch

@@ -0,0 +1,37 @@
+From b4931e6c151acad06b4c12dc7cdb634366d7d27a Mon Sep 17 00:00:00 2001
+From: Steven Noonan <steven@uplinklabs.net>
+Date: Mon, 8 Sep 2008 16:19:10 -0700
+Subject: [PATCH] init/initramfs.c: unused function when compiling without CONFIG_BLK_DEV_RAM
+
+Fixing compiler warning when the kernel isn't compiled with support
+for RAM block devices enabled.
+
+Signed-off-by: Steven Noonan <steven@uplinklabs.net>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ init/initramfs.c |    2 ++
+ 1 files changed, 2 insertions(+), 0 deletions(-)
+
+diff --git a/init/initramfs.c b/init/initramfs.c
+index da8d030..2f056e2 100644
+--- a/init/initramfs.c
++++ b/init/initramfs.c
+@@ -512,6 +512,7 @@ skip:
+ 	initrd_end = 0;
+ }
+ 
++#ifdef CONFIG_BLK_DEV_RAM
+ #define BUF_SIZE 1024
+ static void __init clean_rootfs(void)
+ {
+@@ -558,6 +559,7 @@ static void __init clean_rootfs(void)
+ 	sys_close(fd);
+ 	kfree(buf);
+ }
++#endif
+ 
+ static int __init populate_rootfs(void)
+ {
+-- 
+1.5.4.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0038-fastboot-fix-blackfin-breakage-due-to-vmlinux.lds-c.patch

@@ -0,0 +1,38 @@
+From 5e4f25d1f43991324794657655bbbc43983522a2 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@infradead.org>
+Date: Wed, 10 Sep 2008 08:25:34 -0700
+Subject: [PATCH] fastboot: fix blackfin breakage due to vmlinux.lds change
+
+As reported by Mike Frysinger, the vmlinux.lds changes should
+have used VMLINUX_SYMBOL()...
+
+Reported-by: Mike Frysinger <vapier.adi@gmail.com>
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Acked-by: Bryan Wu <cooloney@kernel.org>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ include/asm-generic/vmlinux.lds.h |    6 +++---
+ 1 files changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
+index b9be858..ccabc4e 100644
+--- a/include/asm-generic/vmlinux.lds.h
++++ b/include/asm-generic/vmlinux.lds.h
+@@ -377,11 +377,11 @@
+   	*(.initcall5s.init)						\
+ 	*(.initcallrootfs.init)						\
+ 	*(.initcall6s.init)						\
+-	__async_initcall_start = .;					\
++	VMLINUX_SYMBOL(__async_initcall_start) = .;			\
+ 	*(.initcall6a.init)						\
+-	__async_initcall_end = .;					\
++	VMLINUX_SYMBOL(__async_initcall_end) = .;			\
+   	*(.initcall6.init)						\
+-	__device_initcall_end = .;					\
++	VMLINUX_SYMBOL(__device_initcall_end) = .;			\
+   	*(.initcall7.init)						\
+   	*(.initcall7s.init)
+ 
+-- 
+1.5.4.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0039-Add-a-script-to-visualize-the-kernel-boot-process.patch

@@ -0,0 +1,177 @@
+From 77e9695b9d5c9ce761dedc193045d9cb64b8e245 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sat, 13 Sep 2008 09:36:06 -0700
+Subject: [PATCH] Add a script to visualize the kernel boot process / time
+
+When optimizing the kernel boot time, it's very valuable to visualize
+what is going on at which time. In addition, with the fastboot asynchronous
+initcall level, it's very valuable to see which initcall gets run where
+and when.
+
+This patch adds a script to turn a dmesg into a SVG graph (that can be
+shown with tools such as InkScape, Gimp or Firefox) and a small change
+to the initcall code to print the PID of the thread calling the initcall
+(so that the script can work out the parallelism).
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+---
+ init/main.c          |    1 
+ scripts/bootgraph.pl |  138 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 139 insertions(+)
+ create mode 100644 scripts/bootgraph.pl
+
+Index: linux-2.6.27/init/main.c
+===================================================================
+--- linux-2.6.27.orig/init/main.c	2008-10-14 17:02:46.000000000 +0200
++++ linux-2.6.27/init/main.c	2008-10-14 17:05:23.000000000 +0200
+@@ -709,6 +709,7 @@ int do_one_initcall(initcall_t fn)
+ 
+ 	if (initcall_debug) {
+ 		printk("calling  %pF\n", fn);
++ 		printk(" @ %i\n",  task_pid_nr(current));
+ 		t0 = ktime_get();
+ 	}
+ 
+Index: linux-2.6.27/scripts/bootgraph.pl
+===================================================================
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.27/scripts/bootgraph.pl	2008-10-14 17:03:34.000000000 +0200
+@@ -0,0 +1,138 @@
++#!/usr/bin/perl
++
++# Copyright 2008, Intel Corporation
++#
++# This file is part of the Linux kernel
++#
++# This program file is free software; you can redistribute it and/or modify it
++# under the terms of the GNU General Public License as published by the
++# Free Software Foundation; version 2 of the License.
++#
++# This program is distributed in the hope that it will be useful, but WITHOUT
++# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
++# for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program in a file named COPYING; if not, write to the
++# Free Software Foundation, Inc.,
++# 51 Franklin Street, Fifth Floor,
++# Boston, MA 02110-1301 USA
++#
++# Authors:
++# 	Arjan van de Ven <arjan@linux.intel.com>
++
++
++#
++# This script turns a dmesg output into a SVG graphic that shows which
++# functions take how much time. You can view SVG graphics with various
++# programs, including Inkscape, The Gimp and Firefox.
++#
++#
++# For this script to work, the kernel needs to be compiled with the
++# CONFIG_PRINTK_TIME configuration option enabled, and with
++# "initcall_debug" passed on the kernel command line.
++#
++# usage:
++# 	dmesg | perl scripts/bootgraph.pl > output.svg
++#
++
++my @rows;
++my %start, %end, %row;
++my $done = 0;
++my $rowcount = 0;
++my $maxtime = 0;
++my $count = 0;
++while (<>) {
++	my $line = $_;
++	if ($line =~ /([0-9\.]+)\] calling  ([a-zA-Z\_]+)\+/) {
++		my $func = $2;
++		if ($done == 0) {
++			$start{$func} = $1;
++		}
++		$row{$func} = 1;
++		if ($line =~ /\@ ([0-9]+)/) {
++			my $pid = $1;
++			if (!defined($rows[$pid])) {
++				$rowcount = $rowcount + 1;
++				$rows[$pid] = $rowcount;
++			}
++			$row{$func} = $rows[$pid];
++		}
++		$count = $count + 1;
++	}
++
++	if ($line =~ /([0-9\.]+)\] initcall ([a-zA-Z\_]+)\+.*returned/) {
++		if ($done == 0) {
++			$end{$2} = $1;
++			$maxtime = $1;
++		}
++	}
++	if ($line =~ /Write protecting the/) {
++		$done = 1;
++	}
++}
++
++if ($count == 0) {
++	print "No data found in the dmesg. Make sure CONFIG_PRINTK_TIME is enabled and\n";
++	print "that initcall_debug is passed on the kernel command line.\n\n";
++	print "Usage: \n";
++	print "      dmesg | perl scripts/bootgraph.pl > output.svg\n\n";
++	exit;
++}
++
++print "<?xml version=\"1.0\" standalone=\"no\"?> \n";
++print "<svg width=\"1000\" height=\"100%\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n";
++
++my @styles;
++
++$styles[0] = "fill:rgb(0,0,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[1] = "fill:rgb(0,255,0);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[2] = "fill:rgb(255,0,20);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[3] = "fill:rgb(255,255,20);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[4] = "fill:rgb(255,0,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[5] = "fill:rgb(0,255,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[6] = "fill:rgb(0,128,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[7] = "fill:rgb(0,255,128);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[8] = "fill:rgb(255,0,128);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[9] = "fill:rgb(255,255,128);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[10] = "fill:rgb(255,128,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++$styles[11] = "fill:rgb(128,255,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
++
++my $mult = 950.0 / $maxtime;
++my $threshold = 0.0500 / $maxtime;
++my $stylecounter = 0;
++while (($key,$value) = each %start) {
++	my $duration = $end{$key} - $start{$key};
++
++	if ($duration >= $threshold) {
++		my $s, $s2, $e, $y;
++		$s = $value * $mult;
++		$s2 = $s + 6;
++		$e = $end{$key} * $mult;
++		$w = $e - $s;
++
++		$y = $row{$key} * 150;
++		$y2 = $y + 4;
++
++		$style = $styles[$stylecounter];
++		$stylecounter = $stylecounter + 1;
++		if ($stylecounter > 11) {
++			$stylecounter = 0;
++		};
++
++		print "<rect x=\"$s\" width=\"$w\" y=\"$y\" height=\"145\" style=\"$style\"/>\n";
++		print "<text transform=\"translate($s2,$y2) rotate(90)\">$key</text>\n";
++	}
++}
++
++
++# print the time line on top
++my $time = 0.0;
++while ($time < $maxtime) {
++	my $s2 = $time * $mult;
++	print "<text transform=\"translate($s2,89) rotate(90)\">$time</text>\n";
++	$time = $time + 0.1;
++}
++
++print "</svg>\n";

meta-moblin/packages/linux/linux-moblin-2.6.27/0040-fastboot-fix-issues-and-improve-output-of-bootgraph.patch

@@ -0,0 +1,91 @@
+From 5470e09b98074974316bbf98c8b8da01d670c2a4 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Sun, 14 Sep 2008 15:30:52 -0700
+Subject: [PATCH] fastboot: fix issues and improve output of bootgraph.pl
+
+David Sanders reported some issues with bootgraph.pl's display
+of his sytems bootup; this commit fixes these by scaling the graph
+not from 0 - end time but from the first initcall to the end time;
+the minimum display size etc also now need to scale with this, as does
+the axis display.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+---
+ scripts/bootgraph.pl |   25 +++++++++++++++++--------
+ 1 files changed, 17 insertions(+), 8 deletions(-)
+
+diff --git a/scripts/bootgraph.pl b/scripts/bootgraph.pl
+index d459b8b..4e5f4ab 100644
+--- a/scripts/bootgraph.pl
++++ b/scripts/bootgraph.pl
+@@ -42,6 +42,7 @@ my %start, %end, %row;
+ my $done = 0;
+ my $rowcount = 0;
+ my $maxtime = 0;
++my $firsttime = 100;
+ my $count = 0;
+ while (<>) {
+ 	my $line = $_;
+@@ -49,6 +50,9 @@ while (<>) {
+ 		my $func = $2;
+ 		if ($done == 0) {
+ 			$start{$func} = $1;
++			if ($1 < $firsttime) {
++				$firsttime = $1;
++			}
+ 		}
+ 		$row{$func} = 1;
+ 		if ($line =~ /\@ ([0-9]+)/) {
+@@ -71,6 +75,9 @@ while (<>) {
+ 	if ($line =~ /Write protecting the/) {
+ 		$done = 1;
+ 	}
++	if ($line =~ /Freeing unused kernel memory/) {
++		$done = 1;
++	}
+ }
+ 
+ if ($count == 0) {
+@@ -99,17 +106,17 @@ $styles[9] = "fill:rgb(255,255,128);fill-opacity:0.5;stroke-width:1;stroke:rgb(0
+ $styles[10] = "fill:rgb(255,128,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+ $styles[11] = "fill:rgb(128,255,255);fill-opacity:0.5;stroke-width:1;stroke:rgb(0,0,0)";
+ 
+-my $mult = 950.0 / $maxtime;
+-my $threshold = 0.0500 / $maxtime;
++my $mult = 950.0 / ($maxtime - $firsttime);
++my $threshold = ($maxtime - $firsttime) / 60.0;
+ my $stylecounter = 0;
+ while (($key,$value) = each %start) {
+ 	my $duration = $end{$key} - $start{$key};
+ 
+ 	if ($duration >= $threshold) {
+ 		my $s, $s2, $e, $y;
+-		$s = $value * $mult;
++		$s = ($value - $firsttime) * $mult;
+ 		$s2 = $s + 6;
+-		$e = $end{$key} * $mult;
++		$e = ($end{$key} - $firsttime) * $mult;
+ 		$w = $e - $s;
+ 
+ 		$y = $row{$key} * 150;
+@@ -128,11 +135,13 @@ while (($key,$value) = each %start) {
+ 
+ 
+ # print the time line on top
+-my $time = 0.0;
++my $time = $firsttime;
++my $step = ($maxtime - $firsttime) / 15;
+ while ($time < $maxtime) {
+-	my $s2 = $time * $mult;
+-	print "<text transform=\"translate($s2,89) rotate(90)\">$time</text>\n";
+-	$time = $time + 0.1;
++	my $s2 = ($time - $firsttime) * $mult;
++	my $tm = int($time * 100) / 100.0;
++	print "<text transform=\"translate($s2,89) rotate(90)\">$tm</text>\n";
++	$time = $time + $step;
+ }
+ 
+ print "</svg>\n";
+-- 
+1.5.4.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0041-r8169-8101e.patch

@@ -0,0 +1,940 @@
+From 771c0d99c0ab3ca7f1a9bc400e8259171b518d5f Mon Sep 17 00:00:00 2001
+From: Francois Romieu <romieu@fr.zoreil.com>
+Date: Thu, 21 Aug 2008 23:20:40 +0200
+Subject: [PATCH] r8169: fix RxMissed register access
+
+- the register location is defined for the 8169 chipset only and
+  there is no 8169 beyond RTL_GIGA_MAC_VER_06
+- only the lower 3 bytes of the register are valid
+
+Fixes:
+1. http://bugzilla.kernel.org/show_bug.cgi?id=10180
+2. http://bugzilla.kernel.org/show_bug.cgi?id=11062 (bits of)
+
+Tested by Hermann Gausterer and Adam Huffman.
+
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/r8169.c |   25 ++++++++++++++-----------
+ 1 files changed, 14 insertions(+), 11 deletions(-)
+
+diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
+index 0f6f974..4190ee7 100644
+--- a/drivers/net/r8169.c
++++ b/drivers/net/r8169.c
+@@ -2099,8 +2099,6 @@ static void rtl_hw_start_8168(struct net_device *dev)
+ 
+ 	RTL_R8(IntrMask);
+ 
+-	RTL_W32(RxMissed, 0);
+-
+ 	rtl_set_rx_mode(dev);
+ 
+ 	RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
+@@ -2143,8 +2141,6 @@ static void rtl_hw_start_8101(struct net_device *dev)
+ 
+ 	RTL_R8(IntrMask);
+ 
+-	RTL_W32(RxMissed, 0);
+-
+ 	rtl_set_rx_mode(dev);
+ 
+ 	RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
+@@ -2922,6 +2918,17 @@ static int rtl8169_poll(struct napi_struct *napi, int budget)
+ 	return work_done;
+ }
+ 
++static void rtl8169_rx_missed(struct net_device *dev, void __iomem *ioaddr)
++{
++	struct rtl8169_private *tp = netdev_priv(dev);
++
++	if (tp->mac_version > RTL_GIGA_MAC_VER_06)
++		return;
++
++	dev->stats.rx_missed_errors += (RTL_R32(RxMissed) & 0xffffff);
++	RTL_W32(RxMissed, 0);
++}
++
+ static void rtl8169_down(struct net_device *dev)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+@@ -2939,9 +2946,7 @@ core_down:
+ 
+ 	rtl8169_asic_down(ioaddr);
+ 
+-	/* Update the error counts. */
+-	dev->stats.rx_missed_errors += RTL_R32(RxMissed);
+-	RTL_W32(RxMissed, 0);
++	rtl8169_rx_missed(dev, ioaddr);
+ 
+ 	spin_unlock_irq(&tp->lock);
+ 
+@@ -3063,8 +3068,7 @@ static struct net_device_stats *rtl8169_get_stats(struct net_device *dev)
+ 
+ 	if (netif_running(dev)) {
+ 		spin_lock_irqsave(&tp->lock, flags);
+-		dev->stats.rx_missed_errors += RTL_R32(RxMissed);
+-		RTL_W32(RxMissed, 0);
++		rtl8169_rx_missed(dev, ioaddr);
+ 		spin_unlock_irqrestore(&tp->lock, flags);
+ 	}
+ 
+@@ -3089,8 +3093,7 @@ static int rtl8169_suspend(struct pci_dev *pdev, pm_message_t state)
+ 
+ 	rtl8169_asic_down(ioaddr);
+ 
+-	dev->stats.rx_missed_errors += RTL_R32(RxMissed);
+-	RTL_W32(RxMissed, 0);
++	rtl8169_rx_missed(dev, ioaddr);
+ 
+ 	spin_unlock_irq(&tp->lock);
+ 
+-- 
+1.5.3.3
+
+From 6ee4bc96d446a9c466a18b715c7ab2d662c03ebd Mon Sep 17 00:00:00 2001
+From: Francois Romieu <romieu@fr.zoreil.com>
+Date: Sat, 26 Jul 2008 14:26:06 +0200
+Subject: [PATCH] r8169: get ethtool settings through the generic mii helper
+
+It avoids to report unsupported link capabilities with
+the fast-ethernet only 8101/8102.
+
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Tested-by: Martin Capitanio <martin@capitanio.org>
+Fixed-by: Ivan Vecera <ivecera@redhat.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/r8169.c |   99 +++++++++++++++++++++++---------------------------
+ 1 files changed, 46 insertions(+), 53 deletions(-)
+
+diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
+index 4190ee7..7e026a6 100644
+--- a/drivers/net/r8169.c
++++ b/drivers/net/r8169.c
+@@ -370,8 +370,9 @@ struct ring_info {
+ };
+ 
+ enum features {
+-	RTL_FEATURE_WOL	= (1 << 0),
+-	RTL_FEATURE_MSI	= (1 << 1),
++	RTL_FEATURE_WOL		= (1 << 0),
++	RTL_FEATURE_MSI		= (1 << 1),
++	RTL_FEATURE_GMII	= (1 << 2),
+ };
+ 
+ struct rtl8169_private {
+@@ -406,13 +407,15 @@ struct rtl8169_private {
+ 	struct vlan_group *vlgrp;
+ #endif
+ 	int (*set_speed)(struct net_device *, u8 autoneg, u16 speed, u8 duplex);
+-	void (*get_settings)(struct net_device *, struct ethtool_cmd *);
++	int (*get_settings)(struct net_device *, struct ethtool_cmd *);
+ 	void (*phy_reset_enable)(void __iomem *);
+ 	void (*hw_start)(struct net_device *);
+ 	unsigned int (*phy_reset_pending)(void __iomem *);
+ 	unsigned int (*link_ok)(void __iomem *);
+ 	struct delayed_work task;
+ 	unsigned features;
++
++	struct mii_if_info mii;
+ };
+ 
+ MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>");
+@@ -482,6 +485,23 @@ static int mdio_read(void __iomem *ioaddr, int reg_addr)
+ 	return value;
+ }
+ 
++static void rtl_mdio_write(struct net_device *dev, int phy_id, int location,
++			   int val)
++{
++	struct rtl8169_private *tp = netdev_priv(dev);
++	void __iomem *ioaddr = tp->mmio_addr;
++
++	mdio_write(ioaddr, location, val);
++}
++
++static int rtl_mdio_read(struct net_device *dev, int phy_id, int location)
++{
++	struct rtl8169_private *tp = netdev_priv(dev);
++	void __iomem *ioaddr = tp->mmio_addr;
++
++	return mdio_read(ioaddr, location);
++}
++
+ static void rtl8169_irq_mask_and_ack(void __iomem *ioaddr)
+ {
+ 	RTL_W16(IntrMask, 0x0000);
+@@ -850,7 +870,7 @@ static int rtl8169_rx_vlan_skb(struct rtl8169_private *tp, struct RxDesc *desc,
+ 
+ #endif
+ 
+-static void rtl8169_gset_tbi(struct net_device *dev, struct ethtool_cmd *cmd)
++static int rtl8169_gset_tbi(struct net_device *dev, struct ethtool_cmd *cmd)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+ 	void __iomem *ioaddr = tp->mmio_addr;
+@@ -867,65 +887,29 @@ static void rtl8169_gset_tbi(struct net_device *dev, struct ethtool_cmd *cmd)
+ 
+ 	cmd->speed = SPEED_1000;
+ 	cmd->duplex = DUPLEX_FULL; /* Always set */
++
++	return 0;
+ }
+ 
+-static void rtl8169_gset_xmii(struct net_device *dev, struct ethtool_cmd *cmd)
++static int rtl8169_gset_xmii(struct net_device *dev, struct ethtool_cmd *cmd)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+-	void __iomem *ioaddr = tp->mmio_addr;
+-	u8 status;
+-
+-	cmd->supported = SUPPORTED_10baseT_Half |
+-			 SUPPORTED_10baseT_Full |
+-			 SUPPORTED_100baseT_Half |
+-			 SUPPORTED_100baseT_Full |
+-			 SUPPORTED_1000baseT_Full |
+-			 SUPPORTED_Autoneg |
+-			 SUPPORTED_TP;
+-
+-	cmd->autoneg = 1;
+-	cmd->advertising = ADVERTISED_TP | ADVERTISED_Autoneg;
+-
+-	if (tp->phy_auto_nego_reg & ADVERTISE_10HALF)
+-		cmd->advertising |= ADVERTISED_10baseT_Half;
+-	if (tp->phy_auto_nego_reg & ADVERTISE_10FULL)
+-		cmd->advertising |= ADVERTISED_10baseT_Full;
+-	if (tp->phy_auto_nego_reg & ADVERTISE_100HALF)
+-		cmd->advertising |= ADVERTISED_100baseT_Half;
+-	if (tp->phy_auto_nego_reg & ADVERTISE_100FULL)
+-		cmd->advertising |= ADVERTISED_100baseT_Full;
+-	if (tp->phy_1000_ctrl_reg & ADVERTISE_1000FULL)
+-		cmd->advertising |= ADVERTISED_1000baseT_Full;
+-
+-	status = RTL_R8(PHYstatus);
+-
+-	if (status & _1000bpsF)
+-		cmd->speed = SPEED_1000;
+-	else if (status & _100bps)
+-		cmd->speed = SPEED_100;
+-	else if (status & _10bps)
+-		cmd->speed = SPEED_10;
+-
+-	if (status & TxFlowCtrl)
+-		cmd->advertising |= ADVERTISED_Asym_Pause;
+-	if (status & RxFlowCtrl)
+-		cmd->advertising |= ADVERTISED_Pause;
+-
+-	cmd->duplex = ((status & _1000bpsF) || (status & FullDup)) ?
+-		      DUPLEX_FULL : DUPLEX_HALF;
++
++	return mii_ethtool_gset(&tp->mii, cmd);
+ }
+ 
+ static int rtl8169_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+ 	unsigned long flags;
++	int rc;
+ 
+ 	spin_lock_irqsave(&tp->lock, flags);
+ 
+-	tp->get_settings(dev, cmd);
++	rc = tp->get_settings(dev, cmd);
+ 
+ 	spin_unlock_irqrestore(&tp->lock, flags);
+-	return 0;
++	return rc;
+ }
+ 
+ static void rtl8169_get_regs(struct net_device *dev, struct ethtool_regs *regs,
+@@ -1513,7 +1497,7 @@ static const struct rtl_cfg_info {
+ 	unsigned int align;
+ 	u16 intr_event;
+ 	u16 napi_event;
+-	unsigned msi;
++	unsigned features;
+ } rtl_cfg_infos [] = {
+ 	[RTL_CFG_0] = {
+ 		.hw_start	= rtl_hw_start_8169,
+@@ -1522,7 +1506,7 @@ static const struct rtl_cfg_info {
+ 		.intr_event	= SYSErr | LinkChg | RxOverflow |
+ 				  RxFIFOOver | TxErr | TxOK | RxOK | RxErr,
+ 		.napi_event	= RxFIFOOver | TxErr | TxOK | RxOK | RxOverflow,
+-		.msi		= 0
++		.features	= RTL_FEATURE_GMII
+ 	},
+ 	[RTL_CFG_1] = {
+ 		.hw_start	= rtl_hw_start_8168,
+@@ -1531,7 +1515,7 @@ static const struct rtl_cfg_info {
+ 		.intr_event	= SYSErr | LinkChg | RxOverflow |
+ 				  TxErr | TxOK | RxOK | RxErr,
+ 		.napi_event	= TxErr | TxOK | RxOK | RxOverflow,
+-		.msi		= RTL_FEATURE_MSI
++		.features	= RTL_FEATURE_GMII | RTL_FEATURE_MSI
+ 	},
+ 	[RTL_CFG_2] = {
+ 		.hw_start	= rtl_hw_start_8101,
+@@ -1540,7 +1524,7 @@ static const struct rtl_cfg_info {
+ 		.intr_event	= SYSErr | LinkChg | RxOverflow | PCSTimeout |
+ 				  RxFIFOOver | TxErr | TxOK | RxOK | RxErr,
+ 		.napi_event	= RxFIFOOver | TxErr | TxOK | RxOK | RxOverflow,
+-		.msi		= RTL_FEATURE_MSI
++		.features	= RTL_FEATURE_MSI
+ 	}
+ };
+ 
+@@ -1552,7 +1536,7 @@ static unsigned rtl_try_msi(struct pci_dev *pdev, void __iomem *ioaddr,
+ 	u8 cfg2;
+ 
+ 	cfg2 = RTL_R8(Config2) & ~MSIEnable;
+-	if (cfg->msi) {
++	if (cfg->features & RTL_FEATURE_MSI) {
+ 		if (pci_enable_msi(pdev)) {
+ 			dev_info(&pdev->dev, "no MSI. Back to INTx.\n");
+ 		} else {
+@@ -1578,6 +1562,7 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+ 	const struct rtl_cfg_info *cfg = rtl_cfg_infos + ent->driver_data;
+ 	const unsigned int region = cfg->region;
+ 	struct rtl8169_private *tp;
++	struct mii_if_info *mii;
+ 	struct net_device *dev;
+ 	void __iomem *ioaddr;
+ 	unsigned int i;
+@@ -1602,6 +1587,14 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+ 	tp->pci_dev = pdev;
+ 	tp->msg_enable = netif_msg_init(debug.msg_enable, R8169_MSG_DEFAULT);
+ 
++	mii = &tp->mii;
++	mii->dev = dev;
++	mii->mdio_read = rtl_mdio_read;
++	mii->mdio_write = rtl_mdio_write;
++	mii->phy_id_mask = 0x1f;
++	mii->reg_num_mask = 0x1f;
++	mii->supports_gmii = !!(cfg->features & RTL_FEATURE_GMII);
++
+ 	/* enable device (incl. PCI PM wakeup and hotplug setup) */
+ 	rc = pci_enable_device(pdev);
+ 	if (rc < 0) {
+-- 
+1.5.3.3
+
+From ef60b2a38e223a331e13ef503aee7cd5d4d5c12c Mon Sep 17 00:00:00 2001
+From: Hugh Dickins <hugh@veritas.com>
+Date: Mon, 8 Sep 2008 21:49:01 +0100
+Subject: [PATCH] r8169: select MII in Kconfig
+
+drivers/built-in.o: In function `rtl8169_gset_xmii':
+r8169.c:(.text+0x82259): undefined reference to `mii_ethtool_gset'
+suggests that the r8169 driver now needs to select MII.
+
+Signed-off-by: Hugh Dickins <hugh@veritas.com>
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/Kconfig |    1 +
+ 1 files changed, 1 insertions(+), 0 deletions(-)
+
+diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
+index 4a11296..60a0453 100644
+--- a/drivers/net/Kconfig
++++ b/drivers/net/Kconfig
+@@ -2046,6 +2046,7 @@ config R8169
+ 	tristate "Realtek 8169 gigabit ethernet support"
+ 	depends on PCI
+ 	select CRC32
++	select MII
+ 	---help---
+ 	  Say Y here if you have a Realtek 8169 PCI Gigabit Ethernet adapter.
+ 
+-- 
+1.5.3.3
+
+From bca31864fca6004c4a4a9bd549e95c93b3c3bb10 Mon Sep 17 00:00:00 2001
+From: Francois Romieu <romieu@fr.zoreil.com>
+Date: Sat, 2 Aug 2008 15:50:02 +0200
+Subject: [PATCH] r8169: Tx performance tweak helper
+
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/r8169.c |   15 ++++++++++-----
+ 1 files changed, 10 insertions(+), 5 deletions(-)
+
+diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
+index 7e026a6..eea96fb 100644
+--- a/drivers/net/r8169.c
++++ b/drivers/net/r8169.c
+@@ -2054,12 +2054,20 @@ static void rtl_hw_start_8169(struct net_device *dev)
+ 	RTL_W16(IntrMask, tp->intr_event);
+ }
+ 
++static void rtl_tx_performance_tweak(struct pci_dev *pdev, u8 force)
++{
++	u8 ctl;
++
++	pci_read_config_byte(pdev, 0x69, &ctl);
++	ctl = (ctl & ~0x70) | force;
++	pci_write_config_byte(pdev, 0x69, ctl);
++}
++
+ static void rtl_hw_start_8168(struct net_device *dev)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+ 	void __iomem *ioaddr = tp->mmio_addr;
+ 	struct pci_dev *pdev = tp->pci_dev;
+-	u8 ctl;
+ 
+ 	RTL_W8(Cfg9346, Cfg9346_Unlock);
+ 
+@@ -2073,10 +2081,7 @@ static void rtl_hw_start_8168(struct net_device *dev)
+ 
+ 	RTL_W16(CPlusCmd, tp->cp_cmd);
+ 
+-	/* Tx performance tweak. */
+-	pci_read_config_byte(pdev, 0x69, &ctl);
+-	ctl = (ctl & ~0x70) | 0x50;
+-	pci_write_config_byte(pdev, 0x69, ctl);
++	rtl_tx_performance_tweak(pdev, 0x50);
+ 
+ 	RTL_W16(IntrMitigate, 0x5151);
+ 
+-- 
+1.5.3.3
+
+From 7a929ae7d5a3618f56bf1ccaf8c62df628e820aa Mon Sep 17 00:00:00 2001
+From: Francois Romieu <romieu@fr.zoreil.com>
+Date: Sat, 5 Jul 2008 00:21:15 +0200
+Subject: [PATCH] r8169: use pci_find_capability for the PCI-E features
+
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/r8169.c |   32 ++++++++++++++++++++++++--------
+ 1 files changed, 24 insertions(+), 8 deletions(-)
+
+diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
+index eea96fb..5c00522 100644
+--- a/drivers/net/r8169.c
++++ b/drivers/net/r8169.c
+@@ -61,6 +61,7 @@ static const int multicast_filter_limit = 32;
+ /* MAC address length */
+ #define MAC_ADDR_LEN	6
+ 
++#define MAX_READ_REQUEST_SHIFT	12
+ #define RX_FIFO_THRESH	7	/* 7 means NO threshold, Rx buffer level before first PCI xfer. */
+ #define RX_DMA_BURST	6	/* Maximum PCI burst, '6' is 1024 */
+ #define TX_DMA_BURST	6	/* Maximum PCI burst, '6' is 1024 */
+@@ -412,6 +413,7 @@ struct rtl8169_private {
+ 	void (*hw_start)(struct net_device *);
+ 	unsigned int (*phy_reset_pending)(void __iomem *);
+ 	unsigned int (*link_ok)(void __iomem *);
++	int pcie_cap;
+ 	struct delayed_work task;
+ 	unsigned features;
+ 
+@@ -1663,6 +1665,10 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+ 		goto err_out_free_res_4;
+ 	}
+ 
++	tp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
++	if (!tp->pcie_cap && netif_msg_probe(tp))
++		dev_info(&pdev->dev, "no PCI Express capability\n");
++
+ 	/* Unneeded ? Don't mess with Mrs. Murphy. */
+ 	rtl8169_irq_mask_and_ack(ioaddr);
+ 
+@@ -2054,13 +2060,19 @@ static void rtl_hw_start_8169(struct net_device *dev)
+ 	RTL_W16(IntrMask, tp->intr_event);
+ }
+ 
+-static void rtl_tx_performance_tweak(struct pci_dev *pdev, u8 force)
++static void rtl_tx_performance_tweak(struct pci_dev *pdev, u16 force)
+ {
+-	u8 ctl;
++	struct net_device *dev = pci_get_drvdata(pdev);
++	struct rtl8169_private *tp = netdev_priv(dev);
++	int cap = tp->pcie_cap;
++
++	if (cap) {
++		u16 ctl;
+ 
+-	pci_read_config_byte(pdev, 0x69, &ctl);
+-	ctl = (ctl & ~0x70) | force;
+-	pci_write_config_byte(pdev, 0x69, ctl);
++		pci_read_config_word(pdev, cap + PCI_EXP_DEVCTL, &ctl);
++		ctl = (ctl & ~PCI_EXP_DEVCTL_READRQ) | force;
++		pci_write_config_word(pdev, cap + PCI_EXP_DEVCTL, ctl);
++	}
+ }
+ 
+ static void rtl_hw_start_8168(struct net_device *dev)
+@@ -2081,7 +2093,7 @@ static void rtl_hw_start_8168(struct net_device *dev)
+ 
+ 	RTL_W16(CPlusCmd, tp->cp_cmd);
+ 
+-	rtl_tx_performance_tweak(pdev, 0x50);
++	rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
+ 
+ 	RTL_W16(IntrMitigate, 0x5151);
+ 
+@@ -2114,8 +2126,12 @@ static void rtl_hw_start_8101(struct net_device *dev)
+ 
+ 	if ((tp->mac_version == RTL_GIGA_MAC_VER_13) ||
+ 	    (tp->mac_version == RTL_GIGA_MAC_VER_16)) {
+-		pci_write_config_word(pdev, 0x68, 0x00);
+-		pci_write_config_word(pdev, 0x69, 0x08);
++		int cap = tp->pcie_cap;
++
++		if (cap) {
++			pci_write_config_word(pdev, cap + PCI_EXP_DEVCTL,
++					      PCI_EXP_DEVCTL_NOSNOOP_EN);
++		}
+ 	}
+ 
+ 	RTL_W8(Cfg9346, Cfg9346_Unlock);
+-- 
+1.5.3.3
+
+From ba648bdcbca93084360d348eb43dde4b19b2489e Mon Sep 17 00:00:00 2001
+From: Francois Romieu <romieu@fr.zoreil.com>
+Date: Sun, 1 Jun 2008 22:37:49 +0200
+Subject: [PATCH] r8169: add 8168/8101 registers description
+
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/r8169.c |   47 +++++++++++++++++++++++++++++++++++++++++++----
+ 1 files changed, 43 insertions(+), 4 deletions(-)
+
+diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
+index 5c00522..0b8db03 100644
+--- a/drivers/net/r8169.c
++++ b/drivers/net/r8169.c
+@@ -197,9 +197,6 @@ enum rtl_registers {
+ 	Config5		= 0x56,
+ 	MultiIntr	= 0x5c,
+ 	PHYAR		= 0x60,
+-	TBICSR		= 0x64,
+-	TBI_ANAR	= 0x68,
+-	TBI_LPAR	= 0x6a,
+ 	PHYstatus	= 0x6c,
+ 	RxMaxSize	= 0xda,
+ 	CPlusCmd	= 0xe0,
+@@ -213,6 +210,32 @@ enum rtl_registers {
+ 	FuncForceEvent	= 0xfc,
+ };
+ 
++enum rtl8110_registers {
++	TBICSR			= 0x64,
++	TBI_ANAR		= 0x68,
++	TBI_LPAR		= 0x6a,
++};
++
++enum rtl8168_8101_registers {
++	CSIDR			= 0x64,
++	CSIAR			= 0x68,
++#define	CSIAR_FLAG			0x80000000
++#define	CSIAR_WRITE_CMD			0x80000000
++#define	CSIAR_BYTE_ENABLE		0x0f
++#define	CSIAR_BYTE_ENABLE_SHIFT		12
++#define	CSIAR_ADDR_MASK			0x0fff
++
++	EPHYAR			= 0x80,
++#define	EPHYAR_FLAG			0x80000000
++#define	EPHYAR_WRITE_CMD		0x80000000
++#define	EPHYAR_REG_MASK			0x1f
++#define	EPHYAR_REG_SHIFT		16
++#define	EPHYAR_DATA_MASK		0xffff
++	DBG_REG			= 0xd1,
++#define	FIX_NAK_1			(1 << 4)
++#define	FIX_NAK_2			(1 << 3)
++};
++
+ enum rtl_register_content {
+ 	/* InterruptStatusBits */
+ 	SYSErr		= 0x8000,
+@@ -266,7 +289,13 @@ enum rtl_register_content {
+ 	TxDMAShift = 8,	/* DMA burst value (0-7) is shift this many bits */
+ 
+ 	/* Config1 register p.24 */
++	LEDS1		= (1 << 7),
++	LEDS0		= (1 << 6),
+ 	MSIEnable	= (1 << 5),	/* Enable Message Signaled Interrupt */
++	Speed_down	= (1 << 4),
++	MEMMAP		= (1 << 3),
++	IOMAP		= (1 << 2),
++	VPD		= (1 << 1),
+ 	PMEnable	= (1 << 0),	/* Power Management Enable */
+ 
+ 	/* Config2 register p. 25 */
+@@ -276,6 +305,7 @@ enum rtl_register_content {
+ 	/* Config3 register p.25 */
+ 	MagicPacket	= (1 << 5),	/* Wake up when receives a Magic Packet */
+ 	LinkUp		= (1 << 4),	/* Wake up when the cable connection is re-established */
++	Beacon_en	= (1 << 0),	/* 8168 only. Reserved in the 8168b */
+ 
+ 	/* Config5 register p.27 */
+ 	BWF		= (1 << 6),	/* Accept Broadcast wakeup frame */
+@@ -293,7 +323,16 @@ enum rtl_register_content {
+ 	TBINwComplete	= 0x01000000,
+ 
+ 	/* CPlusCmd p.31 */
+-	PktCntrDisable	= (1 << 7),	// 8168
++	EnableBist	= (1 << 15),	// 8168 8101
++	Mac_dbgo_oe	= (1 << 14),	// 8168 8101
++	Normal_mode	= (1 << 13),	// unused
++	Force_half_dup	= (1 << 12),	// 8168 8101
++	Force_rxflow_en	= (1 << 11),	// 8168 8101
++	Force_txflow_en	= (1 << 10),	// 8168 8101
++	Cxpl_dbg_sel	= (1 << 9),	// 8168 8101
++	ASF		= (1 << 8),	// 8168 8101
++	PktCntrDisable	= (1 << 7),	// 8168 8101
++	Mac_dbgo_sel	= 0x001c,	// 8168
+ 	RxVlan		= (1 << 6),
+ 	RxChkSum	= (1 << 5),
+ 	PCIDAC		= (1 << 4),
+-- 
+1.5.3.3
+
+From 61650c9e3d637b0990d9f26b1421ac4b55f5c744 Mon Sep 17 00:00:00 2001
+From: Francois Romieu <romieu@fr.zoreil.com>
+Date: Sat, 2 Aug 2008 20:44:13 +0200
+Subject: [PATCH] r8169: add hw start helpers for the 8168 and the 8101
+
+This commit triggers three 'defined but not used' warnings but
+I prefer avoiding to tie these helpers to a specific change in
+the hw start sequences of the 8168 or of the 8101.
+
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/r8169.c |   96 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 files changed, 96 insertions(+), 0 deletions(-)
+
+diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
+index 0b8db03..52eba5c 100644
+--- a/drivers/net/r8169.c
++++ b/drivers/net/r8169.c
+@@ -526,6 +526,11 @@ static int mdio_read(void __iomem *ioaddr, int reg_addr)
+ 	return value;
+ }
+ 
++static void mdio_patch(void __iomem *ioaddr, int reg_addr, int value)
++{
++	mdio_write(ioaddr, reg_addr, mdio_read(ioaddr, reg_addr) | value);
++}
++
+ static void rtl_mdio_write(struct net_device *dev, int phy_id, int location,
+ 			   int val)
+ {
+@@ -543,6 +548,72 @@ static int rtl_mdio_read(struct net_device *dev, int phy_id, int location)
+ 	return mdio_read(ioaddr, location);
+ }
+ 
++static void rtl_ephy_write(void __iomem *ioaddr, int reg_addr, int value)
++{
++	unsigned int i;
++
++	RTL_W32(EPHYAR, EPHYAR_WRITE_CMD | (value & EPHYAR_DATA_MASK) |
++		(reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT);
++
++	for (i = 0; i < 100; i++) {
++		if (!(RTL_R32(EPHYAR) & EPHYAR_FLAG))
++			break;
++		udelay(10);
++	}
++}
++
++static u16 rtl_ephy_read(void __iomem *ioaddr, int reg_addr)
++{
++	u16 value = 0xffff;
++	unsigned int i;
++
++	RTL_W32(EPHYAR, (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT);
++
++	for (i = 0; i < 100; i++) {
++		if (RTL_R32(EPHYAR) & EPHYAR_FLAG) {
++			value = RTL_R32(EPHYAR) & EPHYAR_DATA_MASK;
++			break;
++		}
++		udelay(10);
++	}
++
++	return value;
++}
++
++static void rtl_csi_write(void __iomem *ioaddr, int addr, int value)
++{
++	unsigned int i;
++
++	RTL_W32(CSIDR, value);
++	RTL_W32(CSIAR, CSIAR_WRITE_CMD | (addr & CSIAR_ADDR_MASK) |
++		CSIAR_BYTE_ENABLE << CSIAR_BYTE_ENABLE_SHIFT);
++
++	for (i = 0; i < 100; i++) {
++		if (!(RTL_R32(CSIAR) & CSIAR_FLAG))
++			break;
++		udelay(10);
++	}
++}
++
++static u32 rtl_csi_read(void __iomem *ioaddr, int addr)
++{
++	u32 value = ~0x00;
++	unsigned int i;
++
++	RTL_W32(CSIAR, (addr & CSIAR_ADDR_MASK) |
++		CSIAR_BYTE_ENABLE << CSIAR_BYTE_ENABLE_SHIFT);
++
++	for (i = 0; i < 100; i++) {
++		if (RTL_R32(CSIAR) & CSIAR_FLAG) {
++			value = RTL_R32(CSIDR);
++			break;
++		}
++		udelay(10);
++	}
++
++	return value;
++}
++
+ static void rtl8169_irq_mask_and_ack(void __iomem *ioaddr)
+ {
+ 	RTL_W16(IntrMask, 0x0000);
+@@ -2114,6 +2185,31 @@ static void rtl_tx_performance_tweak(struct pci_dev *pdev, u16 force)
+ 	}
+ }
+ 
++static void rtl_csi_access_enable(void __iomem *ioaddr)
++{
++	u32 csi;
++
++	csi = rtl_csi_read(ioaddr, 0x070c) & 0x00ffffff;
++	rtl_csi_write(ioaddr, 0x070c, csi | 0x27000000);
++}
++
++struct ephy_info {
++	unsigned int offset;
++	u16 mask;
++	u16 bits;
++};
++
++static void rtl_ephy_init(void __iomem *ioaddr, struct ephy_info *e, int len)
++{
++	u16 w;
++
++	while (len-- > 0) {
++		w = (rtl_ephy_read(ioaddr, e->offset) & ~e->mask) | e->bits;
++		rtl_ephy_write(ioaddr, e->offset, w);
++		e++;
++	}
++}
++
+ static void rtl_hw_start_8168(struct net_device *dev)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+-- 
+1.5.3.3
+
+From 81fbfc404f2a13646bee46fa98545c0023e3a67a Mon Sep 17 00:00:00 2001
+From: Francois Romieu <romieu@fr.zoreil.com>
+Date: Sat, 2 Aug 2008 21:08:49 +0200
+Subject: [PATCH] r8169: additional 8101 and 8102 support
+
+Signed-off-by: Ivan Vecera <ivecera@redhat.com>
+Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
+Cc: Edward Hsu <edward_hsu@realtek.com.tw>
+---
+ drivers/net/r8169.c |  124 ++++++++++++++++++++++++++++++++++++++++++++++++++-
+ 1 files changed, 122 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
+index 52eba5c..f28c202 100644
+--- a/drivers/net/r8169.c
++++ b/drivers/net/r8169.c
+@@ -96,6 +96,10 @@ enum mac_version {
+ 	RTL_GIGA_MAC_VER_04 = 0x04, // 8169SB
+ 	RTL_GIGA_MAC_VER_05 = 0x05, // 8110SCd
+ 	RTL_GIGA_MAC_VER_06 = 0x06, // 8110SCe
++	RTL_GIGA_MAC_VER_07 = 0x07, // 8102e
++	RTL_GIGA_MAC_VER_08 = 0x08, // 8102e
++	RTL_GIGA_MAC_VER_09 = 0x09, // 8102e
++	RTL_GIGA_MAC_VER_10 = 0x0a, // 8101e
+ 	RTL_GIGA_MAC_VER_11 = 0x0b, // 8168Bb
+ 	RTL_GIGA_MAC_VER_12 = 0x0c, // 8168Be
+ 	RTL_GIGA_MAC_VER_13 = 0x0d, // 8101Eb
+@@ -122,6 +126,10 @@ static const struct {
+ 	_R("RTL8169sb/8110sb",	RTL_GIGA_MAC_VER_04, 0xff7e1880), // 8169SB
+ 	_R("RTL8169sc/8110sc",	RTL_GIGA_MAC_VER_05, 0xff7e1880), // 8110SCd
+ 	_R("RTL8169sc/8110sc",	RTL_GIGA_MAC_VER_06, 0xff7e1880), // 8110SCe
++	_R("RTL8102e",		RTL_GIGA_MAC_VER_07, 0xff7e1880), // PCI-E
++	_R("RTL8102e",		RTL_GIGA_MAC_VER_08, 0xff7e1880), // PCI-E
++	_R("RTL8102e",		RTL_GIGA_MAC_VER_09, 0xff7e1880), // PCI-E
++	_R("RTL8101e",		RTL_GIGA_MAC_VER_10, 0xff7e1880), // PCI-E
+ 	_R("RTL8168b/8111b",	RTL_GIGA_MAC_VER_11, 0xff7e1880), // PCI-E
+ 	_R("RTL8168b/8111b",	RTL_GIGA_MAC_VER_12, 0xff7e1880), // PCI-E
+ 	_R("RTL8101e",		RTL_GIGA_MAC_VER_13, 0xff7e1880), // PCI-E 8139
+@@ -837,8 +845,12 @@ static int rtl8169_set_speed_xmii(struct net_device *dev,
+ 		}
+ 	}
+ 
+-	/* The 8100e/8101e do Fast Ethernet only. */
+-	if ((tp->mac_version == RTL_GIGA_MAC_VER_13) ||
++	/* The 8100e/8101e/8102e do Fast Ethernet only. */
++	if ((tp->mac_version == RTL_GIGA_MAC_VER_07) ||
++	    (tp->mac_version == RTL_GIGA_MAC_VER_08) ||
++	    (tp->mac_version == RTL_GIGA_MAC_VER_09) ||
++	    (tp->mac_version == RTL_GIGA_MAC_VER_10) ||
++	    (tp->mac_version == RTL_GIGA_MAC_VER_13) ||
+ 	    (tp->mac_version == RTL_GIGA_MAC_VER_14) ||
+ 	    (tp->mac_version == RTL_GIGA_MAC_VER_15) ||
+ 	    (tp->mac_version == RTL_GIGA_MAC_VER_16)) {
+@@ -1212,8 +1224,17 @@ static void rtl8169_get_mac_version(struct rtl8169_private *tp,
+ 		{ 0x7c800000, 0x30000000,	RTL_GIGA_MAC_VER_11 },
+ 
+ 		/* 8101 family. */
++		{ 0x7cf00000, 0x34a00000,	RTL_GIGA_MAC_VER_09 },
++		{ 0x7cf00000, 0x24a00000,	RTL_GIGA_MAC_VER_09 },
++		{ 0x7cf00000, 0x34900000,	RTL_GIGA_MAC_VER_08 },
++		{ 0x7cf00000, 0x24900000,	RTL_GIGA_MAC_VER_08 },
++		{ 0x7cf00000, 0x34800000,	RTL_GIGA_MAC_VER_07 },
++		{ 0x7cf00000, 0x24800000,	RTL_GIGA_MAC_VER_07 },
+ 		{ 0x7cf00000, 0x34000000,	RTL_GIGA_MAC_VER_13 },
++		{ 0x7cf00000, 0x34300000,	RTL_GIGA_MAC_VER_10 },
+ 		{ 0x7cf00000, 0x34200000,	RTL_GIGA_MAC_VER_16 },
++		{ 0x7c800000, 0x34800000,	RTL_GIGA_MAC_VER_09 },
++		{ 0x7c800000, 0x24800000,	RTL_GIGA_MAC_VER_09 },
+ 		{ 0x7c800000, 0x34000000,	RTL_GIGA_MAC_VER_16 },
+ 		/* FIXME: where did these entries come from ? -- FR */
+ 		{ 0xfc800000, 0x38800000,	RTL_GIGA_MAC_VER_15 },
+@@ -1375,6 +1396,22 @@ static void rtl8168cx_hw_phy_config(void __iomem *ioaddr)
+ 	rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
+ }
+ 
++static void rtl8102e_hw_phy_config(void __iomem *ioaddr)
++{
++	struct phy_reg phy_reg_init[] = {
++		{ 0x1f, 0x0003 },
++		{ 0x08, 0x441d },
++		{ 0x01, 0x9100 },
++		{ 0x1f, 0x0000 }
++	};
++
++	mdio_write(ioaddr, 0x1f, 0x0000);
++	mdio_patch(ioaddr, 0x11, 1 << 12);
++	mdio_patch(ioaddr, 0x19, 1 << 13);
++
++	rtl_phy_write(ioaddr, phy_reg_init, ARRAY_SIZE(phy_reg_init));
++}
++
+ static void rtl_hw_phy_config(struct net_device *dev)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+@@ -1392,6 +1429,11 @@ static void rtl_hw_phy_config(struct net_device *dev)
+ 	case RTL_GIGA_MAC_VER_04:
+ 		rtl8169sb_hw_phy_config(ioaddr);
+ 		break;
++	case RTL_GIGA_MAC_VER_07:
++	case RTL_GIGA_MAC_VER_08:
++	case RTL_GIGA_MAC_VER_09:
++		rtl8102e_hw_phy_config(ioaddr);
++		break;
+ 	case RTL_GIGA_MAC_VER_18:
+ 		rtl8168cp_hw_phy_config(ioaddr);
+ 		break;
+@@ -2253,6 +2295,70 @@ static void rtl_hw_start_8168(struct net_device *dev)
+ 	RTL_W16(IntrMask, tp->intr_event);
+ }
+ 
++#define R810X_CPCMD_QUIRK_MASK (\
++	EnableBist | \
++	Mac_dbgo_oe | \
++	Force_half_dup | \
++	Force_half_dup | \
++	Force_txflow_en | \
++	Cxpl_dbg_sel | \
++	ASF | \
++	PktCntrDisable | \
++	PCIDAC | \
++	PCIMulRW)
++
++static void rtl_hw_start_8102e_1(void __iomem *ioaddr, struct pci_dev *pdev)
++{
++	static struct ephy_info e_info_8102e_1[] = {
++		{ 0x01,	0, 0x6e65 },
++		{ 0x02,	0, 0x091f },
++		{ 0x03,	0, 0xc2f9 },
++		{ 0x06,	0, 0xafb5 },
++		{ 0x07,	0, 0x0e00 },
++		{ 0x19,	0, 0xec80 },
++		{ 0x01,	0, 0x2e65 },
++		{ 0x01,	0, 0x6e65 }
++	};
++	u8 cfg1;
++
++	rtl_csi_access_enable(ioaddr);
++
++	RTL_W8(DBG_REG, FIX_NAK_1);
++
++	rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
++
++	RTL_W8(Config1,
++	       LEDS1 | LEDS0 | Speed_down | MEMMAP | IOMAP | VPD | PMEnable);
++	RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
++
++	cfg1 = RTL_R8(Config1);
++	if ((cfg1 & LEDS0) && (cfg1 & LEDS1))
++		RTL_W8(Config1, cfg1 & ~LEDS0);
++
++	RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R810X_CPCMD_QUIRK_MASK);
++
++	rtl_ephy_init(ioaddr, e_info_8102e_1, ARRAY_SIZE(e_info_8102e_1));
++}
++
++static void rtl_hw_start_8102e_2(void __iomem *ioaddr, struct pci_dev *pdev)
++{
++	rtl_csi_access_enable(ioaddr);
++
++	rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
++
++	RTL_W8(Config1, MEMMAP | IOMAP | VPD | PMEnable);
++	RTL_W8(Config3, RTL_R8(Config3) & ~Beacon_en);
++
++	RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R810X_CPCMD_QUIRK_MASK);
++}
++
++static void rtl_hw_start_8102e_3(void __iomem *ioaddr, struct pci_dev *pdev)
++{
++	rtl_hw_start_8102e_2(ioaddr, pdev);
++
++	rtl_ephy_write(ioaddr, 0x03, 0xc2f9);
++}
++
+ static void rtl_hw_start_8101(struct net_device *dev)
+ {
+ 	struct rtl8169_private *tp = netdev_priv(dev);
+@@ -2269,6 +2375,20 @@ static void rtl_hw_start_8101(struct net_device *dev)
+ 		}
+ 	}
+ 
++	switch (tp->mac_version) {
++	case RTL_GIGA_MAC_VER_07:
++		rtl_hw_start_8102e_1(ioaddr, pdev);
++		break;
++
++	case RTL_GIGA_MAC_VER_08:
++		rtl_hw_start_8102e_3(ioaddr, pdev);
++		break;
++
++	case RTL_GIGA_MAC_VER_09:
++		rtl_hw_start_8102e_2(ioaddr, pdev);
++		break;
++	}
++
+ 	RTL_W8(Cfg9346, Cfg9346_Unlock);
+ 
+ 	RTL_W8(EarlyTxThres, EarlyTxThld);
+-- 
+1.5.3.3
+

meta-moblin/packages/linux/linux-moblin-2.6.27/0042-intelfb-945gme.patch

@@ -0,0 +1,154 @@
+The following patch adds support for Intel's 945GME graphics chip to
+the intelfb driver.  I have assumed that the 945GME is identical to the
+already-supported 945GM apart from its PCI IDs; this is based on a quick
+look at the X driver for these chips which seems to treat them
+identically.
+
+Signed-off-by: Phil Endecott <spam_from_intelfb@chezphil.org>
+
+---
+
+The 945GME is used in the ASUS Eee 901, and I coded this in the hope that 
+I'd be able to use it to get a console at the native 1024x600 resolution 
+which is not known to the BIOS.  I realised too late that the intelfb 
+driver does not support mode changing on laptops, so it won't be any 
+use for me.  But rather than throw it away I will post it here as 
+essentially "untested"; maybe someone who knows more about this driver, 
+and with more useful hardware to test on, can pick it up.
+
+---
+ Documentation/fb/intelfb.txt        |    1 +
+ drivers/video/intelfb/intelfb.h     |    7 +++++--
+ drivers/video/intelfb/intelfb_i2c.c |    1 +
+ drivers/video/intelfb/intelfbdrv.c  |    7 ++++++-
+ drivers/video/intelfb/intelfbhw.c   |    7 +++++++
+ 5 files changed, 20 insertions(+), 3 deletions(-)
+
+Index: linux-2.6.27/Documentation/fb/intelfb.txt
+===================================================================
+--- linux-2.6.27.orig/Documentation/fb/intelfb.txt	2008-10-14 16:54:54.000000000 +0200
++++ linux-2.6.27/Documentation/fb/intelfb.txt	2008-10-14 17:05:36.000000000 +0200
+@@ -14,6 +14,7 @@ graphics devices.  These would include:
+ 	Intel 915GM
+ 	Intel 945G
+ 	Intel 945GM
++	Intel 945GME
+ 	Intel 965G
+ 	Intel 965GM
+ 
+Index: linux-2.6.27/drivers/video/intelfb/intelfb.h
+===================================================================
+--- linux-2.6.27.orig/drivers/video/intelfb/intelfb.h	2008-10-14 16:55:37.000000000 +0200
++++ linux-2.6.27/drivers/video/intelfb/intelfb.h	2008-10-14 17:05:36.000000000 +0200
+@@ -12,9 +12,9 @@
+ #endif
+ 
+ /*** Version/name ***/
+-#define INTELFB_VERSION			"0.9.5"
++#define INTELFB_VERSION			"0.9.6"
+ #define INTELFB_MODULE_NAME		"intelfb"
+-#define SUPPORTED_CHIPSETS		"830M/845G/852GM/855GM/865G/915G/915GM/945G/945GM/965G/965GM"
++#define SUPPORTED_CHIPSETS		"830M/845G/852GM/855GM/865G/915G/915GM/945G/945GM/945GME/965G/965GM"
+ 
+ 
+ /*** Debug/feature defines ***/
+@@ -58,6 +58,7 @@
+ #define PCI_DEVICE_ID_INTEL_915GM	0x2592
+ #define PCI_DEVICE_ID_INTEL_945G	0x2772
+ #define PCI_DEVICE_ID_INTEL_945GM	0x27A2
++#define PCI_DEVICE_ID_INTEL_945GME	0x27AE
+ #define PCI_DEVICE_ID_INTEL_965G	0x29A2
+ #define PCI_DEVICE_ID_INTEL_965GM	0x2A02
+ 
+@@ -160,6 +161,7 @@ enum intel_chips {
+ 	INTEL_915GM,
+ 	INTEL_945G,
+ 	INTEL_945GM,
++	INTEL_945GME,
+ 	INTEL_965G,
+ 	INTEL_965GM,
+ };
+@@ -363,6 +365,7 @@ struct intelfb_info {
+ 			((dinfo)->chipset == INTEL_915GM) ||	\
+ 			((dinfo)->chipset == INTEL_945G) ||	\
+ 			((dinfo)->chipset == INTEL_945GM) ||	\
++			((dinfo)->chipset == INTEL_945GME) ||	\
+ 			((dinfo)->chipset == INTEL_965G) ||	\
+ 			((dinfo)->chipset == INTEL_965GM))
+ 
+Index: linux-2.6.27/drivers/video/intelfb/intelfb_i2c.c
+===================================================================
+--- linux-2.6.27.orig/drivers/video/intelfb/intelfb_i2c.c	2008-10-14 16:55:37.000000000 +0200
++++ linux-2.6.27/drivers/video/intelfb/intelfb_i2c.c	2008-10-14 17:05:36.000000000 +0200
+@@ -171,6 +171,7 @@ void intelfb_create_i2c_busses(struct in
+ 		/* has some LVDS + tv-out */
+ 	case INTEL_945G:
+ 	case INTEL_945GM:
++	case INTEL_945GME:
+ 	case INTEL_965G:
+ 	case INTEL_965GM:
+ 		/* SDVO ports have a single control bus - 2 devices */
+Index: linux-2.6.27/drivers/video/intelfb/intelfbdrv.c
+===================================================================
+--- linux-2.6.27.orig/drivers/video/intelfb/intelfbdrv.c	2008-10-14 16:55:37.000000000 +0200
++++ linux-2.6.27/drivers/video/intelfb/intelfbdrv.c	2008-10-14 17:05:36.000000000 +0200
+@@ -2,7 +2,7 @@
+  * intelfb
+  *
+  * Linux framebuffer driver for Intel(R) 830M/845G/852GM/855GM/865G/915G/915GM/
+- * 945G/945GM/965G/965GM integrated graphics chips.
++ * 945G/945GM/945GME/965G/965GM integrated graphics chips.
+  *
+  * Copyright © 2002, 2003 David Dawes <dawes@xfree86.org>
+  *                   2004 Sylvain Meyer
+@@ -102,6 +102,9 @@
+  *
+  *    04/2008 - Version 0.9.5
+  *              Add support for 965G/965GM. (Maik Broemme <mbroemme@plusserver.de>)
++ *
++ *    08/2008 - Version 0.9.6
++ *              Add support for 945GME. (Phil Endecott <spam_from_intelfb@chezphil.org>)
+  */
+ 
+ #include <linux/module.h>
+@@ -183,6 +186,7 @@ static struct pci_device_id intelfb_pci_
+ 	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_915GM, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_915GM },
+ 	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_945G, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_945G },
+ 	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_945GM, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_945GM },
++	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_945GME, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_945GME },
+ 	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_965G, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_965G },
+ 	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_965GM, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, INTELFB_CLASS_MASK, INTEL_965GM },
+ 	{ 0, }
+@@ -555,6 +559,7 @@ static int __devinit intelfb_pci_registe
+ 	    (ent->device == PCI_DEVICE_ID_INTEL_915GM) ||
+ 	    (ent->device == PCI_DEVICE_ID_INTEL_945G)  ||
+ 	    (ent->device == PCI_DEVICE_ID_INTEL_945GM) ||
++	    (ent->device == PCI_DEVICE_ID_INTEL_945GME) ||
+ 	    (ent->device == PCI_DEVICE_ID_INTEL_965G) ||
+ 	    (ent->device == PCI_DEVICE_ID_INTEL_965GM)) {
+ 
+Index: linux-2.6.27/drivers/video/intelfb/intelfbhw.c
+===================================================================
+--- linux-2.6.27.orig/drivers/video/intelfb/intelfbhw.c	2008-10-14 16:55:37.000000000 +0200
++++ linux-2.6.27/drivers/video/intelfb/intelfbhw.c	2008-10-14 17:05:36.000000000 +0200
+@@ -143,6 +143,12 @@ int intelfbhw_get_chipset(struct pci_dev
+ 		dinfo->mobile = 1;
+ 		dinfo->pll_index = PLLS_I9xx;
+ 		return 0;
++	case PCI_DEVICE_ID_INTEL_945GME:
++		dinfo->name = "Intel(R) 945GME";
++		dinfo->chipset = INTEL_945GME;
++		dinfo->mobile = 1;
++		dinfo->pll_index = PLLS_I9xx;
++		return 0;
+ 	case PCI_DEVICE_ID_INTEL_965G:
+ 		dinfo->name = "Intel(R) 965G";
+ 		dinfo->chipset = INTEL_965G;
+@@ -186,6 +192,7 @@ int intelfbhw_get_memory(struct pci_dev 
+ 	case PCI_DEVICE_ID_INTEL_915GM:
+ 	case PCI_DEVICE_ID_INTEL_945G:
+ 	case PCI_DEVICE_ID_INTEL_945GM:
++	case PCI_DEVICE_ID_INTEL_945GME:
+ 	case PCI_DEVICE_ID_INTEL_965G:
+ 	case PCI_DEVICE_ID_INTEL_965GM:
+ 		/* 915, 945 and 965 chipsets support a 256MB aperture.