Trying this old one as the new stuff is broken on macbook pro...

svn path=/; revision=112

1 files changed, 263 insertions, 64 deletions

diff --git a/x11-drivers/ati-drivers/files/8.42.3/ati-drivers-2.6.23-2.patch b/x11-drivers/ati-drivers/files/8.42.3/ati-drivers-2.6.23-2.patch
index 4ab3ac6..5f1a34f 100644
--- a/x11-drivers/ati-drivers/files/8.42.3/ati-drivers-2.6.23-2.patch
+++ b/x11-drivers/ati-drivers/files/8.42.3/ati-drivers-2.6.23-2.patch
@@ -1,78 +1,277 @@
-diff -Naur common/lib/modules/fglrx/build_mod/firegl_public.c.old common/lib/modules/fglrx/build_mod/firegl_public.c
---- common/lib/modules/fglrx/build_mod/firegl_public.c	2007-10-24 14:10:52.000000000 +0000
-+++ common/lib/modules/fglrx/build_mod/firegl_public.c	2007-10-24 14:14:39.000000000 +0000
-@@ -217,6 +217,56 @@
- #define preempt_enable()
- #endif
+diff -urN common/lib/modules/fglrx/build_mod/firegl_public.c~ common/lib/modules/fglrx/build_mod/firegl_public.c
+--- common/lib/modules/fglrx/build_mod/firegl_public.c~	2007-10-22 11:30:01.000000000 -0500
++++ common/lib/modules/fglrx/build_mod/firegl_public.c	2007-10-24 13:31:08.000000000 -0500
+@@ -796,7 +796,7 @@
+         
+     // since privdev->pcidev is acquired in X server, use pdev 
+     // directly here to allow suspend/resume without X server start. 
+-        firegl_pci_save_state(pdev, privdev);
++        firegl_pci_save_state((__ke_pci_dev_t*)pdev, privdev);
+         pci_disable_device(pdev);
+         PMSG_EVENT(pdev->dev.power.power_state) = state;
+     }
+@@ -838,7 +838,7 @@
  
-+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)
-+#if defined(__i386__)
-+#define ptep_test_and_clear_dirty(vma, addr, ptep) ({                  \
-+       int __ret = 0;                                                  \
-+       if (pte_dirty(*(ptep)))                                         \
-+               __ret = test_and_clear_bit(_PAGE_BIT_DIRTY,             \
-+                                               &(ptep)->pte_low);      \
-+       if (__ret)                                                      \
-+               pte_update((vma)->vm_mm, addr, ptep);                   \
-+       __ret;                                                          \
-+})
-+
-+static inline int pte_read(pte_t pte)	{ return (pte).pte_low & _PAGE_USER; }
-+static inline int pte_user(pte_t pte)	{ return (pte).pte_low & _PAGE_USER; }
-+#ifdef CONFIG_X86_PAE
-+/*
-+ * Is the pte executable?
-+ */
-+static inline int pte_x(pte_t pte)
-+{
-+        return !(pte_val(pte) & _PAGE_NX);
-+}
-+ 
-+/*
-+ * All present user-pages with !NX bit are user-executable:
+     // PCI config space needs to be restored very early, in particular
+     // before pci_set_master!
+-    firegl_pci_restore_state(pdev, privdev);
++    firegl_pci_restore_state((__ke_pci_dev_t*)pdev, privdev);
+ 
+     if (pci_enable_device(pdev)) 
+     {
+@@ -2016,7 +2016,11 @@
+ 
+ __ke_pci_dev_t* ATI_API_CALL __ke_pci_find_device (unsigned int vendor, unsigned int dev, __ke_pci_dev_t* from)
+ {
+-	return (__ke_pci_dev_t*)pci_find_device( vendor, dev, (struct pci_dev *)(void *)from );
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
++    return (__ke_pci_dev_t*)pci_get_device( vendor, dev, (struct pci_dev *)(void *)from );
++#else
++    return (__ke_pci_dev_t*)pci_find_device( vendor, dev, (struct pci_dev *)(void *)from );
++#endif
+ }
+ 
+ void* ATI_API_CALL __ke_malloc(__ke_size_t size)
+@@ -2487,16 +2491,80 @@
+ }
+ 
+ #ifndef ptep_clear_flush_dirty
+-#define ptep_clear_flush_dirty(__vma, __address, __ptep) \
+-({							 \
+-    int __dirty = ptep_test_and_clear_dirty(__ptep);	 \
+-    if (__dirty)					 \
+-        flush_tlb_page(__vma, __address);		 \
+-    __dirty;						 \
+-})
++/** \brief Test and clear the "dirty" bit in the page table entry
++ *
++ * \param vma Pointer to the memory region structure
++ * \param addr Virtual address covered by vma
++ * \param ptep Pointer to the table entry structure
++ *
++ * \return Old value of the "dirty" flag
++ *
 + */
-+static inline int pte_exec(pte_t pte)
++static inline int ptep_clear_flush_dirty(struct vm_area_struct *vma, unsigned long addr, pte_t *ptep)
 +{
-+        return pte_user(pte) && pte_x(pte);
-+}
++    int ret = 0;
++    
++    DBG_ENTER("0x%08X, 0x%08X, 0x%08X->0x%08X", vma, addr, ptep, *ptep);
++    
++    if (pte_dirty(*ptep))
++    {
++#ifdef __x86_64__
++        DBG_TRACE("Test and clear bit %d in 0x%08X", _PAGE_BIT_DIRTY, ptep->pte);
++        ret = test_and_clear_bit(_PAGE_BIT_DIRTY, &ptep->pte);
 +#else
-+static inline int pte_exec(pte_t pte)
-+{
-+        return pte_user(pte);
-+}
-+#endif	/* PAE */
++        DBG_TRACE("Test and clear bit %d in 0x%08X", _PAGE_BIT_DIRTY, ptep->pte_low);
++        ret = test_and_clear_bit(_PAGE_BIT_DIRTY, &ptep->pte_low);
 +
-+#elif defined(__x86_64__)
-+static inline int ptep_test_and_clear_dirty(struct vm_area_struct *vma,
-+					unsigned long addr, pte_t *ptep)
-+{
-+	if (!pte_dirty(*ptep))
-+		return 0;
-+	return test_and_clear_bit(_PAGE_BIT_DIRTY, &ptep->pte);
++        // Since we modify PTE directly, it needs to inform the hypervisor
++        if (ret)
++        {
++            pte_update(vma->vm_mm, addr, ptep);
++        }
++#endif        
++    }
++
++    DBG_TRACE("0x%08X->0x%08X", ptep, *ptep);
++    
++    // Flush Translation Lookaside Buffers
++    if (ret)
++    {
++        flush_tlb_page(vma, addr);
++    }
++    
++    DBG_LEAVE("%d", ret);
++    
++    return ret;
 +}
-+static inline int pte_read(pte_t pte)	{ return pte_val(pte) & _PAGE_USER; }
-+static inline int pte_exec(pte_t pte)	{ return !(pte_val(pte) & _PAGE_NX); }
-+#endif
 +#endif
 +
- // ============================================================
- /* globals */
++#ifdef pte_offset_atomic
++#define PTE_OFFSET_FUNC pte_offset_atomic
++#define PTE_UNMAP_FUNC(p) pte_kunmap(p)
++#else
++#ifdef pte_offset_map
++#define PTE_OFFSET_FUNC pte_offset_map
++#define PTE_UNMAP_FUNC(p) pte_unmap(p)
++#else
++#ifdef pte_offset_kernel
++#define PTE_OFFSET_FUNC pte_offset_kernel
++#define PTE_UNMAP_FUNC(p) do {} while (0)
++#else
++#define PTE_OFFSET_FUNC pte_offset
++#define PTE_UNMAP_FUNC(p) do {} while (0)
++#endif
++#endif
+ #endif
  
-@@ -2490,7 +2540,7 @@
- #ifndef ptep_clear_flush_dirty
- #define ptep_clear_flush_dirty(__vma, __address, __ptep) \
- ({							 \
--    int __dirty = ptep_test_and_clear_dirty(__ptep);	 \
-+    int __dirty = ptep_test_and_clear_dirty(__vma, __address, __ptep);	 \
-     if (__dirty)					 \
-         flush_tlb_page(__vma, __address);		 \
-     __dirty;						 \
-@@ -2937,7 +2987,7 @@
+-int ATI_API_CALL __ke_vm_test_and_clear_dirty(struct mm_struct* mm, unsigned long virtual_addr)
++/** \brief Test and clear the "dirty" bit in the page table entry referred by
++ * the virtual address
++ *
++ * \param mm Pointer to the memory descriptor structure
++ * \param virtual_addr Virtual address 
++ *
++ * \return Old value of the "dirty" flag on success or negative on error
++ *
++ */
++int ATI_API_CALL KCL_TestAndClearPageDirtyFlag(struct mm_struct* mm, unsigned long virtual_addr)
+ {
+     int ret = -1; // init with page not present
+     pgd_t* pgd_p;
+@@ -2530,37 +2598,16 @@
+     }
+     __KE_DEBUG("pmd_p=0x%08lx\n", (unsigned long)pmd_p);
+ 
+-#ifdef pte_offset_atomic
+-    pte_p = pte_offset_atomic(pmd_p, virtual_addr);
+-    if (pte_present(*pte_p))
+-        ret = (ptep_clear_flush_dirty(vma, virtual_addr, pte_p) ? 1 : 0);
+-    else
+-        __KE_DEBUG("page not exists!\n");
+-    pte_kunmap(pte_p);
+-#else
+-#ifdef pte_offset_map
+-    pte_p = pte_offset_map(pmd_p, virtual_addr);
+-    if (pte_present(*pte_p))
+-        ret = (ptep_clear_flush_dirty(vma, virtual_addr, pte_p) ? 1 : 0);
+-    else
+-        __KE_DEBUG("page not exists!\n");
+-    pte_unmap(pte_p);
+-#else
+-#ifdef pte_offset_kernel
+-    pte_p = pte_offset_kernel(pmd_p, virtual_addr);
+-    if (pte_present(*pte_p))
+-        ret = (ptep_clear_flush_dirty(vma, virtual_addr, pte_p) ? 1 : 0);
+-    else
+-        __KE_DEBUG("page not exists!\n");
+-#else
+-    pte_p = pte_offset(pmd_p, virtual_addr);
++    pte_p = PTE_OFFSET_FUNC(pmd_p, virtual_addr);
+     if (pte_present(*pte_p))
++    {
+         ret = (ptep_clear_flush_dirty(vma, virtual_addr, pte_p) ? 1 : 0);
++    }
+     else
++    {
+         __KE_DEBUG("page not exists!\n");
+-#endif
+-#endif
+-#endif
++    }
++    PTE_UNMAP_FUNC(pte_p);
+ 
+     if (debuglevel > 2)
+     {
+@@ -2946,20 +2993,35 @@
+ #else
+ static void ATI_API_CALL (*irq_handler_func)(int, void*, void*); /* function pointer variable */
+ 
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
+ static irqreturn_t ke_irq_handler_wrap(int irq, void *arg1, struct pt_regs *regs)
+ {
+     irq_handler_func(irq, arg1, regs);
+     return IRQ_HANDLED;
+ }
+-
+-int ATI_API_CALL __ke_request_irq(unsigned int irq, 
++#else
++static irqreturn_t ke_irq_handler_wrap(int irq, void *arg1)
++{
++    irq_handler_func(irq, arg1, (void *)0);
++    return IRQ_HANDLED;
++}
++#endif
++            
++int ATI_API_CALL __ke_request_irq(unsigned int irq,
+     void (*ATI_API_CALL handler)(int, void *, void *),
+     const char *dev_name, void *dev_id)
  {
-     return request_irq(irq,
-         (void(*)(int, void *, struct pt_regs *))handler,
+     irq_handler_func = handler;
+-    return request_irq(irq,
++    return request_irq(
++        irq,
+         ke_irq_handler_wrap,
 -        SA_SHIRQ, dev_name, dev_id);
-+        IRQF_SHARED, dev_name, dev_id);
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
++        SA_SHIRQ,
++#else
++        IRQF_SHARED,
++#endif                
++        dev_name,
++        dev_id);
  }
  
  void ATI_API_CALL __ke_free_irq(unsigned int irq, void *dev_id)
+@@ -3530,12 +3592,10 @@
+ #else
+         *phys_address = pte_val(pte) & (u64)((u64)PAGE_MASK | (u64)0xf<<32);
+ #endif
+-        sprintf(buf, "0x%Lx %c%c%c%c%c%c\n",
++        sprintf(buf, "0x%Lx %c%c%c%c\n",
+            *phys_address,
+            pte_present (pte) ? 'p' : '-',
+-           pte_read    (pte) ? 'r' : '-',
+            pte_write   (pte) ? 'w' : '-',
+-           pte_exec    (pte) ? 'x' : '-',
+            pte_dirty   (pte) ? 'd' : '-',
+            pte_young   (pte) ? 'a' : '-');
+     }
+@@ -5436,7 +5496,11 @@
+ /** \brief Type definition of the structure describing Slab Cache object */
+ typedef struct tag_kasSlabCache_t
+ {
+-    kmem_cache_t* cache;        /* OS slab cache object */
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
++    struct kmem_cache *cache;   /* OS slab cache object */
++#else
++    kmem_cache_t *cache;        /* OS slab cache object */
++#endif
+     spinlock_t lock;            /* OS spinlock object protecting the cache */
+     unsigned int routine_type;  /* Type of routine the cache might be accessed from */
+     char name[14];              /* Cache object name (kernel 2.4 restricts its length to 19 chars) */
+@@ -5482,8 +5546,12 @@
+     DBG_TRACE("creating slab object '%s'", slabcache_obj->name);
+ 
+     if ((slabcache_obj->cache =
+-            kmem_cache_create(slabcache_obj->name, iEntrySize, 0, 0, NULL, NULL)))
+-    {
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
++         kmem_cache_create(slabcache_obj->name, iEntrySize, 0, 0, NULL, NULL)))
++#else
++         kmem_cache_create(slabcache_obj->name, iEntrySize, 0, 0, NULL)))
++#endif
++{
+         ret = 1;
+     }
+ 
+diff -urN common/lib/modules/fglrx/build_mod/firegl_public.h~ common/lib/modules/fglrx/build_mod/firegl_public.h
+--- common/lib/modules/fglrx/build_mod/firegl_public.h~	2007-10-22 11:30:01.000000000 -0500
++++ common/lib/modules/fglrx/build_mod/firegl_public.h	2007-10-24 13:31:08.000000000 -0500
+@@ -241,9 +241,14 @@
+ /*****************************************************************************/
+ 
+ typedef unsigned long __ke_dev_t;
+-typedef unsigned long __ke_size_t;
+ typedef unsigned long __ke_off_t;
++#ifdef __x86_64__
+ typedef long __ke_ssize_t;
++typedef unsigned long __ke_size_t;
++#else
++typedef int __ke_ssize_t;
++typedef unsigned int __ke_size_t;
++#endif
+ typedef unsigned char __ke_u8;
+ typedef unsigned short __ke_u16;
+ typedef unsigned int __ke_u32;
+@@ -594,7 +599,7 @@
+ extern char* ATI_API_CALL __ke_strchr(const char *s, int c);
+ extern int ATI_API_CALL __ke_sprintf(char* buf, const char* fmt, ...);
+ extern int ATI_API_CALL __ke_snprintf(char* buf, size_t size, const char* fmt, ...);
+-extern int ATI_API_CALL __ke_vm_test_and_clear_dirty(struct mm_struct* mm, unsigned long virtual_addr);
++extern int ATI_API_CALL KCL_TestAndClearPageDirtyFlag(struct mm_struct* mm, unsigned long virtual_addr);
+ extern unsigned long ATI_API_CALL __ke_do_mmap(struct file * file, unsigned long addr, unsigned long len, unsigned long pgoff);
+ extern int ATI_API_CALL __ke_do_munmap(unsigned long addr, unsigned long len);
+ extern void* ATI_API_CALL __ke_vmap(unsigned long *pagelist, unsigned int count);