Public Pastes
daily pastebin goal
9%
SHARE
TWEET

sarvatt

a guest Feb 3rd, 2010 181 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. diff -Nru linux-backports-modules-2.6.32-2.6.32/debian/changelog linux-backports-modules-2.6.32-2.6.32/debian/changelog
  2. --- linux-backports-modules-2.6.32-2.6.32/debian/changelog      2010-02-02 20:33:10.000000000 -0500
  3. +++ linux-backports-modules-2.6.32-2.6.32/debian/changelog      2010-02-03 17:13:31.000000000 -0500
  4.  -1,3 +1,10 @@
  5. +linux-backports-modules-2.6.32 (2.6.32-12.1~pre2) lucid; urgency=low
  6. +
  7. +  * Update nouveau to the latest upstream version as of 2.6.33 pre-rc7
  8. +    up to commit c80d292f137275a1ed88e6ed515ecb457051f1a4
  9. +
  10. + -- Robert Hooker <sarvatt@ubuntu.com>  Wed, 03 Feb 2010 17:11:24 -0500
  11. +
  12.  linux-backports-modules-2.6.32 (2.6.32-12.1~pre1) lucid; urgency=low
  13.  
  14.    * Bump ABI to 12 for new Lucid kernel
  15. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ati_pcigart.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ati_pcigart.c
  16. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ati_pcigart.c 2010-01-25 15:21:29.000000000 -0500
  17. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ati_pcigart.c 2010-02-03 17:11:08.000000000 -0500
  18.  -38,7 +38,7 @@
  19.  static int drm_ati_alloc_pcigart_table(struct drm_device *dev,
  20.                                        struct drm_ati_pcigart_info *gart_info)
  21.  {
  22. -       gart_info->table_handle = drm_pci_alloc(dev, gart_info->table_size,
  23. +       gart_info->table_handle = lbm_drm_pci_alloc(dev, gart_info->table_size,
  24.                                                 PAGE_SIZE);
  25.         if (gart_info->table_handle == NULL)
  26.                 return -ENOMEM;
  27.  -49,11 +49,11 @@
  28.  static void drm_ati_free_pcigart_table(struct drm_device *dev,
  29.                                        struct drm_ati_pcigart_info *gart_info)
  30.  {
  31. -       drm_pci_free(dev, gart_info->table_handle);
  32. +       lbm_drm_pci_free(dev, gart_info->table_handle);
  33.         gart_info->table_handle = NULL;
  34.  }
  35.  
  36. -int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
  37. +int lbm_drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
  38.  {
  39.         struct drm_sg_mem *entry = dev->sg;
  40.         unsigned long pages;
  41.  -90,9 +90,9 @@
  42.  
  43.         return 1;
  44.  }
  45. -EXPORT_SYMBOL(drm_ati_pcigart_cleanup);
  46. +EXPORT_SYMBOL(lbm_drm_ati_pcigart_cleanup);
  47.  
  48. -int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
  49. +int lbm_drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
  50.  {
  51.         struct drm_local_map *map = &gart_info->mapping;
  52.         struct drm_sg_mem *entry = dev->sg;
  53.  -154,7 +154,7 @@
  54.                                                  0, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
  55.                 if (entry->busaddr[i] == 0) {
  56.                         DRM_ERROR("unable to map PCIGART pages!\n");
  57. -                       drm_ati_pcigart_cleanup(dev, gart_info);
  58. +                       lbm_drm_ati_pcigart_cleanup(dev, gart_info);
  59.                         address = NULL;
  60.                         bus_address = 0;
  61.                         goto done;
  62.  -198,4 +198,4 @@
  63.         gart_info->bus_addr = bus_address;
  64.         return ret;
  65.  }
  66. -EXPORT_SYMBOL(drm_ati_pcigart_init);
  67. +EXPORT_SYMBOL(lbm_drm_ati_pcigart_init);
  68. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_agpsupport.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_agpsupport.c
  69. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_agpsupport.c      2010-01-25 15:21:29.000000000 -0500
  70. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_agpsupport.c      2010-02-03 17:11:08.000000000 -0500
  71.  -44,13 +44,13 @@
  72.   * \param inode device inode.
  73.   * \param file_priv DRM file private.
  74.   * \param cmd command.
  75. - * \param arg pointer to a (output) drm_agp_info structure.
  76. + * \param arg pointer to a (output) lbm_drm_agp_info structure.
  77.   * \return zero on success or a negative number on failure.
  78.   *
  79.   * Verifies the AGP device has been initialized and acquired and fills in the
  80. - * drm_agp_info structure with the information in drm_agp_head::agp_info.
  81. + * lbm_drm_agp_info structure with the information in drm_agp_head::agp_info.
  82.   */
  83. -int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info)
  84. +int lbm_drm_agp_info(struct drm_device *dev, struct lbm_drm_agp_info *info)
  85.  {
  86.         DRM_AGP_KERN *kern;
  87.  
  88.  -71,15 +71,15 @@
  89.         return 0;
  90.  }
  91.  
  92. -EXPORT_SYMBOL(drm_agp_info);
  93. +EXPORT_SYMBOL(lbm_drm_agp_info);
  94.  
  95.  int drm_agp_info_ioctl(struct drm_device *dev, void *data,
  96.                        struct drm_file *file_priv)
  97.  {
  98. -       struct drm_agp_info *info = data;
  99. +       struct lbm_drm_agp_info *info = data;
  100.         int err;
  101.  
  102. -       err = drm_agp_info(dev, info);
  103. +       err = lbm_drm_agp_info(dev, info);
  104.         if (err)
  105.                 return err;
  106.  
  107.  -95,7 +95,7 @@
  108.   * Verifies the AGP device hasn't been acquired before and calls
  109.   * \c agp_backend_acquire.
  110.   */
  111. -int drm_agp_acquire(struct drm_device * dev)
  112. +int lbm_drm_agp_acquire(struct drm_device * dev)
  113.  {
  114.         if (!dev->agp)
  115.                 return -ENODEV;
  116.  -107,7 +107,7 @@
  117.         return 0;
  118.  }
  119.  
  120. -EXPORT_SYMBOL(drm_agp_acquire);
  121. +EXPORT_SYMBOL(lbm_drm_agp_acquire);
  122.  
  123.  /**
  124.   * Acquire the AGP device (ioctl).
  125.  -124,7 +124,7 @@
  126.  int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
  127.                           struct drm_file *file_priv)
  128.  {
  129. -       return drm_agp_acquire((struct drm_device *) file_priv->minor->dev);
  130. +       return lbm_drm_agp_acquire((struct drm_device *) file_priv->minor->dev);
  131.  }
  132.  
  133.  /**
  134.  -135,7 +135,7 @@
  135.   *
  136.   * Verifies the AGP device has been acquired and calls \c agp_backend_release.
  137.   */
  138. -int drm_agp_release(struct drm_device * dev)
  139. +int lbm_drm_agp_release(struct drm_device * dev)
  140.  {
  141.         if (!dev->agp || !dev->agp->acquired)
  142.                 return -EINVAL;
  143.  -143,12 +143,12 @@
  144.         dev->agp->acquired = 0;
  145.         return 0;
  146.  }
  147. -EXPORT_SYMBOL(drm_agp_release);
  148. +EXPORT_SYMBOL(lbm_drm_agp_release);
  149.  
  150.  int drm_agp_release_ioctl(struct drm_device *dev, void *data,
  151.                           struct drm_file *file_priv)
  152.  {
  153. -       return drm_agp_release(dev);
  154. +       return lbm_drm_agp_release(dev);
  155.  }
  156.  
  157.  /**
  158.  -161,7 +161,7 @@
  159.   * Verifies the AGP device has been acquired but not enabled, and calls
  160.   * \c agp_enable.
  161.   */
  162. -int drm_agp_enable(struct drm_device * dev, struct drm_agp_mode mode)
  163. +int lbm_drm_agp_enable(struct drm_device * dev, struct drm_agp_mode mode)
  164.  {
  165.         if (!dev->agp || !dev->agp->acquired)
  166.                 return -EINVAL;
  167.  -172,14 +172,14 @@
  168.         return 0;
  169.  }
  170.  
  171. -EXPORT_SYMBOL(drm_agp_enable);
  172. +EXPORT_SYMBOL(lbm_drm_agp_enable);
  173.  
  174.  int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
  175.                          struct drm_file *file_priv)
  176.  {
  177.         struct drm_agp_mode *mode = data;
  178.  
  179. -       return drm_agp_enable(dev, *mode);
  180. +       return lbm_drm_agp_enable(dev, *mode);
  181.  }
  182.  
  183.  /**
  184.  -194,7 +194,7 @@
  185.   * Verifies the AGP device is present and has been acquired, allocates the
  186.   * memory via alloc_agp() and creates a drm_agp_mem entry for it.
  187.   */
  188. -int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
  189. +int lbm_drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
  190.  {
  191.         struct drm_agp_mem *entry;
  192.         DRM_AGP_MEM *memory;
  193.  -226,7 +226,7 @@
  194.  
  195.         return 0;
  196.  }
  197. -EXPORT_SYMBOL(drm_agp_alloc);
  198. +EXPORT_SYMBOL(lbm_drm_agp_alloc);
  199.  
  200.  
  201.  int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
  202.  -234,7 +234,7 @@
  203.  {
  204.         struct drm_agp_buffer *request = data;
  205.  
  206. -       return drm_agp_alloc(dev, request);
  207. +       return lbm_drm_agp_alloc(dev, request);
  208.  }
  209.  
  210.  /**
  211.  -270,7 +270,7 @@
  212.   * Verifies the AGP device is present and acquired, looks-up the AGP memory
  213.   * entry and passes it to the unbind_agp() function.
  214.   */
  215. -int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request)
  216. +int lbm_drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request)
  217.  {
  218.         struct drm_agp_mem *entry;
  219.         int ret;
  220.  -281,12 +281,12 @@
  221.                 return -EINVAL;
  222.         if (!entry->bound)
  223.                 return -EINVAL;
  224. -       ret = drm_unbind_agp(entry->memory);
  225. +       ret = lbm_drm_unbind_agp(entry->memory);
  226.         if (ret == 0)
  227.                 entry->bound = 0;
  228.         return ret;
  229.  }
  230. -EXPORT_SYMBOL(drm_agp_unbind);
  231. +EXPORT_SYMBOL(lbm_drm_agp_unbind);
  232.  
  233.  
  234.  int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
  235.  -294,7 +294,7 @@
  236.  {
  237.         struct drm_agp_binding *request = data;
  238.  
  239. -       return drm_agp_unbind(dev, request);
  240. +       return lbm_drm_agp_unbind(dev, request);
  241.  }
  242.  
  243.  /**
  244.  -310,7 +310,7 @@
  245.   * is currently bound into the GATT. Looks-up the AGP memory entry and passes
  246.   * it to bind_agp() function.
  247.   */
  248. -int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request)
  249. +int lbm_drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request)
  250.  {
  251.         struct drm_agp_mem *entry;
  252.         int retcode;
  253.  -330,7 +330,7 @@
  254.                   dev->agp->base, entry->bound);
  255.         return 0;
  256.  }
  257. -EXPORT_SYMBOL(drm_agp_bind);
  258. +EXPORT_SYMBOL(lbm_drm_agp_bind);
  259.  
  260.  
  261.  int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
  262.  -338,7 +338,7 @@
  263.  {
  264.         struct drm_agp_binding *request = data;
  265.  
  266. -       return drm_agp_bind(dev, request);
  267. +       return lbm_drm_agp_bind(dev, request);
  268.  }
  269.  
  270.  /**
  271.  -355,7 +355,7 @@
  272.   * unbind_agp(). Frees it via free_agp() as well as the entry itself
  273.   * and unlinks from the doubly linked list it's inserted in.
  274.   */
  275. -int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request)
  276. +int lbm_drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request)
  277.  {
  278.         struct drm_agp_mem *entry;
  279.  
  280.  -364,15 +364,15 @@
  281.         if (!(entry = drm_agp_lookup_entry(dev, request->handle)))
  282.                 return -EINVAL;
  283.         if (entry->bound)
  284. -               drm_unbind_agp(entry->memory);
  285. +               lbm_drm_unbind_agp(entry->memory);
  286.  
  287.         list_del(&entry->head);
  288.  
  289. -       drm_free_agp(entry->memory, entry->pages);
  290. +       lbm_drm_free_agp(entry->memory, entry->pages);
  291.         kfree(entry);
  292.         return 0;
  293.  }
  294. -EXPORT_SYMBOL(drm_agp_free);
  295. +EXPORT_SYMBOL(lbm_drm_agp_free);
  296.  
  297.  
  298.  
  299.  -381,7 +381,7 @@
  300.  {
  301.         struct drm_agp_buffer *request = data;
  302.  
  303. -       return drm_agp_free(dev, request);
  304. +       return lbm_drm_agp_free(dev, request);
  305.  }
  306.  
  307.  /**
  308.  -462,7 +462,7 @@
  309.   * caller to handle that.
  310.   */
  311.  DRM_AGP_MEM *
  312. -drm_agp_bind_pages(struct drm_device *dev,
  313. +lbm_drm_agp_bind_pages(struct drm_device *dev,
  314.                    struct page **pages,
  315.                    unsigned long num_pages,
  316.                    uint32_t gtt_offset,
  317.  -495,12 +495,12 @@
  318.  
  319.         return mem;
  320.  }
  321. -EXPORT_SYMBOL(drm_agp_bind_pages);
  322. +EXPORT_SYMBOL(lbm_drm_agp_bind_pages);
  323.  
  324. -void drm_agp_chipset_flush(struct drm_device *dev)
  325. +void lbm_drm_agp_chipset_flush(struct drm_device *dev)
  326.  {
  327.         agp_flush_chipset(dev->agp->bridge);
  328.  }
  329. -EXPORT_SYMBOL(drm_agp_chipset_flush);
  330. +EXPORT_SYMBOL(lbm_drm_agp_chipset_flush);
  331.  
  332.  #endif /* __OS_HAS_AGP */
  333. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_auth.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_auth.c
  334. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_auth.c    2010-01-25 15:21:29.000000000 -0500
  335. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_auth.c    2010-02-03 17:11:08.000000000 -0500
  336.  -53,7 +53,7 @@
  337.         struct drm_device *dev = master->minor->dev;
  338.  
  339.         mutex_lock(&dev->struct_mutex);
  340. -       if (!drm_ht_find_item(&master->magiclist, (unsigned long)magic, &hash)) {
  341. +       if (!lbm_drm_ht_find_item(&master->magiclist, (unsigned long)magic, &hash)) {
  342.                 pt = drm_hash_entry(hash, struct drm_magic_entry, hash_item);
  343.                 retval = pt->priv;
  344.         }
  345.  -86,7 +86,7 @@
  346.         entry->priv = priv;
  347.         entry->hash_item.key = (unsigned long)magic;
  348.         mutex_lock(&dev->struct_mutex);
  349. -       drm_ht_insert_item(&master->magiclist, &entry->hash_item);
  350. +       lbm_drm_ht_insert_item(&master->magiclist, &entry->hash_item);
  351.         list_add_tail(&entry->head, &master->magicfree);
  352.         mutex_unlock(&dev->struct_mutex);
  353.  
  354.  -111,12 +111,12 @@
  355.         DRM_DEBUG("%d\n", magic);
  356.  
  357.         mutex_lock(&dev->struct_mutex);
  358. -       if (drm_ht_find_item(&master->magiclist, (unsigned long)magic, &hash)) {
  359. +       if (lbm_drm_ht_find_item(&master->magiclist, (unsigned long)magic, &hash)) {
  360.                 mutex_unlock(&dev->struct_mutex);
  361.                 return -EINVAL;
  362.         }
  363.         pt = drm_hash_entry(hash, struct drm_magic_entry, hash_item);
  364. -       drm_ht_remove_item(&master->magiclist, hash);
  365. +       lbm_drm_ht_remove_item(&master->magiclist, hash);
  366.         list_del(&pt->head);
  367.         mutex_unlock(&dev->struct_mutex);
  368.  
  369. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_bufs.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_bufs.c
  370. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_bufs.c    2010-01-25 15:21:29.000000000 -0500
  371. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_bufs.c    2010-02-03 17:11:08.000000000 -0500
  372.  -38,18 +38,18 @@
  373.  #include <asm/shmparam.h>
  374.  #include "drmP.h"
  375.  
  376. -resource_size_t drm_get_resource_start(struct drm_device *dev, unsigned int resource)
  377. +resource_size_t lbm_drm_get_resource_start(struct drm_device *dev, unsigned int resource)
  378.  {
  379.         return pci_resource_start(dev->pdev, resource);
  380.  }
  381. -EXPORT_SYMBOL(drm_get_resource_start);
  382. +EXPORT_SYMBOL(lbm_drm_get_resource_start);
  383.  
  384. -resource_size_t drm_get_resource_len(struct drm_device *dev, unsigned int resource)
  385. +resource_size_t lbm_drm_get_resource_len(struct drm_device *dev, unsigned int resource)
  386.  {
  387.         return pci_resource_len(dev->pdev, resource);
  388.  }
  389.  
  390. -EXPORT_SYMBOL(drm_get_resource_len);
  391. +EXPORT_SYMBOL(lbm_drm_get_resource_len);
  392.  
  393.  static struct drm_map_list *drm_find_matching_map(struct drm_device *dev,
  394.                                                   struct drm_local_map *map)
  395.  -101,7 +101,7 @@
  396.         if (!use_hashed_handle) {
  397.                 int ret;
  398.                 hash->key = user_token >> PAGE_SHIFT;
  399. -               ret = drm_ht_insert_item(&dev->map_hash, hash);
  400. +               ret = lbm_drm_ht_insert_item(&dev->map_hash, hash);
  401.                 if (ret != -EINVAL)
  402.                         return ret;
  403.         }
  404.  -127,7 +127,7 @@
  405.                 add |= ((user_token >> PAGE_SHIFT) & ((1UL << bits) - 1UL));
  406.         }
  407.  
  408. -       return drm_ht_just_insert_please(&dev->map_hash, hash,
  409. +       return lbm_drm_ht_just_insert_please(&dev->map_hash, hash,
  410.                                          user_token, 32 - PAGE_SHIFT - 3,
  411.                                          shift, add);
  412.  }
  413.  -249,7 +249,7 @@
  414.                 }
  415.                 map->handle = vmalloc_user(map->size);
  416.                 DRM_DEBUG("%lu %d %p\n",
  417. -                         map->size, drm_order(map->size), map->handle);
  418. +                         map->size, lbm_drm_order(map->size), map->handle);
  419.                 if (!map->handle) {
  420.                         kfree(map);
  421.                         return -ENOMEM;
  422.  -326,7 +326,7 @@
  423.                  * As we're limiting the address to 2^32-1 (or less),
  424.                  * casting it down to 32 bits is no problem, but we
  425.                  * need to point to a 64bit variable first. */
  426. -               dmah = drm_pci_alloc(dev, map->size, map->size);
  427. +               dmah = lbm_drm_pci_alloc(dev, map->size, map->size);
  428.                 if (!dmah) {
  429.                         kfree(map);
  430.                         return -ENOMEM;
  431.  -377,7 +377,7 @@
  432.         return 0;
  433.         }
  434.  
  435. -int drm_addmap(struct drm_device * dev, resource_size_t offset,
  436. +int lbm_drm_addmap(struct drm_device * dev, resource_size_t offset,
  437.                unsigned int size, enum drm_map_type type,
  438.                enum drm_map_flags flags, struct drm_local_map ** map_ptr)
  439.  {
  440.  -390,7 +390,7 @@
  441.         return rc;
  442.  }
  443.  
  444. -EXPORT_SYMBOL(drm_addmap);
  445. +EXPORT_SYMBOL(lbm_drm_addmap);
  446.  
  447.  /**
  448.   * Ioctl to specify a range of memory that is available for mapping by a
  449.  -432,9 +432,9 @@
  450.   * its being used, and free any associate resource (such as MTRR's) if it's not
  451.   * being on use.
  452.   *
  453. - * \sa drm_addmap
  454. + * \sa lbm_drm_addmap
  455.   */
  456. -int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
  457. +int lbm_drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
  458.  {
  459.         struct drm_map_list *r_list = NULL, *list_t;
  460.         drm_dma_handle_t dmah;
  461.  -495,19 +495,19 @@
  462.  
  463.         return 0;
  464.  }
  465. -EXPORT_SYMBOL(drm_rmmap_locked);
  466. +EXPORT_SYMBOL(lbm_drm_rmmap_locked);
  467.  
  468. -int drm_rmmap(struct drm_device *dev, struct drm_local_map *map)
  469. +int lbm_drm_rmmap(struct drm_device *dev, struct drm_local_map *map)
  470.  {
  471.         int ret;
  472.  
  473.         mutex_lock(&dev->struct_mutex);
  474. -       ret = drm_rmmap_locked(dev, map);
  475. +       ret = lbm_drm_rmmap_locked(dev, map);
  476.         mutex_unlock(&dev->struct_mutex);
  477.  
  478.         return ret;
  479.  }
  480. -EXPORT_SYMBOL(drm_rmmap);
  481. +EXPORT_SYMBOL(lbm_drm_rmmap);
  482.  
  483.  /* The rmmap ioctl appears to be unnecessary.  All mappings are torn down on
  484.   * the last close of the device, and this is necessary for cleanup when things
  485.  -556,7 +556,7 @@
  486.                 return 0;
  487.         }
  488.  
  489. -       ret = drm_rmmap_locked(dev, map);
  490. +       ret = lbm_drm_rmmap_locked(dev, map);
  491.  
  492.         mutex_unlock(&dev->struct_mutex);
  493.  
  494.  -579,7 +579,7 @@
  495.         if (entry->seg_count) {
  496.                 for (i = 0; i < entry->seg_count; i++) {
  497.                         if (entry->seglist[i]) {
  498. -                               drm_pci_free(dev, entry->seglist[i]);
  499. +                               lbm_drm_pci_free(dev, entry->seglist[i]);
  500.                         }
  501.                 }
  502.                 kfree(entry->seglist);
  503.  -609,7 +609,7 @@
  504.   * reallocates the buffer list of the same size order to accommodate the new
  505.   * buffers.
  506.   */
  507. -int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
  508. +int lbm_drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
  509.  {
  510.         struct drm_device_dma *dma = dev->dma;
  511.         struct drm_buf_entry *entry;
  512.  -631,7 +631,7 @@
  513.                 return -EINVAL;
  514.  
  515.         count = request->count;
  516. -       order = drm_order(request->size);
  517. +       order = lbm_drm_order(request->size);
  518.         size = 1 << order;
  519.  
  520.         alignment = (request->flags & _DRM_PAGE_ALIGN)
  521.  -774,10 +774,10 @@
  522.         atomic_dec(&dev->buf_alloc);
  523.         return 0;
  524.  }
  525. -EXPORT_SYMBOL(drm_addbufs_agp);
  526. +EXPORT_SYMBOL(lbm_drm_addbufs_agp);
  527.  #endif                         /* __OS_HAS_AGP */
  528.  
  529. -int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
  530. +int lbm_drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
  531.  {
  532.         struct drm_device_dma *dma = dev->dma;
  533.         int count;
  534.  -806,7 +806,7 @@
  535.                 return -EPERM;
  536.  
  537.         count = request->count;
  538. -       order = drm_order(request->size);
  539. +       order = lbm_drm_order(request->size);
  540.         size = 1 << order;
  541.  
  542.         DRM_DEBUG("count=%d, size=%d (%d), order=%d, queue_count=%d\n",
  543.  -885,7 +885,7 @@
  544.  
  545.         while (entry->buf_count < count) {
  546.  
  547. -               dmah = drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000);
  548. +               dmah = lbm_drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000);
  549.  
  550.                 if (!dmah) {
  551.                         /* Set count correctly so we free the proper amount. */
  552.  -985,7 +985,7 @@
  553.         return 0;
  554.  
  555.  }
  556. -EXPORT_SYMBOL(drm_addbufs_pci);
  557. +EXPORT_SYMBOL(lbm_drm_addbufs_pci);
  558.  
  559.  static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request)
  560.  {
  561.  -1014,7 +1014,7 @@
  562.                 return -EPERM;
  563.  
  564.         count = request->count;
  565. -       order = drm_order(request->size);
  566. +       order = lbm_drm_order(request->size);
  567.         size = 1 << order;
  568.  
  569.         alignment = (request->flags & _DRM_PAGE_ALIGN)
  570.  -1175,7 +1175,7 @@
  571.                 return -EPERM;
  572.  
  573.         count = request->count;
  574. -       order = drm_order(request->size);
  575. +       order = lbm_drm_order(request->size);
  576.         size = 1 << order;
  577.  
  578.         alignment = (request->flags & _DRM_PAGE_ALIGN)
  579.  -1333,7 +1333,7 @@
  580.  
  581.  #if __OS_HAS_AGP
  582.         if (request->flags & _DRM_AGP_BUFFER)
  583. -               ret = drm_addbufs_agp(dev, request);
  584. +               ret = lbm_drm_addbufs_agp(dev, request);
  585.         else
  586.  #endif
  587.         if (request->flags & _DRM_SG_BUFFER)
  588.  -1341,7 +1341,7 @@
  589.         else if (request->flags & _DRM_FB_BUFFER)
  590.                 ret = drm_addbufs_fb(dev, request);
  591.         else
  592. -               ret = drm_addbufs_pci(dev, request);
  593. +               ret = lbm_drm_addbufs_pci(dev, request);
  594.  
  595.         return ret;
  596.  }
  597.  -1458,7 +1458,7 @@
  598.  
  599.         DRM_DEBUG("%d, %d, %d\n",
  600.                   request->size, request->low_mark, request->high_mark);
  601. -       order = drm_order(request->size);
  602. +       order = lbm_drm_order(request->size);
  603.         if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
  604.                 return -EINVAL;
  605.         entry = &dma->bufs[order];
  606.  -1533,7 +1533,7 @@
  607.   *
  608.   * Maps the AGP, SG or PCI buffer region with do_mmap(), and copies information
  609.   * about each buffer into user space. For PCI buffers, it calls do_mmap() with
  610. - * offset equal to 0, which drm_mmap() interpretes as PCI buffers and calls
  611. + * offset equal to 0, which lbm_drm_mmap() interpretes as PCI buffers and calls
  612.   * drm_mmap_dma().
  613.   */
  614.  int drm_mapbufs(struct drm_device *dev, void *data,
  615.  -1636,7 +1636,7 @@
  616.   *
  617.   * \todo Can be made faster.
  618.   */
  619. -int drm_order(unsigned long size)
  620. +int lbm_drm_order(unsigned long size)
  621.  {
  622.         int order;
  623.         unsigned long tmp;
  624.  -1648,4 +1648,4 @@
  625.  
  626.         return order;
  627.  }
  628. -EXPORT_SYMBOL(drm_order);
  629. +EXPORT_SYMBOL(lbm_drm_order);
  630. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_cache.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_cache.c
  631. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_cache.c   2010-01-25 15:21:29.000000000 -0500
  632. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_cache.c   2010-02-03 17:11:08.000000000 -0500
  633.  -65,7 +65,7 @@
  634.  #endif
  635.  
  636.  void
  637. -drm_clflush_pages(struct page *pages[], unsigned long num_pages)
  638. +lbm_drm_clflush_pages(struct page *pages[], unsigned long num_pages)
  639.  {
  640.  
  641.  #if defined(CONFIG_X86)
  642.  -96,4 +96,4 @@
  643.         WARN_ON_ONCE(1);
  644.  #endif
  645.  }
  646. -EXPORT_SYMBOL(drm_clflush_pages);
  647. +EXPORT_SYMBOL(lbm_drm_clflush_pages);
  648. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc.c
  649. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc.c    2010-01-25 15:21:29.000000000 -0500
  650. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc.c    2010-02-03 17:11:08.000000000 -0500
  651.  -169,7 +169,7 @@
  652.         { DRM_MODE_ENCODER_TVDAC, "TV" },
  653.  };
  654.  
  655. -char *drm_get_encoder_name(struct drm_encoder *encoder)
  656. +char *lbm_drm_get_encoder_name(struct drm_encoder *encoder)
  657.  {
  658.         static char buf[32];
  659.  
  660.  -178,9 +178,9 @@
  661.                  encoder->base.id);
  662.         return buf;
  663.  }
  664. -EXPORT_SYMBOL(drm_get_encoder_name);
  665. +EXPORT_SYMBOL(lbm_drm_get_encoder_name);
  666.  
  667. -char *drm_get_connector_name(struct drm_connector *connector)
  668. +char *lbm_drm_get_connector_name(struct drm_connector *connector)
  669.  {
  670.         static char buf[32];
  671.  
  672.  -189,7 +189,7 @@
  673.                  connector->connector_type_id);
  674.         return buf;
  675.  }
  676. -EXPORT_SYMBOL(drm_get_connector_name);
  677. +EXPORT_SYMBOL(lbm_drm_get_connector_name);
  678.  
  679.  char *drm_get_connector_status_name(enum drm_connector_status status)
  680.  {
  681.  -257,7 +257,7 @@
  682.         mutex_unlock(&dev->mode_config.idr_mutex);
  683.  }
  684.  
  685. -struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
  686. +struct drm_mode_object *lbm_drm_mode_object_find(struct drm_device *dev,
  687.                 uint32_t id, uint32_t type)
  688.  {
  689.         struct drm_mode_object *obj = NULL;
  690.  -270,10 +270,10 @@
  691.  
  692.         return obj;
  693.  }
  694. -EXPORT_SYMBOL(drm_mode_object_find);
  695. +EXPORT_SYMBOL(lbm_drm_mode_object_find);
  696.  
  697.  /**
  698. - * drm_framebuffer_init - initialize a framebuffer
  699. + * lbm_drm_framebuffer_init - initialize a framebuffer
  700.   * @dev: DRM device
  701.   *
  702.   * LOCKING:
  703.  -285,7 +285,7 @@
  704.   * RETURNS:
  705.   * Zero on success, error code on failure.
  706.   */
  707. -int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
  708. +int lbm_drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
  709.                          const struct drm_framebuffer_funcs *funcs)
  710.  {
  711.         int ret;
  712.  -302,10 +302,10 @@
  713.  
  714.         return 0;
  715.  }
  716. -EXPORT_SYMBOL(drm_framebuffer_init);
  717. +EXPORT_SYMBOL(lbm_drm_framebuffer_init);
  718.  
  719.  /**
  720. - * drm_framebuffer_cleanup - remove a framebuffer object
  721. + * lbm_drm_framebuffer_cleanup - remove a framebuffer object
  722.   * @fb: framebuffer to remove
  723.   *
  724.   * LOCKING:
  725.  -314,7 +314,7 @@
  726.   * Scans all the CRTCs in @dev's mode_config.  If they're using @fb, removes
  727.   * it, setting it to NULL.
  728.   */
  729. -void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
  730. +void lbm_drm_framebuffer_cleanup(struct drm_framebuffer *fb)
  731.  {
  732.         struct drm_device *dev = fb->dev;
  733.         struct drm_crtc *crtc;
  734.  -338,10 +338,10 @@
  735.         list_del(&fb->head);
  736.         dev->mode_config.num_fb--;
  737.  }
  738. -EXPORT_SYMBOL(drm_framebuffer_cleanup);
  739. +EXPORT_SYMBOL(lbm_drm_framebuffer_cleanup);
  740.  
  741.  /**
  742. - * drm_crtc_init - Initialise a new CRTC object
  743. + * lbm_drm_crtc_init - Initialise a new CRTC object
  744.   * @dev: DRM device
  745.   * @crtc: CRTC object to init
  746.   * @funcs: callbacks for the new CRTC
  747.  -351,7 +351,7 @@
  748.   *
  749.   * Inits a new object created as base part of an driver crtc object.
  750.   */
  751. -void drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc,
  752. +void lbm_drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc,
  753.                    const struct drm_crtc_funcs *funcs)
  754.  {
  755.         crtc->dev = dev;
  756.  -364,10 +364,10 @@
  757.         dev->mode_config.num_crtc++;
  758.         mutex_unlock(&dev->mode_config.mutex);
  759.  }
  760. -EXPORT_SYMBOL(drm_crtc_init);
  761. +EXPORT_SYMBOL(lbm_drm_crtc_init);
  762.  
  763.  /**
  764. - * drm_crtc_cleanup - Cleans up the core crtc usage.
  765. + * lbm_drm_crtc_cleanup - Cleans up the core crtc usage.
  766.   * @crtc: CRTC to cleanup
  767.   *
  768.   * LOCKING:
  769.  -376,7 +376,7 @@
  770.   * Cleanup @crtc. Removes from drm modesetting space
  771.   * does NOT free object, caller does that.
  772.   */
  773. -void drm_crtc_cleanup(struct drm_crtc *crtc)
  774. +void lbm_drm_crtc_cleanup(struct drm_crtc *crtc)
  775.  {
  776.         struct drm_device *dev = crtc->dev;
  777.  
  778.  -389,10 +389,10 @@
  779.         list_del(&crtc->head);
  780.         dev->mode_config.num_crtc--;
  781.  }
  782. -EXPORT_SYMBOL(drm_crtc_cleanup);
  783. +EXPORT_SYMBOL(lbm_drm_crtc_cleanup);
  784.  
  785.  /**
  786. - * drm_mode_probed_add - add a mode to a connector's probed mode list
  787. + * lbm_drm_mode_probed_add - add a mode to a connector's probed mode list
  788.   * @connector: connector the new mode
  789.   * @mode: mode data
  790.   *
  791.  -401,15 +401,15 @@
  792.   *
  793.   * Add @mode to @connector's mode list for later use.
  794.   */
  795. -void drm_mode_probed_add(struct drm_connector *connector,
  796. +void lbm_drm_mode_probed_add(struct drm_connector *connector,
  797.                          struct drm_display_mode *mode)
  798.  {
  799.         list_add(&mode->head, &connector->probed_modes);
  800.  }
  801. -EXPORT_SYMBOL(drm_mode_probed_add);
  802. +EXPORT_SYMBOL(lbm_drm_mode_probed_add);
  803.  
  804.  /**
  805. - * drm_mode_remove - remove and free a mode
  806. + * lbm_drm_mode_remove - remove and free a mode
  807.   * @connector: connector list to modify
  808.   * @mode: mode to remove
  809.   *
  810.  -418,16 +418,16 @@
  811.   *
  812.   * Remove @mode from @connector's mode list, then free it.
  813.   */
  814. -void drm_mode_remove(struct drm_connector *connector,
  815. +void lbm_drm_mode_remove(struct drm_connector *connector,
  816.                      struct drm_display_mode *mode)
  817.  {
  818.         list_del(&mode->head);
  819.         kfree(mode);
  820.  }
  821. -EXPORT_SYMBOL(drm_mode_remove);
  822. +EXPORT_SYMBOL(lbm_drm_mode_remove);
  823.  
  824.  /**
  825. - * drm_connector_init - Init a preallocated connector
  826. + * lbm_drm_connector_init - Init a preallocated connector
  827.   * @dev: DRM device
  828.   * @connector: the connector to init
  829.   * @funcs: callbacks for this connector
  830.  -439,7 +439,7 @@
  831.   * Initialises a preallocated connector. Connectors should be
  832.   * subclassed as part of driver connector objects.
  833.   */
  834. -void drm_connector_init(struct drm_device *dev,
  835. +void lbm_drm_connector_init(struct drm_device *dev,
  836.                      struct drm_connector *connector,
  837.                      const struct drm_connector_funcs *funcs,
  838.                      int connector_type)
  839.  -460,18 +460,18 @@
  840.         list_add_tail(&connector->head, &dev->mode_config.connector_list);
  841.         dev->mode_config.num_connector++;
  842.  
  843. -       drm_connector_attach_property(connector,
  844. +       lbm_drm_connector_attach_property(connector,
  845.                                       dev->mode_config.edid_property, 0);
  846.  
  847. -       drm_connector_attach_property(connector,
  848. +       lbm_drm_connector_attach_property(connector,
  849.                                       dev->mode_config.dpms_property, 0);
  850.  
  851.         mutex_unlock(&dev->mode_config.mutex);
  852.  }
  853. -EXPORT_SYMBOL(drm_connector_init);
  854. +EXPORT_SYMBOL(lbm_drm_connector_init);
  855.  
  856.  /**
  857. - * drm_connector_cleanup - cleans up an initialised connector
  858. + * lbm_drm_connector_cleanup - cleans up an initialised connector
  859.   * @connector: connector to cleanup
  860.   *
  861.   * LOCKING:
  862.  -479,19 +479,19 @@
  863.   *
  864.   * Cleans up the connector but doesn't free the object.
  865.   */
  866. -void drm_connector_cleanup(struct drm_connector *connector)
  867. +void lbm_drm_connector_cleanup(struct drm_connector *connector)
  868.  {
  869.         struct drm_device *dev = connector->dev;
  870.         struct drm_display_mode *mode, *t;
  871.  
  872.         list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
  873. -               drm_mode_remove(connector, mode);
  874. +               lbm_drm_mode_remove(connector, mode);
  875.  
  876.         list_for_each_entry_safe(mode, t, &connector->modes, head)
  877. -               drm_mode_remove(connector, mode);
  878. +               lbm_drm_mode_remove(connector, mode);
  879.  
  880.         list_for_each_entry_safe(mode, t, &connector->user_modes, head)
  881. -               drm_mode_remove(connector, mode);
  882. +               lbm_drm_mode_remove(connector, mode);
  883.  
  884.         kfree(connector->fb_helper_private);
  885.         mutex_lock(&dev->mode_config.mutex);
  886.  -499,9 +499,9 @@
  887.         list_del(&connector->head);
  888.         mutex_unlock(&dev->mode_config.mutex);
  889.  }
  890. -EXPORT_SYMBOL(drm_connector_cleanup);
  891. +EXPORT_SYMBOL(lbm_drm_connector_cleanup);
  892.  
  893. -void drm_encoder_init(struct drm_device *dev,
  894. +void lbm_drm_encoder_init(struct drm_device *dev,
  895.                       struct drm_encoder *encoder,
  896.                       const struct drm_encoder_funcs *funcs,
  897.                       int encoder_type)
  898.  -519,9 +519,9 @@
  899.  
  900.         mutex_unlock(&dev->mode_config.mutex);
  901.  }
  902. -EXPORT_SYMBOL(drm_encoder_init);
  903. +EXPORT_SYMBOL(lbm_drm_encoder_init);
  904.  
  905. -void drm_encoder_cleanup(struct drm_encoder *encoder)
  906. +void lbm_drm_encoder_cleanup(struct drm_encoder *encoder)
  907.  {
  908.         struct drm_device *dev = encoder->dev;
  909.         mutex_lock(&dev->mode_config.mutex);
  910.  -529,10 +529,10 @@
  911.         list_del(&encoder->head);
  912.         mutex_unlock(&dev->mode_config.mutex);
  913.  }
  914. -EXPORT_SYMBOL(drm_encoder_cleanup);
  915. +EXPORT_SYMBOL(lbm_drm_encoder_cleanup);
  916.  
  917.  /**
  918. - * drm_mode_create - create a new display mode
  919. + * lbm_drm_mode_create - create a new display mode
  920.   * @dev: DRM device
  921.   *
  922.   * LOCKING:
  923.  -543,7 +543,7 @@
  924.   * RETURNS:
  925.   * Pointer to new mode on success, NULL on error.
  926.   */
  927. -struct drm_display_mode *drm_mode_create(struct drm_device *dev)
  928. +struct drm_display_mode *lbm_drm_mode_create(struct drm_device *dev)
  929.  {
  930.         struct drm_display_mode *nmode;
  931.  
  932.  -554,10 +554,10 @@
  933.         drm_mode_object_get(dev, &nmode->base, DRM_MODE_OBJECT_MODE);
  934.         return nmode;
  935.  }
  936. -EXPORT_SYMBOL(drm_mode_create);
  937. +EXPORT_SYMBOL(lbm_drm_mode_create);
  938.  
  939.  /**
  940. - * drm_mode_destroy - remove a mode
  941. + * lbm_drm_mode_destroy - remove a mode
  942.   * @dev: DRM device
  943.   * @mode: mode to remove
  944.   *
  945.  -566,13 +566,13 @@
  946.   *
  947.   * Free @mode's unique identifier, then free it.
  948.   */
  949. -void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)
  950. +void lbm_drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)
  951.  {
  952.         drm_mode_object_put(dev, &mode->base);
  953.  
  954.         kfree(mode);
  955.  }
  956. -EXPORT_SYMBOL(drm_mode_destroy);
  957. +EXPORT_SYMBOL(lbm_drm_mode_destroy);
  958.  
  959.  static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
  960.  {
  961.  -583,15 +583,15 @@
  962.         /*
  963.          * Standard properties (apply to all connectors)
  964.          */
  965. -       edid = drm_property_create(dev, DRM_MODE_PROP_BLOB |
  966. +       edid = lbm_drm_property_create(dev, DRM_MODE_PROP_BLOB |
  967.                                    DRM_MODE_PROP_IMMUTABLE,
  968.                                    "EDID", 0);
  969.         dev->mode_config.edid_property = edid;
  970.  
  971. -       dpms = drm_property_create(dev, DRM_MODE_PROP_ENUM,
  972. +       dpms = lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM,
  973.                                    "DPMS", ARRAY_SIZE(drm_dpms_enum_list));
  974.         for (i = 0; i < ARRAY_SIZE(drm_dpms_enum_list); i++)
  975. -               drm_property_add_enum(dpms, i, drm_dpms_enum_list[i].type,
  976. +               lbm_drm_property_add_enum(dpms, i, drm_dpms_enum_list[i].type,
  977.                                       drm_dpms_enum_list[i].name);
  978.         dev->mode_config.dpms_property = dpms;
  979.  
  980.  -599,12 +599,12 @@
  981.  }
  982.  
  983.  /**
  984. - * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
  985. + * lbm_drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
  986.   * @dev: DRM device
  987.   *
  988.   * Called by a driver the first time a DVI-I connector is made.
  989.   */
  990. -int drm_mode_create_dvi_i_properties(struct drm_device *dev)
  991. +int lbm_drm_mode_create_dvi_i_properties(struct drm_device *dev)
  992.  {
  993.         struct drm_property *dvi_i_selector;
  994.         struct drm_property *dvi_i_subconnector;
  995.  -614,29 +614,29 @@
  996.                 return 0;
  997.  
  998.         dvi_i_selector =
  999. -               drm_property_create(dev, DRM_MODE_PROP_ENUM,
  1000. +               lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM,
  1001.                                     "select subconnector",
  1002.                                     ARRAY_SIZE(drm_dvi_i_select_enum_list));
  1003.         for (i = 0; i < ARRAY_SIZE(drm_dvi_i_select_enum_list); i++)
  1004. -               drm_property_add_enum(dvi_i_selector, i,
  1005. +               lbm_drm_property_add_enum(dvi_i_selector, i,
  1006.                                       drm_dvi_i_select_enum_list[i].type,
  1007.                                       drm_dvi_i_select_enum_list[i].name);
  1008.         dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
  1009.  
  1010.         dvi_i_subconnector =
  1011. -               drm_property_create(dev, DRM_MODE_PROP_ENUM |
  1012. +               lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM |
  1013.                                     DRM_MODE_PROP_IMMUTABLE,
  1014.                                     "subconnector",
  1015.                                     ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
  1016.         for (i = 0; i < ARRAY_SIZE(drm_dvi_i_subconnector_enum_list); i++)
  1017. -               drm_property_add_enum(dvi_i_subconnector, i,
  1018. +               lbm_drm_property_add_enum(dvi_i_subconnector, i,
  1019.                                       drm_dvi_i_subconnector_enum_list[i].type,
  1020.                                       drm_dvi_i_subconnector_enum_list[i].name);
  1021.         dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
  1022.  
  1023.         return 0;
  1024.  }
  1025. -EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
  1026. +EXPORT_SYMBOL(lbm_drm_mode_create_dvi_i_properties);
  1027.  
  1028.  /**
  1029.   * drm_create_tv_properties - create TV specific connector properties
  1030.  -649,7 +649,7 @@
  1031.   * responsible for allocating a list of format names and passing them to
  1032.   * this routine.
  1033.   */
  1034. -int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
  1035. +int lbm_drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
  1036.                                   char *modes[])
  1037.  {
  1038.         struct drm_property *tv_selector;
  1039.  -662,21 +662,21 @@
  1040.         /*
  1041.          * Basic connector properties
  1042.          */
  1043. -       tv_selector = drm_property_create(dev, DRM_MODE_PROP_ENUM,
  1044. +       tv_selector = lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM,
  1045.                                           "select subconnector",
  1046.                                           ARRAY_SIZE(drm_tv_select_enum_list));
  1047.         for (i = 0; i < ARRAY_SIZE(drm_tv_select_enum_list); i++)
  1048. -               drm_property_add_enum(tv_selector, i,
  1049. +               lbm_drm_property_add_enum(tv_selector, i,
  1050.                                       drm_tv_select_enum_list[i].type,
  1051.                                       drm_tv_select_enum_list[i].name);
  1052.         dev->mode_config.tv_select_subconnector_property = tv_selector;
  1053.  
  1054.         tv_subconnector =
  1055. -               drm_property_create(dev, DRM_MODE_PROP_ENUM |
  1056. +               lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM |
  1057.                                     DRM_MODE_PROP_IMMUTABLE, "subconnector",
  1058.                                     ARRAY_SIZE(drm_tv_subconnector_enum_list));
  1059.         for (i = 0; i < ARRAY_SIZE(drm_tv_subconnector_enum_list); i++)
  1060. -               drm_property_add_enum(tv_subconnector, i,
  1061. +               lbm_drm_property_add_enum(tv_subconnector, i,
  1062.                                       drm_tv_subconnector_enum_list[i].type,
  1063.                                       drm_tv_subconnector_enum_list[i].name);
  1064.         dev->mode_config.tv_subconnector_property = tv_subconnector;
  1065.  -685,84 +685,84 @@
  1066.          * Other, TV specific properties: margins & TV modes.
  1067.          */
  1068.         dev->mode_config.tv_left_margin_property =
  1069. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1070. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1071.                                     "left margin", 2);
  1072.         dev->mode_config.tv_left_margin_property->values[0] = 0;
  1073.         dev->mode_config.tv_left_margin_property->values[1] = 100;
  1074.  
  1075.         dev->mode_config.tv_right_margin_property =
  1076. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1077. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1078.                                     "right margin", 2);
  1079.         dev->mode_config.tv_right_margin_property->values[0] = 0;
  1080.         dev->mode_config.tv_right_margin_property->values[1] = 100;
  1081.  
  1082.         dev->mode_config.tv_top_margin_property =
  1083. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1084. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1085.                                     "top margin", 2);
  1086.         dev->mode_config.tv_top_margin_property->values[0] = 0;
  1087.         dev->mode_config.tv_top_margin_property->values[1] = 100;
  1088.  
  1089.         dev->mode_config.tv_bottom_margin_property =
  1090. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1091. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1092.                                     "bottom margin", 2);
  1093.         dev->mode_config.tv_bottom_margin_property->values[0] = 0;
  1094.         dev->mode_config.tv_bottom_margin_property->values[1] = 100;
  1095.  
  1096.         dev->mode_config.tv_mode_property =
  1097. -               drm_property_create(dev, DRM_MODE_PROP_ENUM,
  1098. +               lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM,
  1099.                                     "mode", num_modes);
  1100.         for (i = 0; i < num_modes; i++)
  1101. -               drm_property_add_enum(dev->mode_config.tv_mode_property, i,
  1102. +               lbm_drm_property_add_enum(dev->mode_config.tv_mode_property, i,
  1103.                                       i, modes[i]);
  1104.  
  1105.         dev->mode_config.tv_brightness_property =
  1106. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1107. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1108.                                     "brightness", 2);
  1109.         dev->mode_config.tv_brightness_property->values[0] = 0;
  1110.         dev->mode_config.tv_brightness_property->values[1] = 100;
  1111.  
  1112.         dev->mode_config.tv_contrast_property =
  1113. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1114. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1115.                                     "contrast", 2);
  1116.         dev->mode_config.tv_contrast_property->values[0] = 0;
  1117.         dev->mode_config.tv_contrast_property->values[1] = 100;
  1118.  
  1119.         dev->mode_config.tv_flicker_reduction_property =
  1120. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1121. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1122.                                     "flicker reduction", 2);
  1123.         dev->mode_config.tv_flicker_reduction_property->values[0] = 0;
  1124.         dev->mode_config.tv_flicker_reduction_property->values[1] = 100;
  1125.  
  1126.         dev->mode_config.tv_overscan_property =
  1127. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1128. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1129.                                     "overscan", 2);
  1130.         dev->mode_config.tv_overscan_property->values[0] = 0;
  1131.         dev->mode_config.tv_overscan_property->values[1] = 100;
  1132.  
  1133.         dev->mode_config.tv_saturation_property =
  1134. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1135. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1136.                                     "saturation", 2);
  1137.         dev->mode_config.tv_saturation_property->values[0] = 0;
  1138.         dev->mode_config.tv_saturation_property->values[1] = 100;
  1139.  
  1140.         dev->mode_config.tv_hue_property =
  1141. -               drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1142. +               lbm_drm_property_create(dev, DRM_MODE_PROP_RANGE,
  1143.                                     "hue", 2);
  1144.         dev->mode_config.tv_hue_property->values[0] = 0;
  1145.         dev->mode_config.tv_hue_property->values[1] = 100;
  1146.  
  1147.         return 0;
  1148.  }
  1149. -EXPORT_SYMBOL(drm_mode_create_tv_properties);
  1150. +EXPORT_SYMBOL(lbm_drm_mode_create_tv_properties);
  1151.  
  1152.  /**
  1153. - * drm_mode_create_scaling_mode_property - create scaling mode property
  1154. + * lbm_drm_mode_create_scaling_mode_property - create scaling mode property
  1155.   * @dev: DRM device
  1156.   *
  1157.   * Called by a driver the first time it's needed, must be attached to desired
  1158.   * connectors.
  1159.   */
  1160. -int drm_mode_create_scaling_mode_property(struct drm_device *dev)
  1161. +int lbm_drm_mode_create_scaling_mode_property(struct drm_device *dev)
  1162.  {
  1163.         struct drm_property *scaling_mode;
  1164.         int i;
  1165.  -771,10 +771,10 @@
  1166.                 return 0;
  1167.  
  1168.         scaling_mode =
  1169. -               drm_property_create(dev, DRM_MODE_PROP_ENUM, "scaling mode",
  1170. +               lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM, "scaling mode",
  1171.                                     ARRAY_SIZE(drm_scaling_mode_enum_list));
  1172.         for (i = 0; i < ARRAY_SIZE(drm_scaling_mode_enum_list); i++)
  1173. -               drm_property_add_enum(scaling_mode, i,
  1174. +               lbm_drm_property_add_enum(scaling_mode, i,
  1175.                                       drm_scaling_mode_enum_list[i].type,
  1176.                                       drm_scaling_mode_enum_list[i].name);
  1177.  
  1178.  -782,16 +782,16 @@
  1179.  
  1180.         return 0;
  1181.  }
  1182. -EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
  1183. +EXPORT_SYMBOL(lbm_drm_mode_create_scaling_mode_property);
  1184.  
  1185.  /**
  1186. - * drm_mode_create_dithering_property - create dithering property
  1187. + * lbm_drm_mode_create_dithering_property - create dithering property
  1188.   * @dev: DRM device
  1189.   *
  1190.   * Called by a driver the first time it's needed, must be attached to desired
  1191.   * connectors.
  1192.   */
  1193. -int drm_mode_create_dithering_property(struct drm_device *dev)
  1194. +int lbm_drm_mode_create_dithering_property(struct drm_device *dev)
  1195.  {
  1196.         struct drm_property *dithering_mode;
  1197.         int i;
  1198.  -800,17 +800,17 @@
  1199.                 return 0;
  1200.  
  1201.         dithering_mode =
  1202. -               drm_property_create(dev, DRM_MODE_PROP_ENUM, "dithering",
  1203. +               lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM, "dithering",
  1204.                                     ARRAY_SIZE(drm_dithering_mode_enum_list));
  1205.         for (i = 0; i < ARRAY_SIZE(drm_dithering_mode_enum_list); i++)
  1206. -               drm_property_add_enum(dithering_mode, i,
  1207. +               lbm_drm_property_add_enum(dithering_mode, i,
  1208.                                       drm_dithering_mode_enum_list[i].type,
  1209.                                       drm_dithering_mode_enum_list[i].name);
  1210.         dev->mode_config.dithering_mode_property = dithering_mode;
  1211.  
  1212.         return 0;
  1213.  }
  1214. -EXPORT_SYMBOL(drm_mode_create_dithering_property);
  1215. +EXPORT_SYMBOL(lbm_drm_mode_create_dithering_property);
  1216.  
  1217.  /**
  1218.   * drm_mode_create_dirty_property - create dirty property
  1219.  -819,7 +819,7 @@
  1220.   * Called by a driver the first time it's needed, must be attached to desired
  1221.   * connectors.
  1222.   */
  1223. -int drm_mode_create_dirty_info_property(struct drm_device *dev)
  1224. +int lbm_drm_mode_create_dirty_info_property(struct drm_device *dev)
  1225.  {
  1226.         struct drm_property *dirty_info;
  1227.         int i;
  1228.  -828,22 +828,22 @@
  1229.                 return 0;
  1230.  
  1231.         dirty_info =
  1232. -               drm_property_create(dev, DRM_MODE_PROP_ENUM |
  1233. +               lbm_drm_property_create(dev, DRM_MODE_PROP_ENUM |
  1234.                                     DRM_MODE_PROP_IMMUTABLE,
  1235.                                     "dirty",
  1236.                                     ARRAY_SIZE(drm_dirty_info_enum_list));
  1237.         for (i = 0; i < ARRAY_SIZE(drm_dirty_info_enum_list); i++)
  1238. -               drm_property_add_enum(dirty_info, i,
  1239. +               lbm_drm_property_add_enum(dirty_info, i,
  1240.                                       drm_dirty_info_enum_list[i].type,
  1241.                                       drm_dirty_info_enum_list[i].name);
  1242.         dev->mode_config.dirty_info_property = dirty_info;
  1243.  
  1244.         return 0;
  1245.  }
  1246. -EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
  1247. +EXPORT_SYMBOL(lbm_drm_mode_create_dirty_info_property);
  1248.  
  1249.  /**
  1250. - * drm_mode_config_init - initialize DRM mode_configuration structure
  1251. + * lbm_drm_mode_config_init - initialize DRM mode_configuration structure
  1252.   * @dev: DRM device
  1253.   *
  1254.   * LOCKING:
  1255.  -852,7 +852,7 @@
  1256.   * Initialize @dev's mode_config structure, used for tracking the graphics
  1257.   * configuration of @dev.
  1258.   */
  1259. -void drm_mode_config_init(struct drm_device *dev)
  1260. +void lbm_drm_mode_config_init(struct drm_device *dev)
  1261.  {
  1262.         mutex_init(&dev->mode_config.mutex);
  1263.         mutex_init(&dev->mode_config.idr_mutex);
  1264.  -875,7 +875,7 @@
  1265.         dev->mode_config.num_crtc = 0;
  1266.         dev->mode_config.num_encoder = 0;
  1267.  }
  1268. -EXPORT_SYMBOL(drm_mode_config_init);
  1269. +EXPORT_SYMBOL(lbm_drm_mode_config_init);
  1270.  
  1271.  int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group)
  1272.  {
  1273.  -924,7 +924,7 @@
  1274.  }
  1275.  
  1276.  /**
  1277. - * drm_mode_config_cleanup - free up DRM mode_config info
  1278. + * lbm_drm_mode_config_cleanup - free up DRM mode_config info
  1279.   * @dev: DRM device
  1280.   *
  1281.   * LOCKING:
  1282.  -935,7 +935,7 @@
  1283.   *
  1284.   * FIXME: cleanup any dangling user buffer objects too
  1285.   */
  1286. -void drm_mode_config_cleanup(struct drm_device *dev)
  1287. +void lbm_drm_mode_config_cleanup(struct drm_device *dev)
  1288.  {
  1289.         struct drm_connector *connector, *ot;
  1290.         struct drm_crtc *crtc, *ct;
  1291.  -955,7 +955,7 @@
  1292.  
  1293.         list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
  1294.                                  head) {
  1295. -               drm_property_destroy(dev, property);
  1296. +               lbm_drm_property_destroy(dev, property);
  1297.         }
  1298.  
  1299.         list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
  1300.  -967,7 +967,7 @@
  1301.         }
  1302.  
  1303.  }
  1304. -EXPORT_SYMBOL(drm_mode_config_cleanup);
  1305. +EXPORT_SYMBOL(lbm_drm_mode_config_cleanup);
  1306.  
  1307.  /**
  1308.   * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo
  1309.  -1244,7 +1244,7 @@
  1310.  
  1311.         mutex_lock(&dev->mode_config.mutex);
  1312.  
  1313. -       obj = drm_mode_object_find(dev, crtc_resp->crtc_id,
  1314. +       obj = lbm_drm_mode_object_find(dev, crtc_resp->crtc_id,
  1315.                                    DRM_MODE_OBJECT_CRTC);
  1316.         if (!obj) {
  1317.                 ret = -EINVAL;
  1318.  -1316,7 +1316,7 @@
  1319.  
  1320.         mutex_lock(&dev->mode_config.mutex);
  1321.  
  1322. -       obj = drm_mode_object_find(dev, out_resp->connector_id,
  1323. +       obj = lbm_drm_mode_object_find(dev, out_resp->connector_id,
  1324.                                    DRM_MODE_OBJECT_CONNECTOR);
  1325.         if (!obj) {
  1326.                 ret = -EINVAL;
  1327.  -1430,7 +1430,7 @@
  1328.         int ret = 0;
  1329.  
  1330.         mutex_lock(&dev->mode_config.mutex);
  1331. -       obj = drm_mode_object_find(dev, enc_resp->encoder_id,
  1332. +       obj = lbm_drm_mode_object_find(dev, enc_resp->encoder_id,
  1333.                                    DRM_MODE_OBJECT_ENCODER);
  1334.         if (!obj) {
  1335.                 ret = -EINVAL;
  1336.  -1485,7 +1485,7 @@
  1337.         int i;
  1338.  
  1339.         mutex_lock(&dev->mode_config.mutex);
  1340. -       obj = drm_mode_object_find(dev, crtc_req->crtc_id,
  1341. +       obj = lbm_drm_mode_object_find(dev, crtc_req->crtc_id,
  1342.                                    DRM_MODE_OBJECT_CRTC);
  1343.         if (!obj) {
  1344.                 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
  1345.  -1507,7 +1507,7 @@
  1346.                                 }
  1347.                         }
  1348.                 } else {
  1349. -                       obj = drm_mode_object_find(dev, crtc_req->fb_id,
  1350. +                       obj = lbm_drm_mode_object_find(dev, crtc_req->fb_id,
  1351.                                                    DRM_MODE_OBJECT_FB);
  1352.                         if (!obj) {
  1353.                                 DRM_DEBUG_KMS("Unknown FB ID%d\n",
  1354.  -1518,9 +1518,9 @@
  1355.                         fb = obj_to_fb(obj);
  1356.                 }
  1357.  
  1358. -               mode = drm_mode_create(dev);
  1359. +               mode = lbm_drm_mode_create(dev);
  1360.                 drm_crtc_convert_umode(mode, &crtc_req->mode);
  1361. -               drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
  1362. +               lbm_drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
  1363.         }
  1364.  
  1365.         if (crtc_req->count_connectors == 0 && mode) {
  1366.  -1560,7 +1560,7 @@
  1367.                                 goto out;
  1368.                         }
  1369.  
  1370. -                       obj = drm_mode_object_find(dev, out_id,
  1371. +                       obj = lbm_drm_mode_object_find(dev, out_id,
  1372.                                                    DRM_MODE_OBJECT_CONNECTOR);
  1373.                         if (!obj) {
  1374.                                 DRM_DEBUG_KMS("Connector id %d unknown\n",
  1375.  -1603,7 +1603,7 @@
  1376.         }
  1377.  
  1378.         mutex_lock(&dev->mode_config.mutex);
  1379. -       obj = drm_mode_object_find(dev, req->crtc_id, DRM_MODE_OBJECT_CRTC);
  1380. +       obj = lbm_drm_mode_object_find(dev, req->crtc_id, DRM_MODE_OBJECT_CRTC);
  1381.         if (!obj) {
  1382.                 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
  1383.                 ret = -EINVAL;
  1384.  -1718,7 +1718,7 @@
  1385.         int found = 0;
  1386.  
  1387.         mutex_lock(&dev->mode_config.mutex);
  1388. -       obj = drm_mode_object_find(dev, *id, DRM_MODE_OBJECT_FB);
  1389. +       obj = lbm_drm_mode_object_find(dev, *id, DRM_MODE_OBJECT_FB);
  1390.         /* TODO check that we realy get a framebuffer back. */
  1391.         if (!obj) {
  1392.                 DRM_ERROR("mode invalid framebuffer id\n");
  1393.  -1774,7 +1774,7 @@
  1394.         int ret = 0;
  1395.  
  1396.         mutex_lock(&dev->mode_config.mutex);
  1397. -       obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB);
  1398. +       obj = lbm_drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB);
  1399.         if (!obj) {
  1400.                 DRM_ERROR("invalid framebuffer id\n");
  1401.                 ret = -EINVAL;
  1402.  -1807,7 +1807,7 @@
  1403.         int ret = 0;
  1404.  
  1405.         mutex_lock(&dev->mode_config.mutex);
  1406. -       obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB);
  1407. +       obj = lbm_drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB);
  1408.         if (!obj) {
  1409.                 DRM_ERROR("invalid framebuffer id\n");
  1410.                 ret = -EINVAL;
  1411.  -1904,7 +1904,7 @@
  1412.         return ret;
  1413.  }
  1414.  
  1415. -int drm_mode_attachmode_crtc(struct drm_device *dev, struct drm_crtc *crtc,
  1416. +int lbm_drm_mode_attachmode_crtc(struct drm_device *dev, struct drm_crtc *crtc,
  1417.                              struct drm_display_mode *mode)
  1418.  {
  1419.         struct drm_connector *connector;
  1420.  -1916,7 +1916,7 @@
  1421.                         break;
  1422.                 if (connector->encoder->crtc == crtc) {
  1423.                         if (need_dup)
  1424. -                               dup_mode = drm_mode_duplicate(dev, mode);
  1425. +                               dup_mode = lbm_drm_mode_duplicate(dev, mode);
  1426.                         else
  1427.                                 dup_mode = mode;
  1428.                         ret = drm_mode_attachmode(dev, connector, dup_mode);
  1429.  -1927,7 +1927,7 @@
  1430.         }
  1431.         return 0;
  1432.  }
  1433. -EXPORT_SYMBOL(drm_mode_attachmode_crtc);
  1434. +EXPORT_SYMBOL(lbm_drm_mode_attachmode_crtc);
  1435.  
  1436.  static int drm_mode_detachmode(struct drm_device *dev,
  1437.                                struct drm_connector *connector,
  1438.  -1938,9 +1938,9 @@
  1439.         struct drm_display_mode *match_mode, *t;
  1440.  
  1441.         list_for_each_entry_safe(match_mode, t, &connector->user_modes, head) {
  1442. -               if (drm_mode_equal(match_mode, mode)) {
  1443. +               if (lbm_drm_mode_equal(match_mode, mode)) {
  1444.                         list_del(&match_mode->head);
  1445. -                       drm_mode_destroy(dev, match_mode);
  1446. +                       lbm_drm_mode_destroy(dev, match_mode);
  1447.                         found = 1;
  1448.                         break;
  1449.                 }
  1450.  -1952,7 +1952,7 @@
  1451.         return ret;
  1452.  }
  1453.  
  1454. -int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode)
  1455. +int lbm_drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode)
  1456.  {
  1457.         struct drm_connector *connector;
  1458.  
  1459.  -1961,7 +1961,7 @@
  1460.         }
  1461.         return 0;
  1462.  }
  1463. -EXPORT_SYMBOL(drm_mode_detachmode_crtc);
  1464. +EXPORT_SYMBOL(lbm_drm_mode_detachmode_crtc);
  1465.  
  1466.  /**
  1467.   * drm_fb_attachmode - Attach a user mode to an connector
  1468.  -1988,14 +1988,14 @@
  1469.  
  1470.         mutex_lock(&dev->mode_config.mutex);
  1471.  
  1472. -       obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR);
  1473. +       obj = lbm_drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR);
  1474.         if (!obj) {
  1475.                 ret = -EINVAL;
  1476.                 goto out;
  1477.         }
  1478.         connector = obj_to_connector(obj);
  1479.  
  1480. -       mode = drm_mode_create(dev);
  1481. +       mode = lbm_drm_mode_create(dev);
  1482.         if (!mode) {
  1483.                 ret = -ENOMEM;
  1484.                 goto out;
  1485.  -2034,7 +2034,7 @@
  1486.  
  1487.         mutex_lock(&dev->mode_config.mutex);
  1488.  
  1489. -       obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR);
  1490. +       obj = lbm_drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR);
  1491.         if (!obj) {
  1492.                 ret = -EINVAL;
  1493.                 goto out;
  1494.  -2048,7 +2048,7 @@
  1495.         return ret;
  1496.  }
  1497.  
  1498. -struct drm_property *drm_property_create(struct drm_device *dev, int flags,
  1499. +struct drm_property *lbm_drm_property_create(struct drm_device *dev, int flags,
  1500.                                          const char *name, int num_values)
  1501.  {
  1502.         struct drm_property *property = NULL;
  1503.  -2077,9 +2077,9 @@
  1504.         kfree(property);
  1505.         return NULL;
  1506.  }
  1507. -EXPORT_SYMBOL(drm_property_create);
  1508. +EXPORT_SYMBOL(lbm_drm_property_create);
  1509.  
  1510. -int drm_property_add_enum(struct drm_property *property, int index,
  1511. +int lbm_drm_property_add_enum(struct drm_property *property, int index,
  1512.                           uint64_t value, const char *name)
  1513.  {
  1514.         struct drm_property_enum *prop_enum;
  1515.  -2109,9 +2109,9 @@
  1516.         list_add_tail(&prop_enum->head, &property->enum_blob_list);
  1517.         return 0;
  1518.  }
  1519. -EXPORT_SYMBOL(drm_property_add_enum);
  1520. +EXPORT_SYMBOL(lbm_drm_property_add_enum);
  1521.  
  1522. -void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
  1523. +void lbm_drm_property_destroy(struct drm_device *dev, struct drm_property *property)
  1524.  {
  1525.         struct drm_property_enum *prop_enum, *pt;
  1526.  
  1527.  -2126,9 +2126,9 @@
  1528.         list_del(&property->head);
  1529.         kfree(property);
  1530.  }
  1531. -EXPORT_SYMBOL(drm_property_destroy);
  1532. +EXPORT_SYMBOL(lbm_drm_property_destroy);
  1533.  
  1534. -int drm_connector_attach_property(struct drm_connector *connector,
  1535. +int lbm_drm_connector_attach_property(struct drm_connector *connector,
  1536.                                struct drm_property *property, uint64_t init_val)
  1537.  {
  1538.         int i;
  1539.  -2145,9 +2145,9 @@
  1540.                 return -EINVAL;
  1541.         return 0;
  1542.  }
  1543. -EXPORT_SYMBOL(drm_connector_attach_property);
  1544. +EXPORT_SYMBOL(lbm_drm_connector_attach_property);
  1545.  
  1546. -int drm_connector_property_set_value(struct drm_connector *connector,
  1547. +int lbm_drm_connector_property_set_value(struct drm_connector *connector,
  1548.                                   struct drm_property *property, uint64_t value)
  1549.  {
  1550.         int i;
  1551.  -2163,9 +2163,9 @@
  1552.                 return -EINVAL;
  1553.         return 0;
  1554.  }
  1555. -EXPORT_SYMBOL(drm_connector_property_set_value);
  1556. +EXPORT_SYMBOL(lbm_drm_connector_property_set_value);
  1557.  
  1558. -int drm_connector_property_get_value(struct drm_connector *connector,
  1559. +int lbm_drm_connector_property_get_value(struct drm_connector *connector,
  1560.                                   struct drm_property *property, uint64_t *val)
  1561.  {
  1562.         int i;
  1563.  -2181,7 +2181,7 @@
  1564.                 return -EINVAL;
  1565.         return 0;
  1566.  }
  1567. -EXPORT_SYMBOL(drm_connector_property_get_value);
  1568. +EXPORT_SYMBOL(lbm_drm_connector_property_get_value);
  1569.  
  1570.  int drm_mode_getproperty_ioctl(struct drm_device *dev,
  1571.                                void *data, struct drm_file *file_priv)
  1572.  -2202,7 +2202,7 @@
  1573.         uint32_t __user *blob_length_ptr;
  1574.  
  1575.         mutex_lock(&dev->mode_config.mutex);
  1576. -       obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY);
  1577. +       obj = lbm_drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY);
  1578.         if (!obj) {
  1579.                 ret = -EINVAL;
  1580.                 goto done;
  1581.  -2324,7 +2324,7 @@
  1582.         void *blob_ptr;
  1583.  
  1584.         mutex_lock(&dev->mode_config.mutex);
  1585. -       obj = drm_mode_object_find(dev, out_resp->blob_id, DRM_MODE_OBJECT_BLOB);
  1586. +       obj = lbm_drm_mode_object_find(dev, out_resp->blob_id, DRM_MODE_OBJECT_BLOB);
  1587.         if (!obj) {
  1588.                 ret = -EINVAL;
  1589.                 goto done;
  1590.  -2345,7 +2345,7 @@
  1591.         return ret;
  1592.  }
  1593.  
  1594. -int drm_mode_connector_update_edid_property(struct drm_connector *connector,
  1595. +int lbm_drm_mode_connector_update_edid_property(struct drm_connector *connector,
  1596.                                             struct edid *edid)
  1597.  {
  1598.         struct drm_device *dev = connector->dev;
  1599.  -2357,19 +2357,19 @@
  1600.         /* Delete edid, when there is none. */
  1601.         if (!edid) {
  1602.                 connector->edid_blob_ptr = NULL;
  1603. -               ret = drm_connector_property_set_value(connector, dev->mode_config.edid_property, 0);
  1604. +               ret = lbm_drm_connector_property_set_value(connector, dev->mode_config.edid_property, 0);
  1605.                 return ret;
  1606.         }
  1607.  
  1608.         connector->edid_blob_ptr = drm_property_create_blob(connector->dev, 128, edid);
  1609.  
  1610. -       ret = drm_connector_property_set_value(connector,
  1611. +       ret = lbm_drm_connector_property_set_value(connector,
  1612.                                                dev->mode_config.edid_property,
  1613.                                                connector->edid_blob_ptr->base.id);
  1614.  
  1615.         return ret;
  1616.  }
  1617. -EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
  1618. +EXPORT_SYMBOL(lbm_drm_mode_connector_update_edid_property);
  1619.  
  1620.  int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
  1621.                                        void *data, struct drm_file *file_priv)
  1622.  -2383,7 +2383,7 @@
  1623.  
  1624.         mutex_lock(&dev->mode_config.mutex);
  1625.  
  1626. -       obj = drm_mode_object_find(dev, out_resp->connector_id, DRM_MODE_OBJECT_CONNECTOR);
  1627. +       obj = lbm_drm_mode_object_find(dev, out_resp->connector_id, DRM_MODE_OBJECT_CONNECTOR);
  1628.         if (!obj) {
  1629.                 goto out;
  1630.         }
  1631.  -2398,7 +2398,7 @@
  1632.                 goto out;
  1633.         }
  1634.  
  1635. -       obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY);
  1636. +       obj = lbm_drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY);
  1637.         if (!obj) {
  1638.                 goto out;
  1639.         }
  1640.  -2436,13 +2436,13 @@
  1641.  
  1642.         /* store the property value if successful */
  1643.         if (!ret)
  1644. -               drm_connector_property_set_value(connector, property, out_resp->value);
  1645. +               lbm_drm_connector_property_set_value(connector, property, out_resp->value);
  1646.  out:
  1647.         mutex_unlock(&dev->mode_config.mutex);
  1648.         return ret;
  1649.  }
  1650.  
  1651. -int drm_mode_connector_attach_encoder(struct drm_connector *connector,
  1652. +int lbm_drm_mode_connector_attach_encoder(struct drm_connector *connector,
  1653.                                       struct drm_encoder *encoder)
  1654.  {
  1655.         int i;
  1656.  -2455,9 +2455,9 @@
  1657.         }
  1658.         return -ENOMEM;
  1659.  }
  1660. -EXPORT_SYMBOL(drm_mode_connector_attach_encoder);
  1661. +EXPORT_SYMBOL(lbm_drm_mode_connector_attach_encoder);
  1662.  
  1663. -void drm_mode_connector_detach_encoder(struct drm_connector *connector,
  1664. +void lbm_drm_mode_connector_detach_encoder(struct drm_connector *connector,
  1665.                                     struct drm_encoder *encoder)
  1666.  {
  1667.         int i;
  1668.  -2470,9 +2470,9 @@
  1669.                 }
  1670.         }
  1671.  }
  1672. -EXPORT_SYMBOL(drm_mode_connector_detach_encoder);
  1673. +EXPORT_SYMBOL(lbm_drm_mode_connector_detach_encoder);
  1674.  
  1675. -bool drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
  1676. +bool lbm_drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
  1677.                                   int gamma_size)
  1678.  {
  1679.         crtc->gamma_size = gamma_size;
  1680.  -2485,7 +2485,7 @@
  1681.  
  1682.         return true;
  1683.  }
  1684. -EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
  1685. +EXPORT_SYMBOL(lbm_drm_mode_crtc_set_gamma_size);
  1686.  
  1687.  int drm_mode_gamma_set_ioctl(struct drm_device *dev,
  1688.                              void *data, struct drm_file *file_priv)
  1689.  -2498,7 +2498,7 @@
  1690.         int ret = 0;
  1691.  
  1692.         mutex_lock(&dev->mode_config.mutex);
  1693. -       obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
  1694. +       obj = lbm_drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
  1695.         if (!obj) {
  1696.                 ret = -EINVAL;
  1697.                 goto out;
  1698.  -2549,7 +2549,7 @@
  1699.         int ret = 0;
  1700.  
  1701.         mutex_lock(&dev->mode_config.mutex);
  1702. -       obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
  1703. +       obj = lbm_drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
  1704.         if (!obj) {
  1705.                 ret = -EINVAL;
  1706.                 goto out;
  1707.  -2601,7 +2601,7 @@
  1708.                 return -EINVAL;
  1709.  
  1710.         mutex_lock(&dev->mode_config.mutex);
  1711. -       obj = drm_mode_object_find(dev, page_flip->crtc_id, DRM_MODE_OBJECT_CRTC);
  1712. +       obj = lbm_drm_mode_object_find(dev, page_flip->crtc_id, DRM_MODE_OBJECT_CRTC);
  1713.         if (!obj)
  1714.                 goto out;
  1715.         crtc = obj_to_crtc(obj);
  1716.  -2609,7 +2609,7 @@
  1717.         if (crtc->funcs->page_flip == NULL)
  1718.                 goto out;
  1719.  
  1720. -       obj = drm_mode_object_find(dev, page_flip->fb_id, DRM_MODE_OBJECT_FB);
  1721. +       obj = lbm_drm_mode_object_find(dev, page_flip->fb_id, DRM_MODE_OBJECT_FB);
  1722.         if (!obj)
  1723.                 goto out;
  1724.         fb = obj_to_fb(obj);
  1725. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc_helper.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc_helper.c
  1726. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc_helper.c     2010-01-25 15:21:29.000000000 -0500
  1727. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_crtc_helper.c     2010-02-03 17:11:08.000000000 -0500
  1728.  -55,7 +55,7 @@
  1729.  }
  1730.  
  1731.  /**
  1732. - * drm_helper_probe_connector_modes - get complete set of display modes
  1733. + * lbm_drm_helper_probe_connector_modes - get complete set of display modes
  1734.   * @dev: DRM device
  1735.   * @maxX: max width for modes
  1736.   * @maxY: max height for modes
  1737.  -76,7 +76,7 @@
  1738.   * RETURNS:
  1739.   * Number of modes found on @connector.
  1740.   */
  1741. -int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
  1742. +int lbm_drm_helper_probe_single_connector_modes(struct drm_connector *connector,
  1743.                                             uint32_t maxX, uint32_t maxY)
  1744.  {
  1745.         struct drm_device *dev = connector->dev;
  1746.  -86,7 +86,7 @@
  1747.         int count = 0;
  1748.         int mode_flags = 0;
  1749.  
  1750. -       DRM_DEBUG_KMS("%s\n", drm_get_connector_name(connector));
  1751. +       DRM_DEBUG_KMS("%s\n", lbm_drm_get_connector_name(connector));
  1752.         /* set all modes to the unverified state */
  1753.         list_for_each_entry_safe(mode, t, &connector->modes, head)
  1754.                 mode->status = MODE_UNVERIFIED;
  1755.  -103,21 +103,21 @@
  1756.  
  1757.         if (connector->status == connector_status_disconnected) {
  1758.                 DRM_DEBUG_KMS("%s is disconnected\n",
  1759. -                         drm_get_connector_name(connector));
  1760. +                         lbm_drm_get_connector_name(connector));
  1761.                 goto prune;
  1762.         }
  1763.  
  1764.         count = (*connector_funcs->get_modes)(connector);
  1765.         if (!count) {
  1766. -               count = drm_add_modes_noedid(connector, 1024, 768);
  1767. +               count = lbm_drm_add_modes_noedid(connector, 1024, 768);
  1768.                 if (!count)
  1769.                         return 0;
  1770.         }
  1771.  
  1772. -       drm_mode_connector_list_update(connector);
  1773. +       lbm_drm_mode_connector_list_update(connector);
  1774.  
  1775.         if (maxX && maxY)
  1776. -               drm_mode_validate_size(dev, &connector->modes, maxX,
  1777. +               lbm_drm_mode_validate_size(dev, &connector->modes, maxX,
  1778.                                        maxY, 0);
  1779.  
  1780.         if (connector->interlace_allowed)
  1781.  -133,43 +133,43 @@
  1782.         }
  1783.  
  1784.  prune:
  1785. -       drm_mode_prune_invalid(dev, &connector->modes, true);
  1786. +       lbm_drm_mode_prune_invalid(dev, &connector->modes, true);
  1787.  
  1788.         if (list_empty(&connector->modes))
  1789.                 return 0;
  1790.  
  1791. -       drm_mode_sort(&connector->modes);
  1792. +       lbm_drm_mode_sort(&connector->modes);
  1793.  
  1794.         DRM_DEBUG_KMS("Probed modes for %s\n",
  1795. -                               drm_get_connector_name(connector));
  1796. +                               lbm_drm_get_connector_name(connector));
  1797.         list_for_each_entry_safe(mode, t, &connector->modes, head) {
  1798. -               mode->vrefresh = drm_mode_vrefresh(mode);
  1799. +               mode->vrefresh = lbm_drm_mode_vrefresh(mode);
  1800.  
  1801. -               drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
  1802. -               drm_mode_debug_printmodeline(mode);
  1803. +               lbm_drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
  1804. +               lbm_drm_mode_debug_printmodeline(mode);
  1805.         }
  1806.  
  1807.         return count;
  1808.  }
  1809. -EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
  1810. +EXPORT_SYMBOL(lbm_drm_helper_probe_single_connector_modes);
  1811.  
  1812. -int drm_helper_probe_connector_modes(struct drm_device *dev, uint32_t maxX,
  1813. +int lbm_drm_helper_probe_connector_modes(struct drm_device *dev, uint32_t maxX,
  1814.                                       uint32_t maxY)
  1815.  {
  1816.         struct drm_connector *connector;
  1817.         int count = 0;
  1818.  
  1819.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1820. -               count += drm_helper_probe_single_connector_modes(connector,
  1821. +               count += lbm_drm_helper_probe_single_connector_modes(connector,
  1822.                                                                  maxX, maxY);
  1823.         }
  1824.  
  1825.         return count;
  1826.  }
  1827. -EXPORT_SYMBOL(drm_helper_probe_connector_modes);
  1828. +EXPORT_SYMBOL(lbm_drm_helper_probe_connector_modes);
  1829.  
  1830.  /**
  1831. - * drm_helper_encoder_in_use - check if a given encoder is in use
  1832. + * lbm_drm_helper_encoder_in_use - check if a given encoder is in use
  1833.   * @encoder: encoder to check
  1834.   *
  1835.   * LOCKING:
  1836.  -180,7 +180,7 @@
  1837.   * RETURNS:
  1838.   * True if @encoder is part of the mode_config, false otherwise.
  1839.   */
  1840. -bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
  1841. +bool lbm_drm_helper_encoder_in_use(struct drm_encoder *encoder)
  1842.  {
  1843.         struct drm_connector *connector;
  1844.         struct drm_device *dev = encoder->dev;
  1845.  -189,10 +189,10 @@
  1846.                         return true;
  1847.         return false;
  1848.  }
  1849. -EXPORT_SYMBOL(drm_helper_encoder_in_use);
  1850. +EXPORT_SYMBOL(lbm_drm_helper_encoder_in_use);
  1851.  
  1852.  /**
  1853. - * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
  1854. + * lbm_drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
  1855.   * @crtc: CRTC to check
  1856.   *
  1857.   * LOCKING:
  1858.  -203,20 +203,20 @@
  1859.   * RETURNS:
  1860.   * True if @crtc is part of the mode_config, false otherwise.
  1861.   */
  1862. -bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
  1863. +bool lbm_drm_helper_crtc_in_use(struct drm_crtc *crtc)
  1864.  {
  1865.         struct drm_encoder *encoder;
  1866.         struct drm_device *dev = crtc->dev;
  1867.         /* FIXME: Locking around list access? */
  1868.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
  1869. -               if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
  1870. +               if (encoder->crtc == crtc && lbm_drm_helper_encoder_in_use(encoder))
  1871.                         return true;
  1872.         return false;
  1873.  }
  1874. -EXPORT_SYMBOL(drm_helper_crtc_in_use);
  1875. +EXPORT_SYMBOL(lbm_drm_helper_crtc_in_use);
  1876.  
  1877.  /**
  1878. - * drm_helper_disable_unused_functions - disable unused objects
  1879. + * lbm_drm_helper_disable_unused_functions - disable unused objects
  1880.   * @dev: DRM device
  1881.   *
  1882.   * LOCKING:
  1883.  -225,7 +225,7 @@
  1884.   * If an connector or CRTC isn't part of @dev's mode_config, it can be disabled
  1885.   * by calling its dpms function, which should power it off.
  1886.   */
  1887. -void drm_helper_disable_unused_functions(struct drm_device *dev)
  1888. +void lbm_drm_helper_disable_unused_functions(struct drm_device *dev)
  1889.  {
  1890.         struct drm_encoder *encoder;
  1891.         struct drm_connector *connector;
  1892.  -241,7 +241,7 @@
  1893.  
  1894.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  1895.                 encoder_funcs = encoder->helper_private;
  1896. -               if (!drm_helper_encoder_in_use(encoder)) {
  1897. +               if (!lbm_drm_helper_encoder_in_use(encoder)) {
  1898.                         if (encoder_funcs->disable)
  1899.                                 (*encoder_funcs->disable)(encoder);
  1900.                         else
  1901.  -253,22 +253,22 @@
  1902.  
  1903.         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
  1904.                 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  1905. -               crtc->enabled = drm_helper_crtc_in_use(crtc);
  1906. +               crtc->enabled = lbm_drm_helper_crtc_in_use(crtc);
  1907.                 if (!crtc->enabled) {
  1908.                         crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
  1909.                         crtc->fb = NULL;
  1910.                 }
  1911.         }
  1912.  }
  1913. -EXPORT_SYMBOL(drm_helper_disable_unused_functions);
  1914. +EXPORT_SYMBOL(lbm_drm_helper_disable_unused_functions);
  1915.  
  1916.  static struct drm_display_mode *drm_has_preferred_mode(struct drm_connector *connector, int width, int height)
  1917.  {
  1918.         struct drm_display_mode *mode;
  1919.  
  1920.         list_for_each_entry(mode, &connector->modes, head) {
  1921. -               if (drm_mode_width(mode) > width ||
  1922. -                   drm_mode_height(mode) > height)
  1923. +               if (lbm_drm_mode_width(mode) > width ||
  1924. +                   lbm_drm_mode_height(mode) > height)
  1925.                         continue;
  1926.                 if (mode->type & DRM_MODE_TYPE_PREFERRED)
  1927.                         return mode;
  1928.  -326,12 +326,12 @@
  1929.         }
  1930.  
  1931.  create_mode:
  1932. -       mode = drm_cvt_mode(connector->dev, cmdline_mode->xres,
  1933. +       mode = lbm_drm_cvt_mode(connector->dev, cmdline_mode->xres,
  1934.                             cmdline_mode->yres,
  1935.                             cmdline_mode->refresh_specified ? cmdline_mode->refresh : 60,
  1936.                             cmdline_mode->rb, cmdline_mode->interlace,
  1937.                             cmdline_mode->margins);
  1938. -       drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
  1939. +       lbm_drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
  1940.         list_add(&mode->head, &connector->modes);
  1941.         return mode;
  1942.  }
  1943.  -626,7 +626,7 @@
  1944.   * RETURNS:
  1945.   * True if the mode was set successfully, or false otherwise.
  1946.   */
  1947. -bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
  1948. +bool lbm_drm_crtc_helper_set_mode(struct drm_crtc *crtc,
  1949.                               struct drm_display_mode *mode,
  1950.                               int x, int y,
  1951.                               struct drm_framebuffer *old_fb)
  1952.  -639,9 +639,9 @@
  1953.         struct drm_encoder *encoder;
  1954.         bool ret = true;
  1955.  
  1956. -       adjusted_mode = drm_mode_duplicate(dev, mode);
  1957. +       adjusted_mode = lbm_drm_mode_duplicate(dev, mode);
  1958.  
  1959. -       crtc->enabled = drm_helper_crtc_in_use(crtc);
  1960. +       crtc->enabled = lbm_drm_helper_crtc_in_use(crtc);
  1961.  
  1962.         if (!crtc->enabled)
  1963.                 return true;
  1964.  -702,7 +702,7 @@
  1965.                 if (encoder->crtc != crtc)
  1966.                         continue;
  1967.  
  1968. -               DRM_INFO("%s: set mode %s %x\n", drm_get_encoder_name(encoder),
  1969. +               DRM_DEBUG("%s: set mode %s %x\n", lbm_drm_get_encoder_name(encoder),
  1970.                          mode->name, mode->base.id);
  1971.                 encoder_funcs = encoder->helper_private;
  1972.                 encoder_funcs->mode_set(encoder, mode, adjusted_mode);
  1973.  -722,7 +722,7 @@
  1974.         }
  1975.  
  1976.         /* XXX free adjustedmode */
  1977. -       drm_mode_destroy(dev, adjusted_mode);
  1978. +       lbm_drm_mode_destroy(dev, adjusted_mode);
  1979.         /* FIXME: add subpixel order */
  1980.  done:
  1981.         if (!ret) {
  1982.  -733,11 +733,11 @@
  1983.  
  1984.         return ret;
  1985.  }
  1986. -EXPORT_SYMBOL(drm_crtc_helper_set_mode);
  1987. +EXPORT_SYMBOL(lbm_drm_crtc_helper_set_mode);
  1988.  
  1989.  
  1990.  /**
  1991. - * drm_crtc_helper_set_config - set a new config from userspace
  1992. + * lbm_drm_crtc_helper_set_config - set a new config from userspace
  1993.   * @crtc: CRTC to setup
  1994.   * @crtc_info: user provided configuration
  1995.   * @new_mode: new mode to set
  1996.  -753,7 +753,7 @@
  1997.   * RETURNS:
  1998.   * Zero. (FIXME)
  1999.   */
  2000. -int drm_crtc_helper_set_config(struct drm_mode_set *set)
  2001. +int lbm_drm_crtc_helper_set_config(struct drm_mode_set *set)
  2002.  {
  2003.         struct drm_device *dev;
  2004.         struct drm_crtc *save_crtcs, *new_crtc, *crtc;
  2005.  -847,10 +847,10 @@
  2006.         if (set->x != set->crtc->x || set->y != set->crtc->y)
  2007.                 fb_changed = true;
  2008.  
  2009. -       if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
  2010. +       if (set->mode && !lbm_drm_mode_equal(set->mode, &set->crtc->mode)) {
  2011.                 DRM_DEBUG_KMS("modes are different, full mode set\n");
  2012. -               drm_mode_debug_printmodeline(&set->crtc->mode);
  2013. -               drm_mode_debug_printmodeline(set->mode);
  2014. +               lbm_drm_mode_debug_printmodeline(&set->crtc->mode);
  2015. +               lbm_drm_mode_debug_printmodeline(set->mode);
  2016.                 mode_changed = true;
  2017.         }
  2018.  
  2019.  -930,8 +930,8 @@
  2020.                 if (set->mode != NULL) {
  2021.                         DRM_DEBUG_KMS("attempting to set mode from"
  2022.                                         " userspace\n");
  2023. -                       drm_mode_debug_printmodeline(set->mode);
  2024. -                       if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
  2025. +                       lbm_drm_mode_debug_printmodeline(set->mode);
  2026. +                       if (!lbm_drm_crtc_helper_set_mode(set->crtc, set->mode,
  2027.                                                       set->x, set->y,
  2028.                                                       old_fb)) {
  2029.                                 DRM_ERROR("failed to set mode on crtc %p\n",
  2030.  -944,7 +944,7 @@
  2031.                         set->crtc->desired_y = set->y;
  2032.                         set->crtc->desired_mode = set->mode;
  2033.                 }
  2034. -               drm_helper_disable_unused_functions(dev);
  2035. +               lbm_drm_helper_disable_unused_functions(dev);
  2036.         } else if (fb_changed) {
  2037.                 set->crtc->x = set->x;
  2038.                 set->crtc->y = set->y;
  2039.  -985,13 +985,13 @@
  2040.         kfree(save_crtcs);
  2041.         return ret;
  2042.  }
  2043. -EXPORT_SYMBOL(drm_crtc_helper_set_config);
  2044. +EXPORT_SYMBOL(lbm_drm_crtc_helper_set_config);
  2045.  
  2046.  bool drm_helper_plugged_event(struct drm_device *dev)
  2047.  {
  2048.         DRM_DEBUG_KMS("\n");
  2049.  
  2050. -       drm_helper_probe_connector_modes(dev, dev->mode_config.max_width,
  2051. +       lbm_drm_helper_probe_connector_modes(dev, dev->mode_config.max_width,
  2052.                                          dev->mode_config.max_height);
  2053.  
  2054.         drm_setup_crtcs(dev);
  2055.  -1016,23 +1016,24 @@
  2056.   * RETURNS:
  2057.   * Zero if everything went ok, nonzero otherwise.
  2058.   */
  2059. -bool drm_helper_initial_config(struct drm_device *dev)
  2060. +bool lbm_drm_helper_initial_config(struct drm_device *dev)
  2061.  {
  2062.         int count = 0;
  2063.  
  2064.         /* disable all the possible outputs/crtcs before entering KMS mode */
  2065. -       drm_helper_disable_unused_functions(dev);
  2066. +       lbm_drm_helper_disable_unused_functions(dev);
  2067.  
  2068.         drm_fb_helper_parse_command_line(dev);
  2069.  
  2070. -       count = drm_helper_probe_connector_modes(dev,
  2071. +       count = lbm_drm_helper_probe_connector_modes(dev,
  2072.                                                  dev->mode_config.max_width,
  2073.                                                  dev->mode_config.max_height);
  2074.  
  2075.         /*
  2076.          * we shouldn't end up with no modes here.
  2077.          */
  2078. -       printk(KERN_INFO "No connectors reported conncted with modes\n");
  2079. +       if (count == 0)
  2080. +               printk(KERN_INFO "No connectors reported connected with modes\n");
  2081.  
  2082.         drm_setup_crtcs(dev);
  2083.  
  2084.  -1041,7 +1042,7 @@
  2085.  
  2086.         return 0;
  2087.  }
  2088. -EXPORT_SYMBOL(drm_helper_initial_config);
  2089. +EXPORT_SYMBOL(lbm_drm_helper_initial_config);
  2090.  
  2091.  static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
  2092.  {
  2093.  -1070,14 +1071,14 @@
  2094.  }
  2095.  
  2096.  /**
  2097. - * drm_helper_connector_dpms
  2098. + * lbm_drm_helper_connector_dpms
  2099.   * @connector affected connector
  2100.   * @mode DPMS mode
  2101.   *
  2102.   * Calls the low-level connector DPMS function, then
  2103.   * calls appropriate encoder and crtc DPMS functions as well
  2104.   */
  2105. -void drm_helper_connector_dpms(struct drm_connector *connector, int mode)
  2106. +void lbm_drm_helper_connector_dpms(struct drm_connector *connector, int mode)
  2107.  {
  2108.         struct drm_encoder *encoder = connector->encoder;
  2109.         struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
  2110.  -1123,7 +1124,7 @@
  2111.  
  2112.         return;
  2113.  }
  2114. -EXPORT_SYMBOL(drm_helper_connector_dpms);
  2115. +EXPORT_SYMBOL(lbm_drm_helper_connector_dpms);
  2116.  
  2117.  /**
  2118.   * drm_hotplug_stage_two
  2119.  -1138,15 +1139,15 @@
  2120.   * RETURNS:
  2121.   * Zero on success, errno on failure.
  2122.   */
  2123. -int drm_helper_hotplug_stage_two(struct drm_device *dev)
  2124. +int lbm_drm_helper_hotplug_stage_two(struct drm_device *dev)
  2125.  {
  2126.         drm_helper_plugged_event(dev);
  2127.  
  2128.         return 0;
  2129.  }
  2130. -EXPORT_SYMBOL(drm_helper_hotplug_stage_two);
  2131. +EXPORT_SYMBOL(lbm_drm_helper_hotplug_stage_two);
  2132.  
  2133. -int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
  2134. +int lbm_drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
  2135.                                    struct drm_mode_fb_cmd *mode_cmd)
  2136.  {
  2137.         fb->width = mode_cmd->width;
  2138.  -1157,9 +1158,9 @@
  2139.  
  2140.         return 0;
  2141.  }
  2142. -EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
  2143. +EXPORT_SYMBOL(lbm_drm_helper_mode_fill_fb_struct);
  2144.  
  2145. -int drm_helper_resume_force_mode(struct drm_device *dev)
  2146. +int lbm_drm_helper_resume_force_mode(struct drm_device *dev)
  2147.  {
  2148.         struct drm_crtc *crtc;
  2149.         struct drm_encoder *encoder;
  2150.  -1172,7 +1173,7 @@
  2151.                 if (!crtc->enabled)
  2152.                         continue;
  2153.  
  2154. -               ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
  2155. +               ret = lbm_drm_crtc_helper_set_mode(crtc, &crtc->mode,
  2156.                                                crtc->x, crtc->y, crtc->fb);
  2157.  
  2158.                 if (ret == false)
  2159.  -1198,7 +1199,7 @@
  2160.                 }
  2161.         }
  2162.         /* disable the unused connectors while restoring the modesetting */
  2163. -       drm_helper_disable_unused_functions(dev);
  2164. +       lbm_drm_helper_disable_unused_functions(dev);
  2165.         return 0;
  2166.  }
  2167. -EXPORT_SYMBOL(drm_helper_resume_force_mode);
  2168. +EXPORT_SYMBOL(lbm_drm_helper_resume_force_mode);
  2169. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_debugfs.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_debugfs.c
  2170. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_debugfs.c 2010-01-25 15:21:29.000000000 -0500
  2171. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_debugfs.c 2010-02-03 17:11:08.000000000 -0500
  2172.  -84,7 +84,7 @@
  2173.   * Create a given set of debugfs files represented by an array of
  2174.   * gdm_debugfs_lists in the given root directory.
  2175.   */
  2176. -int drm_debugfs_create_files(struct drm_info_list *files, int count,
  2177. +int lbm_drm_debugfs_create_files(struct drm_info_list *files, int count,
  2178.                              struct dentry *root, struct drm_minor *minor)
  2179.  {
  2180.         struct drm_device *dev = minor->dev;
  2181.  -123,10 +123,10 @@
  2182.         return 0;
  2183.  
  2184.  fail:
  2185. -       drm_debugfs_remove_files(files, count, minor);
  2186. +       lbm_drm_debugfs_remove_files(files, count, minor);
  2187.         return ret;
  2188.  }
  2189. -EXPORT_SYMBOL(drm_debugfs_create_files);
  2190. +EXPORT_SYMBOL(lbm_drm_debugfs_create_files);
  2191.  
  2192.  /**
  2193.   * Initialize the DRI debugfs filesystem for a device
  2194.  -154,7 +154,7 @@
  2195.                 return -1;
  2196.         }
  2197.  
  2198. -       ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES,
  2199. +       ret = lbm_drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES,
  2200.                                        minor->debugfs_root, minor);
  2201.         if (ret) {
  2202.                 debugfs_remove(minor->debugfs_root);
  2203.  -185,7 +185,7 @@
  2204.   *
  2205.   * Remove all debugfs entries created by debugfs_init().
  2206.   */
  2207. -int drm_debugfs_remove_files(struct drm_info_list *files, int count,
  2208. +int lbm_drm_debugfs_remove_files(struct drm_info_list *files, int count,
  2209.                              struct drm_minor *minor)
  2210.  {
  2211.         struct list_head *pos, *q;
  2212.  -204,7 +204,7 @@
  2213.         }
  2214.         return 0;
  2215.  }
  2216. -EXPORT_SYMBOL(drm_debugfs_remove_files);
  2217. +EXPORT_SYMBOL(lbm_drm_debugfs_remove_files);
  2218.  
  2219.  /**
  2220.   * Cleanup the debugfs filesystem resources.
  2221.  -224,7 +224,7 @@
  2222.         if (dev->driver->debugfs_cleanup)
  2223.                 dev->driver->debugfs_cleanup(minor);
  2224.  
  2225. -       drm_debugfs_remove_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor);
  2226. +       lbm_drm_debugfs_remove_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor);
  2227.  
  2228.         debugfs_remove(minor->debugfs_root);
  2229.         minor->debugfs_root = NULL;
  2230. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dma.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dma.c
  2231. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dma.c     2010-01-25 15:21:29.000000000 -0500
  2232. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dma.c     2010-02-03 17:11:08.000000000 -0500
  2233.  -85,7 +85,7 @@
  2234.                                   dma->bufs[i].seg_count);
  2235.                         for (j = 0; j < dma->bufs[i].seg_count; j++) {
  2236.                                 if (dma->bufs[i].seglist[j]) {
  2237. -                                       drm_pci_free(dev, dma->bufs[i].seglist[j]);
  2238. +                                       lbm_drm_pci_free(dev, dma->bufs[i].seglist[j]);
  2239.                                 }
  2240.                         }
  2241.                         kfree(dma->bufs[i].seglist);
  2242.  -135,7 +135,7 @@
  2243.   *
  2244.   * Frees each buffer associated with \p file_priv not already on the hardware.
  2245.   */
  2246. -void drm_core_reclaim_buffers(struct drm_device *dev,
  2247. +void lbm_drm_core_reclaim_buffers(struct drm_device *dev,
  2248.                               struct drm_file *file_priv)
  2249.  {
  2250.         struct drm_device_dma *dma = dev->dma;
  2251.  -160,4 +160,4 @@
  2252.         }
  2253.  }
  2254.  
  2255. -EXPORT_SYMBOL(drm_core_reclaim_buffers);
  2256. +EXPORT_SYMBOL(lbm_drm_core_reclaim_buffers);
  2257. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dp_i2c_helper.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dp_i2c_helper.c
  2258. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dp_i2c_helper.c   2010-01-25 15:21:29.000000000 -0500
  2259. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_dp_i2c_helper.c   2010-02-03 17:11:09.000000000 -0500
  2260.  -196,7 +196,7 @@
  2261.  }
  2262.  
  2263.  int
  2264. -i2c_dp_aux_add_bus(struct i2c_adapter *adapter)
  2265. +lbm_i2c_dp_aux_add_bus(struct i2c_adapter *adapter)
  2266.  {
  2267.         int error;
  2268.        
  2269.  -206,4 +206,4 @@
  2270.         error = i2c_add_adapter(adapter);
  2271.         return error;
  2272.  }
  2273. -EXPORT_SYMBOL(i2c_dp_aux_add_bus);
  2274. +EXPORT_SYMBOL(lbm_i2c_dp_aux_add_bus);
  2275. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drawable.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drawable.c
  2276. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drawable.c        2010-01-25 15:21:29.000000000 -0500
  2277. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drawable.c        2010-02-03 17:11:09.000000000 -0500
  2278.  -80,7 +80,7 @@
  2279.  
  2280.         spin_lock_irqsave(&dev->drw_lock, irqflags);
  2281.  
  2282. -       info = drm_get_drawable_info(dev, draw->handle);
  2283. +       info = lbm_drm_get_drawable_info(dev, draw->handle);
  2284.         if (info == NULL) {
  2285.                 spin_unlock_irqrestore(&dev->drw_lock, irqflags);
  2286.                 return -EINVAL;
  2287.  -173,11 +173,11 @@
  2288.  /**
  2289.   * Caller must hold the drawable spinlock!
  2290.   */
  2291. -struct drm_drawable_info *drm_get_drawable_info(struct drm_device *dev, drm_drawable_t id)
  2292. +struct drm_drawable_info *lbm_drm_get_drawable_info(struct drm_device *dev, drm_drawable_t id)
  2293.  {
  2294.         return idr_find(&dev->drw_idr, id);
  2295.  }
  2296. -EXPORT_SYMBOL(drm_get_drawable_info);
  2297. +EXPORT_SYMBOL(lbm_drm_get_drawable_info);
  2298.  
  2299.  static int drm_drawable_free(int idr, void *p, void *data)
  2300.  {
  2301. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drv.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drv.c
  2302. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drv.c     2010-01-25 15:21:29.000000000 -0500
  2303. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_drv.c     2010-02-03 17:11:08.000000000 -0500
  2304.  -172,7 +172,7 @@
  2305.         DRM_DEBUG("driver lastclose completed\n");
  2306.  
  2307.         if (dev->irq_enabled && !drm_core_check_feature(dev, DRIVER_MODESET))
  2308. -               drm_irq_uninstall(dev);
  2309. +               lbm_drm_irq_uninstall(dev);
  2310.  
  2311.         mutex_lock(&dev->struct_mutex);
  2312.  
  2313.  -189,14 +189,14 @@
  2314.                    intact until drv_cleanup is called. */
  2315.                 list_for_each_entry_safe(entry, tempe, &dev->agp->memory, head) {
  2316.                         if (entry->bound)
  2317. -                               drm_unbind_agp(entry->memory);
  2318. -                       drm_free_agp(entry->memory, entry->pages);
  2319. +                               lbm_drm_unbind_agp(entry->memory);
  2320. +                       lbm_drm_free_agp(entry->memory, entry->pages);
  2321.                         kfree(entry);
  2322.                 }
  2323.                 INIT_LIST_HEAD(&dev->agp->memory);
  2324.  
  2325.                 if (dev->agp->acquired)
  2326. -                       drm_agp_release(dev);
  2327. +                       lbm_drm_agp_release(dev);
  2328.  
  2329.                 dev->agp->acquired = 0;
  2330.                 dev->agp->enabled = 0;
  2331.  -247,7 +247,7 @@
  2332.   * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
  2333.   * after the initialization for driver customization.
  2334.   */
  2335. -int drm_init(struct drm_driver *driver)
  2336. +int lbm_drm_init(struct drm_driver *driver)
  2337.  {
  2338.         struct pci_dev *pdev = NULL;
  2339.         const struct pci_device_id *pid;
  2340.  -279,15 +279,15 @@
  2341.  
  2342.                         /* stealth mode requires a manual probe */
  2343.                         pci_dev_get(pdev);
  2344. -                       drm_get_dev(pdev, pid, driver);
  2345. +                       lbm_drm_get_dev(pdev, pid, driver);
  2346.                 }
  2347.         }
  2348.         return 0;
  2349.  }
  2350.  
  2351. -EXPORT_SYMBOL(drm_init);
  2352. +EXPORT_SYMBOL(lbm_drm_init);
  2353.  
  2354. -void drm_exit(struct drm_driver *driver)
  2355. +void lbm_drm_exit(struct drm_driver *driver)
  2356.  {
  2357.         struct drm_device *dev, *tmp;
  2358.         DRM_DEBUG("\n");
  2359.  -296,13 +296,13 @@
  2360.                 pci_unregister_driver(&driver->pci_driver);
  2361.         } else {
  2362.                 list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item)
  2363. -                       drm_put_dev(dev);
  2364. +                       lbm_drm_put_dev(dev);
  2365.         }
  2366.  
  2367.         DRM_INFO("Module unloaded\n");
  2368.  }
  2369.  
  2370. -EXPORT_SYMBOL(drm_exit);
  2371. +EXPORT_SYMBOL(lbm_drm_exit);
  2372.  
  2373.  /** File operations structure */
  2374.  static const struct file_operations drm_stub_fops = {
  2375.  -316,24 +316,24 @@
  2376.  
  2377.         idr_init(&drm_minors_idr);
  2378.  
  2379. -       if (register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops))
  2380. +       if (register_chrdev(DRM_MAJOR, "lbm-drm", &drm_stub_fops))
  2381.                 goto err_p1;
  2382.  
  2383. -       drm_class = drm_sysfs_create(THIS_MODULE, "drm");
  2384. +       drm_class = drm_sysfs_create(THIS_MODULE, "lbm-drm");
  2385.         if (IS_ERR(drm_class)) {
  2386.                 printk(KERN_ERR "DRM: Error creating drm class.\n");
  2387.                 ret = PTR_ERR(drm_class);
  2388.                 goto err_p2;
  2389.         }
  2390.  
  2391. -       drm_proc_root = proc_mkdir("dri", NULL);
  2392. +       drm_proc_root = proc_mkdir("lbm-dri", NULL);
  2393.         if (!drm_proc_root) {
  2394.                 DRM_ERROR("Cannot create /proc/dri\n");
  2395.                 ret = -1;
  2396.                 goto err_p3;
  2397.         }
  2398.  
  2399. -       drm_debugfs_root = debugfs_create_dir("dri", NULL);
  2400. +       drm_debugfs_root = debugfs_create_dir("lbm-dri", NULL);
  2401.         if (!drm_debugfs_root) {
  2402.                 DRM_ERROR("Cannot create /sys/kernel/debug/dri\n");
  2403.                 ret = -1;
  2404.  -346,7 +346,7 @@
  2405.  err_p3:
  2406.         drm_sysfs_destroy();
  2407.  err_p2:
  2408. -       unregister_chrdev(DRM_MAJOR, "drm");
  2409. +       unregister_chrdev(DRM_MAJOR, "lbm-drm");
  2410.  
  2411.         idr_destroy(&drm_minors_idr);
  2412.  err_p1:
  2413.  -355,11 +355,11 @@
  2414.  
  2415.  static void __exit drm_core_exit(void)
  2416.  {
  2417. -       remove_proc_entry("dri", NULL);
  2418. +       remove_proc_entry("lbm-dri", NULL);
  2419.         debugfs_remove(drm_debugfs_root);
  2420.         drm_sysfs_destroy();
  2421.  
  2422. -       unregister_chrdev(DRM_MAJOR, "drm");
  2423. +       unregister_chrdev(DRM_MAJOR, "lbm-drm");
  2424.  
  2425.         idr_destroy(&drm_minors_idr);
  2426.  }
  2427.  -434,7 +434,7 @@
  2428.   * Looks up the ioctl function in the ::ioctls table, checking for root
  2429.   * previleges if so required, and dispatches to the respective function.
  2430.   */
  2431. -long drm_ioctl(struct file *filp,
  2432. +long lbm_drm_ioctl(struct file *filp,
  2433.               unsigned int cmd, unsigned long arg)
  2434.  {
  2435.         struct drm_file *file_priv = filp->private_data;
  2436.  -526,9 +526,9 @@
  2437.         return retcode;
  2438.  }
  2439.  
  2440. -EXPORT_SYMBOL(drm_ioctl);
  2441. +EXPORT_SYMBOL(lbm_drm_ioctl);
  2442.  
  2443. -struct drm_local_map *drm_getsarea(struct drm_device *dev)
  2444. +struct drm_local_map *lbm_drm_getsarea(struct drm_device *dev)
  2445.  {
  2446.         struct drm_map_list *entry;
  2447.  
  2448.  -540,4 +540,4 @@
  2449.         }
  2450.         return NULL;
  2451.  }
  2452. -EXPORT_SYMBOL(drm_getsarea);
  2453. +EXPORT_SYMBOL(lbm_drm_getsarea);
  2454. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_edid.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_edid.c
  2455. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_edid.c    2010-01-25 15:21:29.000000000 -0500
  2456. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_edid.c    2010-02-03 17:11:08.000000000 -0500
  2457.  -3,7 +3,7 @@
  2458.   * Copyright (c) 2007-2008 Intel Corporation
  2459.   *   Jesse Barnes <jesse.barnes@intel.com>
  2460.   *
  2461. - * DDC probing routines (drm_ddc_read & drm_do_probe_ddc_edid) originally from
  2462. + * DDC probing routines (drm_ddc_read & lbm_drm_do_probe_ddc_edid) originally from
  2463.   * FB layer.
  2464.   *   Copyright (C) 2006 Dennis Munsie <dmunsie@cecropia.com>
  2465.   *
  2466.  -505,9 +505,9 @@
  2467.                 ptr = &drm_dmt_modes[i];
  2468.                 if (hsize == ptr->hdisplay &&
  2469.                         vsize == ptr->vdisplay &&
  2470. -                       fresh == drm_mode_vrefresh(ptr)) {
  2471. +                       fresh == lbm_drm_mode_vrefresh(ptr)) {
  2472.                         /* get the expected default mode */
  2473. -                       mode = drm_mode_duplicate(dev, ptr);
  2474. +                       mode = lbm_drm_mode_duplicate(dev, ptr);
  2475.                         break;
  2476.                 }
  2477.         }
  2478.  -571,7 +571,7 @@
  2479.                 vsize = (hsize * 9) / 16;
  2480.         /* HDTV hack */
  2481.         if (hsize == 1360 && vsize == 765 && vrefresh_rate == 60) {
  2482. -               mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0,
  2483. +               mode = lbm_drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0,
  2484.                                     false);
  2485.                 mode->hdisplay = 1366;
  2486.                 mode->vsync_start = mode->vsync_start - 1;
  2487.  -588,10 +588,10 @@
  2488.         case LEVEL_DMT:
  2489.                 break;
  2490.         case LEVEL_GTF:
  2491. -               mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
  2492. +               mode = lbm_drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
  2493.                 break;
  2494.         case LEVEL_CVT:
  2495. -               mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0,
  2496. +               mode = lbm_drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0,
  2497.                                     false);
  2498.                 break;
  2499.         }
  2500.  -633,8 +633,7 @@
  2501.                 return NULL;
  2502.         }
  2503.         if (!(pt->misc & DRM_EDID_PT_SEPARATE_SYNC)) {
  2504. -               printk(KERN_WARNING "integrated sync not supported\n");
  2505. -               return NULL;
  2506. +               printk(KERN_WARNING "composite sync not supported\n");
  2507.         }
  2508.  
  2509.         /* it is incorrect if hsync/vsync width is zero */
  2510.  -643,7 +642,7 @@
  2511.                                 "Wrong Hsync/Vsync pulse width\n");
  2512.                 return NULL;
  2513.         }
  2514. -       mode = drm_mode_create(dev);
  2515. +       mode = lbm_drm_mode_create(dev);
  2516.         if (!mode)
  2517.                 return NULL;
  2518.  
  2519.  -667,7 +666,7 @@
  2520.         /* perform the basic check for the detailed timing */
  2521.         if (mode->hsync_end > mode->htotal ||
  2522.                 mode->vsync_end > mode->vtotal) {
  2523. -               drm_mode_destroy(dev, mode);
  2524. +               lbm_drm_mode_destroy(dev, mode);
  2525.                 DRM_DEBUG_KMS("Incorrect detailed timing. "
  2526.                                 "Sync is beyond the blank.\n");
  2527.                 return NULL;
  2528.  -679,7 +678,7 @@
  2529.         if (mode->vsync_end > mode->vtotal)
  2530.                 mode->vtotal = mode->vsync_end + 1;
  2531.  
  2532. -       drm_mode_set_name(mode);
  2533. +       lbm_drm_mode_set_name(mode);
  2534.  
  2535.         if (pt->misc & DRM_EDID_PT_INTERLACED)
  2536.                 mode->flags |= DRM_MODE_FLAG_INTERLACE;
  2537.  -788,9 +787,9 @@
  2538.         for (i = 0; i <= EDID_EST_TIMINGS; i++)
  2539.                 if (est_bits & (1<<i)) {
  2540.                         struct drm_display_mode *newmode;
  2541. -                       newmode = drm_mode_duplicate(dev, &edid_est_modes[i]);
  2542. +                       newmode = lbm_drm_mode_duplicate(dev, &edid_est_modes[i]);
  2543.                         if (newmode) {
  2544. -                               drm_mode_probed_add(connector, newmode);
  2545. +                               lbm_drm_mode_probed_add(connector, newmode);
  2546.                                 modes++;
  2547.                         }
  2548.                 }
  2549.  -837,7 +836,7 @@
  2550.                 newmode = drm_mode_std(dev, &edid->standard_timings[i],
  2551.                                        edid->revision, timing_level);
  2552.                 if (newmode) {
  2553. -                       drm_mode_probed_add(connector, newmode);
  2554. +                       lbm_drm_mode_probed_add(connector, newmode);
  2555.                         modes++;
  2556.                 }
  2557.         }
  2558.  -859,8 +858,8 @@
  2559.  
  2560.         range = &timing->data.other_data.data.range;
  2561.  
  2562. -       hsync = drm_mode_hsync(mode);
  2563. -       vrefresh = drm_mode_vrefresh(mode);
  2564. +       hsync = lbm_drm_mode_hsync(mode);
  2565. +       vrefresh = lbm_drm_mode_vrefresh(mode);
  2566.  
  2567.         if (hsync < range->min_hfreq_khz || hsync > range->max_hfreq_khz)
  2568.                 return false;
  2569.  -892,9 +891,9 @@
  2570.  
  2571.         for (i = 0; i < drm_num_dmt_modes; i++) {
  2572.                 if (mode_in_range(drm_dmt_modes + i, timing)) {
  2573. -                       newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]);
  2574. +                       newmode = lbm_drm_mode_duplicate(dev, &drm_dmt_modes[i]);
  2575.                         if (newmode) {
  2576. -                               drm_mode_probed_add(connector, newmode);
  2577. +                               lbm_drm_mode_probed_add(connector, newmode);
  2578.                                 modes++;
  2579.                         }
  2580.                 }
  2581.  -938,11 +937,11 @@
  2582.  
  2583.                 for (j = 1; j < 5; j++) {
  2584.                         if (cvt->code[2] & (1 << j)) {
  2585. -                               newmode = drm_cvt_mode(dev, width, height,
  2586. +                               newmode = lbm_drm_cvt_mode(dev, width, height,
  2587.                                                        rates[j], j == 0,
  2588.                                                        false, false);
  2589.                                 if (newmode) {
  2590. -                                       drm_mode_probed_add(connector, newmode);
  2591. +                                       lbm_drm_mode_probed_add(connector, newmode);
  2592.                                         modes++;
  2593.                                 }
  2594.                         }
  2595.  -971,7 +970,7 @@
  2596.                 if (preferred)
  2597.                         newmode->type |= DRM_MODE_TYPE_PREFERRED;
  2598.  
  2599. -               drm_mode_probed_add(connector, newmode);
  2600. +               lbm_drm_mode_probed_add(connector, newmode);
  2601.                 return 1;
  2602.         }
  2603.  
  2604.  -991,7 +990,7 @@
  2605.                         newmode = drm_mode_std(dev, std, edid->revision,
  2606.                                                timing_level);
  2607.                         if (newmode) {
  2608. -                               drm_mode_probed_add(connector, newmode);
  2609. +                               lbm_drm_mode_probed_add(connector, newmode);
  2610.                                 modes++;
  2611.                         }
  2612.                 }
  2613.  -1119,7 +1118,7 @@
  2614.   *
  2615.   * Try to fetch EDID information by calling i2c driver function.
  2616.   */
  2617. -int drm_do_probe_ddc_edid(struct i2c_adapter *adapter,
  2618. +int lbm_drm_do_probe_ddc_edid(struct i2c_adapter *adapter,
  2619.                           unsigned char *buf, int len)
  2620.  {
  2621.         unsigned char start = 0x0;
  2622.  -1142,7 +1141,7 @@
  2623.  
  2624.         return -1;
  2625.  }
  2626. -EXPORT_SYMBOL(drm_do_probe_ddc_edid);
  2627. +EXPORT_SYMBOL(lbm_drm_do_probe_ddc_edid);
  2628.  
  2629.  static int drm_ddc_read_edid(struct drm_connector *connector,
  2630.                              struct i2c_adapter *adapter,
  2631.  -1151,7 +1150,7 @@
  2632.         int i;
  2633.  
  2634.         for (i = 0; i < 4; i++) {
  2635. -               if (drm_do_probe_ddc_edid(adapter, buf, len))
  2636. +               if (lbm_drm_do_probe_ddc_edid(adapter, buf, len))
  2637.                         return -1;
  2638.                 if (edid_is_valid((struct edid *)buf))
  2639.                         return 0;
  2640.  -1159,12 +1158,12 @@
  2641.  
  2642.         /* repeated checksum failures; warn, but carry on */
  2643.         dev_warn(&connector->dev->pdev->dev, "%s: EDID invalid.\n",
  2644. -                drm_get_connector_name(connector));
  2645. +                lbm_drm_get_connector_name(connector));
  2646.         return -1;
  2647.  }
  2648.  
  2649.  /**
  2650. - * drm_get_edid - get EDID data, if available
  2651. + * lbm_drm_get_edid - get EDID data, if available
  2652.   * @connector: connector we're probing
  2653.   * @adapter: i2c adapter to use for DDC
  2654.   *
  2655.  -1172,7 +1171,7 @@
  2656.   *
  2657.   * Return edid data or NULL if we couldn't find any.
  2658.   */
  2659. -struct edid *drm_get_edid(struct drm_connector *connector,
  2660. +struct edid *lbm_drm_get_edid(struct drm_connector *connector,
  2661.                           struct i2c_adapter *adapter)
  2662.  {
  2663.         int ret;
  2664.  -1223,18 +1222,18 @@
  2665.         return edid;
  2666.  
  2667.  }
  2668. -EXPORT_SYMBOL(drm_get_edid);
  2669. +EXPORT_SYMBOL(lbm_drm_get_edid);
  2670.  
  2671.  #define HDMI_IDENTIFIER 0x000C03
  2672.  #define VENDOR_BLOCK    0x03
  2673.  /**
  2674. - * drm_detect_hdmi_monitor - detect whether monitor is hdmi.
  2675. + * lbm_drm_detect_hdmi_monitor - detect whether monitor is hdmi.
  2676.   * @edid: monitor EDID information
  2677.   *
  2678.   * Parse the CEA extension according to CEA-861-B.
  2679.   * Return true if HDMI, false if not or unknown.
  2680.   */
  2681. -bool drm_detect_hdmi_monitor(struct edid *edid)
  2682. +bool lbm_drm_detect_hdmi_monitor(struct edid *edid)
  2683.  {
  2684.         char *edid_ext = NULL;
  2685.         int i, hdmi_id, edid_ext_num;
  2686.  -1285,10 +1284,10 @@
  2687.  end:
  2688.         return is_hdmi;
  2689.  }
  2690. -EXPORT_SYMBOL(drm_detect_hdmi_monitor);
  2691. +EXPORT_SYMBOL(lbm_drm_detect_hdmi_monitor);
  2692.  
  2693.  /**
  2694. - * drm_add_edid_modes - add modes from EDID data, if available
  2695. + * lbm_drm_add_edid_modes - add modes from EDID data, if available
  2696.   * @connector: connector we're probing
  2697.   * @edid: edid data
  2698.   *
  2699.  -1296,7 +1295,7 @@
  2700.   *
  2701.   * Return number of modes added or 0 if we couldn't find any.
  2702.   */
  2703. -int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
  2704. +int lbm_drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
  2705.  {
  2706.         int num_modes = 0;
  2707.         u32 quirks;
  2708.  -1306,7 +1305,7 @@
  2709.         }
  2710.         if (!edid_is_valid(edid)) {
  2711.                 dev_warn(&connector->dev->pdev->dev, "%s: EDID invalid.\n",
  2712. -                        drm_get_connector_name(connector));
  2713. +                        lbm_drm_get_connector_name(connector));
  2714.                 return 0;
  2715.         }
  2716.  
  2717.  -1340,10 +1339,10 @@
  2718.  
  2719.         return num_modes;
  2720.  }
  2721. -EXPORT_SYMBOL(drm_add_edid_modes);
  2722. +EXPORT_SYMBOL(lbm_drm_add_edid_modes);
  2723.  
  2724.  /**
  2725. - * drm_add_modes_noedid - add modes for the connectors without EDID
  2726. + * lbm_drm_add_modes_noedid - add modes for the connectors without EDID
  2727.   * @connector: connector we're probing
  2728.   * @hdisplay: the horizontal display limit
  2729.   * @vdisplay: the vertical display limit
  2730.  -1353,7 +1352,7 @@
  2731.   *
  2732.   * Return number of modes added or 0 if we couldn't find any.
  2733.   */
  2734. -int drm_add_modes_noedid(struct drm_connector *connector,
  2735. +int lbm_drm_add_modes_noedid(struct drm_connector *connector,
  2736.                         int hdisplay, int vdisplay)
  2737.  {
  2738.         int i, count, num_modes = 0;
  2739.  -1378,14 +1377,14 @@
  2740.                                         ptr->vdisplay > vdisplay)
  2741.                                 continue;
  2742.                 }
  2743. -               if (drm_mode_vrefresh(ptr) > 61)
  2744. +               if (lbm_drm_mode_vrefresh(ptr) > 61)
  2745.                         continue;
  2746. -               mode = drm_mode_duplicate(dev, ptr);
  2747. +               mode = lbm_drm_mode_duplicate(dev, ptr);
  2748.                 if (mode) {
  2749. -                       drm_mode_probed_add(connector, mode);
  2750. +                       lbm_drm_mode_probed_add(connector, mode);
  2751.                         num_modes++;
  2752.                 }
  2753.         }
  2754.         return num_modes;
  2755.  }
  2756. -EXPORT_SYMBOL(drm_add_modes_noedid);
  2757. +EXPORT_SYMBOL(lbm_drm_add_modes_noedid);
  2758. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_encoder_slave.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_encoder_slave.c
  2759. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_encoder_slave.c   2010-01-25 15:21:29.000000000 -0500
  2760. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_encoder_slave.c   2010-02-03 17:11:08.000000000 -0500
  2761.  -27,10 +27,10 @@
  2762.  #include "drm_encoder_slave.h"
  2763.  
  2764.  /**
  2765. - * drm_i2c_encoder_init - Initialize an I2C slave encoder
  2766. + * lbm_drm_i2c_encoder_init - Initialize an I2C slave encoder
  2767.   * @dev:       DRM device.
  2768.   * @encoder:    Encoder to be attached to the I2C device. You aren't
  2769. - *             required to have called drm_encoder_init() before.
  2770. + *             required to have called lbm_drm_encoder_init() before.
  2771.   * @adap:      I2C adapter that will be used to communicate with
  2772.   *             the device.
  2773.   * @info:      Information that will be used to create the I2C device.
  2774.  -44,7 +44,7 @@
  2775.   * Returns 0 on success or a negative errno on failure, in particular,
  2776.   * -ENODEV is returned when no matching driver is found.
  2777.   */
  2778. -int drm_i2c_encoder_init(struct drm_device *dev,
  2779. +int lbm_drm_i2c_encoder_init(struct drm_device *dev,
  2780.                          struct drm_encoder_slave *encoder,
  2781.                          struct i2c_adapter *adap,
  2782.                          const struct i2c_board_info *info)
  2783.  -93,16 +93,16 @@
  2784.  fail:
  2785.         return err;
  2786.  }
  2787. -EXPORT_SYMBOL(drm_i2c_encoder_init);
  2788. +EXPORT_SYMBOL(lbm_drm_i2c_encoder_init);
  2789.  
  2790.  /**
  2791. - * drm_i2c_encoder_destroy - Unregister the I2C device backing an encoder
  2792. + * lbm_drm_i2c_encoder_destroy - Unregister the I2C device backing an encoder
  2793.   * @drm_encoder:       Encoder to be unregistered.
  2794.   *
  2795.   * This should be called from the @destroy method of an I2C slave
  2796.   * encoder driver once I2C access is no longer needed.
  2797.   */
  2798. -void drm_i2c_encoder_destroy(struct drm_encoder *drm_encoder)
  2799. +void lbm_drm_i2c_encoder_destroy(struct drm_encoder *drm_encoder)
  2800.  {
  2801.         struct drm_encoder_slave *encoder = to_encoder_slave(drm_encoder);
  2802.         struct i2c_client *client = drm_i2c_encoder_get_client(drm_encoder);
  2803.  -113,4 +113,4 @@
  2804.  
  2805.         module_put(module);
  2806.  }
  2807. -EXPORT_SYMBOL(drm_i2c_encoder_destroy);
  2808. +EXPORT_SYMBOL(lbm_drm_i2c_encoder_destroy);
  2809. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fb_helper.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fb_helper.c
  2810. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fb_helper.c       2010-01-25 15:21:29.000000000 -0500
  2811. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fb_helper.c       2010-02-03 17:11:08.000000000 -0500
  2812.  -40,7 +40,7 @@
  2813.  
  2814.  static LIST_HEAD(kernel_fb_helper_list);
  2815.  
  2816. -int drm_fb_helper_add_connector(struct drm_connector *connector)
  2817. +int lbm_drm_fb_helper_add_connector(struct drm_connector *connector)
  2818.  {
  2819.         connector->fb_helper_private = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
  2820.         if (!connector->fb_helper_private)
  2821.  -48,7 +48,7 @@
  2822.  
  2823.         return 0;
  2824.  }
  2825. -EXPORT_SYMBOL(drm_fb_helper_add_connector);
  2826. +EXPORT_SYMBOL(lbm_drm_fb_helper_add_connector);
  2827.  
  2828.  static int my_atoi(const char *name)
  2829.  {
  2830.  -176,7 +176,7 @@
  2831.  done:
  2832.  
  2833.         DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
  2834. -               drm_get_connector_name(connector), xres, yres,
  2835. +               lbm_drm_get_connector_name(connector), xres, yres,
  2836.                 (refresh) ? refresh : 60, (rb) ? " reduced blanking" :
  2837.                 "", (margins) ? " with margins" : "", (interlace) ?
  2838.                 " interlaced" : "");
  2839.  -191,7 +191,7 @@
  2840.                 }
  2841.  
  2842.                 DRM_INFO("forcing %s connector %s\n",
  2843. -                        drm_get_connector_name(connector), s);
  2844. +                        lbm_drm_get_connector_name(connector), s);
  2845.                 connector->force = force;
  2846.         }
  2847.  
  2848.  -225,7 +225,7 @@
  2849.                 char *option = NULL;
  2850.  
  2851.                 /* do something on return - turn off connector maybe */
  2852. -               if (fb_get_options(drm_get_connector_name(connector), &option))
  2853. +               if (fb_get_options(lbm_drm_get_connector_name(connector), &option))
  2854.                         continue;
  2855.  
  2856.                 drm_fb_helper_connector_parse_command_line(connector, option);
  2857.  -245,7 +245,7 @@
  2858.         list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
  2859.                 for (i = 0; i < helper->crtc_count; i++) {
  2860.                         struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
  2861. -                       ret = drm_crtc_helper_set_config(mode_set);
  2862. +                       ret = lbm_drm_crtc_helper_set_config(mode_set);
  2863.                         if (ret)
  2864.                                 error = true;
  2865.                 }
  2866.  -253,37 +253,37 @@
  2867.         return error;
  2868.  }
  2869.  
  2870. -int drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
  2871. +int lbm_drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
  2872.                         void *panic_str)
  2873.  {
  2874.         DRM_ERROR("panic occurred, switching back to text console\n");
  2875.         return drm_fb_helper_force_kernel_mode();
  2876.         return 0;
  2877.  }
  2878. -EXPORT_SYMBOL(drm_fb_helper_panic);
  2879. +EXPORT_SYMBOL(lbm_drm_fb_helper_panic);
  2880.  
  2881.  static struct notifier_block paniced = {
  2882. -       .notifier_call = drm_fb_helper_panic,
  2883. +       .notifier_call = lbm_drm_fb_helper_panic,
  2884.  };
  2885.  
  2886.  /**
  2887. - * drm_fb_helper_restore - restore the framebuffer console (kernel) config
  2888. + * lbm_drm_fb_helper_restore - restore the framebuffer console (kernel) config
  2889.   *
  2890.   * Restore's the kernel's fbcon mode, used for lastclose & panic paths.
  2891.   */
  2892. -void drm_fb_helper_restore(void)
  2893. +void lbm_drm_fb_helper_restore(void)
  2894.  {
  2895.         bool ret;
  2896.         ret = drm_fb_helper_force_kernel_mode();
  2897.         if (ret == true)
  2898.                 DRM_ERROR("Failed to restore crtc configuration\n");
  2899.  }
  2900. -EXPORT_SYMBOL(drm_fb_helper_restore);
  2901. +EXPORT_SYMBOL(lbm_drm_fb_helper_restore);
  2902.  
  2903.  #ifdef CONFIG_MAGIC_SYSRQ
  2904.  static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
  2905.  {
  2906. -       drm_fb_helper_restore();
  2907. +       lbm_drm_fb_helper_restore();
  2908.  }
  2909.  static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
  2910.  
  2911.  -380,7 +380,7 @@
  2912.         }
  2913.  }
  2914.  
  2915. -int drm_fb_helper_blank(int blank, struct fb_info *info)
  2916. +int lbm_drm_fb_helper_blank(int blank, struct fb_info *info)
  2917.  {
  2918.         switch (blank) {
  2919.         /* Display: On; HSync: On, VSync: On */
  2920.  -389,7 +389,7 @@
  2921.                 break;
  2922.         /* Display: Off; HSync: On, VSync: On */
  2923.         case FB_BLANK_NORMAL:
  2924. -               drm_fb_helper_off(info, DRM_MODE_DPMS_ON);
  2925. +               drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
  2926.                 break;
  2927.         /* Display: Off; HSync: Off, VSync: On */
  2928.         case FB_BLANK_HSYNC_SUSPEND:
  2929.  -406,7 +406,7 @@
  2930.         }
  2931.         return 0;
  2932.  }
  2933. -EXPORT_SYMBOL(drm_fb_helper_blank);
  2934. +EXPORT_SYMBOL(lbm_drm_fb_helper_blank);
  2935.  
  2936.  static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
  2937.  {
  2938.  -417,7 +417,7 @@
  2939.         kfree(helper->crtc_info);
  2940.  }
  2941.  
  2942. -int drm_fb_helper_init_crtc_count(struct drm_fb_helper *helper, int crtc_count, int max_conn_count)
  2943. +int lbm_drm_fb_helper_init_crtc_count(struct drm_fb_helper *helper, int crtc_count, int max_conn_count)
  2944.  {
  2945.         struct drm_device *dev = helper->dev;
  2946.         struct drm_crtc *crtc;
  2947.  -455,7 +455,7 @@
  2948.         drm_fb_helper_crtc_free(helper);
  2949.         return -ENOMEM;
  2950.  }
  2951. -EXPORT_SYMBOL(drm_fb_helper_init_crtc_count);
  2952. +EXPORT_SYMBOL(lbm_drm_fb_helper_init_crtc_count);
  2953.  
  2954.  static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
  2955.                      u16 blue, u16 regno, struct fb_info *info)
  2956.  -516,7 +516,7 @@
  2957.         return 0;
  2958.  }
  2959.  
  2960. -int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
  2961. +int lbm_drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
  2962.  {
  2963.         struct drm_fb_helper *fb_helper = info->par;
  2964.         struct drm_device *dev = fb_helper->dev;
  2965.  -558,9 +558,9 @@
  2966.         }
  2967.         return rc;
  2968.  }
  2969. -EXPORT_SYMBOL(drm_fb_helper_setcmap);
  2970. +EXPORT_SYMBOL(lbm_drm_fb_helper_setcmap);
  2971.  
  2972. -int drm_fb_helper_setcolreg(unsigned regno,
  2973. +int lbm_drm_fb_helper_setcolreg(unsigned regno,
  2974.                             unsigned red,
  2975.                             unsigned green,
  2976.                             unsigned blue,
  2977.  -593,9 +593,9 @@
  2978.         }
  2979.         return 0;
  2980.  }
  2981. -EXPORT_SYMBOL(drm_fb_helper_setcolreg);
  2982. +EXPORT_SYMBOL(lbm_drm_fb_helper_setcolreg);
  2983.  
  2984. -int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
  2985. +int lbm_drm_fb_helper_check_var(struct fb_var_screeninfo *var,
  2986.                             struct fb_info *info)
  2987.  {
  2988.         struct drm_fb_helper *fb_helper = info->par;
  2989.  -681,10 +681,10 @@
  2990.         }
  2991.         return 0;
  2992.  }
  2993. -EXPORT_SYMBOL(drm_fb_helper_check_var);
  2994. +EXPORT_SYMBOL(lbm_drm_fb_helper_check_var);
  2995.  
  2996.  /* this will let fbcon do the mode init */
  2997. -int drm_fb_helper_set_par(struct fb_info *info)
  2998. +int lbm_drm_fb_helper_set_par(struct fb_info *info)
  2999.  {
  3000.         struct drm_fb_helper *fb_helper = info->par;
  3001.         struct drm_device *dev = fb_helper->dev;
  3002.  -717,9 +717,9 @@
  3003.         }
  3004.         return 0;
  3005.  }
  3006. -EXPORT_SYMBOL(drm_fb_helper_set_par);
  3007. +EXPORT_SYMBOL(lbm_drm_fb_helper_set_par);
  3008.  
  3009. -int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
  3010. +int lbm_drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
  3011.                               struct fb_info *info)
  3012.  {
  3013.         struct drm_fb_helper *fb_helper = info->par;
  3014.  -755,9 +755,9 @@
  3015.         }
  3016.         return ret;
  3017.  }
  3018. -EXPORT_SYMBOL(drm_fb_helper_pan_display);
  3019. +EXPORT_SYMBOL(lbm_drm_fb_helper_pan_display);
  3020.  
  3021. -int drm_fb_helper_single_fb_probe(struct drm_device *dev,
  3022. +int lbm_drm_fb_helper_single_fb_probe(struct drm_device *dev,
  3023.                                   int preferred_bpp,
  3024.                                   int (*fb_create)(struct drm_device *dev,
  3025.                                                    uint32_t fb_width,
  3026.  -822,7 +822,7 @@
  3027.         }
  3028.  
  3029.         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
  3030. -               if (drm_helper_crtc_in_use(crtc)) {
  3031. +               if (lbm_drm_helper_crtc_in_use(crtc)) {
  3032.                         if (crtc->desired_mode) {
  3033.                                 if (crtc->desired_mode->hdisplay < fb_width)
  3034.                                         fb_width = crtc->desired_mode->hdisplay;
  3035.  -897,8 +897,8 @@
  3036.                 modeset->num_connectors = conn_count;
  3037.                 if (modeset->crtc->desired_mode) {
  3038.                         if (modeset->mode)
  3039. -                               drm_mode_destroy(dev, modeset->mode);
  3040. -                       modeset->mode = drm_mode_duplicate(dev,
  3041. +                               lbm_drm_mode_destroy(dev, modeset->mode);
  3042. +                       modeset->mode = lbm_drm_mode_duplicate(dev,
  3043.                                                            modeset->crtc->desired_mode);
  3044.                 }
  3045.         }
  3046.  -915,7 +915,7 @@
  3047.                         return -EINVAL;
  3048.                 }
  3049.         } else {
  3050. -               drm_fb_helper_set_par(info);
  3051. +               lbm_drm_fb_helper_set_par(info);
  3052.         }
  3053.         printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
  3054.                info->fix.id);
  3055.  -931,9 +931,9 @@
  3056.         list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
  3057.         return 0;
  3058.  }
  3059. -EXPORT_SYMBOL(drm_fb_helper_single_fb_probe);
  3060. +EXPORT_SYMBOL(lbm_drm_fb_helper_single_fb_probe);
  3061.  
  3062. -void drm_fb_helper_free(struct drm_fb_helper *helper)
  3063. +void lbm_drm_fb_helper_free(struct drm_fb_helper *helper)
  3064.  {
  3065.         list_del(&helper->kernel_fb_list);
  3066.         if (list_empty(&kernel_fb_helper_list)) {
  3067.  -945,9 +945,9 @@
  3068.         drm_fb_helper_crtc_free(helper);
  3069.         fb_dealloc_cmap(&helper->fb->fbdev->cmap);
  3070.  }
  3071. -EXPORT_SYMBOL(drm_fb_helper_free);
  3072. +EXPORT_SYMBOL(lbm_drm_fb_helper_free);
  3073.  
  3074. -void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
  3075. +void lbm_drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
  3076.                             uint32_t depth)
  3077.  {
  3078.         info->fix.type = FB_TYPE_PACKED_PIXELS;
  3079.  -963,9 +963,9 @@
  3080.         info->fix.line_length = pitch;
  3081.         return;
  3082.  }
  3083. -EXPORT_SYMBOL(drm_fb_helper_fill_fix);
  3084. +EXPORT_SYMBOL(lbm_drm_fb_helper_fill_fix);
  3085.  
  3086. -void drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb,
  3087. +void lbm_drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb,
  3088.                             uint32_t fb_width, uint32_t fb_height)
  3089.  {
  3090.         info->pseudo_palette = fb->pseudo_palette;
  3091.  -1035,4 +1035,4 @@
  3092.         info->var.xres = fb_width;
  3093.         info->var.yres = fb_height;
  3094.  }
  3095. -EXPORT_SYMBOL(drm_fb_helper_fill_var);
  3096. +EXPORT_SYMBOL(lbm_drm_fb_helper_fill_var);
  3097. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fops.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fops.c
  3098. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fops.c    2010-01-25 15:21:29.000000000 -0500
  3099. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_fops.c    2010-02-03 17:11:08.000000000 -0500
  3100.  -114,7 +114,7 @@
  3101.   * increments the device open count. If the open count was previous at zero,
  3102.   * i.e., it's the first that the device is open, then calls setup().
  3103.   */
  3104. -int drm_open(struct inode *inode, struct file *filp)
  3105. +int lbm_drm_open(struct inode *inode, struct file *filp)
  3106.  {
  3107.         struct drm_device *dev = NULL;
  3108.         int minor_id = iminor(inode);
  3109.  -151,7 +151,7 @@
  3110.  
  3111.         return retcode;
  3112.  }
  3113. -EXPORT_SYMBOL(drm_open);
  3114. +EXPORT_SYMBOL(lbm_drm_open);
  3115.  
  3116.  /**
  3117.   * File \c open operation.
  3118.  -284,7 +284,7 @@
  3119.  
  3120.                 priv->is_master = 1;
  3121.                 /* take another reference for the copy in the local file priv */
  3122. -               priv->master = drm_master_get(priv->minor->master);
  3123. +               priv->master = lbm_drm_master_get(priv->minor->master);
  3124.  
  3125.                 priv->authenticated = 1;
  3126.  
  3127.  -294,8 +294,8 @@
  3128.                         if (ret) {
  3129.                                 mutex_lock(&dev->struct_mutex);
  3130.                                 /* drop both references if this fails */
  3131. -                               drm_master_put(&priv->minor->master);
  3132. -                               drm_master_put(&priv->master);
  3133. +                               lbm_drm_master_put(&priv->minor->master);
  3134. +                               lbm_drm_master_put(&priv->master);
  3135.                                 mutex_unlock(&dev->struct_mutex);
  3136.                                 goto out_free;
  3137.                         }
  3138.  -305,8 +305,8 @@
  3139.                         ret = dev->driver->master_set(dev, priv, true);
  3140.                         if (ret) {
  3141.                                 /* drop both references if this fails */
  3142. -                               drm_master_put(&priv->minor->master);
  3143. -                               drm_master_put(&priv->master);
  3144. +                               lbm_drm_master_put(&priv->minor->master);
  3145. +                               lbm_drm_master_put(&priv->master);
  3146.                                 mutex_unlock(&dev->struct_mutex);
  3147.                                 goto out_free;
  3148.                         }
  3149.  -314,7 +314,7 @@
  3150.                 mutex_unlock(&dev->struct_mutex);
  3151.         } else {
  3152.                 /* get a reference to the master */
  3153. -               priv->master = drm_master_get(priv->minor->master);
  3154. +               priv->master = lbm_drm_master_get(priv->minor->master);
  3155.                 mutex_unlock(&dev->struct_mutex);
  3156.         }
  3157.  
  3158.  -349,7 +349,7 @@
  3159.  }
  3160.  
  3161.  /** No-op. */
  3162. -int drm_fasync(int fd, struct file *filp, int on)
  3163. +int lbm_drm_fasync(int fd, struct file *filp, int on)
  3164.  {
  3165.         struct drm_file *priv = filp->private_data;
  3166.         struct drm_device *dev = priv->minor->dev;
  3167.  -358,7 +358,7 @@
  3168.                   (long)old_encode_dev(priv->minor->device));
  3169.         return fasync_helper(fd, filp, on, &dev->buf_async);
  3170.  }
  3171. -EXPORT_SYMBOL(drm_fasync);
  3172. +EXPORT_SYMBOL(lbm_drm_fasync);
  3173.  
  3174.  /*
  3175.   * Reclaim locked buffers; note that this may be a bad idea if the current
  3176.  -368,13 +368,13 @@
  3177.  {
  3178.         struct drm_file *file_priv = f->private_data;
  3179.  
  3180. -       if (drm_i_have_hw_lock(dev, file_priv)) {
  3181. +       if (lbm_drm_i_have_hw_lock(dev, file_priv)) {
  3182.                 dev->driver->reclaim_buffers_locked(dev, file_priv);
  3183.         } else {
  3184.                 unsigned long _end = jiffies + 3 * DRM_HZ;
  3185.                 int locked = 0;
  3186.  
  3187. -               drm_idlelock_take(&file_priv->master->lock);
  3188. +               lbm_drm_idlelock_take(&file_priv->master->lock);
  3189.  
  3190.                 /*
  3191.                  * Wait for a while.
  3192.  -395,7 +395,7 @@
  3193.                 }
  3194.  
  3195.                 dev->driver->reclaim_buffers_locked(dev, file_priv);
  3196. -               drm_idlelock_release(&file_priv->master->lock);
  3197. +               lbm_drm_idlelock_release(&file_priv->master->lock);
  3198.         }
  3199.  }
  3200.  
  3201.  -409,16 +409,16 @@
  3202.  
  3203.         if (dev->driver->reclaim_buffers_idlelocked &&
  3204.             file_priv->master->lock.hw_lock) {
  3205. -               drm_idlelock_take(&file_priv->master->lock);
  3206. +               lbm_drm_idlelock_take(&file_priv->master->lock);
  3207.                 dev->driver->reclaim_buffers_idlelocked(dev, file_priv);
  3208. -               drm_idlelock_release(&file_priv->master->lock);
  3209. +               lbm_drm_idlelock_release(&file_priv->master->lock);
  3210.         }
  3211.  
  3212.  
  3213. -       if (drm_i_have_hw_lock(dev, file_priv)) {
  3214. +       if (lbm_drm_i_have_hw_lock(dev, file_priv)) {
  3215.                 DRM_DEBUG("File %p released, freeing lock for context %d\n",
  3216.                           filp, _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
  3217. -               drm_lock_free(&file_priv->master->lock,
  3218. +               lbm_drm_lock_free(&file_priv->master->lock,
  3219.                               _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
  3220.         }
  3221.  
  3222.  -441,7 +441,7 @@
  3223.         list_for_each_entry_safe(v, vt, &dev->vblank_event_list, base.link)
  3224.                 if (v->base.file_priv == file_priv) {
  3225.                         list_del(&v->base.link);
  3226. -                       drm_vblank_put(dev, v->pipe);
  3227. +                       lbm_drm_vblank_put(dev, v->pipe);
  3228.                         v->base.destroy(&v->base);
  3229.                 }
  3230.  
  3231.  -464,7 +464,7 @@
  3232.   * data from its list and free it. Decreases the open count and if it reaches
  3233.   * zero calls drm_lastclose().
  3234.   */
  3235. -int drm_release(struct inode *inode, struct file *filp)
  3236. +int lbm_drm_release(struct inode *inode, struct file *filp)
  3237.  {
  3238.         struct drm_file *file_priv = filp->private_data;
  3239.         struct drm_device *dev = file_priv->minor->dev;
  3240.  -478,7 +478,7 @@
  3241.                 dev->driver->preclose(dev, file_priv);
  3242.  
  3243.         /* ========================================================
  3244. -        * Begin inline drm_release
  3245. +        * Begin inline lbm_drm_release
  3246.          */
  3247.  
  3248.         DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
  3249.  -547,12 +547,12 @@
  3250.                         /* drop the reference held my the minor */
  3251.                         if (dev->driver->master_drop)
  3252.                                 dev->driver->master_drop(dev, file_priv, true);
  3253. -                       drm_master_put(&file_priv->minor->master);
  3254. +                       lbm_drm_master_put(&file_priv->minor->master);
  3255.                 }
  3256.         }
  3257.  
  3258.         /* drop the reference held my the file priv */
  3259. -       drm_master_put(&file_priv->master);
  3260. +       lbm_drm_master_put(&file_priv->master);
  3261.         file_priv->is_master = 0;
  3262.         list_del(&file_priv->lhead);
  3263.         mutex_unlock(&dev->struct_mutex);
  3264.  -562,7 +562,7 @@
  3265.         kfree(file_priv);
  3266.  
  3267.         /* ========================================================
  3268. -        * End inline drm_release
  3269. +        * End inline lbm_drm_release
  3270.          */
  3271.  
  3272.         atomic_inc(&dev->counts[_DRM_STAT_CLOSES]);
  3273.  -585,7 +585,7 @@
  3274.  
  3275.         return retcode;
  3276.  }
  3277. -EXPORT_SYMBOL(drm_release);
  3278. +EXPORT_SYMBOL(lbm_drm_release);
  3279.  
  3280.  static bool
  3281.  drm_dequeue_event(struct drm_file *file_priv,
  3282.  -616,7 +616,7 @@
  3283.         return ret;
  3284.  }
  3285.  
  3286. -ssize_t drm_read(struct file *filp, char __user *buffer,
  3287. +ssize_t lbm_drm_read(struct file *filp, char __user *buffer,
  3288.                  size_t count, loff_t *offset)
  3289.  {
  3290.         struct drm_file *file_priv = filp->private_data;
  3291.  -643,9 +643,9 @@
  3292.  
  3293.         return total;
  3294.  }
  3295. -EXPORT_SYMBOL(drm_read);
  3296. +EXPORT_SYMBOL(lbm_drm_read);
  3297.  
  3298. -unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait)
  3299. +unsigned int lbm_drm_poll(struct file *filp, struct poll_table_struct *wait)
  3300.  {
  3301.         struct drm_file *file_priv = filp->private_data;
  3302.         unsigned int mask = 0;
  3303.  -657,4 +657,4 @@
  3304.  
  3305.         return mask;
  3306.  }
  3307. -EXPORT_SYMBOL(drm_poll);
  3308. +EXPORT_SYMBOL(lbm_drm_poll);
  3309. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_gem.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_gem.c
  3310. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_gem.c     2010-01-25 15:21:29.000000000 -0500
  3311. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_gem.c     2010-02-03 17:11:08.000000000 -0500
  3312.  -97,14 +97,14 @@
  3313.  
  3314.         dev->mm_private = mm;
  3315.  
  3316. -       if (drm_ht_create(&mm->offset_hash, 19)) {
  3317. +       if (lbm_drm_ht_create(&mm->offset_hash, 19)) {
  3318.                 kfree(mm);
  3319.                 return -ENOMEM;
  3320.         }
  3321.  
  3322. -       if (drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
  3323. +       if (lbm_drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
  3324.                         DRM_FILE_PAGE_OFFSET_SIZE)) {
  3325. -               drm_ht_remove(&mm->offset_hash);
  3326. +               lbm_drm_ht_remove(&mm->offset_hash);
  3327.                 kfree(mm);
  3328.                 return -ENOMEM;
  3329.         }
  3330.  -117,8 +117,8 @@
  3331.  {
  3332.         struct drm_gem_mm *mm = dev->mm_private;
  3333.  
  3334. -       drm_mm_takedown(&mm->offset_manager);
  3335. -       drm_ht_remove(&mm->offset_hash);
  3336. +       lbm_drm_mm_takedown(&mm->offset_manager);
  3337. +       lbm_drm_ht_remove(&mm->offset_hash);
  3338.         kfree(mm);
  3339.         dev->mm_private = NULL;
  3340.  }
  3341.  -127,7 +127,7 @@
  3342.   * Allocate a GEM object of the specified size with shmfs backing store
  3343.   */
  3344.  struct drm_gem_object *
  3345. -drm_gem_object_alloc(struct drm_device *dev, size_t size)
  3346. +lbm_drm_gem_object_alloc(struct drm_device *dev, size_t size)
  3347.  {
  3348.         struct drm_gem_object *obj;
  3349.  
  3350.  -142,19 +142,6 @@
  3351.         if (IS_ERR(obj->filp))
  3352.                 goto free;
  3353.  
  3354. -       /* Basically we want to disable the OOM killer and handle ENOMEM
  3355. -        * ourselves by sacrificing pages from cached buffers.
  3356. -        * XXX shmem_file_[gs]et_gfp_mask()
  3357. -        */
  3358. -       mapping_set_gfp_mask(obj->filp->f_path.dentry->d_inode->i_mapping,
  3359. -                            GFP_HIGHUSER |
  3360. -                            __GFP_COLD |
  3361. -                            __GFP_FS |
  3362. -                            __GFP_RECLAIMABLE |
  3363. -                            __GFP_NORETRY |
  3364. -                            __GFP_NOWARN |
  3365. -                            __GFP_NOMEMALLOC);
  3366. -
  3367.         kref_init(&obj->refcount);
  3368.         kref_init(&obj->handlecount);
  3369.         obj->size = size;
  3370.  -171,7 +158,7 @@
  3371.         kfree(obj);
  3372.         return NULL;
  3373.  }
  3374. -EXPORT_SYMBOL(drm_gem_object_alloc);
  3375. +EXPORT_SYMBOL(lbm_drm_gem_object_alloc);
  3376.  
  3377.  /**
  3378.   * Removes the mapping from handle to filp for this object.
  3379.  -218,7 +205,7 @@
  3380.   * will likely want to dereference the object afterwards.
  3381.   */
  3382.  int
  3383. -drm_gem_handle_create(struct drm_file *file_priv,
  3384. +lbm_drm_gem_handle_create(struct drm_file *file_priv,
  3385.                        struct drm_gem_object *obj,
  3386.                        u32 *handlep)
  3387.  {
  3388.  -245,11 +232,11 @@
  3389.         drm_gem_object_handle_reference(obj);
  3390.         return 0;
  3391.  }
  3392. -EXPORT_SYMBOL(drm_gem_handle_create);
  3393. +EXPORT_SYMBOL(lbm_drm_gem_handle_create);
  3394.  
  3395.  /** Returns a reference to the object named by the handle. */
  3396.  struct drm_gem_object *
  3397. -drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp,
  3398. +lbm_drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp,
  3399.                       u32 handle)
  3400.  {
  3401.         struct drm_gem_object *obj;
  3402.  -269,7 +256,7 @@
  3403.  
  3404.         return obj;
  3405.  }
  3406. -EXPORT_SYMBOL(drm_gem_object_lookup);
  3407. +EXPORT_SYMBOL(lbm_drm_gem_object_lookup);
  3408.  
  3409.  /**
  3410.   * Releases the handle to an mm object.
  3411.  -306,7 +293,7 @@
  3412.         if (!(dev->driver->driver_features & DRIVER_GEM))
  3413.                 return -ENODEV;
  3414.  
  3415. -       obj = drm_gem_object_lookup(dev, file_priv, args->handle);
  3416. +       obj = lbm_drm_gem_object_lookup(dev, file_priv, args->handle);
  3417.         if (obj == NULL)
  3418.                 return -EBADF;
  3419.  
  3420.  -370,7 +357,7 @@
  3421.         if (!obj)
  3422.                 return -ENOENT;
  3423.  
  3424. -       ret = drm_gem_handle_create(file_priv, obj, &handle);
  3425. +       ret = lbm_drm_gem_handle_create(file_priv, obj, &handle);
  3426.         mutex_lock(&dev->struct_mutex);
  3427.         drm_gem_object_unreference(obj);
  3428.         mutex_unlock(&dev->struct_mutex);
  3429.  -430,7 +417,7 @@
  3430.   * Frees the object
  3431.   */
  3432.  void
  3433. -drm_gem_object_free(struct kref *kref)
  3434. +lbm_drm_gem_object_free(struct kref *kref)
  3435.  {
  3436.         struct drm_gem_object *obj = (struct drm_gem_object *) kref;
  3437.         struct drm_device *dev = obj->dev;
  3438.  -445,17 +432,17 @@
  3439.         atomic_sub(obj->size, &dev->object_memory);
  3440.         kfree(obj);
  3441.  }
  3442. -EXPORT_SYMBOL(drm_gem_object_free);
  3443. +EXPORT_SYMBOL(lbm_drm_gem_object_free);
  3444.  
  3445.  /**
  3446.   * Called after the last handle to the object has been closed
  3447.   *
  3448.   * Removes any name for the object. Note that this must be
  3449. - * called before drm_gem_object_free or we'll be touching
  3450. + * called before lbm_drm_gem_object_free or we'll be touching
  3451.   * freed memory
  3452.   */
  3453.  void
  3454. -drm_gem_object_handle_free(struct kref *kref)
  3455. +lbm_drm_gem_object_handle_free(struct kref *kref)
  3456.  {
  3457.         struct drm_gem_object *obj = container_of(kref,
  3458.                                                   struct drm_gem_object,
  3459.  -477,17 +464,17 @@
  3460.                 spin_unlock(&dev->object_name_lock);
  3461.  
  3462.  }
  3463. -EXPORT_SYMBOL(drm_gem_object_handle_free);
  3464. +EXPORT_SYMBOL(lbm_drm_gem_object_handle_free);
  3465.  
  3466. -void drm_gem_vm_open(struct vm_area_struct *vma)
  3467. +void lbm_drm_gem_vm_open(struct vm_area_struct *vma)
  3468.  {
  3469.         struct drm_gem_object *obj = vma->vm_private_data;
  3470.  
  3471.         drm_gem_object_reference(obj);
  3472.  }
  3473. -EXPORT_SYMBOL(drm_gem_vm_open);
  3474. +EXPORT_SYMBOL(lbm_drm_gem_vm_open);
  3475.  
  3476. -void drm_gem_vm_close(struct vm_area_struct *vma)
  3477. +void lbm_drm_gem_vm_close(struct vm_area_struct *vma)
  3478.  {
  3479.         struct drm_gem_object *obj = vma->vm_private_data;
  3480.         struct drm_device *dev = obj->dev;
  3481.  -496,11 +483,11 @@
  3482.         drm_gem_object_unreference(obj);
  3483.         mutex_unlock(&dev->struct_mutex);
  3484.  }
  3485. -EXPORT_SYMBOL(drm_gem_vm_close);
  3486. +EXPORT_SYMBOL(lbm_drm_gem_vm_close);
  3487.  
  3488.  
  3489.  /**
  3490. - * drm_gem_mmap - memory map routine for GEM objects
  3491. + * lbm_drm_gem_mmap - memory map routine for GEM objects
  3492.   * @filp: DRM file pointer
  3493.   * @vma: VMA for the area to be mapped
  3494.   *
  3495.  -513,7 +500,7 @@
  3496.   * to the object can be trapped, to perform migration, GTT binding, surface
  3497.   * register allocation, or performance monitoring.
  3498.   */
  3499. -int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
  3500. +int lbm_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
  3501.  {
  3502.         struct drm_file *priv = filp->private_data;
  3503.         struct drm_device *dev = priv->minor->dev;
  3504.  -525,9 +512,9 @@
  3505.  
  3506.         mutex_lock(&dev->struct_mutex);
  3507.  
  3508. -       if (drm_ht_find_item(&mm->offset_hash, vma->vm_pgoff, &hash)) {
  3509. +       if (lbm_drm_ht_find_item(&mm->offset_hash, vma->vm_pgoff, &hash)) {
  3510.                 mutex_unlock(&dev->struct_mutex);
  3511. -               return drm_mmap(filp, vma);
  3512. +               return lbm_drm_mmap(filp, vma);
  3513.         }
  3514.  
  3515.         map = drm_hash_entry(hash, struct drm_map_list, hash)->map;
  3516.  -570,4 +557,4 @@
  3517.  
  3518.         return ret;
  3519.  }
  3520. -EXPORT_SYMBOL(drm_gem_mmap);
  3521. +EXPORT_SYMBOL(lbm_drm_gem_mmap);
  3522. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_hashtab.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_hashtab.c
  3523. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_hashtab.c 2010-01-25 15:21:29.000000000 -0500
  3524. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_hashtab.c 2010-02-03 17:11:09.000000000 -0500
  3525.  -36,7 +36,7 @@
  3526.  #include "drm_hashtab.h"
  3527.  #include <linux/hash.h>
  3528.  
  3529. -int drm_ht_create(struct drm_open_hash *ht, unsigned int order)
  3530. +int lbm_drm_ht_create(struct drm_open_hash *ht, unsigned int order)
  3531.  {
  3532.         unsigned int i;
  3533.  
  3534.  -61,7 +61,7 @@
  3535.         }
  3536.         return 0;
  3537.  }
  3538. -EXPORT_SYMBOL(drm_ht_create);
  3539. +EXPORT_SYMBOL(lbm_drm_ht_create);
  3540.  
  3541.  void drm_ht_verbose_list(struct drm_open_hash *ht, unsigned long key)
  3542.  {
  3543.  -101,7 +101,7 @@
  3544.  }
  3545.  
  3546.  
  3547. -int drm_ht_insert_item(struct drm_open_hash *ht, struct drm_hash_item *item)
  3548. +int lbm_drm_ht_insert_item(struct drm_open_hash *ht, struct drm_hash_item *item)
  3549.  {
  3550.         struct drm_hash_item *entry;
  3551.         struct hlist_head *h_list;
  3552.  -127,13 +127,13 @@
  3553.         }
  3554.         return 0;
  3555.  }
  3556. -EXPORT_SYMBOL(drm_ht_insert_item);
  3557. +EXPORT_SYMBOL(lbm_drm_ht_insert_item);
  3558.  
  3559.  /*
  3560.   * Just insert an item and return any "bits" bit key that hasn't been
  3561.   * used before.
  3562.   */
  3563. -int drm_ht_just_insert_please(struct drm_open_hash *ht, struct drm_hash_item *item,
  3564. +int lbm_drm_ht_just_insert_please(struct drm_open_hash *ht, struct drm_hash_item *item,
  3565.                               unsigned long seed, int bits, int shift,
  3566.                               unsigned long add)
  3567.  {
  3568.  -145,7 +145,7 @@
  3569.         first = unshifted_key;
  3570.         do {
  3571.                 item->key = (unshifted_key << shift) + add;
  3572. -               ret = drm_ht_insert_item(ht, item);
  3573. +               ret = lbm_drm_ht_insert_item(ht, item);
  3574.                 if (ret)
  3575.                         unshifted_key = (unshifted_key + 1) & mask;
  3576.         } while(ret && (unshifted_key != first));
  3577.  -156,9 +156,9 @@
  3578.         }
  3579.         return 0;
  3580.  }
  3581. -EXPORT_SYMBOL(drm_ht_just_insert_please);
  3582. +EXPORT_SYMBOL(lbm_drm_ht_just_insert_please);
  3583.  
  3584. -int drm_ht_find_item(struct drm_open_hash *ht, unsigned long key,
  3585. +int lbm_drm_ht_find_item(struct drm_open_hash *ht, unsigned long key,
  3586.                      struct drm_hash_item **item)
  3587.  {
  3588.         struct hlist_node *list;
  3589.  -170,7 +170,7 @@
  3590.         *item = hlist_entry(list, struct drm_hash_item, head);
  3591.         return 0;
  3592.  }
  3593. -EXPORT_SYMBOL(drm_ht_find_item);
  3594. +EXPORT_SYMBOL(lbm_drm_ht_find_item);
  3595.  
  3596.  int drm_ht_remove_key(struct drm_open_hash *ht, unsigned long key)
  3597.  {
  3598.  -185,15 +185,15 @@
  3599.         return -EINVAL;
  3600.  }
  3601.  
  3602. -int drm_ht_remove_item(struct drm_open_hash *ht, struct drm_hash_item *item)
  3603. +int lbm_drm_ht_remove_item(struct drm_open_hash *ht, struct drm_hash_item *item)
  3604.  {
  3605.         hlist_del_init(&item->head);
  3606.         ht->fill--;
  3607.         return 0;
  3608.  }
  3609. -EXPORT_SYMBOL(drm_ht_remove_item);
  3610. +EXPORT_SYMBOL(lbm_drm_ht_remove_item);
  3611.  
  3612. -void drm_ht_remove(struct drm_open_hash *ht)
  3613. +void lbm_drm_ht_remove(struct drm_open_hash *ht)
  3614.  {
  3615.         if (ht->table) {
  3616.                 if (ht->use_vmalloc)
  3617.  -203,4 +203,4 @@
  3618.                 ht->table = NULL;
  3619.         }
  3620.  }
  3621. -EXPORT_SYMBOL(drm_ht_remove);
  3622. +EXPORT_SYMBOL(lbm_drm_ht_remove);
  3623. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_info.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_info.c
  3624. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_info.c    2010-01-25 15:21:29.000000000 -0500
  3625. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_info.c    2010-02-03 17:11:09.000000000 -0500
  3626.  -201,7 +201,7 @@
  3627.                 seq_printf(m, "CRTC %d enable:     %d\n",
  3628.                            crtc, atomic_read(&dev->vblank_refcount[crtc]));
  3629.                 seq_printf(m, "CRTC %d counter:    %d\n",
  3630. -                          crtc, drm_vblank_count(dev, crtc));
  3631. +                          crtc, lbm_drm_vblank_count(dev, crtc));
  3632.                 seq_printf(m, "CRTC %d last wait:  %d\n",
  3633.                            crtc, dev->last_vblank_wait[crtc]);
  3634.                 seq_printf(m, "CRTC %d in modeset: %d\n",
  3635. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioc32.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioc32.c
  3636. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioc32.c   2010-01-25 15:21:29.000000000 -0500
  3637. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioc32.c   2010-02-03 17:11:08.000000000 -0500
  3638.  -104,7 +104,7 @@
  3639.                           &version->desc))
  3640.                 return -EFAULT;
  3641.  
  3642. -       err = drm_ioctl(file,
  3643. +       err = lbm_drm_ioctl(file,
  3644.                         DRM_IOCTL_VERSION, (unsigned long)version);
  3645.         if (err)
  3646.                 return err;
  3647.  -145,7 +145,7 @@
  3648.                           &u->unique))
  3649.                 return -EFAULT;
  3650.  
  3651. -       err = drm_ioctl(file, DRM_IOCTL_GET_UNIQUE, (unsigned long)u);
  3652. +       err = lbm_drm_ioctl(file, DRM_IOCTL_GET_UNIQUE, (unsigned long)u);
  3653.         if (err)
  3654.                 return err;
  3655.  
  3656.  -173,7 +173,7 @@
  3657.                           &u->unique))
  3658.                 return -EFAULT;
  3659.  
  3660. -       return drm_ioctl(file, DRM_IOCTL_SET_UNIQUE, (unsigned long)u);
  3661. +       return lbm_drm_ioctl(file, DRM_IOCTL_SET_UNIQUE, (unsigned long)u);
  3662.  }
  3663.  
  3664.  typedef struct drm_map32 {
  3665.  -203,7 +203,7 @@
  3666.         if (__put_user(idx, &map->offset))
  3667.                 return -EFAULT;
  3668.  
  3669. -       err = drm_ioctl(file, DRM_IOCTL_GET_MAP, (unsigned long)map);
  3670. +       err = lbm_drm_ioctl(file, DRM_IOCTL_GET_MAP, (unsigned long)map);
  3671.         if (err)
  3672.                 return err;
  3673.  
  3674.  -243,7 +243,7 @@
  3675.             || __put_user(m32.flags, &map->flags))
  3676.                 return -EFAULT;
  3677.  
  3678. -       err = drm_ioctl(file, DRM_IOCTL_ADD_MAP, (unsigned long)map);
  3679. +       err = lbm_drm_ioctl(file, DRM_IOCTL_ADD_MAP, (unsigned long)map);
  3680.         if (err)
  3681.                 return err;
  3682.  
  3683.  -280,7 +280,7 @@
  3684.         if (__put_user((void *)(unsigned long)handle, &map->handle))
  3685.                 return -EFAULT;
  3686.  
  3687. -       return drm_ioctl(file, DRM_IOCTL_RM_MAP, (unsigned long)map);
  3688. +       return lbm_drm_ioctl(file, DRM_IOCTL_RM_MAP, (unsigned long)map);
  3689.  }
  3690.  
  3691.  typedef struct drm_client32 {
  3692.  -309,7 +309,7 @@
  3693.         if (__put_user(idx, &client->idx))
  3694.                 return -EFAULT;
  3695.  
  3696. -       err = drm_ioctl(file, DRM_IOCTL_GET_CLIENT, (unsigned long)client);
  3697. +       err = lbm_drm_ioctl(file, DRM_IOCTL_GET_CLIENT, (unsigned long)client);
  3698.         if (err)
  3699.                 return err;
  3700.  
  3701.  -345,7 +345,7 @@
  3702.         if (!access_ok(VERIFY_WRITE, stats, sizeof(*stats)))
  3703.                 return -EFAULT;
  3704.  
  3705. -       err = drm_ioctl(file, DRM_IOCTL_GET_STATS, (unsigned long)stats);
  3706. +       err = lbm_drm_ioctl(file, DRM_IOCTL_GET_STATS, (unsigned long)stats);
  3707.         if (err)
  3708.                 return err;
  3709.  
  3710.  -388,7 +388,7 @@
  3711.             || __put_user(agp_start, &buf->agp_start))
  3712.                 return -EFAULT;
  3713.  
  3714. -       err = drm_ioctl(file, DRM_IOCTL_ADD_BUFS, (unsigned long)buf);
  3715. +       err = lbm_drm_ioctl(file, DRM_IOCTL_ADD_BUFS, (unsigned long)buf);
  3716.         if (err)
  3717.                 return err;
  3718.  
  3719.  -419,7 +419,7 @@
  3720.             || __put_user(b32.high_mark, &buf->high_mark))
  3721.                 return -EFAULT;
  3722.  
  3723. -       return drm_ioctl(file, DRM_IOCTL_MARK_BUFS, (unsigned long)buf);
  3724. +       return lbm_drm_ioctl(file, DRM_IOCTL_MARK_BUFS, (unsigned long)buf);
  3725.  }
  3726.  
  3727.  typedef struct drm_buf_info32 {
  3728.  -460,7 +460,7 @@
  3729.             || __put_user(list, &request->list))
  3730.                 return -EFAULT;
  3731.  
  3732. -       err = drm_ioctl(file, DRM_IOCTL_INFO_BUFS, (unsigned long)request);
  3733. +       err = lbm_drm_ioctl(file, DRM_IOCTL_INFO_BUFS, (unsigned long)request);
  3734.         if (err)
  3735.                 return err;
  3736.  
  3737.  -521,7 +521,7 @@
  3738.             || __put_user(list, &request->list))
  3739.                 return -EFAULT;
  3740.  
  3741. -       err = drm_ioctl(file, DRM_IOCTL_MAP_BUFS, (unsigned long)request);
  3742. +       err = lbm_drm_ioctl(file, DRM_IOCTL_MAP_BUFS, (unsigned long)request);
  3743.         if (err)
  3744.                 return err;
  3745.  
  3746.  -567,7 +567,7 @@
  3747.                           &request->list))
  3748.                 return -EFAULT;
  3749.  
  3750. -       return drm_ioctl(file, DRM_IOCTL_FREE_BUFS, (unsigned long)request);
  3751. +       return lbm_drm_ioctl(file, DRM_IOCTL_FREE_BUFS, (unsigned long)request);
  3752.  }
  3753.  
  3754.  typedef struct drm_ctx_priv_map32 {
  3755.  -593,7 +593,7 @@
  3756.                           &request->handle))
  3757.                 return -EFAULT;
  3758.  
  3759. -       return drm_ioctl(file, DRM_IOCTL_SET_SAREA_CTX, (unsigned long)request);
  3760. +       return lbm_drm_ioctl(file, DRM_IOCTL_SET_SAREA_CTX, (unsigned long)request);
  3761.  }
  3762.  
  3763.  static int compat_drm_getsareactx(struct file *file, unsigned int cmd,
  3764.  -615,7 +615,7 @@
  3765.         if (__put_user(ctx_id, &request->ctx_id))
  3766.                 return -EFAULT;
  3767.  
  3768. -       err = drm_ioctl(file, DRM_IOCTL_GET_SAREA_CTX, (unsigned long)request);
  3769. +       err = lbm_drm_ioctl(file, DRM_IOCTL_GET_SAREA_CTX, (unsigned long)request);
  3770.         if (err)
  3771.                 return err;
  3772.  
  3773.  -650,7 +650,7 @@
  3774.                           &res->contexts))
  3775.                 return -EFAULT;
  3776.  
  3777. -       err = drm_ioctl(file, DRM_IOCTL_RES_CTX, (unsigned long)res);
  3778. +       err = lbm_drm_ioctl(file, DRM_IOCTL_RES_CTX, (unsigned long)res);
  3779.         if (err)
  3780.                 return err;
  3781.  
  3782.  -703,7 +703,7 @@
  3783.                           &d->request_sizes))
  3784.                 return -EFAULT;
  3785.  
  3786. -       err = drm_ioctl(file, DRM_IOCTL_DMA, (unsigned long)d);
  3787. +       err = lbm_drm_ioctl(file, DRM_IOCTL_DMA, (unsigned long)d);
  3788.         if (err)
  3789.                 return err;
  3790.  
  3791.  -735,7 +735,7 @@
  3792.         if (put_user(m32.mode, &mode->mode))
  3793.                 return -EFAULT;
  3794.  
  3795. -       return drm_ioctl(file, DRM_IOCTL_AGP_ENABLE, (unsigned long)mode);
  3796. +       return lbm_drm_ioctl(file, DRM_IOCTL_AGP_ENABLE, (unsigned long)mode);
  3797.  }
  3798.  
  3799.  typedef struct drm_agp_info32 {
  3800.  -757,14 +757,14 @@
  3801.  {
  3802.         drm_agp_info32_t __user *argp = (void __user *)arg;
  3803.         drm_agp_info32_t i32;
  3804. -       struct drm_agp_info __user *info;
  3805. +       struct lbm_drm_agp_info __user *info;
  3806.         int err;
  3807.  
  3808.         info = compat_alloc_user_space(sizeof(*info));
  3809.         if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
  3810.                 return -EFAULT;
  3811.  
  3812. -       err = drm_ioctl(file, DRM_IOCTL_AGP_INFO, (unsigned long)info);
  3813. +       err = lbm_drm_ioctl(file, DRM_IOCTL_AGP_INFO, (unsigned long)info);
  3814.         if (err)
  3815.                 return err;
  3816.  
  3817.  -809,14 +809,14 @@
  3818.             || __put_user(req32.type, &request->type))
  3819.                 return -EFAULT;
  3820.  
  3821. -       err = drm_ioctl(file, DRM_IOCTL_AGP_ALLOC, (unsigned long)request);
  3822. +       err = lbm_drm_ioctl(file, DRM_IOCTL_AGP_ALLOC, (unsigned long)request);
  3823.         if (err)
  3824.                 return err;
  3825.  
  3826.         if (__get_user(req32.handle, &request->handle)
  3827.             || __get_user(req32.physical, &request->physical)
  3828.             || copy_to_user(argp, &req32, sizeof(req32))) {
  3829. -               drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
  3830. +               lbm_drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
  3831.                 return -EFAULT;
  3832.         }
  3833.  
  3834.  -836,7 +836,7 @@
  3835.             || __put_user(handle, &request->handle))
  3836.                 return -EFAULT;
  3837.  
  3838. -       return drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
  3839. +       return lbm_drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
  3840.  }
  3841.  
  3842.  typedef struct drm_agp_binding32 {
  3843.  -860,7 +860,7 @@
  3844.             || __put_user(req32.offset, &request->offset))
  3845.                 return -EFAULT;
  3846.  
  3847. -       return drm_ioctl(file, DRM_IOCTL_AGP_BIND, (unsigned long)request);
  3848. +       return lbm_drm_ioctl(file, DRM_IOCTL_AGP_BIND, (unsigned long)request);
  3849.  }
  3850.  
  3851.  static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,
  3852.  -876,7 +876,7 @@
  3853.             || __put_user(handle, &request->handle))
  3854.                 return -EFAULT;
  3855.  
  3856. -       return drm_ioctl(file, DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
  3857. +       return lbm_drm_ioctl(file, DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
  3858.  }
  3859.  #endif                         /* __OS_HAS_AGP */
  3860.  
  3861.  -900,7 +900,7 @@
  3862.             || __put_user(x, &request->size))
  3863.                 return -EFAULT;
  3864.  
  3865. -       err = drm_ioctl(file, DRM_IOCTL_SG_ALLOC, (unsigned long)request);
  3866. +       err = lbm_drm_ioctl(file, DRM_IOCTL_SG_ALLOC, (unsigned long)request);
  3867.         if (err)
  3868.                 return err;
  3869.  
  3870.  -926,7 +926,7 @@
  3871.             || __put_user(x << PAGE_SHIFT, &request->handle))
  3872.                 return -EFAULT;
  3873.  
  3874. -       return drm_ioctl(file, DRM_IOCTL_SG_FREE, (unsigned long)request);
  3875. +       return lbm_drm_ioctl(file, DRM_IOCTL_SG_FREE, (unsigned long)request);
  3876.  }
  3877.  
  3878.  #if defined(CONFIG_X86) || defined(CONFIG_IA64)
  3879.  -956,7 +956,7 @@
  3880.             __put_user(update32.data, &request->data))
  3881.                 return -EFAULT;
  3882.  
  3883. -       err = drm_ioctl(file, DRM_IOCTL_UPDATE_DRAW, (unsigned long)request);
  3884. +       err = lbm_drm_ioctl(file, DRM_IOCTL_UPDATE_DRAW, (unsigned long)request);
  3885.         return err;
  3886.  }
  3887.  #endif
  3888.  -997,7 +997,7 @@
  3889.             || __put_user(req32.request.signal, &request->request.signal))
  3890.                 return -EFAULT;
  3891.  
  3892. -       err = drm_ioctl(file, DRM_IOCTL_WAIT_VBLANK, (unsigned long)request);
  3893. +       err = lbm_drm_ioctl(file, DRM_IOCTL_WAIT_VBLANK, (unsigned long)request);
  3894.         if (err)
  3895.                 return err;
  3896.  
  3897.  -1056,7 +1056,7 @@
  3898.   * \param arg user argument.
  3899.   * \return zero on success or negative number on failure.
  3900.   */
  3901. -long drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  3902. +long lbm_drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  3903.  {
  3904.         unsigned int nr = DRM_IOCTL_NR(cmd);
  3905.         drm_ioctl_compat_t *fn;
  3906.  -1067,16 +1067,16 @@
  3907.          * than always failing.
  3908.          */
  3909.         if (nr >= ARRAY_SIZE(drm_compat_ioctls))
  3910. -               return drm_ioctl(filp, cmd, arg);
  3911. +               return lbm_drm_ioctl(filp, cmd, arg);
  3912.  
  3913.         fn = drm_compat_ioctls[nr];
  3914.  
  3915.         if (fn != NULL)
  3916.                 ret = (*fn) (filp, cmd, arg);
  3917.         else
  3918. -               ret = drm_ioctl(filp, cmd, arg);
  3919. +               ret = lbm_drm_ioctl(filp, cmd, arg);
  3920.  
  3921.         return ret;
  3922.  }
  3923.  
  3924. -EXPORT_SYMBOL(drm_compat_ioctl);
  3925. +EXPORT_SYMBOL(lbm_drm_compat_ioctl);
  3926. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioctl.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioctl.c
  3927. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioctl.c   2010-01-25 15:21:29.000000000 -0500
  3928. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_ioctl.c   2010-02-03 17:11:08.000000000 -0500
  3929.  -1,5 +1,5 @@
  3930.  /**
  3931. - * \file drm_ioctl.c
  3932. + * \file lbm_drm_ioctl.c
  3933.   * IOCTL processing for DRM
  3934.   *
  3935.   * \author Rickard E. (Rik) Faith <faith@valinux.com>
  3936. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_irq.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_irq.c
  3937. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_irq.c     2010-01-25 15:21:29.000000000 -0500
  3938. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_irq.c     2010-02-03 17:11:09.000000000 -0500
  3939.  -95,9 +95,9 @@
  3940.         }
  3941.  }
  3942.  
  3943. -void drm_vblank_cleanup(struct drm_device *dev)
  3944. +void lbm_drm_vblank_cleanup(struct drm_device *dev)
  3945.  {
  3946. -       /* Bail if the driver didn't call drm_vblank_init() */
  3947. +       /* Bail if the driver didn't call lbm_drm_vblank_init() */
  3948.         if (dev->num_crtcs == 0)
  3949.                 return;
  3950.  
  3951.  -115,9 +115,9 @@
  3952.  
  3953.         dev->num_crtcs = 0;
  3954.  }
  3955. -EXPORT_SYMBOL(drm_vblank_cleanup);
  3956. +EXPORT_SYMBOL(lbm_drm_vblank_cleanup);
  3957.  
  3958. -int drm_vblank_init(struct drm_device *dev, int num_crtcs)
  3959. +int lbm_drm_vblank_init(struct drm_device *dev, int num_crtcs)
  3960.  {
  3961.         int i, ret = -ENOMEM;
  3962.  
  3963.  -167,10 +167,10 @@
  3964.         return 0;
  3965.  
  3966.  err:
  3967. -       drm_vblank_cleanup(dev);
  3968. +       lbm_drm_vblank_cleanup(dev);
  3969.         return ret;
  3970.  }
  3971. -EXPORT_SYMBOL(drm_vblank_init);
  3972. +EXPORT_SYMBOL(lbm_drm_vblank_init);
  3973.  
  3974.  static void drm_irq_vgaarb_nokms(void *cookie, bool state)
  3975.  {
  3976.  -201,7 +201,7 @@
  3977.   * \c drm_driver_irq_preinstall() and \c drm_driver_irq_postinstall() functions
  3978.   * before and after the installation.
  3979.   */
  3980. -int drm_irq_install(struct drm_device *dev)
  3981. +int lbm_drm_irq_install(struct drm_device *dev)
  3982.  {
  3983.         int ret = 0;
  3984.         unsigned long sh_flags = 0;
  3985.  -265,7 +265,7 @@
  3986.  
  3987.         return ret;
  3988.  }
  3989. -EXPORT_SYMBOL(drm_irq_install);
  3990. +EXPORT_SYMBOL(lbm_drm_irq_install);
  3991.  
  3992.  /**
  3993.   * Uninstall the IRQ handler.
  3994.  -274,7 +274,7 @@
  3995.   *
  3996.   * Calls the driver's \c drm_driver_irq_uninstall() function, and stops the irq.
  3997.   */
  3998. -int drm_irq_uninstall(struct drm_device * dev)
  3999. +int lbm_drm_irq_uninstall(struct drm_device * dev)
  4000.  {
  4001.         unsigned long irqflags;
  4002.         int irq_enabled, i;
  4003.  -312,7 +312,7 @@
  4004.  
  4005.         return 0;
  4006.  }
  4007. -EXPORT_SYMBOL(drm_irq_uninstall);
  4008. +EXPORT_SYMBOL(lbm_drm_irq_uninstall);
  4009.  
  4010.  /**
  4011.   * IRQ control ioctl.
  4012.  -342,20 +342,20 @@
  4013.                 if (dev->if_version < DRM_IF_VERSION(1, 2) &&
  4014.                     ctl->irq != dev->pdev->irq)
  4015.                         return -EINVAL;
  4016. -               return drm_irq_install(dev);
  4017. +               return lbm_drm_irq_install(dev);
  4018.         case DRM_UNINST_HANDLER:
  4019.                 if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
  4020.                         return 0;
  4021.                 if (drm_core_check_feature(dev, DRIVER_MODESET))
  4022.                         return 0;
  4023. -               return drm_irq_uninstall(dev);
  4024. +               return lbm_drm_irq_uninstall(dev);
  4025.         default:
  4026.                 return -EINVAL;
  4027.         }
  4028.  }
  4029.  
  4030.  /**
  4031. - * drm_vblank_count - retrieve "cooked" vblank counter value
  4032. + * lbm_drm_vblank_count - retrieve "cooked" vblank counter value
  4033.   * @dev: DRM device
  4034.   * @crtc: which counter to retrieve
  4035.   *
  4036.  -363,11 +363,11 @@
  4037.   * vblank events since the system was booted, including lost events due to
  4038.   * modesetting activity.
  4039.   */
  4040. -u32 drm_vblank_count(struct drm_device *dev, int crtc)
  4041. +u32 lbm_drm_vblank_count(struct drm_device *dev, int crtc)
  4042.  {
  4043.         return atomic_read(&dev->_vblank_count[crtc]);
  4044.  }
  4045. -EXPORT_SYMBOL(drm_vblank_count);
  4046. +EXPORT_SYMBOL(lbm_drm_vblank_count);
  4047.  
  4048.  /**
  4049.   * drm_update_vblank_count - update the master vblank counter
  4050.  -412,7 +412,7 @@
  4051.  }
  4052.  
  4053.  /**
  4054. - * drm_vblank_get - get a reference count on vblank events
  4055. + * lbm_drm_vblank_get - get a reference count on vblank events
  4056.   * @dev: DRM device
  4057.   * @crtc: which CRTC to own
  4058.   *
  4059.  -422,7 +422,7 @@
  4060.   * RETURNS
  4061.   * Zero on success, nonzero on failure.
  4062.   */
  4063. -int drm_vblank_get(struct drm_device *dev, int crtc)
  4064. +int lbm_drm_vblank_get(struct drm_device *dev, int crtc)
  4065.  {
  4066.         unsigned long irqflags;
  4067.         int ret = 0;
  4068.  -450,17 +450,17 @@
  4069.  
  4070.         return ret;
  4071.  }
  4072. -EXPORT_SYMBOL(drm_vblank_get);
  4073. +EXPORT_SYMBOL(lbm_drm_vblank_get);
  4074.  
  4075.  /**
  4076. - * drm_vblank_put - give up ownership of vblank events
  4077. + * lbm_drm_vblank_put - give up ownership of vblank events
  4078.   * @dev: DRM device
  4079.   * @crtc: which counter to give up
  4080.   *
  4081.   * Release ownership of a given vblank counter, turning off interrupts
  4082.   * if possible.
  4083.   */
  4084. -void drm_vblank_put(struct drm_device *dev, int crtc)
  4085. +void lbm_drm_vblank_put(struct drm_device *dev, int crtc)
  4086.  {
  4087.         BUG_ON (atomic_read (&dev->vblank_refcount[crtc]) == 0);
  4088.  
  4089.  -468,9 +468,9 @@
  4090.         if (atomic_dec_and_test(&dev->vblank_refcount[crtc]))
  4091.                 mod_timer(&dev->vblank_disable_timer, jiffies + 5*DRM_HZ);
  4092.  }
  4093. -EXPORT_SYMBOL(drm_vblank_put);
  4094. +EXPORT_SYMBOL(lbm_drm_vblank_put);
  4095.  
  4096. -void drm_vblank_off(struct drm_device *dev, int crtc)
  4097. +void lbm_drm_vblank_off(struct drm_device *dev, int crtc)
  4098.  {
  4099.         unsigned long irqflags;
  4100.  
  4101.  -480,10 +480,10 @@
  4102.         dev->last_vblank[crtc] = dev->driver->get_vblank_counter(dev, crtc);
  4103.         spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
  4104.  }
  4105. -EXPORT_SYMBOL(drm_vblank_off);
  4106. +EXPORT_SYMBOL(lbm_drm_vblank_off);
  4107.  
  4108.  /**
  4109. - * drm_vblank_pre_modeset - account for vblanks across mode sets
  4110. + * lbm_drm_vblank_pre_modeset - account for vblanks across mode sets
  4111.   * @dev: DRM device
  4112.   * @crtc: CRTC in question
  4113.   * @post: post or pre mode set?
  4114.  -491,7 +491,7 @@
  4115.   * Account for vblank events across mode setting events, which will likely
  4116.   * reset the hardware frame counter.
  4117.   */
  4118. -void drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
  4119. +void lbm_drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
  4120.  {
  4121.         /* vblank is not initialized (IRQ not installed ?) */
  4122.         if (!dev->num_crtcs)
  4123.  -505,13 +505,13 @@
  4124.          */
  4125.         if (!dev->vblank_inmodeset[crtc]) {
  4126.                 dev->vblank_inmodeset[crtc] = 0x1;
  4127. -               if (drm_vblank_get(dev, crtc) == 0)
  4128. +               if (lbm_drm_vblank_get(dev, crtc) == 0)
  4129.                         dev->vblank_inmodeset[crtc] |= 0x2;
  4130.         }
  4131.  }
  4132. -EXPORT_SYMBOL(drm_vblank_pre_modeset);
  4133. +EXPORT_SYMBOL(lbm_drm_vblank_pre_modeset);
  4134.  
  4135. -void drm_vblank_post_modeset(struct drm_device *dev, int crtc)
  4136. +void lbm_drm_vblank_post_modeset(struct drm_device *dev, int crtc)
  4137.  {
  4138.         unsigned long irqflags;
  4139.  
  4140.  -521,12 +521,12 @@
  4141.                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
  4142.  
  4143.                 if (dev->vblank_inmodeset[crtc] & 0x2)
  4144. -                       drm_vblank_put(dev, crtc);
  4145. +                       lbm_drm_vblank_put(dev, crtc);
  4146.  
  4147.                 dev->vblank_inmodeset[crtc] = 0;
  4148.         }
  4149.  }
  4150. -EXPORT_SYMBOL(drm_vblank_post_modeset);
  4151. +EXPORT_SYMBOL(lbm_drm_vblank_post_modeset);
  4152.  
  4153.  /**
  4154.   * drm_modeset_ctl - handle vblank event counter changes across mode switch
  4155.  -545,7 +545,7 @@
  4156.         struct drm_modeset_ctl *modeset = data;
  4157.         int crtc, ret = 0;
  4158.  
  4159. -       /* If drm_vblank_init() hasn't been called yet, just no-op */
  4160. +       /* If lbm_drm_vblank_init() hasn't been called yet, just no-op */
  4161.         if (!dev->num_crtcs)
  4162.                 goto out;
  4163.  
  4164.  -557,10 +557,10 @@
  4165.  
  4166.         switch (modeset->cmd) {
  4167.         case _DRM_PRE_MODESET:
  4168. -               drm_vblank_pre_modeset(dev, crtc);
  4169. +               lbm_drm_vblank_pre_modeset(dev, crtc);
  4170.                 break;
  4171.         case _DRM_POST_MODESET:
  4172. -               drm_vblank_post_modeset(dev, crtc);
  4173. +               lbm_drm_vblank_post_modeset(dev, crtc);
  4174.                 break;
  4175.         default:
  4176.                 ret = -EINVAL;
  4177.  -602,7 +602,7 @@
  4178.         }
  4179.  
  4180.         file_priv->event_space -= sizeof e->event;
  4181. -       seq = drm_vblank_count(dev, pipe);
  4182. +       seq = lbm_drm_vblank_count(dev, pipe);
  4183.         if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) &&
  4184.             (seq - vblwait->request.sequence) <= (1 << 23)) {
  4185.                 vblwait->request.sequence = seq + 1;
  4186.  -616,7 +616,7 @@
  4187.         if ((seq - vblwait->request.sequence) <= (1 << 23)) {
  4188.                 e->event.tv_sec = now.tv_sec;
  4189.                 e->event.tv_usec = now.tv_usec;
  4190. -               drm_vblank_put(dev, e->pipe);
  4191. +               lbm_drm_vblank_put(dev, e->pipe);
  4192.                 list_add_tail(&e->base.link, &e->base.file_priv->event_list);
  4193.                 wake_up_interruptible(&e->base.file_priv->event_wait);
  4194.         } else {
  4195.  -669,12 +669,12 @@
  4196.         if (crtc >= dev->num_crtcs)
  4197.                 return -EINVAL;
  4198.  
  4199. -       ret = drm_vblank_get(dev, crtc);
  4200. +       ret = lbm_drm_vblank_get(dev, crtc);
  4201.         if (ret) {
  4202.                 DRM_DEBUG("failed to acquire vblank counter, %d\n", ret);
  4203.                 return ret;
  4204.         }
  4205. -       seq = drm_vblank_count(dev, crtc);
  4206. +       seq = lbm_drm_vblank_count(dev, crtc);
  4207.  
  4208.         switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
  4209.         case _DRM_VBLANK_RELATIVE:
  4210.  -699,7 +699,7 @@
  4211.                   vblwait->request.sequence, crtc);
  4212.         dev->last_vblank_wait[crtc] = vblwait->request.sequence;
  4213.         DRM_WAIT_ON(ret, dev->vbl_queue[crtc], 3 * DRM_HZ,
  4214. -                   (((drm_vblank_count(dev, crtc) -
  4215. +                   (((lbm_drm_vblank_count(dev, crtc) -
  4216.                        vblwait->request.sequence) <= (1 << 23)) ||
  4217.                      !dev->irq_enabled));
  4218.  
  4219.  -710,7 +710,7 @@
  4220.  
  4221.                 vblwait->reply.tval_sec = now.tv_sec;
  4222.                 vblwait->reply.tval_usec = now.tv_usec;
  4223. -               vblwait->reply.sequence = drm_vblank_count(dev, crtc);
  4224. +               vblwait->reply.sequence = lbm_drm_vblank_count(dev, crtc);
  4225.                 DRM_DEBUG("returning %d to client\n",
  4226.                           vblwait->reply.sequence);
  4227.         } else {
  4228.  -718,7 +718,7 @@
  4229.         }
  4230.  
  4231.  done:
  4232. -       drm_vblank_put(dev, crtc);
  4233. +       lbm_drm_vblank_put(dev, crtc);
  4234.         return ret;
  4235.  }
  4236.  
  4237.  -730,7 +730,7 @@
  4238.         unsigned int seq;
  4239.  
  4240.         do_gettimeofday(&now);
  4241. -       seq = drm_vblank_count(dev, crtc);
  4242. +       seq = lbm_drm_vblank_count(dev, crtc);
  4243.  
  4244.         spin_lock_irqsave(&dev->event_lock, flags);
  4245.  
  4246.  -746,7 +746,7 @@
  4247.                 e->event.sequence = seq;
  4248.                 e->event.tv_sec = now.tv_sec;
  4249.                 e->event.tv_usec = now.tv_usec;
  4250. -               drm_vblank_put(dev, e->pipe);
  4251. +               lbm_drm_vblank_put(dev, e->pipe);
  4252.                 list_move_tail(&e->base.link, &e->base.file_priv->event_list);
  4253.                 wake_up_interruptible(&e->base.file_priv->event_wait);
  4254.         }
  4255.  -755,14 +755,14 @@
  4256.  }
  4257.  
  4258.  /**
  4259. - * drm_handle_vblank - handle a vblank event
  4260. + * lbm_drm_handle_vblank - handle a vblank event
  4261.   * @dev: DRM device
  4262.   * @crtc: where this event occurred
  4263.   *
  4264.   * Drivers should call this routine in their vblank interrupt handlers to
  4265.   * update the vblank counter and send any signals that may be pending.
  4266.   */
  4267. -void drm_handle_vblank(struct drm_device *dev, int crtc)
  4268. +void lbm_drm_handle_vblank(struct drm_device *dev, int crtc)
  4269.  {
  4270.         if (!dev->num_crtcs)
  4271.                 return;
  4272.  -771,4 +771,4 @@
  4273.         DRM_WAKEUP(&dev->vbl_queue[crtc]);
  4274.         drm_handle_vblank_events(dev, crtc);
  4275.  }
  4276. -EXPORT_SYMBOL(drm_handle_vblank);
  4277. +EXPORT_SYMBOL(lbm_drm_handle_vblank);
  4278. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_lock.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_lock.c
  4279. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_lock.c    2010-01-25 15:21:29.000000000 -0500
  4280. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_lock.c    2010-02-03 17:11:08.000000000 -0500
  4281.  -84,7 +84,7 @@
  4282.                         ret = -EINTR;
  4283.                         break;
  4284.                 }
  4285. -               if (drm_lock_take(&master->lock, lock->context)) {
  4286. +               if (lbm_drm_lock_take(&master->lock, lock->context)) {
  4287.                         master->lock.file_priv = file_priv;
  4288.                         master->lock.lock_time = jiffies;
  4289.                         atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
  4290.  -173,7 +173,7 @@
  4291.         if (dev->driver->kernel_context_switch_unlock)
  4292.                 dev->driver->kernel_context_switch_unlock(dev);
  4293.         else {
  4294. -               if (drm_lock_free(&master->lock, lock->context)) {
  4295. +               if (lbm_drm_lock_free(&master->lock, lock->context)) {
  4296.                         /* FIXME: Should really bail out here. */
  4297.                 }
  4298.         }
  4299.  -191,7 +191,7 @@
  4300.   *
  4301.   * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
  4302.   */
  4303. -int drm_lock_take(struct drm_lock_data *lock_data,
  4304. +int lbm_drm_lock_take(struct drm_lock_data *lock_data,
  4305.                   unsigned int context)
  4306.  {
  4307.         unsigned int old, new, prev;
  4308.  -227,7 +227,7 @@
  4309.         }
  4310.         return 0;
  4311.  }
  4312. -EXPORT_SYMBOL(drm_lock_take);
  4313. +EXPORT_SYMBOL(lbm_drm_lock_take);
  4314.  
  4315.  /**
  4316.   * This takes a lock forcibly and hands it to context. Should ONLY be used
  4317.  -267,7 +267,7 @@
  4318.   * Marks the lock as not held, via the \p cmpxchg instruction. Wakes any task
  4319.   * waiting on the lock queue.
  4320.   */
  4321. -int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context)
  4322. +int lbm_drm_lock_free(struct drm_lock_data *lock_data, unsigned int context)
  4323.  {
  4324.         unsigned int old, new, prev;
  4325.         volatile unsigned int *lock = &lock_data->hw_lock->lock;
  4326.  -295,7 +295,7 @@
  4327.         wake_up_interruptible(&lock_data->lock_queue);
  4328.         return 0;
  4329.  }
  4330. -EXPORT_SYMBOL(drm_lock_free);
  4331. +EXPORT_SYMBOL(lbm_drm_lock_free);
  4332.  
  4333.  /**
  4334.   * If we get here, it means that the process has called DRM_IOCTL_LOCK
  4335.  -341,7 +341,7 @@
  4336.   * having to worry about starvation.
  4337.   */
  4338.  
  4339. -void drm_idlelock_take(struct drm_lock_data *lock_data)
  4340. +void lbm_drm_idlelock_take(struct drm_lock_data *lock_data)
  4341.  {
  4342.         int ret = 0;
  4343.  
  4344.  -350,7 +350,7 @@
  4345.         if (!lock_data->idle_has_lock) {
  4346.  
  4347.                 spin_unlock_bh(&lock_data->spinlock);
  4348. -               ret = drm_lock_take(lock_data, DRM_KERNEL_CONTEXT);
  4349. +               ret = lbm_drm_lock_take(lock_data, DRM_KERNEL_CONTEXT);
  4350.                 spin_lock_bh(&lock_data->spinlock);
  4351.  
  4352.                 if (ret == 1)
  4353.  -358,9 +358,9 @@
  4354.         }
  4355.         spin_unlock_bh(&lock_data->spinlock);
  4356.  }
  4357. -EXPORT_SYMBOL(drm_idlelock_take);
  4358. +EXPORT_SYMBOL(lbm_drm_idlelock_take);
  4359.  
  4360. -void drm_idlelock_release(struct drm_lock_data *lock_data)
  4361. +void lbm_drm_idlelock_release(struct drm_lock_data *lock_data)
  4362.  {
  4363.         unsigned int old, prev;
  4364.         volatile unsigned int *lock = &lock_data->hw_lock->lock;
  4365.  -378,10 +378,10 @@
  4366.         }
  4367.         spin_unlock_bh(&lock_data->spinlock);
  4368.  }
  4369. -EXPORT_SYMBOL(drm_idlelock_release);
  4370. +EXPORT_SYMBOL(lbm_drm_idlelock_release);
  4371.  
  4372.  
  4373. -int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv)
  4374. +int lbm_drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv)
  4375.  {
  4376.         struct drm_master *master = file_priv->master;
  4377.         return (file_priv->lock_count && master->lock.hw_lock &&
  4378.  -389,4 +389,4 @@
  4379.                 master->lock.file_priv == file_priv);
  4380.  }
  4381.  
  4382. -EXPORT_SYMBOL(drm_i_have_hw_lock);
  4383. +EXPORT_SYMBOL(lbm_drm_i_have_hw_lock);
  4384. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_memory.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_memory.c
  4385. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_memory.c  2010-01-25 15:21:29.000000000 -0500
  4386. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_memory.c  2010-02-03 17:11:08.000000000 -0500
  4387.  -106,11 +106,11 @@
  4388.  }
  4389.  
  4390.  /** Wrapper around agp_free_memory() */
  4391. -int drm_free_agp(DRM_AGP_MEM * handle, int pages)
  4392. +int lbm_drm_free_agp(DRM_AGP_MEM * handle, int pages)
  4393.  {
  4394.         return drm_agp_free_memory(handle) ? 0 : -EINVAL;
  4395.  }
  4396. -EXPORT_SYMBOL(drm_free_agp);
  4397. +EXPORT_SYMBOL(lbm_drm_free_agp);
  4398.  
  4399.  /** Wrapper around agp_bind_memory() */
  4400.  int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start)
  4401.  -119,11 +119,11 @@
  4402.  }
  4403.  
  4404.  /** Wrapper around agp_unbind_memory() */
  4405. -int drm_unbind_agp(DRM_AGP_MEM * handle)
  4406. +int lbm_drm_unbind_agp(DRM_AGP_MEM * handle)
  4407.  {
  4408.         return drm_agp_unbind_memory(handle);
  4409.  }
  4410. -EXPORT_SYMBOL(drm_unbind_agp);
  4411. +EXPORT_SYMBOL(lbm_drm_unbind_agp);
  4412.  
  4413.  #else  /*  __OS_HAS_AGP  */
  4414.  static inline void *agp_remap(unsigned long offset, unsigned long size,
  4415.  -134,7 +134,7 @@
  4416.  
  4417.  #endif                         /* agp */
  4418.  
  4419. -void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev)
  4420. +void lbm_drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev)
  4421.  {
  4422.         if (drm_core_has_AGP(dev) &&
  4423.             dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
  4424.  -142,9 +142,9 @@
  4425.         else
  4426.                 map->handle = ioremap(map->offset, map->size);
  4427.  }
  4428. -EXPORT_SYMBOL(drm_core_ioremap);
  4429. +EXPORT_SYMBOL(lbm_drm_core_ioremap);
  4430.  
  4431. -void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev)
  4432. +void lbm_drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev)
  4433.  {
  4434.         if (drm_core_has_AGP(dev) &&
  4435.             dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
  4436.  -152,9 +152,9 @@
  4437.         else
  4438.                 map->handle = ioremap_wc(map->offset, map->size);
  4439.  }
  4440. -EXPORT_SYMBOL(drm_core_ioremap_wc);
  4441. +EXPORT_SYMBOL(lbm_drm_core_ioremap_wc);
  4442.  
  4443. -void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev)
  4444. +void lbm_drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev)
  4445.  {
  4446.         if (!map->handle || !map->size)
  4447.                 return;
  4448.  -165,4 +165,4 @@
  4449.         else
  4450.                 iounmap(map->handle);
  4451.  }
  4452. -EXPORT_SYMBOL(drm_core_ioremapfree);
  4453. +EXPORT_SYMBOL(lbm_drm_core_ioremapfree);
  4454. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_mm.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_mm.c
  4455. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_mm.c      2010-01-25 15:21:29.000000000 -0500
  4456. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_mm.c      2010-02-03 17:11:08.000000000 -0500
  4457.  -103,12 +103,12 @@
  4458.         return child;
  4459.  }
  4460.  
  4461. -/* drm_mm_pre_get() - pre allocate drm_mm_node structure
  4462. +/* lbm_drm_mm_pre_get() - pre allocate drm_mm_node structure
  4463.   * drm_mm:     memory manager struct we are pre-allocating for
  4464.   *
  4465.   * Returns 0 on success or -ENOMEM if allocation fails.
  4466.   */
  4467. -int drm_mm_pre_get(struct drm_mm *mm)
  4468. +int lbm_drm_mm_pre_get(struct drm_mm *mm)
  4469.  {
  4470.         struct drm_mm_node *node;
  4471.  
  4472.  -129,7 +129,7 @@
  4473.         spin_unlock(&mm->unused_lock);
  4474.         return 0;
  4475.  }
  4476. -EXPORT_SYMBOL(drm_mm_pre_get);
  4477. +EXPORT_SYMBOL(lbm_drm_mm_pre_get);
  4478.  
  4479.  static int drm_mm_create_tail_node(struct drm_mm *mm,
  4480.                                    unsigned long start,
  4481.  -193,7 +193,7 @@
  4482.  }
  4483.  
  4484.  
  4485. -struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *node,
  4486. +struct drm_mm_node *lbm_drm_mm_get_block_generic(struct drm_mm_node *node,
  4487.                                              unsigned long size,
  4488.                                              unsigned alignment,
  4489.                                              int atomic)
  4490.  -220,13 +220,13 @@
  4491.         }
  4492.  
  4493.         if (align_splitoff)
  4494. -               drm_mm_put_block(align_splitoff);
  4495. +               lbm_drm_mm_put_block(align_splitoff);
  4496.  
  4497.         return node;
  4498.  }
  4499. -EXPORT_SYMBOL(drm_mm_get_block_generic);
  4500. +EXPORT_SYMBOL(lbm_drm_mm_get_block_generic);
  4501.  
  4502. -struct drm_mm_node *drm_mm_get_block_range_generic(struct drm_mm_node *node,
  4503. +struct drm_mm_node *lbm_drm_mm_get_block_range_generic(struct drm_mm_node *node,
  4504.                                                 unsigned long size,
  4505.                                                 unsigned alignment,
  4506.                                                 unsigned long start,
  4507.  -258,18 +258,18 @@
  4508.         }
  4509.  
  4510.         if (align_splitoff)
  4511. -               drm_mm_put_block(align_splitoff);
  4512. +               lbm_drm_mm_put_block(align_splitoff);
  4513.  
  4514.         return node;
  4515.  }
  4516. -EXPORT_SYMBOL(drm_mm_get_block_range_generic);
  4517. +EXPORT_SYMBOL(lbm_drm_mm_get_block_range_generic);
  4518.  
  4519.  /*
  4520.   * Put a block. Merge with the previous and / or next block if they are free.
  4521.   * Otherwise add to the free stack.
  4522.   */
  4523.  
  4524. -void drm_mm_put_block(struct drm_mm_node *cur)
  4525. +void lbm_drm_mm_put_block(struct drm_mm_node *cur)
  4526.  {
  4527.  
  4528.         struct drm_mm *mm = cur->mm;
  4529.  -326,9 +326,9 @@
  4530.         }
  4531.  }
  4532.  
  4533. -EXPORT_SYMBOL(drm_mm_put_block);
  4534. +EXPORT_SYMBOL(lbm_drm_mm_put_block);
  4535.  
  4536. -struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm,
  4537. +struct drm_mm_node *lbm_drm_mm_search_free(const struct drm_mm *mm,
  4538.                                        unsigned long size,
  4539.                                        unsigned alignment, int best_match)
  4540.  {
  4541.  -367,9 +367,9 @@
  4542.  
  4543.         return best;
  4544.  }
  4545. -EXPORT_SYMBOL(drm_mm_search_free);
  4546. +EXPORT_SYMBOL(lbm_drm_mm_search_free);
  4547.  
  4548. -struct drm_mm_node *drm_mm_search_free_in_range(const struct drm_mm *mm,
  4549. +struct drm_mm_node *lbm_drm_mm_search_free_in_range(const struct drm_mm *mm,
  4550.                                                 unsigned long size,
  4551.                                                 unsigned alignment,
  4552.                                                 unsigned long start,
  4553.  -417,17 +417,17 @@
  4554.  
  4555.         return best;
  4556.  }
  4557. -EXPORT_SYMBOL(drm_mm_search_free_in_range);
  4558. +EXPORT_SYMBOL(lbm_drm_mm_search_free_in_range);
  4559.  
  4560. -int drm_mm_clean(struct drm_mm * mm)
  4561. +int lbm_drm_mm_clean(struct drm_mm * mm)
  4562.  {
  4563.         struct list_head *head = &mm->ml_entry;
  4564.  
  4565.         return (head->next->next == head);
  4566.  }
  4567. -EXPORT_SYMBOL(drm_mm_clean);
  4568. +EXPORT_SYMBOL(lbm_drm_mm_clean);
  4569.  
  4570. -int drm_mm_init(struct drm_mm * mm, unsigned long start, unsigned long size)
  4571. +int lbm_drm_mm_init(struct drm_mm * mm, unsigned long start, unsigned long size)
  4572.  {
  4573.         INIT_LIST_HEAD(&mm->ml_entry);
  4574.         INIT_LIST_HEAD(&mm->fl_entry);
  4575.  -437,9 +437,9 @@
  4576.  
  4577.         return drm_mm_create_tail_node(mm, start, size, 0);
  4578.  }
  4579. -EXPORT_SYMBOL(drm_mm_init);
  4580. +EXPORT_SYMBOL(lbm_drm_mm_init);
  4581.  
  4582. -void drm_mm_takedown(struct drm_mm * mm)
  4583. +void lbm_drm_mm_takedown(struct drm_mm * mm)
  4584.  {
  4585.         struct list_head *bnode = mm->fl_entry.next;
  4586.         struct drm_mm_node *entry;
  4587.  -467,9 +467,9 @@
  4588.  
  4589.         BUG_ON(mm->num_unused != 0);
  4590.  }
  4591. -EXPORT_SYMBOL(drm_mm_takedown);
  4592. +EXPORT_SYMBOL(lbm_drm_mm_takedown);
  4593.  
  4594. -void drm_mm_debug_table(struct drm_mm *mm, const char *prefix)
  4595. +void lbm_drm_mm_debug_table(struct drm_mm *mm, const char *prefix)
  4596.  {
  4597.         struct drm_mm_node *entry;
  4598.         int total_used = 0, total_free = 0, total = 0;
  4599.  -487,10 +487,10 @@
  4600.         printk(KERN_DEBUG "%s total: %d, used %d free %d\n", prefix, total,
  4601.                 total_used, total_free);
  4602.  }
  4603. -EXPORT_SYMBOL(drm_mm_debug_table);
  4604. +EXPORT_SYMBOL(lbm_drm_mm_debug_table);
  4605.  
  4606.  #if defined(CONFIG_DEBUG_FS)
  4607. -int drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm)
  4608. +int lbm_drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm)
  4609.  {
  4610.         struct drm_mm_node *entry;
  4611.         int total_used = 0, total_free = 0, total = 0;
  4612.  -506,5 +506,5 @@
  4613.         seq_printf(m, "total: %d, used %d free %d\n", total, total_used, total_free);
  4614.         return 0;
  4615.  }
  4616. -EXPORT_SYMBOL(drm_mm_dump_table);
  4617. +EXPORT_SYMBOL(lbm_drm_mm_dump_table);
  4618.  #endif
  4619. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_modes.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_modes.c
  4620. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_modes.c   2010-01-25 15:21:29.000000000 -0500
  4621. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_modes.c   2010-02-03 17:11:08.000000000 -0500
  4622.  -37,7 +37,7 @@
  4623.  #include "drm_crtc.h"
  4624.  
  4625.  /**
  4626. - * drm_mode_debug_printmodeline - debug print a mode
  4627. + * lbm_drm_mode_debug_printmodeline - debug print a mode
  4628.   * @dev: DRM device
  4629.   * @mode: mode to print
  4630.   *
  4631.  -46,7 +46,7 @@
  4632.   *
  4633.   * Describe @mode using DRM_DEBUG.
  4634.   */
  4635. -void drm_mode_debug_printmodeline(struct drm_display_mode *mode)
  4636. +void lbm_drm_mode_debug_printmodeline(struct drm_display_mode *mode)
  4637.  {
  4638.         DRM_DEBUG_KMS("Modeline %d:\"%s\" %d %d %d %d %d %d %d %d %d %d "
  4639.                         "0x%x 0x%x\n",
  4640.  -56,10 +56,10 @@
  4641.                 mode->vdisplay, mode->vsync_start,
  4642.                 mode->vsync_end, mode->vtotal, mode->type, mode->flags);
  4643.  }
  4644. -EXPORT_SYMBOL(drm_mode_debug_printmodeline);
  4645. +EXPORT_SYMBOL(lbm_drm_mode_debug_printmodeline);
  4646.  
  4647.  /**
  4648. - * drm_cvt_mode -create a modeline based on CVT algorithm
  4649. + * lbm_drm_cvt_mode -create a modeline based on CVT algorithm
  4650.   * @dev: DRM device
  4651.   * @hdisplay: hdisplay size
  4652.   * @vdisplay: vdisplay size
  4653.  -82,7 +82,7 @@
  4654.   * What I have done is to translate it by using integer calculation.
  4655.   */
  4656.  #define HV_FACTOR                      1000
  4657. -struct drm_display_mode *drm_cvt_mode(struct drm_device *dev, int hdisplay,
  4658. +struct drm_display_mode *lbm_drm_cvt_mode(struct drm_device *dev, int hdisplay,
  4659.                                       int vdisplay, int vrefresh,
  4660.                                       bool reduced, bool interlaced, bool margins)
  4661.  {
  4662.  -104,7 +104,7 @@
  4663.         /* allocate the drm_display_mode structure. If failure, we will
  4664.          * return directly
  4665.          */
  4666. -       drm_mode = drm_mode_create(dev);
  4667. +       drm_mode = lbm_drm_mode_create(dev);
  4668.         if (!drm_mode)
  4669.                 return NULL;
  4670.  
  4671.  -261,7 +261,7 @@
  4672.         if (interlaced)
  4673.                 drm_mode->vtotal *= 2;
  4674.         /* Fill the mode line name */
  4675. -       drm_mode_set_name(drm_mode);
  4676. +       lbm_drm_mode_set_name(drm_mode);
  4677.         if (reduced)
  4678.                 drm_mode->flags |= (DRM_MODE_FLAG_PHSYNC |
  4679.                                         DRM_MODE_FLAG_NVSYNC);
  4680.  -273,10 +273,10 @@
  4681.  
  4682.      return drm_mode;
  4683.  }
  4684. -EXPORT_SYMBOL(drm_cvt_mode);
  4685. +EXPORT_SYMBOL(lbm_drm_cvt_mode);
  4686.  
  4687.  /**
  4688. - * drm_gtf_mode - create the modeline based on GTF algorithm
  4689. + * lbm_drm_gtf_mode - create the modeline based on GTF algorithm
  4690.   *
  4691.   * @dev                :drm device
  4692.   * @hdisplay   :hdisplay size
  4693.  -300,7 +300,7 @@
  4694.   * I also refer to the function of fb_get_mode in the file of
  4695.   * drivers/video/fbmon.c
  4696.   */
  4697. -struct drm_display_mode *drm_gtf_mode(struct drm_device *dev, int hdisplay,
  4698. +struct drm_display_mode *lbm_drm_gtf_mode(struct drm_device *dev, int hdisplay,
  4699.                                       int vdisplay, int vrefresh,
  4700.                                       bool interlaced, int margins)
  4701.  {
  4702.  -341,7 +341,7 @@
  4703.         int hsync, hfront_porch, vodd_front_porch_lines;
  4704.         unsigned int tmp1, tmp2;
  4705.  
  4706. -       drm_mode = drm_mode_create(dev);
  4707. +       drm_mode = lbm_drm_mode_create(dev);
  4708.         if (!drm_mode)
  4709.                 return NULL;
  4710.  
  4711.  -460,7 +460,7 @@
  4712.  
  4713.         drm_mode->clock = pixel_freq;
  4714.  
  4715. -       drm_mode_set_name(drm_mode);
  4716. +       lbm_drm_mode_set_name(drm_mode);
  4717.         drm_mode->flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC;
  4718.  
  4719.         if (interlaced) {
  4720.  -470,9 +470,9 @@
  4721.  
  4722.         return drm_mode;
  4723.  }
  4724. -EXPORT_SYMBOL(drm_gtf_mode);
  4725. +EXPORT_SYMBOL(lbm_drm_gtf_mode);
  4726.  /**
  4727. - * drm_mode_set_name - set the name on a mode
  4728. + * lbm_drm_mode_set_name - set the name on a mode
  4729.   * @mode: name will be set in this mode
  4730.   *
  4731.   * LOCKING:
  4732.  -480,15 +480,15 @@
  4733.   *
  4734.   * Set the name of @mode to a standard format.
  4735.   */
  4736. -void drm_mode_set_name(struct drm_display_mode *mode)
  4737. +void lbm_drm_mode_set_name(struct drm_display_mode *mode)
  4738.  {
  4739.         snprintf(mode->name, DRM_DISPLAY_MODE_LEN, "%dx%d", mode->hdisplay,
  4740.                  mode->vdisplay);
  4741.  }
  4742. -EXPORT_SYMBOL(drm_mode_set_name);
  4743. +EXPORT_SYMBOL(lbm_drm_mode_set_name);
  4744.  
  4745.  /**
  4746. - * drm_mode_list_concat - move modes from one list to another
  4747. + * lbm_drm_mode_list_concat - move modes from one list to another
  4748.   * @head: source list
  4749.   * @new: dst list
  4750.   *
  4751.  -497,7 +497,7 @@
  4752.   *
  4753.   * Move all the modes from @head to @new.
  4754.   */
  4755. -void drm_mode_list_concat(struct list_head *head, struct list_head *new)
  4756. +void lbm_drm_mode_list_concat(struct list_head *head, struct list_head *new)
  4757.  {
  4758.  
  4759.         struct list_head *entry, *tmp;
  4760.  -506,10 +506,10 @@
  4761.                 list_move_tail(entry, new);
  4762.         }
  4763.  }
  4764. -EXPORT_SYMBOL(drm_mode_list_concat);
  4765. +EXPORT_SYMBOL(lbm_drm_mode_list_concat);
  4766.  
  4767.  /**
  4768. - * drm_mode_width - get the width of a mode
  4769. + * lbm_drm_mode_width - get the width of a mode
  4770.   * @mode: mode
  4771.   *
  4772.   * LOCKING:
  4773.  -522,15 +522,15 @@
  4774.   * RETURNS:
  4775.   * @mode->hdisplay
  4776.   */
  4777. -int drm_mode_width(struct drm_display_mode *mode)
  4778. +int lbm_drm_mode_width(struct drm_display_mode *mode)
  4779.  {
  4780.         return mode->hdisplay;
  4781.  
  4782.  }
  4783. -EXPORT_SYMBOL(drm_mode_width);
  4784. +EXPORT_SYMBOL(lbm_drm_mode_width);
  4785.  
  4786.  /**
  4787. - * drm_mode_height - get the height of a mode
  4788. + * lbm_drm_mode_height - get the height of a mode
  4789.   * @mode: mode
  4790.   *
  4791.   * LOCKING:
  4792.  -543,13 +543,13 @@
  4793.   * RETURNS:
  4794.   * @mode->vdisplay
  4795.   */
  4796. -int drm_mode_height(struct drm_display_mode *mode)
  4797. +int lbm_drm_mode_height(struct drm_display_mode *mode)
  4798.  {
  4799.         return mode->vdisplay;
  4800.  }
  4801. -EXPORT_SYMBOL(drm_mode_height);
  4802. +EXPORT_SYMBOL(lbm_drm_mode_height);
  4803.  
  4804. -/** drm_mode_hsync - get the hsync of a mode
  4805. +/** lbm_drm_mode_hsync - get the hsync of a mode
  4806.   * @mode: mode
  4807.   *
  4808.   * LOCKING:
  4809.  -557,7 +557,7 @@
  4810.   *
  4811.   * Return @modes's hsync rate in kHz, rounded to the nearest int.
  4812.   */
  4813. -int drm_mode_hsync(struct drm_display_mode *mode)
  4814. +int lbm_drm_mode_hsync(struct drm_display_mode *mode)
  4815.  {
  4816.         unsigned int calc_val;
  4817.  
  4818.  -573,10 +573,10 @@
  4819.  
  4820.         return calc_val;
  4821.  }
  4822. -EXPORT_SYMBOL(drm_mode_hsync);
  4823. +EXPORT_SYMBOL(lbm_drm_mode_hsync);
  4824.  
  4825.  /**
  4826. - * drm_mode_vrefresh - get the vrefresh of a mode
  4827. + * lbm_drm_mode_vrefresh - get the vrefresh of a mode
  4828.   * @mode: mode
  4829.   *
  4830.   * LOCKING:
  4831.  -591,7 +591,7 @@
  4832.   * If it is 70.288, it will return 70Hz.
  4833.   * If it is 59.6, it will return 60Hz.
  4834.   */
  4835. -int drm_mode_vrefresh(struct drm_display_mode *mode)
  4836. +int lbm_drm_mode_vrefresh(struct drm_display_mode *mode)
  4837.  {
  4838.         int refresh = 0;
  4839.         unsigned int calc_val;
  4840.  -615,10 +615,10 @@
  4841.         }
  4842.         return refresh;
  4843.  }
  4844. -EXPORT_SYMBOL(drm_mode_vrefresh);
  4845. +EXPORT_SYMBOL(lbm_drm_mode_vrefresh);
  4846.  
  4847.  /**
  4848. - * drm_mode_set_crtcinfo - set CRTC modesetting parameters
  4849. + * lbm_drm_mode_set_crtcinfo - set CRTC modesetting parameters
  4850.   * @p: mode
  4851.   * @adjust_flags: unused? (FIXME)
  4852.   *
  4853.  -627,7 +627,7 @@
  4854.   *
  4855.   * Setup the CRTC modesetting parameters for @p, adjusting if necessary.
  4856.   */
  4857. -void drm_mode_set_crtcinfo(struct drm_display_mode *p, int adjust_flags)
  4858. +void lbm_drm_mode_set_crtcinfo(struct drm_display_mode *p, int adjust_flags)
  4859.  {
  4860.         if ((p == NULL) || ((p->type & DRM_MODE_TYPE_CRTC_C) == DRM_MODE_TYPE_BUILTIN))
  4861.                 return;
  4862.  -675,11 +675,11 @@
  4863.         p->crtc_hadjusted = false;
  4864.         p->crtc_vadjusted = false;
  4865.  }
  4866. -EXPORT_SYMBOL(drm_mode_set_crtcinfo);
  4867. +EXPORT_SYMBOL(lbm_drm_mode_set_crtcinfo);
  4868.  
  4869.  
  4870.  /**
  4871. - * drm_mode_duplicate - allocate and duplicate an existing mode
  4872. + * lbm_drm_mode_duplicate - allocate and duplicate an existing mode
  4873.   * @m: mode to duplicate
  4874.   *
  4875.   * LOCKING:
  4876.  -688,13 +688,13 @@
  4877.   * Just allocate a new mode, copy the existing mode into it, and return
  4878.   * a pointer to it.  Used to create new instances of established modes.
  4879.   */
  4880. -struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev,
  4881. +struct drm_display_mode *lbm_drm_mode_duplicate(struct drm_device *dev,
  4882.                                             struct drm_display_mode *mode)
  4883.  {
  4884.         struct drm_display_mode *nmode;
  4885.         int new_id;
  4886.  
  4887. -       nmode = drm_mode_create(dev);
  4888. +       nmode = lbm_drm_mode_create(dev);
  4889.         if (!nmode)
  4890.                 return NULL;
  4891.  
  4892.  -704,10 +704,10 @@
  4893.         INIT_LIST_HEAD(&nmode->head);
  4894.         return nmode;
  4895.  }
  4896. -EXPORT_SYMBOL(drm_mode_duplicate);
  4897. +EXPORT_SYMBOL(lbm_drm_mode_duplicate);
  4898.  
  4899.  /**
  4900. - * drm_mode_equal - test modes for equality
  4901. + * lbm_drm_mode_equal - test modes for equality
  4902.   * @mode1: first mode
  4903.   * @mode2: second mode
  4904.   *
  4905.  -719,7 +719,7 @@
  4906.   * RETURNS:
  4907.   * True if the modes are equal, false otherwise.
  4908.   */
  4909. -bool drm_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2)
  4910. +bool lbm_drm_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2)
  4911.  {
  4912.         /* do clock check convert to PICOS so fb modes get matched
  4913.          * the same */
  4914.  -744,10 +744,10 @@
  4915.  
  4916.         return false;
  4917.  }
  4918. -EXPORT_SYMBOL(drm_mode_equal);
  4919. +EXPORT_SYMBOL(lbm_drm_mode_equal);
  4920.  
  4921.  /**
  4922. - * drm_mode_validate_size - make sure modes adhere to size constraints
  4923. + * lbm_drm_mode_validate_size - make sure modes adhere to size constraints
  4924.   * @dev: DRM device
  4925.   * @mode_list: list of modes to check
  4926.   * @maxX: maximum width
  4927.  -761,7 +761,7 @@
  4928.   * modes we probed for @dev against those limits and set their status as
  4929.   * necessary.
  4930.   */
  4931. -void drm_mode_validate_size(struct drm_device *dev,
  4932. +void lbm_drm_mode_validate_size(struct drm_device *dev,
  4933.                             struct list_head *mode_list,
  4934.                             int maxX, int maxY, int maxPitch)
  4935.  {
  4936.  -778,10 +778,10 @@
  4937.                         mode->status = MODE_VIRTUAL_Y;
  4938.         }
  4939.  }
  4940. -EXPORT_SYMBOL(drm_mode_validate_size);
  4941. +EXPORT_SYMBOL(lbm_drm_mode_validate_size);
  4942.  
  4943.  /**
  4944. - * drm_mode_validate_clocks - validate modes against clock limits
  4945. + * lbm_drm_mode_validate_clocks - validate modes against clock limits
  4946.   * @dev: DRM device
  4947.   * @mode_list: list of modes to check
  4948.   * @min: minimum clock rate array
  4949.  -796,7 +796,7 @@
  4950.   * sure each mode falls within a given range (defined by @min and @max
  4951.   * arrays) and sets @mode->status as needed.
  4952.   */
  4953. -void drm_mode_validate_clocks(struct drm_device *dev,
  4954. +void lbm_drm_mode_validate_clocks(struct drm_device *dev,
  4955.                               struct list_head *mode_list,
  4956.                               int *min, int *max, int n_ranges)
  4957.  {
  4958.  -815,10 +815,10 @@
  4959.                         mode->status = MODE_CLOCK_RANGE;
  4960.         }
  4961.  }
  4962. -EXPORT_SYMBOL(drm_mode_validate_clocks);
  4963. +EXPORT_SYMBOL(lbm_drm_mode_validate_clocks);
  4964.  
  4965.  /**
  4966. - * drm_mode_prune_invalid - remove invalid modes from mode list
  4967. + * lbm_drm_mode_prune_invalid - remove invalid modes from mode list
  4968.   * @dev: DRM device
  4969.   * @mode_list: list of modes to check
  4970.   * @verbose: be verbose about it
  4971.  -830,7 +830,7 @@
  4972.   * remove invalid modes from a mode list.  If any of the modes have a
  4973.   * status other than %MODE_OK, they are removed from @mode_list and freed.
  4974.   */
  4975. -void drm_mode_prune_invalid(struct drm_device *dev,
  4976. +void lbm_drm_mode_prune_invalid(struct drm_device *dev,
  4977.                             struct list_head *mode_list, bool verbose)
  4978.  {
  4979.         struct drm_display_mode *mode, *t;
  4980.  -839,15 +839,15 @@
  4981.                 if (mode->status != MODE_OK) {
  4982.                         list_del(&mode->head);
  4983.                         if (verbose) {
  4984. -                               drm_mode_debug_printmodeline(mode);
  4985. +                               lbm_drm_mode_debug_printmodeline(mode);
  4986.                                 DRM_DEBUG_KMS("Not using %s mode %d\n",
  4987.                                         mode->name, mode->status);
  4988.                         }
  4989. -                       drm_mode_destroy(dev, mode);
  4990. +                       lbm_drm_mode_destroy(dev, mode);
  4991.                 }
  4992.         }
  4993.  }
  4994. -EXPORT_SYMBOL(drm_mode_prune_invalid);
  4995. +EXPORT_SYMBOL(lbm_drm_mode_prune_invalid);
  4996.  
  4997.  /**
  4998.   * drm_mode_compare - compare modes for favorability
  4999.  -883,7 +883,7 @@
  5000.  }
  5001.  
  5002.  /**
  5003. - * drm_mode_sort - sort mode list
  5004. + * lbm_drm_mode_sort - sort mode list
  5005.   * @mode_list: list to sort
  5006.   *
  5007.   * LOCKING:
  5008.  -891,14 +891,14 @@
  5009.   *
  5010.   * Sort @mode_list by favorability, putting good modes first.
  5011.   */
  5012. -void drm_mode_sort(struct list_head *mode_list)
  5013. +void lbm_drm_mode_sort(struct list_head *mode_list)
  5014.  {
  5015. -       list_sort(NULL, mode_list, drm_mode_compare);
  5016. +       lbm_list_sort(NULL, mode_list, drm_mode_compare);
  5017.  }
  5018. -EXPORT_SYMBOL(drm_mode_sort);
  5019. +EXPORT_SYMBOL(lbm_drm_mode_sort);
  5020.  
  5021.  /**
  5022. - * drm_mode_connector_list_update - update the mode list for the connector
  5023. + * lbm_drm_mode_connector_list_update - update the mode list for the connector
  5024.   * @connector: the connector to update
  5025.   *
  5026.   * LOCKING:
  5027.  -909,7 +909,7 @@
  5028.   * list and only adds different modes. All modes unverified after this point
  5029.   * will be removed by the prune invalid modes.
  5030.   */
  5031. -void drm_mode_connector_list_update(struct drm_connector *connector)
  5032. +void lbm_drm_mode_connector_list_update(struct drm_connector *connector)
  5033.  {
  5034.         struct drm_display_mode *mode;
  5035.         struct drm_display_mode *pmode, *pt;
  5036.  -920,14 +920,14 @@
  5037.                 found_it = 0;
  5038.                 /* go through current modes checking for the new probed mode */
  5039.                 list_for_each_entry(mode, &connector->modes, head) {
  5040. -                       if (drm_mode_equal(pmode, mode)) {
  5041. +                       if (lbm_drm_mode_equal(pmode, mode)) {
  5042.                                 found_it = 1;
  5043.                                 /* if equal delete the probed mode */
  5044.                                 mode->status = pmode->status;
  5045.                                 /* Merge type bits together */
  5046.                                 mode->type |= pmode->type;
  5047.                                 list_del(&pmode->head);
  5048. -                               drm_mode_destroy(connector->dev, pmode);
  5049. +                               lbm_drm_mode_destroy(connector->dev, pmode);
  5050.                                 break;
  5051.                         }
  5052.                 }
  5053.  -937,4 +937,4 @@
  5054.                 }
  5055.         }
  5056.  }
  5057. -EXPORT_SYMBOL(drm_mode_connector_list_update);
  5058. +EXPORT_SYMBOL(lbm_drm_mode_connector_list_update);
  5059. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_pci.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_pci.c
  5060. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_pci.c     2010-01-25 15:21:29.000000000 -0500
  5061. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_pci.c     2010-02-03 17:11:08.000000000 -0500
  5062.  -47,7 +47,7 @@
  5063.  /**
  5064.   * \brief Allocate a PCI consistent memory block, for DMA.
  5065.   */
  5066. -drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align)
  5067. +drm_dma_handle_t *lbm_drm_pci_alloc(struct drm_device * dev, size_t size, size_t align)
  5068.  {
  5069.         drm_dma_handle_t *dmah;
  5070.  #if 1
  5071.  -86,7 +86,7 @@
  5072.         return dmah;
  5073.  }
  5074.  
  5075. -EXPORT_SYMBOL(drm_pci_alloc);
  5076. +EXPORT_SYMBOL(lbm_drm_pci_alloc);
  5077.  
  5078.  /**
  5079.   * \brief Free a PCI consistent memory block without freeing its descriptor.
  5080.  -115,12 +115,12 @@
  5081.  /**
  5082.   * \brief Free a PCI consistent memory block
  5083.   */
  5084. -void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
  5085. +void lbm_drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
  5086.  {
  5087.         __drm_pci_free(dev, dmah);
  5088.         kfree(dmah);
  5089.  }
  5090.  
  5091. -EXPORT_SYMBOL(drm_pci_free);
  5092. +EXPORT_SYMBOL(lbm_drm_pci_free);
  5093.  
  5094.  /*@}*/
  5095. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_scatter.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_scatter.c
  5096. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_scatter.c 2010-01-25 15:21:29.000000000 -0500
  5097. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_scatter.c 2010-02-03 17:11:08.000000000 -0500
  5098.  -69,7 +69,7 @@
  5099.  # define ScatterHandle(x) (unsigned int)(x)
  5100.  #endif
  5101.  
  5102. -int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
  5103. +int lbm_drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
  5104.  {
  5105.         struct drm_sg_mem *entry;
  5106.         unsigned long pages, i, j;
  5107.  -183,7 +183,7 @@
  5108.         drm_sg_cleanup(entry);
  5109.         return -ENOMEM;
  5110.  }
  5111. -EXPORT_SYMBOL(drm_sg_alloc);
  5112. +EXPORT_SYMBOL(lbm_drm_sg_alloc);
  5113.  
  5114.  
  5115.  int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
  5116.  -191,7 +191,7 @@
  5117.  {
  5118.         struct drm_scatter_gather *request = data;
  5119.  
  5120. -       return drm_sg_alloc(dev, request);
  5121. +       return lbm_drm_sg_alloc(dev, request);
  5122.  
  5123.  }
  5124.  
  5125. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sman.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sman.c
  5126. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sman.c    2010-01-25 15:21:29.000000000 -0500
  5127. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sman.c    2010-02-03 17:11:08.000000000 -0500
  5128.  -44,17 +44,17 @@
  5129.         struct list_head mem_blocks;
  5130.  };
  5131.  
  5132. -void drm_sman_takedown(struct drm_sman * sman)
  5133. +void lbm_drm_sman_takedown(struct drm_sman * sman)
  5134.  {
  5135. -       drm_ht_remove(&sman->user_hash_tab);
  5136. -       drm_ht_remove(&sman->owner_hash_tab);
  5137. +       lbm_drm_ht_remove(&sman->user_hash_tab);
  5138. +       lbm_drm_ht_remove(&sman->owner_hash_tab);
  5139.         kfree(sman->mm);
  5140.  }
  5141.  
  5142. -EXPORT_SYMBOL(drm_sman_takedown);
  5143. +EXPORT_SYMBOL(lbm_drm_sman_takedown);
  5144.  
  5145.  int
  5146. -drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
  5147. +lbm_drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
  5148.               unsigned int user_order, unsigned int owner_order)
  5149.  {
  5150.         int ret = 0;
  5151.  -68,21 +68,21 @@
  5152.         }
  5153.         sman->num_managers = num_managers;
  5154.         INIT_LIST_HEAD(&sman->owner_items);
  5155. -       ret = drm_ht_create(&sman->owner_hash_tab, owner_order);
  5156. +       ret = lbm_drm_ht_create(&sman->owner_hash_tab, owner_order);
  5157.         if (ret)
  5158.                 goto out1;
  5159. -       ret = drm_ht_create(&sman->user_hash_tab, user_order);
  5160. +       ret = lbm_drm_ht_create(&sman->user_hash_tab, user_order);
  5161.         if (!ret)
  5162.                 goto out;
  5163.  
  5164. -       drm_ht_remove(&sman->owner_hash_tab);
  5165. +       lbm_drm_ht_remove(&sman->owner_hash_tab);
  5166.  out1:
  5167.         kfree(sman->mm);
  5168.  out:
  5169.         return ret;
  5170.  }
  5171.  
  5172. -EXPORT_SYMBOL(drm_sman_init);
  5173. +EXPORT_SYMBOL(lbm_drm_sman_init);
  5174.  
  5175.  static void *drm_sman_mm_allocate(void *private, unsigned long size,
  5176.                                   unsigned alignment)
  5177.  -90,7 +90,7 @@
  5178.         struct drm_mm *mm = (struct drm_mm *) private;
  5179.         struct drm_mm_node *tmp;
  5180.  
  5181. -       tmp = drm_mm_search_free(mm, size, alignment, 1);
  5182. +       tmp = lbm_drm_mm_search_free(mm, size, alignment, 1);
  5183.         if (!tmp) {
  5184.                 return NULL;
  5185.         }
  5186.  -102,13 +102,13 @@
  5187.  {
  5188.         struct drm_mm_node *node = (struct drm_mm_node *) ref;
  5189.  
  5190. -       drm_mm_put_block(node);
  5191. +       lbm_drm_mm_put_block(node);
  5192.  }
  5193.  
  5194.  static void drm_sman_mm_destroy(void *private)
  5195.  {
  5196.         struct drm_mm *mm = (struct drm_mm *) private;
  5197. -       drm_mm_takedown(mm);
  5198. +       lbm_drm_mm_takedown(mm);
  5199.         kfree(mm);
  5200.  }
  5201.  
  5202.  -119,7 +119,7 @@
  5203.  }
  5204.  
  5205.  int
  5206. -drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
  5207. +lbm_drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
  5208.                    unsigned long start, unsigned long size)
  5209.  {
  5210.         struct drm_sman_mm *sman_mm;
  5211.  -134,7 +134,7 @@
  5212.                 return -ENOMEM;
  5213.         }
  5214.         sman_mm->private = mm;
  5215. -       ret = drm_mm_init(mm, start, size);
  5216. +       ret = lbm_drm_mm_init(mm, start, size);
  5217.  
  5218.         if (ret) {
  5219.                 kfree(mm);
  5220.  -149,10 +149,10 @@
  5221.         return 0;
  5222.  }
  5223.  
  5224. -EXPORT_SYMBOL(drm_sman_set_range);
  5225. +EXPORT_SYMBOL(lbm_drm_sman_set_range);
  5226.  
  5227.  int
  5228. -drm_sman_set_manager(struct drm_sman * sman, unsigned int manager,
  5229. +lbm_drm_sman_set_manager(struct drm_sman * sman, unsigned int manager,
  5230.                      struct drm_sman_mm * allocator)
  5231.  {
  5232.         BUG_ON(manager >= sman->num_managers);
  5233.  -160,7 +160,7 @@
  5234.  
  5235.         return 0;
  5236.  }
  5237. -EXPORT_SYMBOL(drm_sman_set_manager);
  5238. +EXPORT_SYMBOL(lbm_drm_sman_set_manager);
  5239.  
  5240.  static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
  5241.                                                  unsigned long owner)
  5242.  -169,7 +169,7 @@
  5243.         struct drm_hash_item *owner_hash_item;
  5244.         struct drm_owner_item *owner_item;
  5245.  
  5246. -       ret = drm_ht_find_item(&sman->owner_hash_tab, owner, &owner_hash_item);
  5247. +       ret = lbm_drm_ht_find_item(&sman->owner_hash_tab, owner, &owner_hash_item);
  5248.         if (!ret) {
  5249.                 return drm_hash_entry(owner_hash_item, struct drm_owner_item,
  5250.                                       owner_hash);
  5251.  -181,7 +181,7 @@
  5252.  
  5253.         INIT_LIST_HEAD(&owner_item->mem_blocks);
  5254.         owner_item->owner_hash.key = owner;
  5255. -       if (drm_ht_insert_item(&sman->owner_hash_tab, &owner_item->owner_hash))
  5256. +       if (lbm_drm_ht_insert_item(&sman->owner_hash_tab, &owner_item->owner_hash))
  5257.                 goto out1;
  5258.  
  5259.         list_add_tail(&owner_item->sman_list, &sman->owner_items);
  5260.  -193,7 +193,7 @@
  5261.         return NULL;
  5262.  }
  5263.  
  5264. -struct drm_memblock_item *drm_sman_alloc(struct drm_sman *sman, unsigned int manager,
  5265. +struct drm_memblock_item *lbm_drm_sman_alloc(struct drm_sman *sman, unsigned int manager,
  5266.                                     unsigned long size, unsigned alignment,
  5267.                                     unsigned long owner)
  5268.  {
  5269.  -220,7 +220,7 @@
  5270.         memblock->mm = sman_mm;
  5271.         memblock->sman = sman;
  5272.  
  5273. -       if (drm_ht_just_insert_please
  5274. +       if (lbm_drm_ht_just_insert_please
  5275.             (&sman->user_hash_tab, &memblock->user_hash,
  5276.              (unsigned long)memblock, 32, 0, 0))
  5277.                 goto out1;
  5278.  -234,7 +234,7 @@
  5279.         return memblock;
  5280.  
  5281.  out2:
  5282. -       drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
  5283. +       lbm_drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
  5284.  out1:
  5285.         kfree(memblock);
  5286.  out:
  5287.  -243,24 +243,24 @@
  5288.         return NULL;
  5289.  }
  5290.  
  5291. -EXPORT_SYMBOL(drm_sman_alloc);
  5292. +EXPORT_SYMBOL(lbm_drm_sman_alloc);
  5293.  
  5294.  static void drm_sman_free(struct drm_memblock_item *item)
  5295.  {
  5296.         struct drm_sman *sman = item->sman;
  5297.  
  5298.         list_del(&item->owner_list);
  5299. -       drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
  5300. +       lbm_drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
  5301.         item->mm->free(item->mm->private, item->mm_info);
  5302.         kfree(item);
  5303.  }
  5304.  
  5305. -int drm_sman_free_key(struct drm_sman *sman, unsigned int key)
  5306. +int lbm_drm_sman_free_key(struct drm_sman *sman, unsigned int key)
  5307.  {
  5308.         struct drm_hash_item *hash_item;
  5309.         struct drm_memblock_item *memblock_item;
  5310.  
  5311. -       if (drm_ht_find_item(&sman->user_hash_tab, key, &hash_item))
  5312. +       if (lbm_drm_ht_find_item(&sman->user_hash_tab, key, &hash_item))
  5313.                 return -EINVAL;
  5314.  
  5315.         memblock_item = drm_hash_entry(hash_item, struct drm_memblock_item,
  5316.  -269,23 +269,23 @@
  5317.         return 0;
  5318.  }
  5319.  
  5320. -EXPORT_SYMBOL(drm_sman_free_key);
  5321. +EXPORT_SYMBOL(lbm_drm_sman_free_key);
  5322.  
  5323.  static void drm_sman_remove_owner(struct drm_sman *sman,
  5324.                                   struct drm_owner_item *owner_item)
  5325.  {
  5326.         list_del(&owner_item->sman_list);
  5327. -       drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
  5328. +       lbm_drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
  5329.         kfree(owner_item);
  5330.  }
  5331.  
  5332. -int drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner)
  5333. +int lbm_drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner)
  5334.  {
  5335.  
  5336.         struct drm_hash_item *hash_item;
  5337.         struct drm_owner_item *owner_item;
  5338.  
  5339. -       if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
  5340. +       if (lbm_drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
  5341.                 return -1;
  5342.         }
  5343.  
  5344.  -298,7 +298,7 @@
  5345.         return 0;
  5346.  }
  5347.  
  5348. -EXPORT_SYMBOL(drm_sman_owner_clean);
  5349. +EXPORT_SYMBOL(lbm_drm_sman_owner_clean);
  5350.  
  5351.  static void drm_sman_do_owner_cleanup(struct drm_sman *sman,
  5352.                                       struct drm_owner_item *owner_item)
  5353.  -312,13 +312,13 @@
  5354.         drm_sman_remove_owner(sman, owner_item);
  5355.  }
  5356.  
  5357. -void drm_sman_owner_cleanup(struct drm_sman *sman, unsigned long owner)
  5358. +void lbm_drm_sman_owner_cleanup(struct drm_sman *sman, unsigned long owner)
  5359.  {
  5360.  
  5361.         struct drm_hash_item *hash_item;
  5362.         struct drm_owner_item *owner_item;
  5363.  
  5364. -       if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
  5365. +       if (lbm_drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
  5366.  
  5367.                 return;
  5368.         }
  5369.  -327,9 +327,9 @@
  5370.         drm_sman_do_owner_cleanup(sman, owner_item);
  5371.  }
  5372.  
  5373. -EXPORT_SYMBOL(drm_sman_owner_cleanup);
  5374. +EXPORT_SYMBOL(lbm_drm_sman_owner_cleanup);
  5375.  
  5376. -void drm_sman_cleanup(struct drm_sman *sman)
  5377. +void lbm_drm_sman_cleanup(struct drm_sman *sman)
  5378.  {
  5379.         struct drm_owner_item *entry, *next;
  5380.         unsigned int i;
  5381.  -349,4 +349,4 @@
  5382.         }
  5383.  }
  5384.  
  5385. -EXPORT_SYMBOL(drm_sman_cleanup);
  5386. +EXPORT_SYMBOL(lbm_drm_sman_cleanup);
  5387. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_stub.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_stub.c
  5388. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_stub.c    2010-01-25 15:21:29.000000000 -0500
  5389. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_stub.c    2010-02-03 17:11:09.000000000 -0500
  5390.  -36,29 +36,29 @@
  5391.  #include "drmP.h"
  5392.  #include "drm_core.h"
  5393.  
  5394. -unsigned int drm_debug = 0;    /* 1 to enable debug output */
  5395. -EXPORT_SYMBOL(drm_debug);
  5396. +unsigned int lbm_drm_debug = 0;        /* 1 to enable debug output */
  5397. +EXPORT_SYMBOL(lbm_drm_debug);
  5398.  
  5399.  MODULE_AUTHOR(CORE_AUTHOR);
  5400.  MODULE_DESCRIPTION(CORE_DESC);
  5401.  MODULE_LICENSE("GPL and additional rights");
  5402.  MODULE_PARM_DESC(debug, "Enable debug output");
  5403.  
  5404. -module_param_named(debug, drm_debug, int, 0600);
  5405. +module_param_named(debug, lbm_drm_debug, int, 0600);
  5406.  
  5407.  struct idr drm_minors_idr;
  5408.  
  5409.  struct class *drm_class;
  5410.  struct proc_dir_entry *drm_proc_root;
  5411.  struct dentry *drm_debugfs_root;
  5412. -void drm_ut_debug_printk(unsigned int request_level,
  5413. +void lbm_drm_ut_debug_printk(unsigned int request_level,
  5414.                          const char *prefix,
  5415.                          const char *function_name,
  5416.                          const char *format, ...)
  5417.  {
  5418.         va_list args;
  5419.  
  5420. -       if (drm_debug & request_level) {
  5421. +       if (lbm_drm_debug & request_level) {
  5422.                 if (function_name)
  5423.                         printk(KERN_DEBUG "[%s:%s], ", prefix, function_name);
  5424.                 va_start(args, format);
  5425.  -66,7 +66,7 @@
  5426.                 va_end(args);
  5427.         }
  5428.  }
  5429. -EXPORT_SYMBOL(drm_ut_debug_printk);
  5430. +EXPORT_SYMBOL(lbm_drm_ut_debug_printk);
  5431.  static int drm_minor_get_id(struct drm_device *dev, int type)
  5432.  {
  5433.         int new_id;
  5434.  -114,7 +114,7 @@
  5435.         kref_init(&master->refcount);
  5436.         spin_lock_init(&master->lock.spinlock);
  5437.         init_waitqueue_head(&master->lock.lock_queue);
  5438. -       drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER);
  5439. +       lbm_drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER);
  5440.         INIT_LIST_HEAD(&master->magicfree);
  5441.         master->minor = minor;
  5442.  
  5443.  -123,12 +123,12 @@
  5444.         return master;
  5445.  }
  5446.  
  5447. -struct drm_master *drm_master_get(struct drm_master *master)
  5448. +struct drm_master *lbm_drm_master_get(struct drm_master *master)
  5449.  {
  5450.         kref_get(&master->refcount);
  5451.         return master;
  5452.  }
  5453. -EXPORT_SYMBOL(drm_master_get);
  5454. +EXPORT_SYMBOL(lbm_drm_master_get);
  5455.  
  5456.  static void drm_master_destroy(struct kref *kref)
  5457.  {
  5458.  -144,7 +144,7 @@
  5459.  
  5460.         list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
  5461.                 if (r_list->master == master) {
  5462. -                       drm_rmmap_locked(dev, r_list->map);
  5463. +                       lbm_drm_rmmap_locked(dev, r_list->map);
  5464.                         r_list = NULL;
  5465.                 }
  5466.         }
  5467.  -157,21 +157,21 @@
  5468.  
  5469.         list_for_each_entry_safe(pt, next, &master->magicfree, head) {
  5470.                 list_del(&pt->head);
  5471. -               drm_ht_remove_item(&master->magiclist, &pt->hash_item);
  5472. +               lbm_drm_ht_remove_item(&master->magiclist, &pt->hash_item);
  5473.                 kfree(pt);
  5474.         }
  5475.  
  5476. -       drm_ht_remove(&master->magiclist);
  5477. +       lbm_drm_ht_remove(&master->magiclist);
  5478.  
  5479.         kfree(master);
  5480.  }
  5481.  
  5482. -void drm_master_put(struct drm_master **master)
  5483. +void lbm_drm_master_put(struct drm_master **master)
  5484.  {
  5485.         kref_put(&(*master)->refcount, drm_master_destroy);
  5486.         *master = NULL;
  5487.  }
  5488. -EXPORT_SYMBOL(drm_master_put);
  5489. +EXPORT_SYMBOL(lbm_drm_master_put);
  5490.  
  5491.  int drm_setmaster_ioctl(struct drm_device *dev, void *data,
  5492.                         struct drm_file *file_priv)
  5493.  -190,13 +190,13 @@
  5494.         if (!file_priv->minor->master &&
  5495.             file_priv->minor->master != file_priv->master) {
  5496.                 mutex_lock(&dev->struct_mutex);
  5497. -               file_priv->minor->master = drm_master_get(file_priv->master);
  5498. +               file_priv->minor->master = lbm_drm_master_get(file_priv->master);
  5499.                 file_priv->is_master = 1;
  5500.                 if (dev->driver->master_set) {
  5501.                         ret = dev->driver->master_set(dev, file_priv, false);
  5502.                         if (unlikely(ret != 0)) {
  5503.                                 file_priv->is_master = 0;
  5504. -                               drm_master_put(&file_priv->minor->master);
  5505. +                               lbm_drm_master_put(&file_priv->minor->master);
  5506.                         }
  5507.                 }
  5508.                 mutex_unlock(&dev->struct_mutex);
  5509.  -217,7 +217,7 @@
  5510.         mutex_lock(&dev->struct_mutex);
  5511.         if (dev->driver->master_drop)
  5512.                 dev->driver->master_drop(dev, file_priv, false);
  5513. -       drm_master_put(&file_priv->minor->master);
  5514. +       lbm_drm_master_put(&file_priv->minor->master);
  5515.         file_priv->is_master = 0;
  5516.         mutex_unlock(&dev->struct_mutex);
  5517.         return 0;
  5518.  -252,7 +252,7 @@
  5519.         dev->hose = pdev->sysdata;
  5520.  #endif
  5521.  
  5522. -       if (drm_ht_create(&dev->map_hash, 12)) {
  5523. +       if (lbm_drm_ht_create(&dev->map_hash, 12)) {
  5524.                 return -ENOMEM;
  5525.         }
  5526.  
  5527.  -393,11 +393,11 @@
  5528.   * \param ent entry from the PCI ID table with device type flags
  5529.   * \return zero on success or a negative number on failure.
  5530.   *
  5531. - * Attempt to gets inter module "drm" information. If we are first
  5532. + * Attempt to gets inter module "lbm-drm" information. If we are first
  5533.   * then register the character device and inter module information.
  5534.   * Try and register, if we fail to register, backout previous work.
  5535.   */
  5536. -int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
  5537. +int lbm_drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
  5538.                 struct drm_driver *driver)
  5539.  {
  5540.         struct drm_device *dev;
  5541.  -461,7 +461,7 @@
  5542.         kfree(dev);
  5543.         return ret;
  5544.  }
  5545. -EXPORT_SYMBOL(drm_get_dev);
  5546. +EXPORT_SYMBOL(lbm_drm_get_dev);
  5547.  
  5548.  /**
  5549.   * Put a secondary minor number.
  5550.  -495,14 +495,14 @@
  5551.  }
  5552.  
  5553.  /**
  5554. - * Called via drm_exit() at module unload time or when pci device is
  5555. + * Called via lbm_drm_exit() at module unload time or when pci device is
  5556.   * unplugged.
  5557.   *
  5558.   * Cleans up all DRM device, calling drm_lastclose().
  5559.   *
  5560. - * \sa drm_init
  5561. + * \sa lbm_drm_init
  5562.   */
  5563. -void drm_put_dev(struct drm_device *dev)
  5564. +void lbm_drm_put_dev(struct drm_device *dev)
  5565.  {
  5566.         struct drm_driver *driver;
  5567.         struct drm_map_list *r_list, *list_temp;
  5568.  -515,7 +515,7 @@
  5569.         }
  5570.         driver = dev->driver;
  5571.  
  5572. -       drm_vblank_cleanup(dev);
  5573. +       lbm_drm_vblank_cleanup(dev);
  5574.  
  5575.         drm_lastclose(dev);
  5576.  
  5577.  -537,8 +537,8 @@
  5578.         }
  5579.  
  5580.         list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
  5581. -               drm_rmmap(dev, r_list->map);
  5582. -       drm_ht_remove(&dev->map_hash);
  5583. +               lbm_drm_rmmap(dev, r_list->map);
  5584. +       lbm_drm_ht_remove(&dev->map_hash);
  5585.  
  5586.         drm_ctxbitmap_cleanup(dev);
  5587.  
  5588.  -556,4 +556,4 @@
  5589.         }
  5590.         kfree(dev);
  5591.  }
  5592. -EXPORT_SYMBOL(drm_put_dev);
  5593. +EXPORT_SYMBOL(lbm_drm_put_dev);
  5594. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sysfs.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sysfs.c
  5595. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sysfs.c   2010-01-25 15:21:29.000000000 -0500
  5596. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_sysfs.c   2010-02-03 17:11:08.000000000 -0500
  5597.  -174,7 +174,7 @@
  5598.         uint64_t dpms_status;
  5599.         int ret;
  5600.  
  5601. -       ret = drm_connector_property_get_value(connector,
  5602. +       ret = lbm_drm_connector_property_get_value(connector,
  5603.                                             dev->mode_config.dpms_property,
  5604.                                             &dpms_status);
  5605.         if (ret)
  5606.  -268,7 +268,7 @@
  5607.                 return 0;
  5608.         }
  5609.  
  5610. -       ret = drm_connector_property_get_value(connector, prop, &subconnector);
  5611. +       ret = lbm_drm_connector_property_get_value(connector, prop, &subconnector);
  5612.         if (ret)
  5613.                 return 0;
  5614.  
  5615.  -309,7 +309,7 @@
  5616.                 return 0;
  5617.         }
  5618.  
  5619. -       ret = drm_connector_property_get_value(connector, prop, &subconnector);
  5620. +       ret = lbm_drm_connector_property_get_value(connector, prop, &subconnector);
  5621.         if (ret)
  5622.                 return 0;
  5623.  
  5624.  -339,7 +339,7 @@
  5625.  };
  5626.  
  5627.  /**
  5628. - * drm_sysfs_connector_add - add an connector to sysfs
  5629. + * lbm_drm_sysfs_connector_add - add an connector to sysfs
  5630.   * @connector: connector to add
  5631.   *
  5632.   * Create an connector device in sysfs, along with its associated connector
  5633.  -352,7 +352,7 @@
  5634.   * A second call for an already registered device will trigger the BUG_ON
  5635.   * below.
  5636.   */
  5637. -int drm_sysfs_connector_add(struct drm_connector *connector)
  5638. +int lbm_drm_sysfs_connector_add(struct drm_connector *connector)
  5639.  {
  5640.         struct drm_device *dev = connector->dev;
  5641.         int ret = 0, i, j;
  5642.  -365,10 +365,10 @@
  5643.         connector->kdev.release = drm_sysfs_device_release;
  5644.  
  5645.         DRM_DEBUG("adding \"%s\" to sysfs\n",
  5646. -                 drm_get_connector_name(connector));
  5647. +                 lbm_drm_get_connector_name(connector));
  5648.  
  5649.         dev_set_name(&connector->kdev, "card%d-%s",
  5650. -                    dev->primary->index, drm_get_connector_name(connector));
  5651. +                    dev->primary->index, lbm_drm_get_connector_name(connector));
  5652.         ret = device_register(&connector->kdev);
  5653.  
  5654.         if (ret) {
  5655.  -410,7 +410,7 @@
  5656.                 goto err_out_files;
  5657.  
  5658.         /* Let userspace know we have a new connector */
  5659. -       drm_sysfs_hotplug_event(dev);
  5660. +       lbm_drm_sysfs_hotplug_event(dev);
  5661.  
  5662.         return 0;
  5663.  
  5664.  -424,10 +424,10 @@
  5665.  out:
  5666.         return ret;
  5667.  }
  5668. -EXPORT_SYMBOL(drm_sysfs_connector_add);
  5669. +EXPORT_SYMBOL(lbm_drm_sysfs_connector_add);
  5670.  
  5671.  /**
  5672. - * drm_sysfs_connector_remove - remove an connector device from sysfs
  5673. + * lbm_drm_sysfs_connector_remove - remove an connector device from sysfs
  5674.   * @connector: connector to remove
  5675.   *
  5676.   * Remove @connector and its associated attributes from sysfs.  Note that
  5677.  -439,29 +439,29 @@
  5678.   * successfully registered.  If @connector hasn't been registered yet,
  5679.   * you'll likely see a panic somewhere deep in sysfs code when called.
  5680.   */
  5681. -void drm_sysfs_connector_remove(struct drm_connector *connector)
  5682. +void lbm_drm_sysfs_connector_remove(struct drm_connector *connector)
  5683.  {
  5684.         int i;
  5685.  
  5686.         DRM_DEBUG("removing \"%s\" from sysfs\n",
  5687. -                 drm_get_connector_name(connector));
  5688. +                 lbm_drm_get_connector_name(connector));
  5689.  
  5690.         for (i = 0; i < ARRAY_SIZE(connector_attrs); i++)
  5691.                 device_remove_file(&connector->kdev, &connector_attrs[i]);
  5692.         sysfs_remove_bin_file(&connector->kdev.kobj, &edid_attr);
  5693.         device_unregister(&connector->kdev);
  5694.  }
  5695. -EXPORT_SYMBOL(drm_sysfs_connector_remove);
  5696. +EXPORT_SYMBOL(lbm_drm_sysfs_connector_remove);
  5697.  
  5698.  /**
  5699. - * drm_sysfs_hotplug_event - generate a DRM uevent
  5700. + * lbm_drm_sysfs_hotplug_event - generate a DRM uevent
  5701.   * @dev: DRM device
  5702.   *
  5703.   * Send a uevent for the DRM device specified by @dev.  Currently we only
  5704.   * set HOTPLUG=1 in the uevent environment, but this could be expanded to
  5705.   * deal with other types of events.
  5706.   */
  5707. -void drm_sysfs_hotplug_event(struct drm_device *dev)
  5708. +void lbm_drm_sysfs_hotplug_event(struct drm_device *dev)
  5709.  {
  5710.         char *event_string = "HOTPLUG=1";
  5711.         char *envp[] = { event_string, NULL };
  5712.  -470,7 +470,7 @@
  5713.  
  5714.         kobject_uevent_env(&dev->primary->kdev.kobj, KOBJ_CHANGE, envp);
  5715.  }
  5716. -EXPORT_SYMBOL(drm_sysfs_hotplug_event);
  5717. +EXPORT_SYMBOL(lbm_drm_sysfs_hotplug_event);
  5718.  
  5719.  /**
  5720.   * drm_sysfs_device_add - adds a class device to sysfs for a character driver
  5721.  -526,7 +526,7 @@
  5722.  
  5723.  
  5724.  /**
  5725. - * drm_class_device_register - Register a struct device in the drm class.
  5726. + * lbm_drm_class_device_register - Register a struct device in the drm class.
  5727.   *
  5728.   * @dev: pointer to struct device to register.
  5729.   *
  5730.  -535,15 +535,15 @@
  5731.   * be set.
  5732.   */
  5733.  
  5734. -int drm_class_device_register(struct device *dev)
  5735. +int lbm_drm_class_device_register(struct device *dev)
  5736.  {
  5737.         dev->class = drm_class;
  5738.         return device_register(dev);
  5739.  }
  5740. -EXPORT_SYMBOL_GPL(drm_class_device_register);
  5741. +EXPORT_SYMBOL_GPL(lbm_drm_class_device_register);
  5742.  
  5743. -void drm_class_device_unregister(struct device *dev)
  5744. +void lbm_drm_class_device_unregister(struct device *dev)
  5745.  {
  5746.         return device_unregister(dev);
  5747.  }
  5748. -EXPORT_SYMBOL_GPL(drm_class_device_unregister);
  5749. +EXPORT_SYMBOL_GPL(lbm_drm_class_device_unregister);
  5750. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_vm.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_vm.c
  5751. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_vm.c      2010-01-25 15:21:29.000000000 -0500
  5752. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/drm_vm.c      2010-02-03 17:11:08.000000000 -0500
  5753.  -104,7 +104,7 @@
  5754.         if (!dev->agp || !dev->agp->cant_use_aperture)
  5755.                 goto vm_fault_error;
  5756.  
  5757. -       if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash))
  5758. +       if (lbm_drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash))
  5759.                 goto vm_fault_error;
  5760.  
  5761.         r_list = drm_hash_entry(hash, struct drm_map_list, hash);
  5762.  -514,14 +514,14 @@
  5763.         return 0;
  5764.  }
  5765.  
  5766. -resource_size_t drm_core_get_map_ofs(struct drm_local_map * map)
  5767. +resource_size_t lbm_drm_core_get_map_ofs(struct drm_local_map * map)
  5768.  {
  5769.         return map->offset;
  5770.  }
  5771.  
  5772. -EXPORT_SYMBOL(drm_core_get_map_ofs);
  5773. +EXPORT_SYMBOL(lbm_drm_core_get_map_ofs);
  5774.  
  5775. -resource_size_t drm_core_get_reg_ofs(struct drm_device *dev)
  5776. +resource_size_t lbm_drm_core_get_reg_ofs(struct drm_device *dev)
  5777.  {
  5778.  #ifdef __alpha__
  5779.         return dev->hose->dense_mem_base - dev->hose->mem_space->start;
  5780.  -530,7 +530,7 @@
  5781.  #endif
  5782.  }
  5783.  
  5784. -EXPORT_SYMBOL(drm_core_get_reg_ofs);
  5785. +EXPORT_SYMBOL(lbm_drm_core_get_reg_ofs);
  5786.  
  5787.  /**
  5788.   * mmap DMA memory.
  5789.  -571,7 +571,7 @@
  5790.             )
  5791.                 return drm_mmap_dma(filp, vma);
  5792.  
  5793. -       if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash)) {
  5794. +       if (lbm_drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash)) {
  5795.                 DRM_ERROR("Could not find map\n");
  5796.                 return -EINVAL;
  5797.         }
  5798.  -663,7 +663,7 @@
  5799.         return 0;
  5800.  }
  5801.  
  5802. -int drm_mmap(struct file *filp, struct vm_area_struct *vma)
  5803. +int lbm_drm_mmap(struct file *filp, struct vm_area_struct *vma)
  5804.  {
  5805.         struct drm_file *priv = filp->private_data;
  5806.         struct drm_device *dev = priv->minor->dev;
  5807.  -675,4 +675,4 @@
  5808.  
  5809.         return ret;
  5810.  }
  5811. -EXPORT_SYMBOL(drm_mmap);
  5812. +EXPORT_SYMBOL(lbm_drm_mmap);
  5813. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_cache.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_cache.h
  5814. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_cache.h       2010-01-25 15:21:29.000000000 -0500
  5815. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_cache.h       2010-02-03 17:11:08.000000000 -0500
  5816.  -33,6 +33,6 @@
  5817.  #ifndef _DRM_CACHE_H_
  5818.  #define _DRM_CACHE_H_
  5819.  
  5820. -void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
  5821. +void lbm_drm_clflush_pages(struct page *pages[], unsigned long num_pages);
  5822.  
  5823.  #endif
  5824. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_core.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_core.h
  5825. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_core.h        2010-01-25 15:21:29.000000000 -0500
  5826. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_core.h        2010-02-03 17:11:08.000000000 -0500
  5827.  -22,7 +22,7 @@
  5828.   */
  5829.  #define CORE_AUTHOR            "Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl"
  5830.  
  5831. -#define CORE_NAME              "drm"
  5832. +#define CORE_NAME              "lbm-drm"
  5833.  #define CORE_DESC              "DRM shared core routines"
  5834.  #define CORE_DATE              "20060810"
  5835.  
  5836. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc.h
  5837. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc.h        2010-01-25 15:21:29.000000000 -0500
  5838. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc.h        2010-02-03 17:11:08.000000000 -0500
  5839.  -637,26 +637,26 @@
  5840.  #define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
  5841.  
  5842.  
  5843. -extern void drm_crtc_init(struct drm_device *dev,
  5844. +extern void lbm_drm_crtc_init(struct drm_device *dev,
  5845.                           struct drm_crtc *crtc,
  5846.                           const struct drm_crtc_funcs *funcs);
  5847. -extern void drm_crtc_cleanup(struct drm_crtc *crtc);
  5848. +extern void lbm_drm_crtc_cleanup(struct drm_crtc *crtc);
  5849.  
  5850. -extern void drm_connector_init(struct drm_device *dev,
  5851. +extern void lbm_drm_connector_init(struct drm_device *dev,
  5852.                             struct drm_connector *connector,
  5853.                             const struct drm_connector_funcs *funcs,
  5854.                             int connector_type);
  5855.  
  5856. -extern void drm_connector_cleanup(struct drm_connector *connector);
  5857. +extern void lbm_drm_connector_cleanup(struct drm_connector *connector);
  5858.  
  5859. -extern void drm_encoder_init(struct drm_device *dev,
  5860. +extern void lbm_drm_encoder_init(struct drm_device *dev,
  5861.                              struct drm_encoder *encoder,
  5862.                              const struct drm_encoder_funcs *funcs,
  5863.                              int encoder_type);
  5864.  
  5865. -extern void drm_encoder_cleanup(struct drm_encoder *encoder);
  5866. +extern void lbm_drm_encoder_cleanup(struct drm_encoder *encoder);
  5867.  
  5868. -extern char *drm_get_connector_name(struct drm_connector *connector);
  5869. +extern char *lbm_drm_get_connector_name(struct drm_connector *connector);
  5870.  extern char *drm_get_dpms_name(int val);
  5871.  extern char *drm_get_dvi_i_subconnector_name(int val);
  5872.  extern char *drm_get_dvi_i_select_name(int val);
  5873.  -664,86 +664,86 @@
  5874.  extern char *drm_get_tv_select_name(int val);
  5875.  extern void drm_fb_release(struct drm_file *file_priv);
  5876.  extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
  5877. -extern struct edid *drm_get_edid(struct drm_connector *connector,
  5878. +extern struct edid *lbm_drm_get_edid(struct drm_connector *connector,
  5879.                                  struct i2c_adapter *adapter);
  5880. -extern int drm_do_probe_ddc_edid(struct i2c_adapter *adapter,
  5881. +extern int lbm_drm_do_probe_ddc_edid(struct i2c_adapter *adapter,
  5882.                                  unsigned char *buf, int len);
  5883. -extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
  5884. -extern void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
  5885. -extern void drm_mode_remove(struct drm_connector *connector, struct drm_display_mode *mode);
  5886. -extern struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev,
  5887. +extern int lbm_drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
  5888. +extern void lbm_drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
  5889. +extern void lbm_drm_mode_remove(struct drm_connector *connector, struct drm_display_mode *mode);
  5890. +extern struct drm_display_mode *lbm_drm_mode_duplicate(struct drm_device *dev,
  5891.                                                    struct drm_display_mode *mode);
  5892. -extern void drm_mode_debug_printmodeline(struct drm_display_mode *mode);
  5893. -extern void drm_mode_config_init(struct drm_device *dev);
  5894. -extern void drm_mode_config_cleanup(struct drm_device *dev);
  5895. -extern void drm_mode_set_name(struct drm_display_mode *mode);
  5896. -extern bool drm_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2);
  5897. -extern int drm_mode_width(struct drm_display_mode *mode);
  5898. -extern int drm_mode_height(struct drm_display_mode *mode);
  5899. +extern void lbm_drm_mode_debug_printmodeline(struct drm_display_mode *mode);
  5900. +extern void lbm_drm_mode_config_init(struct drm_device *dev);
  5901. +extern void lbm_drm_mode_config_cleanup(struct drm_device *dev);
  5902. +extern void lbm_drm_mode_set_name(struct drm_display_mode *mode);
  5903. +extern bool lbm_drm_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2);
  5904. +extern int lbm_drm_mode_width(struct drm_display_mode *mode);
  5905. +extern int lbm_drm_mode_height(struct drm_display_mode *mode);
  5906.  
  5907.  /* for us by fb module */
  5908. -extern int drm_mode_attachmode_crtc(struct drm_device *dev,
  5909. +extern int lbm_drm_mode_attachmode_crtc(struct drm_device *dev,
  5910.                                     struct drm_crtc *crtc,
  5911.                                     struct drm_display_mode *mode);
  5912. -extern int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode);
  5913. +extern int lbm_drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode);
  5914.  
  5915. -extern struct drm_display_mode *drm_mode_create(struct drm_device *dev);
  5916. -extern void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode);
  5917. -extern void drm_mode_list_concat(struct list_head *head,
  5918. +extern struct drm_display_mode *lbm_drm_mode_create(struct drm_device *dev);
  5919. +extern void lbm_drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode);
  5920. +extern void lbm_drm_mode_list_concat(struct list_head *head,
  5921.                                  struct list_head *new);
  5922. -extern void drm_mode_validate_size(struct drm_device *dev,
  5923. +extern void lbm_drm_mode_validate_size(struct drm_device *dev,
  5924.                                    struct list_head *mode_list,
  5925.                                    int maxX, int maxY, int maxPitch);
  5926. -extern void drm_mode_prune_invalid(struct drm_device *dev,
  5927. +extern void lbm_drm_mode_prune_invalid(struct drm_device *dev,
  5928.                                    struct list_head *mode_list, bool verbose);
  5929. -extern void drm_mode_sort(struct list_head *mode_list);
  5930. -extern int drm_mode_hsync(struct drm_display_mode *mode);
  5931. -extern int drm_mode_vrefresh(struct drm_display_mode *mode);
  5932. -extern void drm_mode_set_crtcinfo(struct drm_display_mode *p,
  5933. +extern void lbm_drm_mode_sort(struct list_head *mode_list);
  5934. +extern int lbm_drm_mode_hsync(struct drm_display_mode *mode);
  5935. +extern int lbm_drm_mode_vrefresh(struct drm_display_mode *mode);
  5936. +extern void lbm_drm_mode_set_crtcinfo(struct drm_display_mode *p,
  5937.                                   int adjust_flags);
  5938. -extern void drm_mode_connector_list_update(struct drm_connector *connector);
  5939. -extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
  5940. +extern void lbm_drm_mode_connector_list_update(struct drm_connector *connector);
  5941. +extern int lbm_drm_mode_connector_update_edid_property(struct drm_connector *connector,
  5942.                                                 struct edid *edid);
  5943. -extern int drm_connector_property_set_value(struct drm_connector *connector,
  5944. +extern int lbm_drm_connector_property_set_value(struct drm_connector *connector,
  5945.                                          struct drm_property *property,
  5946.                                          uint64_t value);
  5947. -extern int drm_connector_property_get_value(struct drm_connector *connector,
  5948. +extern int lbm_drm_connector_property_get_value(struct drm_connector *connector,
  5949.                                          struct drm_property *property,
  5950.                                          uint64_t *value);
  5951.  extern struct drm_display_mode *drm_crtc_mode_create(struct drm_device *dev);
  5952.  extern void drm_framebuffer_set_object(struct drm_device *dev,
  5953.                                        unsigned long handle);
  5954. -extern int drm_framebuffer_init(struct drm_device *dev,
  5955. +extern int lbm_drm_framebuffer_init(struct drm_device *dev,
  5956.                                 struct drm_framebuffer *fb,
  5957.                                 const struct drm_framebuffer_funcs *funcs);
  5958. -extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
  5959. +extern void lbm_drm_framebuffer_cleanup(struct drm_framebuffer *fb);
  5960.  extern int drmfb_probe(struct drm_device *dev, struct drm_crtc *crtc);
  5961.  extern int drmfb_remove(struct drm_device *dev, struct drm_framebuffer *fb);
  5962.  extern void drm_crtc_probe_connector_modes(struct drm_device *dev, int maxX, int maxY);
  5963.  extern bool drm_crtc_in_use(struct drm_crtc *crtc);
  5964.  
  5965. -extern int drm_connector_attach_property(struct drm_connector *connector,
  5966. +extern int lbm_drm_connector_attach_property(struct drm_connector *connector,
  5967.                                       struct drm_property *property, uint64_t init_val);
  5968. -extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
  5969. +extern struct drm_property *lbm_drm_property_create(struct drm_device *dev, int flags,
  5970.                                                 const char *name, int num_values);
  5971. -extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
  5972. -extern int drm_property_add_enum(struct drm_property *property, int index,
  5973. +extern void lbm_drm_property_destroy(struct drm_device *dev, struct drm_property *property);
  5974. +extern int lbm_drm_property_add_enum(struct drm_property *property, int index,
  5975.                                  uint64_t value, const char *name);
  5976. -extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
  5977. -extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats,
  5978. +extern int lbm_drm_mode_create_dvi_i_properties(struct drm_device *dev);
  5979. +extern int lbm_drm_mode_create_tv_properties(struct drm_device *dev, int num_formats,
  5980.                                      char *formats[]);
  5981. -extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
  5982. -extern int drm_mode_create_dithering_property(struct drm_device *dev);
  5983. -extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
  5984. -extern char *drm_get_encoder_name(struct drm_encoder *encoder);
  5985. +extern int lbm_drm_mode_create_scaling_mode_property(struct drm_device *dev);
  5986. +extern int lbm_drm_mode_create_dithering_property(struct drm_device *dev);
  5987. +extern int lbm_drm_mode_create_dirty_info_property(struct drm_device *dev);
  5988. +extern char *lbm_drm_get_encoder_name(struct drm_encoder *encoder);
  5989.  
  5990. -extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
  5991. +extern int lbm_drm_mode_connector_attach_encoder(struct drm_connector *connector,
  5992.                                              struct drm_encoder *encoder);
  5993. -extern void drm_mode_connector_detach_encoder(struct drm_connector *connector,
  5994. +extern void lbm_drm_mode_connector_detach_encoder(struct drm_connector *connector,
  5995.                                            struct drm_encoder *encoder);
  5996. -extern bool drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
  5997. +extern bool lbm_drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
  5998.                                          int gamma_size);
  5999. -extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
  6000. +extern struct drm_mode_object *lbm_drm_mode_object_find(struct drm_device *dev,
  6001.                 uint32_t id, uint32_t type);
  6002.  /* IOCTLs */
  6003.  extern int drm_mode_getresources(struct drm_device *dev,
  6004.  -790,15 +790,15 @@
  6005.                                     void *data, struct drm_file *file_priv);
  6006.  extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
  6007.                                     void *data, struct drm_file *file_priv);
  6008. -extern bool drm_detect_hdmi_monitor(struct edid *edid);
  6009. +extern bool lbm_drm_detect_hdmi_monitor(struct edid *edid);
  6010.  extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
  6011.                                     void *data, struct drm_file *file_priv);
  6012. -extern struct drm_display_mode *drm_cvt_mode(struct drm_device *dev,
  6013. +extern struct drm_display_mode *lbm_drm_cvt_mode(struct drm_device *dev,
  6014.                                 int hdisplay, int vdisplay, int vrefresh,
  6015.                                 bool reduced, bool interlaced, bool margins);
  6016. -extern struct drm_display_mode *drm_gtf_mode(struct drm_device *dev,
  6017. +extern struct drm_display_mode *lbm_drm_gtf_mode(struct drm_device *dev,
  6018.                                 int hdisplay, int vdisplay, int vrefresh,
  6019.                                 bool interlaced, int margins);
  6020. -extern int drm_add_modes_noedid(struct drm_connector *connector,
  6021. +extern int lbm_drm_add_modes_noedid(struct drm_connector *connector,
  6022.                                 int hdisplay, int vdisplay);
  6023.  #endif /* __DRM_CRTC_H__ */
  6024. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc_helper.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc_helper.h
  6025. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc_helper.h 2010-01-25 15:21:29.000000000 -0500
  6026. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_crtc_helper.h 2010-02-03 17:11:08.000000000 -0500
  6027.  -94,21 +94,21 @@
  6028.         struct drm_encoder *(*best_encoder)(struct drm_connector *connector);
  6029.  };
  6030.  
  6031. -extern int drm_helper_probe_single_connector_modes(struct drm_connector *connector, uint32_t maxX, uint32_t maxY);
  6032. -extern void drm_helper_disable_unused_functions(struct drm_device *dev);
  6033. -extern int drm_helper_hotplug_stage_two(struct drm_device *dev);
  6034. -extern bool drm_helper_initial_config(struct drm_device *dev);
  6035. -extern int drm_crtc_helper_set_config(struct drm_mode_set *set);
  6036. -extern bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
  6037. +extern int lbm_drm_helper_probe_single_connector_modes(struct drm_connector *connector, uint32_t maxX, uint32_t maxY);
  6038. +extern void lbm_drm_helper_disable_unused_functions(struct drm_device *dev);
  6039. +extern int lbm_drm_helper_hotplug_stage_two(struct drm_device *dev);
  6040. +extern bool lbm_drm_helper_initial_config(struct drm_device *dev);
  6041. +extern int lbm_drm_crtc_helper_set_config(struct drm_mode_set *set);
  6042. +extern bool lbm_drm_crtc_helper_set_mode(struct drm_crtc *crtc,
  6043.                                      struct drm_display_mode *mode,
  6044.                                      int x, int y,
  6045.                                      struct drm_framebuffer *old_fb);
  6046. -extern bool drm_helper_crtc_in_use(struct drm_crtc *crtc);
  6047. -extern bool drm_helper_encoder_in_use(struct drm_encoder *encoder);
  6048. +extern bool lbm_drm_helper_crtc_in_use(struct drm_crtc *crtc);
  6049. +extern bool lbm_drm_helper_encoder_in_use(struct drm_encoder *encoder);
  6050.  
  6051. -extern void drm_helper_connector_dpms(struct drm_connector *connector, int mode);
  6052. +extern void lbm_drm_helper_connector_dpms(struct drm_connector *connector, int mode);
  6053.  
  6054. -extern int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
  6055. +extern int lbm_drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
  6056.                                           struct drm_mode_fb_cmd *mode_cmd);
  6057.  
  6058.  static inline void drm_crtc_helper_add(struct drm_crtc *crtc,
  6059.  -127,8 +127,8 @@
  6060.                                             const struct drm_connector_helper_funcs *funcs)
  6061.  {
  6062.         connector->helper_private = (void *)funcs;
  6063. -       return drm_fb_helper_add_connector(connector);
  6064. +       return lbm_drm_fb_helper_add_connector(connector);
  6065.  }
  6066.  
  6067. -extern int drm_helper_resume_force_mode(struct drm_device *dev);
  6068. +extern int lbm_drm_helper_resume_force_mode(struct drm_device *dev);
  6069.  #endif
  6070. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_dp_helper.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_dp_helper.h
  6071. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_dp_helper.h   2010-01-25 15:21:29.000000000 -0500
  6072. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_dp_helper.h   2010-02-03 17:11:08.000000000 -0500
  6073.  -175,6 +175,6 @@
  6074.  };
  6075.  
  6076.  int
  6077. -i2c_dp_aux_add_bus(struct i2c_adapter *adapter);
  6078. +lbm_i2c_dp_aux_add_bus(struct i2c_adapter *adapter);
  6079.  
  6080.  #endif /* _DRM_DP_HELPER_H_ */
  6081. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_encoder_slave.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_encoder_slave.h
  6082. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_encoder_slave.h       2010-01-25 15:21:29.000000000 -0500
  6083. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_encoder_slave.h       2010-02-03 17:11:08.000000000 -0500
  6084.  -89,7 +89,7 @@
  6085.   * GPU-agnostic lower layer: It's the GPU driver responsibility to
  6086.   * call the slave methods when appropriate.
  6087.   *
  6088. - * drm_i2c_encoder_init() provides a way to get an implementation of
  6089. + * lbm_drm_i2c_encoder_init() provides a way to get an implementation of
  6090.   * this.
  6091.   */
  6092.  struct drm_encoder_slave {
  6093.  -101,7 +101,7 @@
  6094.  };
  6095.  #define to_encoder_slave(x) container_of((x), struct drm_encoder_slave, base)
  6096.  
  6097. -int drm_i2c_encoder_init(struct drm_device *dev,
  6098. +int lbm_drm_i2c_encoder_init(struct drm_device *dev,
  6099.                          struct drm_encoder_slave *encoder,
  6100.                          struct i2c_adapter *adap,
  6101.                          const struct i2c_board_info *info);
  6102.  -157,6 +157,6 @@
  6103.         i2c_del_driver(&driver->i2c_driver);
  6104.  }
  6105.  
  6106. -void drm_i2c_encoder_destroy(struct drm_encoder *encoder);
  6107. +void lbm_drm_i2c_encoder_destroy(struct drm_encoder *encoder);
  6108.  
  6109.  #endif
  6110. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_fb_helper.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_fb_helper.h
  6111. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_fb_helper.h   2010-01-25 15:21:29.000000000 -0500
  6112. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_fb_helper.h   2010-02-03 17:11:08.000000000 -0500
  6113.  -72,7 +72,7 @@
  6114.         struct list_head kernel_fb_list;
  6115.  };
  6116.  
  6117. -int drm_fb_helper_single_fb_probe(struct drm_device *dev,
  6118. +int lbm_drm_fb_helper_single_fb_probe(struct drm_device *dev,
  6119.                                   int preferred_bpp,
  6120.                                   int (*fb_create)(struct drm_device *dev,
  6121.                                                    uint32_t fb_width,
  6122.  -82,30 +82,30 @@
  6123.                                                    uint32_t surface_depth,
  6124.                                                    uint32_t surface_bpp,
  6125.                                                    struct drm_framebuffer **fb_ptr));
  6126. -int drm_fb_helper_init_crtc_count(struct drm_fb_helper *helper, int crtc_count,
  6127. +int lbm_drm_fb_helper_init_crtc_count(struct drm_fb_helper *helper, int crtc_count,
  6128.                                   int max_conn);
  6129. -void drm_fb_helper_free(struct drm_fb_helper *helper);
  6130. -int drm_fb_helper_blank(int blank, struct fb_info *info);
  6131. -int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
  6132. +void lbm_drm_fb_helper_free(struct drm_fb_helper *helper);
  6133. +int lbm_drm_fb_helper_blank(int blank, struct fb_info *info);
  6134. +int lbm_drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
  6135.                               struct fb_info *info);
  6136. -int drm_fb_helper_set_par(struct fb_info *info);
  6137. -int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
  6138. +int lbm_drm_fb_helper_set_par(struct fb_info *info);
  6139. +int lbm_drm_fb_helper_check_var(struct fb_var_screeninfo *var,
  6140.                             struct fb_info *info);
  6141. -int drm_fb_helper_setcolreg(unsigned regno,
  6142. +int lbm_drm_fb_helper_setcolreg(unsigned regno,
  6143.                             unsigned red,
  6144.                             unsigned green,
  6145.                             unsigned blue,
  6146.                             unsigned transp,
  6147.                             struct fb_info *info);
  6148.  
  6149. -void drm_fb_helper_restore(void);
  6150. -void drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb,
  6151. +void lbm_drm_fb_helper_restore(void);
  6152. +void lbm_drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb,
  6153.                             uint32_t fb_width, uint32_t fb_height);
  6154. -void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
  6155. +void lbm_drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
  6156.                             uint32_t depth);
  6157.  
  6158. -int drm_fb_helper_add_connector(struct drm_connector *connector);
  6159. +int lbm_drm_fb_helper_add_connector(struct drm_connector *connector);
  6160.  int drm_fb_helper_parse_command_line(struct drm_device *dev);
  6161. -int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info);
  6162. +int lbm_drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info);
  6163.  
  6164.  #endif
  6165. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm.h
  6166. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm.h     2010-01-25 15:21:29.000000000 -0500
  6167. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm.h     2010-02-03 17:11:08.000000000 -0500
  6168.  -58,7 +58,7 @@
  6169.  
  6170.  #endif
  6171.  
  6172. -#define DRM_NAME       "drm"     /**< Name in kernel, /dev, and /proc */
  6173. +#define DRM_NAME       "lbm-drm"         /**< Name in kernel, /dev, and /proc */
  6174.  #define DRM_MIN_ORDER  5         /**< At least 2^5 bytes = 32 bytes */
  6175.  #define DRM_MAX_ORDER  22        /**< Up to 2^22 bytes = 4MB */
  6176.  #define DRM_RAM_PERCENT 10       /**< How much system ram can we lock? */
  6177.  -548,7 +548,7 @@
  6178.   * drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(),
  6179.   * drmAgpVendorId() and drmAgpDeviceId().
  6180.   */
  6181. -struct drm_agp_info {
  6182. +struct lbm_drm_agp_info {
  6183.         int agp_version_major;
  6184.         int agp_version_minor;
  6185.         unsigned long mode;
  6186.  -666,7 +666,7 @@
  6187.  #define DRM_IOCTL_AGP_ACQUIRE          DRM_IO(  0x30)
  6188.  #define DRM_IOCTL_AGP_RELEASE          DRM_IO(  0x31)
  6189.  #define DRM_IOCTL_AGP_ENABLE           DRM_IOW( 0x32, struct drm_agp_mode)
  6190. -#define DRM_IOCTL_AGP_INFO             DRM_IOR( 0x33, struct drm_agp_info)
  6191. +#define DRM_IOCTL_AGP_INFO             DRM_IOR( 0x33, struct lbm_drm_agp_info)
  6192.  #define DRM_IOCTL_AGP_ALLOC            DRM_IOWR(0x34, struct drm_agp_buffer)
  6193.  #define DRM_IOCTL_AGP_FREE             DRM_IOW( 0x35, struct drm_agp_buffer)
  6194.  #define DRM_IOCTL_AGP_BIND             DRM_IOW( 0x36, struct drm_agp_binding)
  6195.  -779,7 +779,7 @@
  6196.  
  6197.  typedef struct drm_agp_buffer drm_agp_buffer_t;
  6198.  typedef struct drm_agp_binding drm_agp_binding_t;
  6199. -typedef struct drm_agp_info drm_agp_info_t;
  6200. +typedef struct lbm_drm_agp_info drm_agp_info_t;
  6201.  typedef struct drm_scatter_gather drm_scatter_gather_t;
  6202.  typedef struct drm_set_version drm_set_version_t;
  6203.  #endif
  6204. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_hashtab.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_hashtab.h
  6205. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_hashtab.h     2010-01-25 15:21:29.000000000 -0500
  6206. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_hashtab.h     2010-02-03 17:11:08.000000000 -0500
  6207.  -53,17 +53,17 @@
  6208.  };
  6209.  
  6210.  
  6211. -extern int drm_ht_create(struct drm_open_hash *ht, unsigned int order);
  6212. -extern int drm_ht_insert_item(struct drm_open_hash *ht, struct drm_hash_item *item);
  6213. -extern int drm_ht_just_insert_please(struct drm_open_hash *ht, struct drm_hash_item *item,
  6214. +extern int lbm_drm_ht_create(struct drm_open_hash *ht, unsigned int order);
  6215. +extern int lbm_drm_ht_insert_item(struct drm_open_hash *ht, struct drm_hash_item *item);
  6216. +extern int lbm_drm_ht_just_insert_please(struct drm_open_hash *ht, struct drm_hash_item *item,
  6217.                                      unsigned long seed, int bits, int shift,
  6218.                                      unsigned long add);
  6219. -extern int drm_ht_find_item(struct drm_open_hash *ht, unsigned long key, struct drm_hash_item **item);
  6220. +extern int lbm_drm_ht_find_item(struct drm_open_hash *ht, unsigned long key, struct drm_hash_item **item);
  6221.  
  6222.  extern void drm_ht_verbose_list(struct drm_open_hash *ht, unsigned long key);
  6223.  extern int drm_ht_remove_key(struct drm_open_hash *ht, unsigned long key);
  6224. -extern int drm_ht_remove_item(struct drm_open_hash *ht, struct drm_hash_item *item);
  6225. -extern void drm_ht_remove(struct drm_open_hash *ht);
  6226. +extern int lbm_drm_ht_remove_item(struct drm_open_hash *ht, struct drm_hash_item *item);
  6227. +extern void lbm_drm_ht_remove(struct drm_open_hash *ht);
  6228.  
  6229.  
  6230.  #endif
  6231. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mm.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mm.h
  6232. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mm.h  2010-01-25 15:21:29.000000000 -0500
  6233. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mm.h  2010-02-03 17:11:08.000000000 -0500
  6234.  -62,11 +62,11 @@
  6235.  /*
  6236.   * Basic range manager support (drm_mm.c)
  6237.   */
  6238. -extern struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *node,
  6239. +extern struct drm_mm_node *lbm_drm_mm_get_block_generic(struct drm_mm_node *node,
  6240.                                                     unsigned long size,
  6241.                                                     unsigned alignment,
  6242.                                                     int atomic);
  6243. -extern struct drm_mm_node *drm_mm_get_block_range_generic(
  6244. +extern struct drm_mm_node *lbm_drm_mm_get_block_range_generic(
  6245.                                                 struct drm_mm_node *node,
  6246.                                                 unsigned long size,
  6247.                                                 unsigned alignment,
  6248.  -77,13 +77,13 @@
  6249.                                                    unsigned long size,
  6250.                                                    unsigned alignment)
  6251.  {
  6252. -       return drm_mm_get_block_generic(parent, size, alignment, 0);
  6253. +       return lbm_drm_mm_get_block_generic(parent, size, alignment, 0);
  6254.  }
  6255.  static inline struct drm_mm_node *drm_mm_get_block_atomic(struct drm_mm_node *parent,
  6256.                                                           unsigned long size,
  6257.                                                           unsigned alignment)
  6258.  {
  6259. -       return drm_mm_get_block_generic(parent, size, alignment, 1);
  6260. +       return lbm_drm_mm_get_block_generic(parent, size, alignment, 1);
  6261.  }
  6262.  static inline struct drm_mm_node *drm_mm_get_block_range(
  6263.                                                 struct drm_mm_node *parent,
  6264.  -92,7 +92,7 @@
  6265.                                                 unsigned long start,
  6266.                                                 unsigned long end)
  6267.  {
  6268. -       return drm_mm_get_block_range_generic(parent, size, alignment,
  6269. +       return lbm_drm_mm_get_block_range_generic(parent, size, alignment,
  6270.                                                 start, end, 0);
  6271.  }
  6272.  static inline struct drm_mm_node *drm_mm_get_block_atomic_range(
  6273.  -102,40 +102,40 @@
  6274.                                                 unsigned long start,
  6275.                                                 unsigned long end)
  6276.  {
  6277. -       return drm_mm_get_block_range_generic(parent, size, alignment,
  6278. +       return lbm_drm_mm_get_block_range_generic(parent, size, alignment,
  6279.                                                 start, end, 1);
  6280.  }
  6281. -extern void drm_mm_put_block(struct drm_mm_node *cur);
  6282. -extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm,
  6283. +extern void lbm_drm_mm_put_block(struct drm_mm_node *cur);
  6284. +extern struct drm_mm_node *lbm_drm_mm_search_free(const struct drm_mm *mm,
  6285.                                               unsigned long size,
  6286.                                               unsigned alignment,
  6287.                                               int best_match);
  6288. -extern struct drm_mm_node *drm_mm_search_free_in_range(
  6289. +extern struct drm_mm_node *lbm_drm_mm_search_free_in_range(
  6290.                                                 const struct drm_mm *mm,
  6291.                                                 unsigned long size,
  6292.                                                 unsigned alignment,
  6293.                                                 unsigned long start,
  6294.                                                 unsigned long end,
  6295.                                                 int best_match);
  6296. -extern int drm_mm_init(struct drm_mm *mm, unsigned long start,
  6297. +extern int lbm_drm_mm_init(struct drm_mm *mm, unsigned long start,
  6298.                        unsigned long size);
  6299. -extern void drm_mm_takedown(struct drm_mm *mm);
  6300. -extern int drm_mm_clean(struct drm_mm *mm);
  6301. +extern void lbm_drm_mm_takedown(struct drm_mm *mm);
  6302. +extern int lbm_drm_mm_clean(struct drm_mm *mm);
  6303.  extern unsigned long drm_mm_tail_space(struct drm_mm *mm);
  6304.  extern int drm_mm_remove_space_from_tail(struct drm_mm *mm,
  6305.                                          unsigned long size);
  6306.  extern int drm_mm_add_space_to_tail(struct drm_mm *mm,
  6307.                                     unsigned long size, int atomic);
  6308. -extern int drm_mm_pre_get(struct drm_mm *mm);
  6309. +extern int lbm_drm_mm_pre_get(struct drm_mm *mm);
  6310.  
  6311.  static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block)
  6312.  {
  6313.         return block->mm;
  6314.  }
  6315.  
  6316. -extern void drm_mm_debug_table(struct drm_mm *mm, const char *prefix);
  6317. +extern void lbm_drm_mm_debug_table(struct drm_mm *mm, const char *prefix);
  6318.  #ifdef CONFIG_DEBUG_FS
  6319. -int drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm);
  6320. +int lbm_drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm);
  6321.  #endif
  6322.  
  6323.  #endif
  6324. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mode.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mode.h
  6325. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mode.h        2010-01-25 15:21:29.000000000 -0500
  6326. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_mode.h        2010-02-03 17:11:08.000000000 -0500
  6327.  -85,7 +85,7 @@
  6328.         __u16 hdisplay, hsync_start, hsync_end, htotal, hskew;
  6329.         __u16 vdisplay, vsync_start, vsync_end, vtotal, vscan;
  6330.  
  6331. -       __u32 vrefresh; /* vertical refresh * 1000 */
  6332. +       __u32 vrefresh;
  6333.  
  6334.         __u32 flags;
  6335.         __u32 type;
  6336. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drmP.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drmP.h
  6337. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drmP.h    2010-01-25 15:21:29.000000000 -0500
  6338. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drmP.h    2010-02-03 17:11:08.000000000 -0500
  6339.  -92,7 +92,7 @@
  6340.   * Three debug levels are defined.
  6341.   * drm_core, drm_driver, drm_kms
  6342.   * drm_core level can be used in the generic drm code. For example:
  6343. - *     drm_ioctl, drm_mm, drm_memory
  6344. + *     lbm_drm_ioctl, drm_mm, drm_memory
  6345.   * The macro definiton of DRM_DEBUG is used.
  6346.   *     DRM_DEBUG(fmt, args...)
  6347.   *     The debug info by using the DRM_DEBUG can be obtained by adding
  6348.  -120,7 +120,7 @@
  6349.   * using the DRM_DEBUG_KMS and DRM_DEBUG.
  6350.   */
  6351.  
  6352. -extern void drm_ut_debug_printk(unsigned int request_level,
  6353. +extern void lbm_drm_ut_debug_printk(unsigned int request_level,
  6354.                                 const char *prefix,
  6355.                                 const char *function_name,
  6356.                                 const char *format, ...);
  6357.  -200,38 +200,38 @@
  6358.  #if DRM_DEBUG_CODE
  6359.  #define DRM_DEBUG(fmt, args...)                                                \
  6360.         do {                                                            \
  6361. -               drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME,              \
  6362. +               lbm_drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME,          \
  6363.                                         __func__, fmt, ##args);         \
  6364.         } while (0)
  6365.  
  6366.  #define DRM_DEBUG_DRIVER(fmt, args...)                                 \
  6367.         do {                                                            \
  6368. -               drm_ut_debug_printk(DRM_UT_DRIVER, DRM_NAME,            \
  6369. +               lbm_drm_ut_debug_printk(DRM_UT_DRIVER, DRM_NAME,                \
  6370.                                         __func__, fmt, ##args);         \
  6371.         } while (0)
  6372.  #define DRM_DEBUG_KMS(fmt, args...)                            \
  6373.         do {                                                            \
  6374. -               drm_ut_debug_printk(DRM_UT_KMS, DRM_NAME,               \
  6375. +               lbm_drm_ut_debug_printk(DRM_UT_KMS, DRM_NAME,           \
  6376.                                          __func__, fmt, ##args);        \
  6377.         } while (0)
  6378.  #define DRM_LOG(fmt, args...)                                          \
  6379.         do {                                                            \
  6380. -               drm_ut_debug_printk(DRM_UT_CORE, NULL,                  \
  6381. +               lbm_drm_ut_debug_printk(DRM_UT_CORE, NULL,                      \
  6382.                                         NULL, fmt, ##args);             \
  6383.         } while (0)
  6384.  #define DRM_LOG_KMS(fmt, args...)                                      \
  6385.         do {                                                            \
  6386. -               drm_ut_debug_printk(DRM_UT_KMS, NULL,                   \
  6387. +               lbm_drm_ut_debug_printk(DRM_UT_KMS, NULL,                       \
  6388.                                         NULL, fmt, ##args);             \
  6389.         } while (0)
  6390.  #define DRM_LOG_MODE(fmt, args...)                                     \
  6391.         do {                                                            \
  6392. -               drm_ut_debug_printk(DRM_UT_MODE, NULL,                  \
  6393. +               lbm_drm_ut_debug_printk(DRM_UT_MODE, NULL,                      \
  6394.                                         NULL, fmt, ##args);             \
  6395.         } while (0)
  6396.  #define DRM_LOG_DRIVER(fmt, args...)                                   \
  6397.         do {                                                            \
  6398. -               drm_ut_debug_printk(DRM_UT_DRIVER, NULL,                \
  6399. +               lbm_drm_ut_debug_printk(DRM_UT_DRIVER, NULL,            \
  6400.                                         NULL, fmt, ##args);             \
  6401.         } while (0)
  6402.  #else
  6403.  -290,7 +290,7 @@
  6404.                                unsigned long arg);
  6405.  
  6406.  #define DRM_IOCTL_NR(n)                _IOC_NR(n)
  6407. -#define DRM_MAJOR       226
  6408. +#define DRM_MAJOR 227
  6409.  
  6410.  #define DRM_AUTH       0x1
  6411.  #define        DRM_MASTER      0x2
  6412.  -306,7 +306,7 @@
  6413.  
  6414.  /**
  6415.   * Creates a driver or general drm_ioctl_desc array entry for the given
  6416. - * ioctl, for use by drm_ioctl().
  6417. + * ioctl, for use by lbm_drm_ioctl().
  6418.   */
  6419.  #define DRM_IOCTL_DEF(ioctl, _func, _flags) \
  6420.         [DRM_IOCTL_NR(ioctl)] = {.cmd = ioctl, .func = _func, .flags = _flags}
  6421.  -707,7 +707,7 @@
  6422.          *
  6423.          * Driver callback for fetching a raw hardware vblank counter
  6424.          * for @crtc.  If a device doesn't have a hardware counter, the
  6425. -        * driver can simply return the value of drm_vblank_count and
  6426. +        * driver can simply return the value of lbm_drm_vblank_count and
  6427.          * make the enable_vblank() and disable_vblank() hooks into no-ops,
  6428.          * leaving interrupts enabled at all times.
  6429.          *
  6430.  -1127,29 +1127,29 @@
  6431.  /*@{*/
  6432.  
  6433.                                 /* Driver support (drm_drv.h) */
  6434. -extern int drm_init(struct drm_driver *driver);
  6435. -extern void drm_exit(struct drm_driver *driver);
  6436. -extern long drm_ioctl(struct file *filp,
  6437. +extern int lbm_drm_init(struct drm_driver *driver);
  6438. +extern void lbm_drm_exit(struct drm_driver *driver);
  6439. +extern long lbm_drm_ioctl(struct file *filp,
  6440.                       unsigned int cmd, unsigned long arg);
  6441. -extern long drm_compat_ioctl(struct file *filp,
  6442. +extern long lbm_drm_compat_ioctl(struct file *filp,
  6443.                              unsigned int cmd, unsigned long arg);
  6444.  extern int drm_lastclose(struct drm_device *dev);
  6445.  
  6446.                                 /* Device support (drm_fops.h) */
  6447. -extern int drm_open(struct inode *inode, struct file *filp);
  6448. +extern int lbm_drm_open(struct inode *inode, struct file *filp);
  6449.  extern int drm_stub_open(struct inode *inode, struct file *filp);
  6450. -extern int drm_fasync(int fd, struct file *filp, int on);
  6451. -extern ssize_t drm_read(struct file *filp, char __user *buffer,
  6452. +extern int lbm_drm_fasync(int fd, struct file *filp, int on);
  6453. +extern ssize_t lbm_drm_read(struct file *filp, char __user *buffer,
  6454.                         size_t count, loff_t *offset);
  6455. -extern int drm_release(struct inode *inode, struct file *filp);
  6456. +extern int lbm_drm_release(struct inode *inode, struct file *filp);
  6457.  
  6458.                                 /* Mapping support (drm_vm.h) */
  6459. -extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
  6460. +extern int lbm_drm_mmap(struct file *filp, struct vm_area_struct *vma);
  6461.  extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
  6462.  extern void drm_vm_open_locked(struct vm_area_struct *vma);
  6463. -extern resource_size_t drm_core_get_map_ofs(struct drm_local_map * map);
  6464. -extern resource_size_t drm_core_get_reg_ofs(struct drm_device *dev);
  6465. -extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
  6466. +extern resource_size_t lbm_drm_core_get_map_ofs(struct drm_local_map * map);
  6467. +extern resource_size_t lbm_drm_core_get_reg_ofs(struct drm_device *dev);
  6468. +extern unsigned int lbm_drm_poll(struct file *filp, struct poll_table_struct *wait);
  6469.  
  6470.                                 /* Memory management support (drm_memory.h) */
  6471.  #include "drm_memory.h"
  6472.  -1159,16 +1159,16 @@
  6473.  extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area);
  6474.  
  6475.  extern DRM_AGP_MEM *drm_alloc_agp(struct drm_device *dev, int pages, u32 type);
  6476. -extern int drm_free_agp(DRM_AGP_MEM * handle, int pages);
  6477. +extern int lbm_drm_free_agp(DRM_AGP_MEM * handle, int pages);
  6478.  extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
  6479. -extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev,
  6480. +extern DRM_AGP_MEM *lbm_drm_agp_bind_pages(struct drm_device *dev,
  6481.                                        struct page **pages,
  6482.                                        unsigned long num_pages,
  6483.                                        uint32_t gtt_offset,
  6484.                                        uint32_t type);
  6485. -extern int drm_unbind_agp(DRM_AGP_MEM * handle);
  6486. +extern int lbm_drm_unbind_agp(DRM_AGP_MEM * handle);
  6487.  
  6488. -                               /* Misc. IOCTL support (drm_ioctl.h) */
  6489. +                               /* Misc. IOCTL support (lbm_drm_ioctl.h) */
  6490.  extern int drm_irq_by_busid(struct drm_device *dev, void *data,
  6491.                             struct drm_file *file_priv);
  6492.  extern int drm_getunique(struct drm_device *dev, void *data,
  6493.  -1218,7 +1218,7 @@
  6494.                       struct drm_file *file_priv);
  6495.  extern int drm_update_drawable_info(struct drm_device *dev, void *data,
  6496.                                     struct drm_file *file_priv);
  6497. -extern struct drm_drawable_info *drm_get_drawable_info(struct drm_device *dev,
  6498. +extern struct drm_drawable_info *lbm_drm_get_drawable_info(struct drm_device *dev,
  6499.                                                   drm_drawable_t id);
  6500.  extern void drm_drawable_free_all(struct drm_device *dev);
  6501.  
  6502.  -1229,35 +1229,35 @@
  6503.                          struct drm_file *file_priv);
  6504.  
  6505.  /* Cache management (drm_cache.c) */
  6506. -void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
  6507. +void lbm_drm_clflush_pages(struct page *pages[], unsigned long num_pages);
  6508.  
  6509.                                 /* Locking IOCTL support (drm_lock.h) */
  6510.  extern int drm_lock(struct drm_device *dev, void *data,
  6511.                     struct drm_file *file_priv);
  6512.  extern int drm_unlock(struct drm_device *dev, void *data,
  6513.                       struct drm_file *file_priv);
  6514. -extern int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
  6515. -extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
  6516. -extern void drm_idlelock_take(struct drm_lock_data *lock_data);
  6517. -extern void drm_idlelock_release(struct drm_lock_data *lock_data);
  6518. +extern int lbm_drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
  6519. +extern int lbm_drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
  6520. +extern void lbm_drm_idlelock_take(struct drm_lock_data *lock_data);
  6521. +extern void lbm_drm_idlelock_release(struct drm_lock_data *lock_data);
  6522.  
  6523.  /*
  6524.   * These are exported to drivers so that they can implement fencing using
  6525.   * DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
  6526.   */
  6527.  
  6528. -extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
  6529. +extern int lbm_drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
  6530.  
  6531.                                 /* Buffer management support (drm_bufs.h) */
  6532. -extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
  6533. -extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
  6534. -extern int drm_addmap(struct drm_device *dev, resource_size_t offset,
  6535. +extern int lbm_drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
  6536. +extern int lbm_drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
  6537. +extern int lbm_drm_addmap(struct drm_device *dev, resource_size_t offset,
  6538.                       unsigned int size, enum drm_map_type type,
  6539.                       enum drm_map_flags flags, struct drm_local_map **map_ptr);
  6540.  extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
  6541.                             struct drm_file *file_priv);
  6542. -extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
  6543. -extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
  6544. +extern int lbm_drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
  6545. +extern int lbm_drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
  6546.  extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
  6547.                            struct drm_file *file_priv);
  6548.  extern int drm_addbufs(struct drm_device *dev, void *data,
  6549.  -1270,76 +1270,76 @@
  6550.                         struct drm_file *file_priv);
  6551.  extern int drm_mapbufs(struct drm_device *dev, void *data,
  6552.                        struct drm_file *file_priv);
  6553. -extern int drm_order(unsigned long size);
  6554. -extern resource_size_t drm_get_resource_start(struct drm_device *dev,
  6555. +extern int lbm_drm_order(unsigned long size);
  6556. +extern resource_size_t lbm_drm_get_resource_start(struct drm_device *dev,
  6557.                                               unsigned int resource);
  6558. -extern resource_size_t drm_get_resource_len(struct drm_device *dev,
  6559. +extern resource_size_t lbm_drm_get_resource_len(struct drm_device *dev,
  6560.                                             unsigned int resource);
  6561.  
  6562.                                 /* DMA support (drm_dma.h) */
  6563.  extern int drm_dma_setup(struct drm_device *dev);
  6564.  extern void drm_dma_takedown(struct drm_device *dev);
  6565.  extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
  6566. -extern void drm_core_reclaim_buffers(struct drm_device *dev,
  6567. +extern void lbm_drm_core_reclaim_buffers(struct drm_device *dev,
  6568.                                      struct drm_file *filp);
  6569.  
  6570.                                 /* IRQ support (drm_irq.h) */
  6571.  extern int drm_control(struct drm_device *dev, void *data,
  6572.                        struct drm_file *file_priv);
  6573.  extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
  6574. -extern int drm_irq_install(struct drm_device *dev);
  6575. -extern int drm_irq_uninstall(struct drm_device *dev);
  6576. +extern int lbm_drm_irq_install(struct drm_device *dev);
  6577. +extern int lbm_drm_irq_uninstall(struct drm_device *dev);
  6578.  extern void drm_driver_irq_preinstall(struct drm_device *dev);
  6579.  extern void drm_driver_irq_postinstall(struct drm_device *dev);
  6580.  extern void drm_driver_irq_uninstall(struct drm_device *dev);
  6581.  
  6582. -extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
  6583. +extern int lbm_drm_vblank_init(struct drm_device *dev, int num_crtcs);
  6584.  extern int drm_wait_vblank(struct drm_device *dev, void *data,
  6585.                            struct drm_file *filp);
  6586.  extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
  6587. -extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
  6588. -extern void drm_handle_vblank(struct drm_device *dev, int crtc);
  6589. -extern int drm_vblank_get(struct drm_device *dev, int crtc);
  6590. -extern void drm_vblank_put(struct drm_device *dev, int crtc);
  6591. -extern void drm_vblank_off(struct drm_device *dev, int crtc);
  6592. -extern void drm_vblank_cleanup(struct drm_device *dev);
  6593. +extern u32 lbm_drm_vblank_count(struct drm_device *dev, int crtc);
  6594. +extern void lbm_drm_handle_vblank(struct drm_device *dev, int crtc);
  6595. +extern int lbm_drm_vblank_get(struct drm_device *dev, int crtc);
  6596. +extern void lbm_drm_vblank_put(struct drm_device *dev, int crtc);
  6597. +extern void lbm_drm_vblank_off(struct drm_device *dev, int crtc);
  6598. +extern void lbm_drm_vblank_cleanup(struct drm_device *dev);
  6599.  /* Modesetting support */
  6600. -extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
  6601. -extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
  6602. +extern void lbm_drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
  6603. +extern void lbm_drm_vblank_post_modeset(struct drm_device *dev, int crtc);
  6604.  extern int drm_modeset_ctl(struct drm_device *dev, void *data,
  6605.                            struct drm_file *file_priv);
  6606.  
  6607.                                 /* AGP/GART support (drm_agpsupport.h) */
  6608.  extern struct drm_agp_head *drm_agp_init(struct drm_device *dev);
  6609. -extern int drm_agp_acquire(struct drm_device *dev);
  6610. +extern int lbm_drm_agp_acquire(struct drm_device *dev);
  6611.  extern int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
  6612.                                  struct drm_file *file_priv);
  6613. -extern int drm_agp_release(struct drm_device *dev);
  6614. +extern int lbm_drm_agp_release(struct drm_device *dev);
  6615.  extern int drm_agp_release_ioctl(struct drm_device *dev, void *data,
  6616.                                  struct drm_file *file_priv);
  6617. -extern int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
  6618. +extern int lbm_drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
  6619.  extern int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
  6620.                                 struct drm_file *file_priv);
  6621. -extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info);
  6622. +extern int lbm_drm_agp_info(struct drm_device *dev, struct lbm_drm_agp_info *info);
  6623.  extern int drm_agp_info_ioctl(struct drm_device *dev, void *data,
  6624.                         struct drm_file *file_priv);
  6625. -extern int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request);
  6626. +extern int lbm_drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request);
  6627.  extern int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
  6628.                          struct drm_file *file_priv);
  6629. -extern int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request);
  6630. +extern int lbm_drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request);
  6631.  extern int drm_agp_free_ioctl(struct drm_device *dev, void *data,
  6632.                         struct drm_file *file_priv);
  6633. -extern int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request);
  6634. +extern int lbm_drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request);
  6635.  extern int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
  6636.                           struct drm_file *file_priv);
  6637. -extern int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
  6638. +extern int lbm_drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
  6639.  extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
  6640.                         struct drm_file *file_priv);
  6641.  extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size_t pages, u32 type);
  6642.  extern int drm_agp_free_memory(DRM_AGP_MEM * handle);
  6643.  extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start);
  6644.  extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
  6645. -extern void drm_agp_chipset_flush(struct drm_device *dev);
  6646. +extern void lbm_drm_agp_chipset_flush(struct drm_device *dev);
  6647.  
  6648.                                 /* Stub support (drm_stub.h) */
  6649.  extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
  6650.  -1347,13 +1347,13 @@
  6651.  extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
  6652.                                 struct drm_file *file_priv);
  6653.  struct drm_master *drm_master_create(struct drm_minor *minor);
  6654. -extern struct drm_master *drm_master_get(struct drm_master *master);
  6655. -extern void drm_master_put(struct drm_master **master);
  6656. -extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
  6657. +extern struct drm_master *lbm_drm_master_get(struct drm_master *master);
  6658. +extern void lbm_drm_master_put(struct drm_master **master);
  6659. +extern int lbm_drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
  6660.                        struct drm_driver *driver);
  6661. -extern void drm_put_dev(struct drm_device *dev);
  6662. +extern void lbm_drm_put_dev(struct drm_device *dev);
  6663.  extern int drm_put_minor(struct drm_minor **minor);
  6664. -extern unsigned int drm_debug;
  6665. +extern unsigned int lbm_drm_debug;
  6666.  
  6667.  extern struct class *drm_class;
  6668.  extern struct proc_dir_entry *drm_proc_root;
  6669.  -1361,7 +1361,7 @@
  6670.  
  6671.  extern struct idr drm_minors_idr;
  6672.  
  6673. -extern struct drm_local_map *drm_getsarea(struct drm_device *dev);
  6674. +extern struct drm_local_map *lbm_drm_getsarea(struct drm_device *dev);
  6675.  
  6676.                                 /* Proc support (drm_proc.h) */
  6677.  extern int drm_proc_init(struct drm_minor *minor, int minor_id,
  6678.  -1372,9 +1372,9 @@
  6679.  #if defined(CONFIG_DEBUG_FS)
  6680.  extern int drm_debugfs_init(struct drm_minor *minor, int minor_id,
  6681.                             struct dentry *root);
  6682. -extern int drm_debugfs_create_files(struct drm_info_list *files, int count,
  6683. +extern int lbm_drm_debugfs_create_files(struct drm_info_list *files, int count,
  6684.                                     struct dentry *root, struct drm_minor *minor);
  6685. -extern int drm_debugfs_remove_files(struct drm_info_list *files, int count,
  6686. +extern int lbm_drm_debugfs_remove_files(struct drm_info_list *files, int count,
  6687.                                      struct drm_minor *minor);
  6688.  extern int drm_debugfs_cleanup(struct drm_minor *minor);
  6689.  #endif
  6690.  -1397,42 +1397,42 @@
  6691.  extern void drm_sg_cleanup(struct drm_sg_mem * entry);
  6692.  extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
  6693.                         struct drm_file *file_priv);
  6694. -extern int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request);
  6695. +extern int lbm_drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request);
  6696.  extern int drm_sg_free(struct drm_device *dev, void *data,
  6697.                        struct drm_file *file_priv);
  6698.  
  6699.                                /* ATI PCIGART support (ati_pcigart.h) */
  6700. -extern int drm_ati_pcigart_init(struct drm_device *dev,
  6701. +extern int lbm_drm_ati_pcigart_init(struct drm_device *dev,
  6702.                                 struct drm_ati_pcigart_info * gart_info);
  6703. -extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
  6704. +extern int lbm_drm_ati_pcigart_cleanup(struct drm_device *dev,
  6705.                                    struct drm_ati_pcigart_info * gart_info);
  6706.  
  6707. -extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
  6708. +extern drm_dma_handle_t *lbm_drm_pci_alloc(struct drm_device *dev, size_t size,
  6709.                                        size_t align);
  6710.  extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
  6711. -extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
  6712. +extern void lbm_drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
  6713.  
  6714.                                /* sysfs support (drm_sysfs.c) */
  6715.  struct drm_sysfs_class;
  6716.  extern struct class *drm_sysfs_create(struct module *owner, char *name);
  6717.  extern void drm_sysfs_destroy(void);
  6718.  extern int drm_sysfs_device_add(struct drm_minor *minor);
  6719. -extern void drm_sysfs_hotplug_event(struct drm_device *dev);
  6720. +extern void lbm_drm_sysfs_hotplug_event(struct drm_device *dev);
  6721.  extern void drm_sysfs_device_remove(struct drm_minor *minor);
  6722.  extern char *drm_get_connector_status_name(enum drm_connector_status status);
  6723. -extern int drm_sysfs_connector_add(struct drm_connector *connector);
  6724. -extern void drm_sysfs_connector_remove(struct drm_connector *connector);
  6725. +extern int lbm_drm_sysfs_connector_add(struct drm_connector *connector);
  6726. +extern void lbm_drm_sysfs_connector_remove(struct drm_connector *connector);
  6727.  
  6728.  /* Graphics Execution Manager library functions (drm_gem.c) */
  6729.  int drm_gem_init(struct drm_device *dev);
  6730.  void drm_gem_destroy(struct drm_device *dev);
  6731. -void drm_gem_object_free(struct kref *kref);
  6732. -struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
  6733. +void lbm_drm_gem_object_free(struct kref *kref);
  6734. +struct drm_gem_object *lbm_drm_gem_object_alloc(struct drm_device *dev,
  6735.                                             size_t size);
  6736. -void drm_gem_object_handle_free(struct kref *kref);
  6737. -void drm_gem_vm_open(struct vm_area_struct *vma);
  6738. -void drm_gem_vm_close(struct vm_area_struct *vma);
  6739. -int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
  6740. +void lbm_drm_gem_object_handle_free(struct kref *kref);
  6741. +void lbm_drm_gem_vm_open(struct vm_area_struct *vma);
  6742. +void lbm_drm_gem_vm_close(struct vm_area_struct *vma);
  6743. +int lbm_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
  6744.  
  6745.  static inline void
  6746.  drm_gem_object_reference(struct drm_gem_object *obj)
  6747.  -1446,10 +1446,10 @@
  6748.         if (obj == NULL)
  6749.                 return;
  6750.  
  6751. -       kref_put(&obj->refcount, drm_gem_object_free);
  6752. +       kref_put(&obj->refcount, lbm_drm_gem_object_free);
  6753.  }
  6754.  
  6755. -int drm_gem_handle_create(struct drm_file *file_priv,
  6756. +int lbm_drm_gem_handle_create(struct drm_file *file_priv,
  6757.                           struct drm_gem_object *obj,
  6758.                           u32 *handlep);
  6759.  
  6760.  -1471,11 +1471,11 @@
  6761.          * ref, in which case the object would disappear before we
  6762.          * checked for a name
  6763.          */
  6764. -       kref_put(&obj->handlecount, drm_gem_object_handle_free);
  6765. +       kref_put(&obj->handlecount, lbm_drm_gem_object_handle_free);
  6766.         drm_gem_object_unreference(obj);
  6767.  }
  6768.  
  6769. -struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
  6770. +struct drm_gem_object *lbm_drm_gem_object_lookup(struct drm_device *dev,
  6771.                                              struct drm_file *filp,
  6772.                                              u32 handle);
  6773.  int drm_gem_close_ioctl(struct drm_device *dev, void *data,
  6774.  -1487,9 +1487,9 @@
  6775.  void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
  6776.  void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
  6777.  
  6778. -extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
  6779. -extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
  6780. -extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
  6781. +extern void lbm_drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
  6782. +extern void lbm_drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
  6783. +extern void lbm_drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
  6784.  
  6785.  static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev,
  6786.                                                          unsigned int token)
  6787. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sman.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sman.h
  6788. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sman.h        2010-01-25 15:21:29.000000000 -0500
  6789. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sman.h        2010-02-03 17:11:08.000000000 -0500
  6790.  -94,10 +94,10 @@
  6791.  
  6792.  /*
  6793.   * Take down a memory manager. This function should only be called after a
  6794. - * successful init and after a call to drm_sman_cleanup.
  6795. + * successful init and after a call to lbm_drm_sman_cleanup.
  6796.   */
  6797.  
  6798. -extern void drm_sman_takedown(struct drm_sman * sman);
  6799. +extern void lbm_drm_sman_takedown(struct drm_sman * sman);
  6800.  
  6801.  /*
  6802.   * Allocate structures for a manager.
  6803.  -112,7 +112,7 @@
  6804.   *
  6805.   */
  6806.  
  6807. -extern int drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
  6808. +extern int lbm_drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
  6809.                          unsigned int user_order, unsigned int owner_order);
  6810.  
  6811.  /*
  6812.  -120,7 +120,7 @@
  6813.   * manager unless a customized allogator is used.
  6814.   */
  6815.  
  6816. -extern int drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
  6817. +extern int lbm_drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
  6818.                               unsigned long start, unsigned long size);
  6819.  
  6820.  /*
  6821.  -129,14 +129,14 @@
  6822.   * so it can be destroyed after this call.
  6823.   */
  6824.  
  6825. -extern int drm_sman_set_manager(struct drm_sman * sman, unsigned int mananger,
  6826. +extern int lbm_drm_sman_set_manager(struct drm_sman * sman, unsigned int mananger,
  6827.                                 struct drm_sman_mm * allocator);
  6828.  
  6829.  /*
  6830.   * Allocate a memory block. Aligment is not implemented yet.
  6831.   */
  6832.  
  6833. -extern struct drm_memblock_item *drm_sman_alloc(struct drm_sman * sman,
  6834. +extern struct drm_memblock_item *lbm_drm_sman_alloc(struct drm_sman * sman,
  6835.                                                 unsigned int manager,
  6836.                                                 unsigned long size,
  6837.                                                 unsigned alignment,
  6838.  -145,16 +145,16 @@
  6839.   * Free a memory block identified by its user hash key.
  6840.   */
  6841.  
  6842. -extern int drm_sman_free_key(struct drm_sman * sman, unsigned int key);
  6843. +extern int lbm_drm_sman_free_key(struct drm_sman * sman, unsigned int key);
  6844.  
  6845.  /*
  6846.   * returns 1 iff there are no stale memory blocks associated with this owner.
  6847.   * Typically called to determine if we need to idle the hardware and call
  6848. - * drm_sman_owner_cleanup. If there are no stale memory blocks, it removes all
  6849. + * lbm_drm_sman_owner_cleanup. If there are no stale memory blocks, it removes all
  6850.   * resources associated with owner.
  6851.   */
  6852.  
  6853. -extern int drm_sman_owner_clean(struct drm_sman * sman, unsigned long owner);
  6854. +extern int lbm_drm_sman_owner_clean(struct drm_sman * sman, unsigned long owner);
  6855.  
  6856.  /*
  6857.   * Frees all stale memory blocks associated with this owner. Note that this
  6858.  -164,13 +164,13 @@
  6859.   * is not going to be referenced anymore.
  6860.   */
  6861.  
  6862. -extern void drm_sman_owner_cleanup(struct drm_sman * sman, unsigned long owner);
  6863. +extern void lbm_drm_sman_owner_cleanup(struct drm_sman * sman, unsigned long owner);
  6864.  
  6865.  /*
  6866.   * Frees all stale memory blocks associated with the memory manager.
  6867.   * See idling above.
  6868.   */
  6869.  
  6870. -extern void drm_sman_cleanup(struct drm_sman * sman);
  6871. +extern void lbm_drm_sman_cleanup(struct drm_sman * sman);
  6872.  
  6873.  #endif
  6874. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sysfs.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sysfs.h
  6875. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sysfs.h       2010-01-25 15:21:29.000000000 -0500
  6876. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/drm_sysfs.h       2010-02-03 17:11:08.000000000 -0500
  6877.  -6,7 +6,7 @@
  6878.   * don't want to include the full drmP.h file.
  6879.   */
  6880.  
  6881. -extern int drm_class_device_register(struct device *dev);
  6882. -extern void drm_class_device_unregister(struct device *dev);
  6883. +extern int lbm_drm_class_device_register(struct device *dev);
  6884. +extern void lbm_drm_class_device_unregister(struct device *dev);
  6885.  
  6886.  #endif
  6887. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_api.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_api.h
  6888. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_api.h  2010-01-25 15:21:29.000000000 -0500
  6889. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_api.h  2010-02-03 17:11:08.000000000 -0500
  6890.  -292,7 +292,7 @@
  6891.  }
  6892.  
  6893.  /**
  6894. - * ttm_bo_wait - wait for buffer idle.
  6895. + * lbm_ttm_bo_wait - wait for buffer idle.
  6896.   *
  6897.   * @bo:  The buffer object.
  6898.   * @interruptible:  Use interruptible wait.
  6899.  -305,10 +305,10 @@
  6900.   * Returns -EBUSY if no_wait is true and the buffer is busy.
  6901.   * Returns -ERESTARTSYS if interrupted by a signal.
  6902.   */
  6903. -extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
  6904. +extern int lbm_ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
  6905.                        bool interruptible, bool no_wait);
  6906.  /**
  6907. - * ttm_bo_validate
  6908. + * lbm_ttm_bo_validate
  6909.   *
  6910.   * @bo: The buffer object.
  6911.   * @placement: Proposed placement for the buffer object.
  6912.  -323,21 +323,21 @@
  6913.   * -EBUSY if no_wait is true and buffer busy.
  6914.   * -ERESTARTSYS if interrupted by a signal.
  6915.   */
  6916. -extern int ttm_bo_validate(struct ttm_buffer_object *bo,
  6917. +extern int lbm_ttm_bo_validate(struct ttm_buffer_object *bo,
  6918.                                 struct ttm_placement *placement,
  6919.                                 bool interruptible, bool no_wait);
  6920.  
  6921.  /**
  6922. - * ttm_bo_unref
  6923. + * lbm_ttm_bo_unref
  6924.   *
  6925.   * @bo: The buffer object.
  6926.   *
  6927.   * Unreference and clear a pointer to a buffer object.
  6928.   */
  6929. -extern void ttm_bo_unref(struct ttm_buffer_object **bo);
  6930. +extern void lbm_ttm_bo_unref(struct ttm_buffer_object **bo);
  6931.  
  6932.  /**
  6933. - * ttm_bo_synccpu_write_grab
  6934. + * lbm_ttm_bo_synccpu_write_grab
  6935.   *
  6936.   * @bo: The buffer object:
  6937.   * @no_wait: Return immediately if buffer is busy.
  6938.  -351,18 +351,18 @@
  6939.   */
  6940.  
  6941.  extern int
  6942. -ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);
  6943. +lbm_ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);
  6944.  /**
  6945. - * ttm_bo_synccpu_write_release:
  6946. + * lbm_ttm_bo_synccpu_write_release:
  6947.   *
  6948.   * @bo : The buffer object.
  6949.   *
  6950.   * Releases a synccpu lock.
  6951.   */
  6952. -extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);
  6953. +extern void lbm_ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);
  6954.  
  6955.  /**
  6956. - * ttm_bo_init
  6957. + * lbm_ttm_bo_init
  6958.   *
  6959.   * @bdev: Pointer to a ttm_bo_device struct.
  6960.   * @bo: Pointer to a ttm_buffer_object to be initialized.
  6961.  -393,7 +393,7 @@
  6962.   * -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources.
  6963.   */
  6964.  
  6965. -extern int ttm_bo_init(struct ttm_bo_device *bdev,
  6966. +extern int lbm_ttm_bo_init(struct ttm_bo_device *bdev,
  6967.                         struct ttm_buffer_object *bo,
  6968.                         unsigned long size,
  6969.                         enum ttm_bo_type type,
  6970.  -424,7 +424,7 @@
  6971.   * GEM user interface.
  6972.   * @p_bo: On successful completion *p_bo points to the created object.
  6973.   *
  6974. - * This function allocates a ttm_buffer_object, and then calls ttm_bo_init
  6975. + * This function allocates a ttm_buffer_object, and then calls lbm_ttm_bo_init
  6976.   * on that object. The destroy function is set to kfree().
  6977.   * Returns
  6978.   * -ENOMEM: Out of memory.
  6979.  -457,7 +457,7 @@
  6980.                                         struct ttm_placement *placement);
  6981.  
  6982.  /**
  6983. - * ttm_bo_init_mm
  6984. + * lbm_ttm_bo_init_mm
  6985.   *
  6986.   * @bdev: Pointer to a ttm_bo_device struct.
  6987.   * @mem_type: The memory type.
  6988.  -472,10 +472,10 @@
  6989.   * May also return driver-specified errors.
  6990.   */
  6991.  
  6992. -extern int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
  6993. +extern int lbm_ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
  6994.                                 unsigned long p_size);
  6995.  /**
  6996. - * ttm_bo_clean_mm
  6997. + * lbm_ttm_bo_clean_mm
  6998.   *
  6999.   * @bdev: Pointer to a ttm_bo_device struct.
  7000.   * @mem_type: The memory type.
  7001.  -501,10 +501,10 @@
  7002.   * -EBUSY: There are still buffers left in this memory type.
  7003.   */
  7004.  
  7005. -extern int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  7006. +extern int lbm_ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  7007.  
  7008.  /**
  7009. - * ttm_bo_evict_mm
  7010. + * lbm_ttm_bo_evict_mm
  7011.   *
  7012.   * @bdev: Pointer to a ttm_bo_device struct.
  7013.   * @mem_type: The memory type.
  7014.  -522,16 +522,16 @@
  7015.   * evict a buffer.
  7016.   */
  7017.  
  7018. -extern int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  7019. +extern int lbm_ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  7020.  
  7021.  /**
  7022.   * ttm_kmap_obj_virtual
  7023.   *
  7024. - * @map: A struct ttm_bo_kmap_obj returned from ttm_bo_kmap.
  7025. + * @map: A struct ttm_bo_kmap_obj returned from lbm_ttm_bo_kmap.
  7026.   * @is_iomem: Pointer to an integer that on return indicates 1 if the
  7027.   * virtual map is io memory, 0 if normal memory.
  7028.   *
  7029. - * Returns the virtual address of a buffer object area mapped by ttm_bo_kmap.
  7030. + * Returns the virtual address of a buffer object area mapped by lbm_ttm_bo_kmap.
  7031.   * If *is_iomem is 1 on return, the virtual address points to an io memory area,
  7032.   * that should strictly be accessed by the iowriteXX() and similar functions.
  7033.   */
  7034.  -544,7 +544,7 @@
  7035.  }
  7036.  
  7037.  /**
  7038. - * ttm_bo_kmap
  7039. + * lbm_ttm_bo_kmap
  7040.   *
  7041.   * @bo: The buffer object.
  7042.   * @start_page: The first page to map.
  7043.  -560,24 +560,24 @@
  7044.   * -EINVAL: Invalid range.
  7045.   */
  7046.  
  7047. -extern int ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page,
  7048. +extern int lbm_ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page,
  7049.                        unsigned long num_pages, struct ttm_bo_kmap_obj *map);
  7050.  
  7051.  /**
  7052. - * ttm_bo_kunmap
  7053. + * lbm_ttm_bo_kunmap
  7054.   *
  7055.   * @map: Object describing the map to unmap.
  7056.   *
  7057. - * Unmaps a kernel map set up by ttm_bo_kmap.
  7058. + * Unmaps a kernel map set up by lbm_ttm_bo_kmap.
  7059.   */
  7060.  
  7061. -extern void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map);
  7062. +extern void lbm_ttm_bo_kunmap(struct ttm_bo_kmap_obj *map);
  7063.  
  7064.  #if 0
  7065.  #endif
  7066.  
  7067.  /**
  7068. - * ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object.
  7069. + * lbm_ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object.
  7070.   *
  7071.   * @vma:       vma as input from the fbdev mmap method.
  7072.   * @bo:        The bo backing the address space. The address space will
  7073.  -587,11 +587,11 @@
  7074.   * if the fbdev address space is to be backed by a bo.
  7075.   */
  7076.  
  7077. -extern int ttm_fbdev_mmap(struct vm_area_struct *vma,
  7078. +extern int lbm_ttm_fbdev_mmap(struct vm_area_struct *vma,
  7079.                           struct ttm_buffer_object *bo);
  7080.  
  7081.  /**
  7082. - * ttm_bo_mmap - mmap out of the ttm device address space.
  7083. + * lbm_ttm_bo_mmap - mmap out of the ttm device address space.
  7084.   *
  7085.   * @filp:      filp as input from the mmap method.
  7086.   * @vma:       vma as input from the mmap method.
  7087.  -601,7 +601,7 @@
  7088.   * if the device address space is to be backed by the bo manager.
  7089.   */
  7090.  
  7091. -extern int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
  7092. +extern int lbm_ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
  7093.                        struct ttm_bo_device *bdev);
  7094.  
  7095.  /**
  7096.  -629,6 +629,6 @@
  7097.                          const char __user *wbuf, char __user *rbuf,
  7098.                          size_t count, loff_t *f_pos, bool write);
  7099.  
  7100. -extern void ttm_bo_swapout_all(struct ttm_bo_device *bdev);
  7101. +extern void lbm_ttm_bo_swapout_all(struct ttm_bo_device *bdev);
  7102.  
  7103.  #endif
  7104. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_driver.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_driver.h
  7105. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_driver.h       2010-01-25 15:21:29.000000000 -0500
  7106. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_bo_driver.h       2010-02-03 17:11:08.000000000 -0500
  7107.  -353,6 +353,11 @@
  7108.         /* notify the driver we are taking a fault on this BO
  7109.          * and have reserved it */
  7110.         void (*fault_reserve_notify)(struct ttm_buffer_object *bo);
  7111. +
  7112. +       /**
  7113. +        * notify the driver that we're about to swap out this bo
  7114. +        */
  7115. +       void (*swap_notify) (struct ttm_buffer_object *bo);
  7116.  };
  7117.  
  7118.  /**
  7119.  -532,16 +537,16 @@
  7120.   *
  7121.   * Bind the pages of @ttm to an aperture location identified by @bo_mem
  7122.   */
  7123. -extern int ttm_tt_bind(struct ttm_tt *ttm, struct ttm_mem_reg *bo_mem);
  7124. +extern int lbm_ttm_tt_bind(struct ttm_tt *ttm, struct ttm_mem_reg *bo_mem);
  7125.  
  7126.  /**
  7127. - * ttm_tt_populate:
  7128. + * lbm_ttm_tt_populate:
  7129.   *
  7130.   * @ttm: The struct ttm_tt to contain the backing pages.
  7131.   *
  7132.   * Add backing pages to all of @ttm
  7133.   */
  7134. -extern int ttm_tt_populate(struct ttm_tt *ttm);
  7135. +extern int lbm_ttm_tt_populate(struct ttm_tt *ttm);
  7136.  
  7137.  /**
  7138.   * ttm_ttm_destroy:
  7139.  -589,7 +594,7 @@
  7140.  extern void ttm_tt_cache_flush(struct page *pages[], unsigned long num_pages);
  7141.  
  7142.  /**
  7143. - * ttm_tt_set_placement_caching:
  7144. + * lbm_ttm_tt_set_placement_caching:
  7145.   *
  7146.   * @ttm A struct ttm_tt the backing pages of which will change caching policy.
  7147.   * @placement: Flag indicating the desired caching policy.
  7148.  -601,7 +606,7 @@
  7149.   * hit RAM. This function may be very costly as it involves global TLB
  7150.   * and cache flushes and potential page splitting / combining.
  7151.   */
  7152. -extern int ttm_tt_set_placement_caching(struct ttm_tt *ttm, uint32_t placement);
  7153. +extern int lbm_ttm_tt_set_placement_caching(struct ttm_tt *ttm, uint32_t placement);
  7154.  extern int ttm_tt_swapout(struct ttm_tt *ttm,
  7155.                           struct file *persistant_swap_storage);
  7156.  
  7157.  -622,7 +627,7 @@
  7158.                                    struct ttm_mem_reg *mem);
  7159.  
  7160.  /**
  7161. - * ttm_bo_mem_space
  7162. + * lbm_ttm_bo_mem_space
  7163.   *
  7164.   * @bo: Pointer to a struct ttm_buffer_object. the data of which
  7165.   * we want to allocate space for.
  7166.  -640,7 +645,7 @@
  7167.   * fragmentation or concurrent allocators.
  7168.   * -ERESTARTSYS: An interruptible sleep was interrupted by a signal.
  7169.   */
  7170. -extern int ttm_bo_mem_space(struct ttm_buffer_object *bo,
  7171. +extern int lbm_ttm_bo_mem_space(struct ttm_buffer_object *bo,
  7172.                                 struct ttm_placement *placement,
  7173.                                 struct ttm_mem_reg *mem,
  7174.                                 bool interruptible, bool no_wait);
  7175.  -656,7 +661,7 @@
  7176.   * -ERESTARTSYS: An interruptible sleep was interrupted by a signal.
  7177.   */
  7178.  
  7179. -extern int ttm_bo_wait_cpu(struct ttm_buffer_object *bo, bool no_wait);
  7180. +extern int lbm_ttm_bo_wait_cpu(struct ttm_buffer_object *bo, bool no_wait);
  7181.  
  7182.  /**
  7183.   * ttm_bo_pci_offset - Get the PCI offset for the buffer object memory.
  7184.  -678,13 +683,13 @@
  7185.                              unsigned long *bus_offset,
  7186.                              unsigned long *bus_size);
  7187.  
  7188. -extern void ttm_bo_global_release(struct ttm_global_reference *ref);
  7189. -extern int ttm_bo_global_init(struct ttm_global_reference *ref);
  7190. +extern void lbm_ttm_bo_global_release(struct ttm_global_reference *ref);
  7191. +extern int lbm_ttm_bo_global_init(struct ttm_global_reference *ref);
  7192.  
  7193. -extern int ttm_bo_device_release(struct ttm_bo_device *bdev);
  7194. +extern int lbm_ttm_bo_device_release(struct ttm_bo_device *bdev);
  7195.  
  7196.  /**
  7197. - * ttm_bo_device_init
  7198. + * lbm_ttm_bo_device_init
  7199.   *
  7200.   * @bdev: A pointer to a struct ttm_bo_device to initialize.
  7201.   * @mem_global: A pointer to an initialized struct ttm_mem_global.
  7202.  -697,20 +702,20 @@
  7203.   * Returns:
  7204.   * !0: Failure.
  7205.   */
  7206. -extern int ttm_bo_device_init(struct ttm_bo_device *bdev,
  7207. +extern int lbm_ttm_bo_device_init(struct ttm_bo_device *bdev,
  7208.                               struct ttm_bo_global *glob,
  7209.                               struct ttm_bo_driver *driver,
  7210.                               uint64_t file_page_offset, bool need_dma32);
  7211.  
  7212.  /**
  7213. - * ttm_bo_unmap_virtual
  7214. + * lbm_ttm_bo_unmap_virtual
  7215.   *
  7216.   * @bo: tear down the virtual mappings for this BO
  7217.   */
  7218. -extern void ttm_bo_unmap_virtual(struct ttm_buffer_object *bo);
  7219. +extern void lbm_ttm_bo_unmap_virtual(struct ttm_buffer_object *bo);
  7220.  
  7221.  /**
  7222. - * ttm_bo_reserve:
  7223. + * lbm_ttm_bo_reserve:
  7224.   *
  7225.   * @bo: A pointer to a struct ttm_buffer_object.
  7226.   * @interruptible: Sleep interruptible if waiting.
  7227.  -760,21 +765,21 @@
  7228.   * -ERESTARTSYS: A wait for the buffer to become unreserved was interrupted by
  7229.   * a signal. Release all buffer reservations and return to user-space.
  7230.   */
  7231. -extern int ttm_bo_reserve(struct ttm_buffer_object *bo,
  7232. +extern int lbm_ttm_bo_reserve(struct ttm_buffer_object *bo,
  7233.                           bool interruptible,
  7234.                           bool no_wait, bool use_sequence, uint32_t sequence);
  7235.  
  7236.  /**
  7237. - * ttm_bo_unreserve
  7238. + * lbm_ttm_bo_unreserve
  7239.   *
  7240.   * @bo: A pointer to a struct ttm_buffer_object.
  7241.   *
  7242.   * Unreserve a previous reservation of @bo.
  7243.   */
  7244. -extern void ttm_bo_unreserve(struct ttm_buffer_object *bo);
  7245. +extern void lbm_ttm_bo_unreserve(struct ttm_buffer_object *bo);
  7246.  
  7247.  /**
  7248. - * ttm_bo_wait_unreserved
  7249. + * lbm_ttm_bo_wait_unreserved
  7250.   *
  7251.   * @bo: A pointer to a struct ttm_buffer_object.
  7252.   *
  7253.  -782,7 +787,7 @@
  7254.   * This is typically used in the execbuf code to relax cpu-usage when
  7255.   * a potential deadlock condition backoff.
  7256.   */
  7257. -extern int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo,
  7258. +extern int lbm_ttm_bo_wait_unreserved(struct ttm_buffer_object *bo,
  7259.                                   bool interruptible);
  7260.  
  7261.  /**
  7262.  -818,7 +823,7 @@
  7263.   */
  7264.  
  7265.  /**
  7266. - * ttm_bo_move_ttm
  7267. + * lbm_ttm_bo_move_ttm
  7268.   *
  7269.   * @bo: A pointer to a struct ttm_buffer_object.
  7270.   * @evict: 1: This is an eviction. Don't try to pipeline.
  7271.  -835,12 +840,12 @@
  7272.   * !0: Failure.
  7273.   */
  7274.  
  7275. -extern int ttm_bo_move_ttm(struct ttm_buffer_object *bo,
  7276. +extern int lbm_ttm_bo_move_ttm(struct ttm_buffer_object *bo,
  7277.                            bool evict, bool no_wait,
  7278.                            struct ttm_mem_reg *new_mem);
  7279.  
  7280.  /**
  7281. - * ttm_bo_move_memcpy
  7282. + * lbm_ttm_bo_move_memcpy
  7283.   *
  7284.   * @bo: A pointer to a struct ttm_buffer_object.
  7285.   * @evict: 1: This is an eviction. Don't try to pipeline.
  7286.  -857,7 +862,7 @@
  7287.   * !0: Failure.
  7288.   */
  7289.  
  7290. -extern int ttm_bo_move_memcpy(struct ttm_buffer_object *bo,
  7291. +extern int lbm_ttm_bo_move_memcpy(struct ttm_buffer_object *bo,
  7292.                               bool evict,
  7293.                               bool no_wait, struct ttm_mem_reg *new_mem);
  7294.  
  7295.  -871,7 +876,7 @@
  7296.  extern void ttm_bo_free_old_node(struct ttm_buffer_object *bo);
  7297.  
  7298.  /**
  7299. - * ttm_bo_move_accel_cleanup.
  7300. + * lbm_ttm_bo_move_accel_cleanup.
  7301.   *
  7302.   * @bo: A pointer to a struct ttm_buffer_object.
  7303.   * @sync_obj: A sync object that signals when moving is complete.
  7304.  -889,13 +894,13 @@
  7305.   * buffer moves.
  7306.   */
  7307.  
  7308. -extern int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
  7309. +extern int lbm_ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
  7310.                                      void *sync_obj,
  7311.                                      void *sync_obj_arg,
  7312.                                      bool evict, bool no_wait,
  7313.                                      struct ttm_mem_reg *new_mem);
  7314.  /**
  7315. - * ttm_io_prot
  7316. + * lbm_ttm_io_prot
  7317.   *
  7318.   * @c_state: Caching state.
  7319.   * @tmp: Page protection flag for a normal, cached mapping.
  7320.  -903,14 +908,14 @@
  7321.   * Utility function that returns the pgprot_t that should be used for
  7322.   * setting up a PTE with the caching model indicated by @c_state.
  7323.   */
  7324. -extern pgprot_t ttm_io_prot(enum ttm_caching_state c_state, pgprot_t tmp);
  7325. +extern pgprot_t lbm_ttm_io_prot(enum ttm_caching_state c_state, pgprot_t tmp);
  7326.  
  7327.  #if (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
  7328.  #define TTM_HAS_AGP
  7329.  #include <linux/agp_backend.h>
  7330.  
  7331.  /**
  7332. - * ttm_agp_backend_init
  7333. + * lbm_ttm_agp_backend_init
  7334.   *
  7335.   * @bdev: Pointer to a struct ttm_bo_device.
  7336.   * @bridge: The agp bridge this device is sitting on.
  7337.  -919,7 +924,7 @@
  7338.   * for TT memory. This function uses the linux agpgart interface to
  7339.   * bind and unbind memory backing a ttm_tt.
  7340.   */
  7341. -extern struct ttm_backend *ttm_agp_backend_init(struct ttm_bo_device *bdev,
  7342. +extern struct ttm_backend *lbm_ttm_agp_backend_init(struct ttm_bo_device *bdev,
  7343.                                                 struct agp_bridge_data *bridge);
  7344.  #endif
  7345.  
  7346. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_execbuf_util.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_execbuf_util.h
  7347. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_execbuf_util.h    2010-01-25 15:21:29.000000000 -0500
  7348. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_execbuf_util.h    2010-02-03 17:11:08.000000000 -0500
  7349.  -52,7 +52,7 @@
  7350.  };
  7351.  
  7352.  /**
  7353. - * function ttm_eu_backoff_reservation
  7354. + * function lbm_ttm_eu_backoff_reservation
  7355.   *
  7356.   * @list:     thread private list of ttm_validate_buffer structs.
  7357.   *
  7358.  -60,10 +60,10 @@
  7359.   * the list entries.
  7360.   */
  7361.  
  7362. -extern void ttm_eu_backoff_reservation(struct list_head *list);
  7363. +extern void lbm_ttm_eu_backoff_reservation(struct list_head *list);
  7364.  
  7365.  /**
  7366. - * function ttm_eu_reserve_buffers
  7367. + * function lbm_ttm_eu_reserve_buffers
  7368.   *
  7369.   * @list:    thread private list of ttm_validate_buffer structs.
  7370.   * @val_seq: A unique sequence number.
  7371.  -83,15 +83,15 @@
  7372.   * will be reserved upon return.
  7373.   *
  7374.   * Buffers reserved by this function should be unreserved by
  7375. - * a call to either ttm_eu_backoff_reservation() or
  7376. - * ttm_eu_fence_buffer_objects() when command submission is complete or
  7377. + * a call to either lbm_ttm_eu_backoff_reservation() or
  7378. + * lbm_ttm_eu_fence_buffer_objects() when command submission is complete or
  7379.   * has failed.
  7380.   */
  7381.  
  7382. -extern int ttm_eu_reserve_buffers(struct list_head *list, uint32_t val_seq);
  7383. +extern int lbm_ttm_eu_reserve_buffers(struct list_head *list, uint32_t val_seq);
  7384.  
  7385.  /**
  7386. - * function ttm_eu_fence_buffer_objects.
  7387. + * function lbm_ttm_eu_fence_buffer_objects.
  7388.   *
  7389.   * @list:        thread private list of ttm_validate_buffer structs.
  7390.   * @sync_obj:    The new sync object for the buffers.
  7391.  -102,6 +102,6 @@
  7392.   *
  7393.   */
  7394.  
  7395. -extern void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj);
  7396. +extern void lbm_ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj);
  7397.  
  7398.  #endif
  7399. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_lock.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_lock.h
  7400. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_lock.h    2010-01-25 15:21:29.000000000 -0500
  7401. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_lock.h    2010-02-03 17:11:08.000000000 -0500
  7402.  -79,24 +79,24 @@
  7403.  
  7404.  
  7405.  /**
  7406. - * ttm_lock_init
  7407. + * lbm_ttm_lock_init
  7408.   *
  7409.   * @lock: Pointer to a struct ttm_lock
  7410.   * Initializes the lock.
  7411.   */
  7412. -extern void ttm_lock_init(struct ttm_lock *lock);
  7413. +extern void lbm_ttm_lock_init(struct ttm_lock *lock);
  7414.  
  7415.  /**
  7416. - * ttm_read_unlock
  7417. + * lbm_ttm_read_unlock
  7418.   *
  7419.   * @lock: Pointer to a struct ttm_lock
  7420.   *
  7421.   * Releases a read lock.
  7422.   */
  7423. -extern void ttm_read_unlock(struct ttm_lock *lock);
  7424. +extern void lbm_ttm_read_unlock(struct ttm_lock *lock);
  7425.  
  7426.  /**
  7427. - * ttm_read_lock
  7428. + * lbm_ttm_read_lock
  7429.   *
  7430.   * @lock: Pointer to a struct ttm_lock
  7431.   * @interruptible: Interruptible sleeping while waiting for a lock.
  7432.  -105,7 +105,7 @@
  7433.   * Returns:
  7434.   * -ERESTARTSYS If interrupted by a signal and interruptible is true.
  7435.   */
  7436. -extern int ttm_read_lock(struct ttm_lock *lock, bool interruptible);
  7437. +extern int lbm_ttm_read_lock(struct ttm_lock *lock, bool interruptible);
  7438.  
  7439.  /**
  7440.   * ttm_read_trylock
  7441.  -125,16 +125,16 @@
  7442.  extern int ttm_read_trylock(struct ttm_lock *lock, bool interruptible);
  7443.  
  7444.  /**
  7445. - * ttm_write_unlock
  7446. + * lbm_ttm_write_unlock
  7447.   *
  7448.   * @lock: Pointer to a struct ttm_lock
  7449.   *
  7450.   * Releases a write lock.
  7451.   */
  7452. -extern void ttm_write_unlock(struct ttm_lock *lock);
  7453. +extern void lbm_ttm_write_unlock(struct ttm_lock *lock);
  7454.  
  7455.  /**
  7456. - * ttm_write_lock
  7457. + * lbm_ttm_write_lock
  7458.   *
  7459.   * @lock: Pointer to a struct ttm_lock
  7460.   * @interruptible: Interruptible sleeping while waiting for a lock.
  7461.  -143,7 +143,7 @@
  7462.   * Returns:
  7463.   * -ERESTARTSYS If interrupted by a signal and interruptible is true.
  7464.   */
  7465. -extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible);
  7466. +extern int lbm_ttm_write_lock(struct ttm_lock *lock, bool interruptible);
  7467.  
  7468.  /**
  7469.   * ttm_lock_downgrade
  7470.  -155,25 +155,25 @@
  7471.  extern void ttm_lock_downgrade(struct ttm_lock *lock);
  7472.  
  7473.  /**
  7474. - * ttm_suspend_lock
  7475. + * lbm_ttm_suspend_lock
  7476.   *
  7477.   * @lock: Pointer to a struct ttm_lock
  7478.   *
  7479.   * Takes the lock in suspend mode. Excludes read and write mode.
  7480.   */
  7481. -extern void ttm_suspend_lock(struct ttm_lock *lock);
  7482. +extern void lbm_ttm_suspend_lock(struct ttm_lock *lock);
  7483.  
  7484.  /**
  7485. - * ttm_suspend_unlock
  7486. + * lbm_ttm_suspend_unlock
  7487.   *
  7488.   * @lock: Pointer to a struct ttm_lock
  7489.   *
  7490.   * Releases a suspend lock
  7491.   */
  7492. -extern void ttm_suspend_unlock(struct ttm_lock *lock);
  7493. +extern void lbm_ttm_suspend_unlock(struct ttm_lock *lock);
  7494.  
  7495.  /**
  7496. - * ttm_vt_lock
  7497. + * lbm_ttm_vt_lock
  7498.   *
  7499.   * @lock: Pointer to a struct ttm_lock
  7500.   * @interruptible: Interruptible sleeping while waiting for a lock.
  7501.  -184,11 +184,11 @@
  7502.   * -ERESTARTSYS If interrupted by a signal and interruptible is true.
  7503.   * -ENOMEM: Out of memory when locking.
  7504.   */
  7505. -extern int ttm_vt_lock(struct ttm_lock *lock, bool interruptible,
  7506. +extern int lbm_ttm_vt_lock(struct ttm_lock *lock, bool interruptible,
  7507.                        struct ttm_object_file *tfile);
  7508.  
  7509.  /**
  7510. - * ttm_vt_unlock
  7511. + * lbm_ttm_vt_unlock
  7512.   *
  7513.   * @lock: Pointer to a struct ttm_lock
  7514.   *
  7515.  -196,19 +196,19 @@
  7516.   * Returns:
  7517.   * -EINVAL If the lock was not held.
  7518.   */
  7519. -extern int ttm_vt_unlock(struct ttm_lock *lock);
  7520. +extern int lbm_ttm_vt_unlock(struct ttm_lock *lock);
  7521.  
  7522.  /**
  7523. - * ttm_write_unlock
  7524. + * lbm_ttm_write_unlock
  7525.   *
  7526.   * @lock: Pointer to a struct ttm_lock
  7527.   *
  7528.   * Releases a write lock.
  7529.   */
  7530. -extern void ttm_write_unlock(struct ttm_lock *lock);
  7531. +extern void lbm_ttm_write_unlock(struct ttm_lock *lock);
  7532.  
  7533.  /**
  7534. - * ttm_write_lock
  7535. + * lbm_ttm_write_lock
  7536.   *
  7537.   * @lock: Pointer to a struct ttm_lock
  7538.   * @interruptible: Interruptible sleeping while waiting for a lock.
  7539.  -217,7 +217,7 @@
  7540.   * Returns:
  7541.   * -ERESTARTSYS If interrupted by a signal and interruptible is true.
  7542.   */
  7543. -extern int ttm_write_lock(struct ttm_lock *lock, bool interruptible);
  7544. +extern int lbm_ttm_write_lock(struct ttm_lock *lock, bool interruptible);
  7545.  
  7546.  /**
  7547.   * ttm_lock_set_kill
  7548. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_memory.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_memory.h
  7549. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_memory.h  2010-01-25 15:21:29.000000000 -0500
  7550. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_memory.h  2010-02-03 17:11:08.000000000 -0500
  7551.  -144,16 +144,16 @@
  7552.         spin_unlock(&glob->lock);
  7553.  }
  7554.  
  7555. -extern int ttm_mem_global_init(struct ttm_mem_global *glob);
  7556. -extern void ttm_mem_global_release(struct ttm_mem_global *glob);
  7557. -extern int ttm_mem_global_alloc(struct ttm_mem_global *glob, uint64_t memory,
  7558. +extern int lbm_ttm_mem_global_init(struct ttm_mem_global *glob);
  7559. +extern void lbm_ttm_mem_global_release(struct ttm_mem_global *glob);
  7560. +extern int lbm_ttm_mem_global_alloc(struct ttm_mem_global *glob, uint64_t memory,
  7561.                                 bool no_wait, bool interruptible);
  7562. -extern void ttm_mem_global_free(struct ttm_mem_global *glob,
  7563. +extern void lbm_ttm_mem_global_free(struct ttm_mem_global *glob,
  7564.                                 uint64_t amount);
  7565.  extern int ttm_mem_global_alloc_page(struct ttm_mem_global *glob,
  7566.                                      struct page *page,
  7567.                                      bool no_wait, bool interruptible);
  7568.  extern void ttm_mem_global_free_page(struct ttm_mem_global *glob,
  7569.                                      struct page *page);
  7570. -extern size_t ttm_round_pot(size_t size);
  7571. +extern size_t lbm_ttm_round_pot(size_t size);
  7572.  #endif
  7573. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_module.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_module.h
  7574. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_module.h  2010-01-25 15:21:29.000000000 -0500
  7575. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_module.h  2010-02-03 17:11:08.000000000 -0500
  7576.  -53,8 +53,8 @@
  7577.  
  7578.  extern void ttm_global_init(void);
  7579.  extern void ttm_global_release(void);
  7580. -extern int ttm_global_item_ref(struct ttm_global_reference *ref);
  7581. -extern void ttm_global_item_unref(struct ttm_global_reference *ref);
  7582. +extern int lbm_ttm_global_item_ref(struct ttm_global_reference *ref);
  7583. +extern void lbm_ttm_global_item_unref(struct ttm_global_reference *ref);
  7584.  extern struct kobject *ttm_get_kobj(void);
  7585.  
  7586.  #endif /* _TTM_MODULE_H_ */
  7587. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_object.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_object.h
  7588. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_object.h  2010-01-25 15:21:29.000000000 -0500
  7589. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/drm/ttm/ttm_object.h  2010-02-03 17:11:08.000000000 -0500
  7590.  -131,7 +131,7 @@
  7591.  };
  7592.  
  7593.  /**
  7594. - * ttm_base_object_init
  7595. + * lbm_ttm_base_object_init
  7596.   *
  7597.   * @tfile: Pointer to a struct ttm_object_file.
  7598.   * @base: The struct ttm_base_object to initialize.
  7599.  -144,7 +144,7 @@
  7600.   * Initializes a struct ttm_base_object.
  7601.   */
  7602.  
  7603. -extern int ttm_base_object_init(struct ttm_object_file *tfile,
  7604. +extern int lbm_ttm_base_object_init(struct ttm_object_file *tfile,
  7605.                                 struct ttm_base_object *base,
  7606.                                 bool shareable,
  7607.                                 enum ttm_object_type type,
  7608.  -156,7 +156,7 @@
  7609.                                                          ref_type));
  7610.  
  7611.  /**
  7612. - * ttm_base_object_lookup
  7613. + * lbm_ttm_base_object_lookup
  7614.   *
  7615.   * @tfile: Pointer to a struct ttm_object_file.
  7616.   * @key: Hash key
  7617.  -166,11 +166,11 @@
  7618.   * comparing the @tfile argument and checking the object shareable flag.
  7619.   */
  7620.  
  7621. -extern struct ttm_base_object *ttm_base_object_lookup(struct ttm_object_file
  7622. +extern struct ttm_base_object *lbm_ttm_base_object_lookup(struct ttm_object_file
  7623.                                                       *tfile, uint32_t key);
  7624.  
  7625.  /**
  7626. - * ttm_base_object_unref
  7627. + * lbm_ttm_base_object_unref
  7628.   *
  7629.   * @p_base: Pointer to a pointer referncing a struct ttm_base_object.
  7630.   *
  7631.  -178,10 +178,10 @@
  7632.   * p_base.
  7633.   */
  7634.  
  7635. -extern void ttm_base_object_unref(struct ttm_base_object **p_base);
  7636. +extern void lbm_ttm_base_object_unref(struct ttm_base_object **p_base);
  7637.  
  7638.  /**
  7639. - * ttm_ref_object_add.
  7640. + * lbm_ttm_ref_object_add.
  7641.   *
  7642.   * @tfile: A struct ttm_object_file representing the application owning the
  7643.   * ref_object.
  7644.  -199,11 +199,11 @@
  7645.   * make sure the lock is released if the application dies. A ref object
  7646.   * will hold a single reference on a base object.
  7647.   */
  7648. -extern int ttm_ref_object_add(struct ttm_object_file *tfile,
  7649. +extern int lbm_ttm_ref_object_add(struct ttm_object_file *tfile,
  7650.                               struct ttm_base_object *base,
  7651.                               enum ttm_ref_type ref_type, bool *existed);
  7652.  /**
  7653. - * ttm_ref_object_base_unref
  7654. + * lbm_ttm_ref_object_base_unref
  7655.   *
  7656.   * @key: Key representing the base object.
  7657.   * @ref_type: Ref type of the ref object to be dereferenced.
  7658.  -213,12 +213,12 @@
  7659.   * references, the ref object will be destroyed and the base object
  7660.   * will be unreferenced.
  7661.   */
  7662. -extern int ttm_ref_object_base_unref(struct ttm_object_file *tfile,
  7663. +extern int lbm_ttm_ref_object_base_unref(struct ttm_object_file *tfile,
  7664.                                      unsigned long key,
  7665.                                      enum ttm_ref_type ref_type);
  7666.  
  7667.  /**
  7668. - * ttm_object_file_init - initialize a struct ttm_object file
  7669. + * lbm_ttm_object_file_init - initialize a struct ttm_object file
  7670.   *
  7671.   * @tdev: A struct ttm_object device this file is initialized on.
  7672.   * @hash_order: Order of the hash table used to hold the reference objects.
  7673.  -226,12 +226,12 @@
  7674.   * This is typically called by the file_ops::open function.
  7675.   */
  7676.  
  7677. -extern struct ttm_object_file *ttm_object_file_init(struct ttm_object_device
  7678. +extern struct ttm_object_file *lbm_ttm_object_file_init(struct ttm_object_device
  7679.                                                     *tdev,
  7680.                                                     unsigned int hash_order);
  7681.  
  7682.  /**
  7683. - * ttm_object_file_release - release data held by a ttm_object_file
  7684. + * lbm_ttm_object_file_release - release data held by a ttm_object_file
  7685.   *
  7686.   * @p_tfile: Pointer to pointer to the ttm_object_file object to release.
  7687.   * *p_tfile will be set to NULL by this function.
  7688.  -241,7 +241,7 @@
  7689.   * ensure that there are no concurrent users of tfile.
  7690.   */
  7691.  
  7692. -extern void ttm_object_file_release(struct ttm_object_file **p_tfile);
  7693. +extern void lbm_ttm_object_file_release(struct ttm_object_file **p_tfile);
  7694.  
  7695.  /**
  7696.   * ttm_object device init - initialize a struct ttm_object_device
  7697.  -252,11 +252,11 @@
  7698.   * data structures needed for ttm base and ref objects.
  7699.   */
  7700.  
  7701. -extern struct ttm_object_device *ttm_object_device_init
  7702. +extern struct ttm_object_device *lbm_ttm_object_device_init
  7703.      (struct ttm_mem_global *mem_glob, unsigned int hash_order);
  7704.  
  7705.  /**
  7706. - * ttm_object_device_release - release data held by a ttm_object_device
  7707. + * lbm_ttm_object_device_release - release data held by a ttm_object_device
  7708.   *
  7709.   * @p_tdev: Pointer to pointer to the ttm_object_device object to release.
  7710.   * *p_tdev will be set to NULL by this function.
  7711.  -266,6 +266,6 @@
  7712.   * device private data structure.
  7713.   */
  7714.  
  7715. -extern void ttm_object_device_release(struct ttm_object_device **p_tdev);
  7716. +extern void lbm_ttm_object_device_release(struct ttm_object_device **p_tdev);
  7717.  
  7718.  #endif
  7719. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/linux/list_sort.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/linux/list_sort.h
  7720. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/linux/list_sort.h     2010-01-25 15:21:29.000000000 -0500
  7721. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/include/linux/list_sort.h     2010-02-03 17:11:08.000000000 -0500
  7722.  -5,7 +5,7 @@
  7723.  
  7724.  struct list_head;
  7725.  
  7726. -void list_sort(void *priv, struct list_head *head,
  7727. +void lbm_list_sort(void *priv, struct list_head *head,
  7728.                int (*cmp)(void *priv, struct list_head *a,
  7729.                           struct list_head *b));
  7730.  #endif
  7731. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Kconfig linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Kconfig
  7732. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Kconfig       2010-01-25 15:21:29.000000000 -0500
  7733. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Kconfig       2010-02-03 17:10:10.000000000 -0500
  7734.  -66,6 +66,8 @@
  7735.  
  7736.           If M is selected, the module will be called radeon.
  7737.  
  7738. +source "drivers/gpu/drm/radeon/Kconfig"
  7739. +
  7740.  config DRM_I810
  7741.         tristate "Intel I810"
  7742.         depends on DRM && AGP && AGP_INTEL
  7743. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/list_sort.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/list_sort.c
  7744. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/list_sort.c   2010-01-25 15:21:29.000000000 -0500
  7745. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/list_sort.c   2010-02-03 17:11:08.000000000 -0500
  7746.  -5,7 +5,7 @@
  7747.  #include <linux/list.h>
  7748.  
  7749.  /**
  7750. - * list_sort - sort a list.
  7751. + * lbm_list_sort - sort a list.
  7752.   * @priv: private data, passed to @cmp
  7753.   * @head: the list to sort
  7754.   * @cmp: the elements comparison function
  7755.  -18,7 +18,7 @@
  7756.   * less than @b, and a positive value if @a is greater than @b. If @a and @b
  7757.   * are equivalent, then it does not matter what this function returns.
  7758.   */
  7759. -void list_sort(void *priv, struct list_head *head,
  7760. +void lbm_list_sort(void *priv, struct list_head *head,
  7761.                int (*cmp)(void *priv, struct list_head *a,
  7762.                           struct list_head *b))
  7763.  {
  7764.  -99,4 +99,4 @@
  7765.         list->prev = head;
  7766.  }
  7767.  
  7768. -EXPORT_SYMBOL(list_sort);
  7769. +EXPORT_SYMBOL(lbm_list_sort);
  7770. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Makefile linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Makefile
  7771. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Makefile      2010-01-25 15:21:29.000000000 -0500
  7772. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/Makefile      2010-02-03 17:11:08.000000000 -0500
  7773.  -2,9 +2,9 @@
  7774.  # Makefile for the drm device driver.  This driver provides support for the
  7775.  # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
  7776.  
  7777. -ccflags-y := -Iinclude/drm
  7778. +ccflags-y := -I$(M)/nouveau/include/drm -I$(src)/include
  7779.  
  7780. -drm-y       := drm_auth.o drm_bufs.o drm_cache.o \
  7781. +lbm_drm-y       := list_sort.o         drm_auth.o drm_bufs.o drm_cache.o \
  7782.                 drm_context.o drm_dma.o drm_drawable.o \
  7783.                 drm_drv.o drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \
  7784.                 drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
  7785.  -13,24 +13,12 @@
  7786.                 drm_crtc.o drm_modes.o drm_edid.o \
  7787.                 drm_info.o drm_debugfs.o drm_encoder_slave.o
  7788.  
  7789. -drm-$(CONFIG_COMPAT) += drm_ioc32.o
  7790. +lbm_drm-$(CONFIG_COMPAT) += drm_ioc32.o
  7791.  
  7792. -drm_kms_helper-y := drm_fb_helper.o drm_crtc_helper.o drm_dp_i2c_helper.o
  7793. +lbm_drm_kms_helper-y := drm_fb_helper.o drm_crtc_helper.o drm_dp_i2c_helper.o
  7794.  
  7795. -obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o
  7796. +obj-$(CONFIG_DRM_KMS_HELPER) += lbm_drm_kms_helper.o
  7797.  
  7798. -obj-$(CONFIG_DRM)      += drm.o
  7799. +obj-$(CONFIG_DRM)      += lbm_drm.o
  7800.  obj-$(CONFIG_DRM_TTM)  += ttm/
  7801. -obj-$(CONFIG_DRM_TDFX) += tdfx/
  7802. -obj-$(CONFIG_DRM_R128) += r128/
  7803. -obj-$(CONFIG_DRM_RADEON)+= radeon/
  7804. -obj-$(CONFIG_DRM_MGA)  += mga/
  7805. -obj-$(CONFIG_DRM_I810) += i810/
  7806. -obj-$(CONFIG_DRM_I830) += i830/
  7807. -obj-$(CONFIG_DRM_I915)  += i915/
  7808. -obj-$(CONFIG_DRM_SIS)   += sis/
  7809. -obj-$(CONFIG_DRM_SAVAGE)+= savage/
  7810. -obj-$(CONFIG_DRM_VMWGFX)+= vmwgfx/
  7811. -obj-$(CONFIG_DRM_VIA)  +=via/
  7812. -obj-$(CONFIG_DRM_NOUVEAU) +=nouveau/
  7813. -obj-y                  += i2c/
  7814. +obj-m +=nouveau/
  7815. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/Makefile linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/Makefile
  7816. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/Makefile      2010-01-25 15:21:29.000000000 -0500
  7817. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/Makefile      2010-02-03 17:11:08.000000000 -0500
  7818.  -2,8 +2,8 @@
  7819.  # Makefile for the drm device driver.  This driver provides support for the
  7820.  # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
  7821.  
  7822. -ccflags-y := -Iinclude/drm
  7823. -nouveau-y := nouveau_drv.o nouveau_state.o nouveau_channel.o nouveau_mem.o \
  7824. +ccflags-y := -I$(M)/nouveau/include/drm -I$(src)/include
  7825. +lbm_nouveau-y := nouveau_drv.o nouveau_state.o nouveau_channel.o nouveau_mem.o \
  7826.               nouveau_object.o nouveau_irq.o nouveau_notifier.o \
  7827.               nouveau_sgdma.o nouveau_dma.o \
  7828.               nouveau_bo.o nouveau_fence.o nouveau_gem.o nouveau_ttm.o \
  7829.  -24,9 +24,9 @@
  7830.               nv04_crtc.o nv04_display.o nv04_cursor.o nv04_fbcon.o \
  7831.               nv17_gpio.o
  7832.  
  7833. -nouveau-$(CONFIG_DRM_NOUVEAU_DEBUG) += nouveau_debugfs.o
  7834. -nouveau-$(CONFIG_COMPAT) += nouveau_ioc32.o
  7835. -nouveau-$(CONFIG_DRM_NOUVEAU_BACKLIGHT) += nouveau_backlight.o
  7836. -nouveau-$(CONFIG_ACPI) += nouveau_acpi.o
  7837. +lbm_nouveau-$(CONFIG_DRM_NOUVEAU_DEBUG) += nouveau_debugfs.o
  7838. +lbm_nouveau-$(CONFIG_COMPAT) += nouveau_ioc32.o
  7839. +lbm_nouveau-$(CONFIG_DRM_NOUVEAU_BACKLIGHT) += nouveau_backlight.o
  7840. +lbm_nouveau-$(CONFIG_ACPI) += nouveau_acpi.o
  7841.  
  7842. -obj-$(CONFIG_DRM_NOUVEAU)+= nouveau.o
  7843. +obj-m+= lbm_nouveau.o
  7844. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bios.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bios.c
  7845. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bios.c        2010-01-25 15:21:29.000000000 -0500
  7846. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bios.c        2010-02-03 17:11:08.000000000 -0500
  7847.  -310,63 +310,22 @@
  7848.         struct drm_device *dev = bios->dev;
  7849.  
  7850.         /* C51 has misaligned regs on purpose. Marvellous */
  7851. -       if (reg & 0x2 || (reg & 0x1 && dev_priv->VBIOS.pub.chip_version != 0x51)) {
  7852. -               NV_ERROR(dev, "========== misaligned reg 0x%08X ==========\n",
  7853. -                        reg);
  7854. -               return 0;
  7855. -       }
  7856. -       /*
  7857. -        * Warn on C51 regs that have not been verified accessible in
  7858. -        * mmiotracing
  7859. -        */
  7860. +       if (reg & 0x2 ||
  7861. +           (reg & 0x1 && dev_priv->VBIOS.pub.chip_version != 0x51))
  7862. +               NV_ERROR(dev, "======= misaligned reg 0x%08X =======\n", reg);
  7863. +
  7864. +       /* warn on C51 regs that haven't been verified accessible in tracing */
  7865.         if (reg & 0x1 && dev_priv->VBIOS.pub.chip_version == 0x51 &&
  7866.             reg != 0x130d && reg != 0x1311 && reg != 0x60081d)
  7867.                 NV_WARN(dev, "=== C51 misaligned reg 0x%08X not verified ===\n",
  7868.                         reg);
  7869.  
  7870. -       /* Trust the init scripts on G80 */
  7871. -       if (dev_priv->card_type >= NV_50)
  7872. -               return 1;
  7873. -
  7874. -       #define WITHIN(x, y, z) ((x >= y) && (x < y + z))
  7875. -       if (WITHIN(reg, NV_PMC_OFFSET, NV_PMC_SIZE))
  7876. -               return 1;
  7877. -       if (WITHIN(reg, NV_PBUS_OFFSET, NV_PBUS_SIZE))
  7878. -               return 1;
  7879. -       if (WITHIN(reg, NV_PFIFO_OFFSET, NV_PFIFO_SIZE))
  7880. -               return 1;
  7881. -       if (dev_priv->VBIOS.pub.chip_version >= 0x30 &&
  7882. -           (WITHIN(reg, 0x4000, 0x600) || reg == 0x00004600))
  7883. -               return 1;
  7884. -       if (dev_priv->VBIOS.pub.chip_version >= 0x40 &&
  7885. -                                               WITHIN(reg, 0xc000, 0x48))
  7886. -               return 1;
  7887. -       if (dev_priv->VBIOS.pub.chip_version >= 0x17 && reg == 0x0000d204)
  7888. -               return 1;
  7889. -       if (dev_priv->VBIOS.pub.chip_version >= 0x40) {
  7890. -               if (reg == 0x00011014 || reg == 0x00020328)
  7891. -                       return 1;
  7892. -               if (WITHIN(reg, 0x88000, NV_PBUS_SIZE)) /* new PBUS */
  7893. -                       return 1;
  7894. +       if (reg >= (8*1024*1024)) {
  7895. +               NV_ERROR(dev, "=== reg 0x%08x out of mapped bounds ===\n", reg);
  7896. +               return 0;
  7897.         }
  7898. -       if (WITHIN(reg, NV_PFB_OFFSET, NV_PFB_SIZE))
  7899. -               return 1;
  7900. -       if (WITHIN(reg, NV_PEXTDEV_OFFSET, NV_PEXTDEV_SIZE))
  7901. -               return 1;
  7902. -       if (WITHIN(reg, NV_PCRTC0_OFFSET, NV_PCRTC0_SIZE * 2))
  7903. -               return 1;
  7904. -       if (WITHIN(reg, NV_PRAMDAC0_OFFSET, NV_PRAMDAC0_SIZE * 2))
  7905. -               return 1;
  7906. -       if (dev_priv->VBIOS.pub.chip_version >= 0x17 && reg == 0x0070fff0)
  7907. -               return 1;
  7908. -       if (dev_priv->VBIOS.pub.chip_version == 0x51 &&
  7909. -                               WITHIN(reg, NV_PRAMIN_OFFSET, NV_PRAMIN_SIZE))
  7910. -               return 1;
  7911. -       #undef WITHIN
  7912. -
  7913. -       NV_ERROR(dev, "========== unknown reg 0x%08X ==========\n", reg);
  7914.  
  7915. -       return 0;
  7916. +       return 1;
  7917.  }
  7918.  
  7919.  static bool
  7920.  -3196,16 +3155,25 @@
  7921.         }
  7922.  #ifdef __powerpc__
  7923.         /* Powerbook specific quirks */
  7924. -       if (script == LVDS_RESET && ((dev->pci_device & 0xffff) == 0x0179 || (dev->pci_device & 0xffff) == 0x0329))
  7925. -               nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72);
  7926. -       if ((dev->pci_device & 0xffff) == 0x0179 || (dev->pci_device & 0xffff) == 0x0189 || (dev->pci_device & 0xffff) == 0x0329) {
  7927. -               if (script == LVDS_PANEL_ON) {
  7928. -                       bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL, bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL) | (1 << 31));
  7929. -                       bios_wr32(bios, NV_PCRTC_GPIO_EXT, bios_rd32(bios, NV_PCRTC_GPIO_EXT) | 1);
  7930. -               }
  7931. -               if (script == LVDS_PANEL_OFF) {
  7932. -                       bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL, bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL) & ~(1 << 31));
  7933. -                       bios_wr32(bios, NV_PCRTC_GPIO_EXT, bios_rd32(bios, NV_PCRTC_GPIO_EXT) & ~3);
  7934. +       if ((dev->pci_device & 0xffff) == 0x0179 ||
  7935. +           (dev->pci_device & 0xffff) == 0x0189 ||
  7936. +           (dev->pci_device & 0xffff) == 0x0329) {
  7937. +               if (script == LVDS_RESET) {
  7938. +                       nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72);
  7939. +
  7940. +               } else if (script == LVDS_PANEL_ON) {
  7941. +                       bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL,
  7942. +                                 bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL)
  7943. +                                 | (1 << 31));
  7944. +                       bios_wr32(bios, NV_PCRTC_GPIO_EXT,
  7945. +                                 bios_rd32(bios, NV_PCRTC_GPIO_EXT) | 1);
  7946. +
  7947. +               } else if (script == LVDS_PANEL_OFF) {
  7948. +                       bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL,
  7949. +                                 bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL)
  7950. +                                 & ~(1 << 31));
  7951. +                       bios_wr32(bios, NV_PCRTC_GPIO_EXT,
  7952. +                                 bios_rd32(bios, NV_PCRTC_GPIO_EXT) & ~3);
  7953.                 }
  7954.         }
  7955.  #endif
  7956.  -3562,7 +3530,7 @@
  7957.  
  7958.         mode->status = MODE_OK;
  7959.         mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  7960. -       drm_mode_set_name(mode);
  7961. +       lbm_drm_mode_set_name(mode);
  7962.         return bios->fp.mode_ptr;
  7963.  }
  7964.  
  7965.  -5434,52 +5402,49 @@
  7966.  parse_dcb15_entry(struct drm_device *dev, struct parsed_dcb *dcb,
  7967.                   uint32_t conn, uint32_t conf, struct dcb_entry *entry)
  7968.  {
  7969. -       if (conn != 0xf0003f00 && conn != 0xf2247f10 && conn != 0xf2204001 &&
  7970. -           conn != 0xf2204301 && conn != 0xf2204311 && conn != 0xf2208001 &&
  7971. -           conn != 0xf2244001 && conn != 0xf2244301 && conn != 0xf2244311 &&
  7972. -           conn != 0xf4204011 && conn != 0xf4208011 && conn != 0xf4248011 &&
  7973. -           conn != 0xf2045ff2 && conn != 0xf2045f14 && conn != 0xf207df14 &&
  7974. -           conn != 0xf2205004 && conn != 0xf2209004) {
  7975. -               NV_ERROR(dev, "Unknown DCB 1.5 entry, please report\n");
  7976. -
  7977. -               /* cause output setting to fail for !TV, so message is seen */
  7978. -               if ((conn & 0xf) != 0x1)
  7979. -                       dcb->entries = 0;
  7980. -
  7981. -               return false;
  7982. -       }
  7983. -       /* most of the below is a "best guess" atm */
  7984. -       entry->type = conn & 0xf;
  7985. -       if (entry->type == 2)
  7986. -               /* another way of specifying straps based lvds... */
  7987. +       switch (conn & 0x0000000f) {
  7988. +       case 0:
  7989. +               entry->type = OUTPUT_ANALOG;
  7990. +               break;
  7991. +       case 1:
  7992. +               entry->type = OUTPUT_TV;
  7993. +               break;
  7994. +       case 2:
  7995. +       case 3:
  7996.                 entry->type = OUTPUT_LVDS;
  7997. -       if (entry->type == 4) { /* digital */
  7998. -               if (conn & 0x10)
  7999. -                       entry->type = OUTPUT_LVDS;
  8000. -               else
  8001. +               break;
  8002. +       case 4:
  8003. +               switch ((conn & 0x000000f0) >> 4) {
  8004. +               case 0:
  8005.                         entry->type = OUTPUT_TMDS;
  8006. +                       break;
  8007. +               case 1:
  8008. +                       entry->type = OUTPUT_LVDS;
  8009. +                       break;
  8010. +               default:
  8011. +                       NV_ERROR(dev, "Unknown DCB subtype 4/%d\n",
  8012. +                                (conn & 0x000000f0) >> 4);
  8013. +                       return false;
  8014. +               }
  8015. +               break;
  8016. +       default:
  8017. +               NV_ERROR(dev, "Unknown DCB type %d\n", conn & 0x0000000f);
  8018. +               return false;
  8019.         }
  8020. -       /* what's in bits 5-13? could be some encoder maker thing, in tv case */
  8021. -       entry->i2c_index = (conn >> 14) & 0xf;
  8022. -       /* raw heads field is in range 0-1, so move to 1-2 */
  8023. -       entry->heads = ((conn >> 18) & 0x7) + 1;
  8024. -       entry->location = (conn >> 21) & 0xf;
  8025. -       /* unused: entry->bus = (conn >> 25) & 0x7; */
  8026. -       /* set or to be same as heads -- hopefully safe enough */
  8027. -       entry->or = entry->heads;
  8028. +
  8029. +       entry->i2c_index = (conn & 0x0003c000) >> 14;
  8030. +       entry->heads = ((conn & 0x001c0000) >> 18) + 1;
  8031. +       entry->or = entry->heads; /* same as heads, hopefully safe enough */
  8032. +       entry->location = (conn & 0x01e00000) >> 21;
  8033. +       entry->bus = (conn & 0x0e000000) >> 25;
  8034.         entry->duallink_possible = false;
  8035.  
  8036.         switch (entry->type) {
  8037.         case OUTPUT_ANALOG:
  8038.                 entry->crtconf.maxfreq = (conf & 0xffff) * 10;
  8039.                 break;
  8040. -       case OUTPUT_LVDS:
  8041. -               /*
  8042. -                * This is probably buried in conn's unknown bits.
  8043. -                * This will upset EDID-ful models, if they exist
  8044. -                */
  8045. -               entry->lvdsconf.use_straps_for_mode = true;
  8046. -               entry->lvdsconf.use_power_scripts = true;
  8047. +       case OUTPUT_TV:
  8048. +               entry->tvconf.has_component_output = false;
  8049.                 break;
  8050.         case OUTPUT_TMDS:
  8051.                 /*
  8052.  -5488,8 +5453,12 @@
  8053.                  */
  8054.                 fabricate_vga_output(dcb, entry->i2c_index, entry->heads);
  8055.                 break;
  8056. -       case OUTPUT_TV:
  8057. -               entry->tvconf.has_component_output = false;
  8058. +       case OUTPUT_LVDS:
  8059. +               if ((conn & 0x00003f00) != 0x10)
  8060. +                       entry->lvdsconf.use_straps_for_mode = true;
  8061. +               entry->lvdsconf.use_power_scripts = true;
  8062. +               break;
  8063. +       default:
  8064.                 break;
  8065.         }
  8066.  
  8067.  -5564,11 +5533,13 @@
  8068.         dcb->entries = newentries;
  8069.  }
  8070.  
  8071. -static int parse_dcb_table(struct drm_device *dev, struct nvbios *bios, bool twoHeads)
  8072. +static int
  8073. +parse_dcb_table(struct drm_device *dev, struct nvbios *bios, bool twoHeads)
  8074.  {
  8075. +       struct drm_nouveau_private *dev_priv = dev->dev_private;
  8076.         struct bios_parsed_dcb *bdcb = &bios->bdcb;
  8077.         struct parsed_dcb *dcb;
  8078. -       uint16_t dcbptr, i2ctabptr = 0;
  8079. +       uint16_t dcbptr = 0, i2ctabptr = 0;
  8080.         uint8_t *dcbtable;
  8081.         uint8_t headerlen = 0x4, entries = DCB_MAX_NUM_ENTRIES;
  8082.         bool configblock = true;
  8083.  -5579,16 +5550,18 @@
  8084.         dcb->entries = 0;
  8085.  
  8086.         /* get the offset from 0x36 */
  8087. -       dcbptr = ROM16(bios->data[0x36]);
  8088. +       if (dev_priv->card_type > NV_04) {
  8089. +               dcbptr = ROM16(bios->data[0x36]);
  8090. +               if (dcbptr == 0x0000)
  8091. +                       NV_WARN(dev, "No output data (DCB) found in BIOS\n");
  8092. +       }
  8093.  
  8094. +       /* this situation likely means a really old card, pre DCB */
  8095.         if (dcbptr == 0x0) {
  8096. -               NV_WARN(dev, "No output data (DCB) found in BIOS, "
  8097. -                              "assuming a CRT output exists\n");
  8098. -               /* this situation likely means a really old card, pre DCB */
  8099. +               NV_INFO(dev, "Assuming a CRT output exists\n");
  8100.                 fabricate_vga_output(dcb, LEGACY_I2C_CRT, 1);
  8101.  
  8102. -               if (nv04_tv_identify(dev,
  8103. -                                    bios->legacy.i2c_indices.tv) >= 0)
  8104. +               if (nv04_tv_identify(dev, bios->legacy.i2c_indices.tv) >= 0)
  8105.                         fabricate_tv_output(dcb, twoHeads);
  8106.  
  8107.                 return 0;
  8108. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bo.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bo.c
  8109. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bo.c  2010-01-25 15:21:29.000000000 -0500
  8110. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_bo.c  2010-02-03 17:11:09.000000000 -0500
  8111.  -42,7 +42,7 @@
  8112.         struct drm_device *dev = dev_priv->dev;
  8113.         struct nouveau_bo *nvbo = nouveau_bo(bo);
  8114.  
  8115. -       ttm_bo_kunmap(&nvbo->kmap);
  8116. +       lbm_ttm_bo_kunmap(&nvbo->kmap);
  8117.  
  8118.         if (unlikely(nvbo->gem))
  8119.                 DRM_ERROR("bo %p still attached to GEM object\n", bo);
  8120.  -156,7 +156,7 @@
  8121.         nouveau_bo_placement_set(nvbo, flags);
  8122.  
  8123.         nvbo->channel = chan;
  8124. -       ret = ttm_bo_init(&dev_priv->ttm.bdev, &nvbo->bo, size,
  8125. +       ret = lbm_ttm_bo_init(&dev_priv->ttm.bdev, &nvbo->bo, size,
  8126.                           ttm_bo_type_device, &nvbo->placement, align, 0,
  8127.                           false, NULL, size, nouveau_bo_del_ttm);
  8128.         nvbo->channel = NULL;
  8129.  -211,7 +211,7 @@
  8130.         if (nvbo->pin_refcnt++)
  8131.                 return 0;
  8132.  
  8133. -       ret = ttm_bo_reserve(bo, false, false, false, 0);
  8134. +       ret = lbm_ttm_bo_reserve(bo, false, false, false, 0);
  8135.         if (ret)
  8136.                 goto out;
  8137.  
  8138.  -219,7 +219,7 @@
  8139.         for (i = 0; i < nvbo->placement.num_placement; i++)
  8140.                 nvbo->placements[i] |= TTM_PL_FLAG_NO_EVICT;
  8141.  
  8142. -       ret = ttm_bo_validate(bo, &nvbo->placement, false, false);
  8143. +       ret = lbm_ttm_bo_validate(bo, &nvbo->placement, false, false);
  8144.         if (ret == 0) {
  8145.                 switch (bo->mem.mem_type) {
  8146.                 case TTM_PL_VRAM:
  8147.  -232,7 +232,7 @@
  8148.                         break;
  8149.                 }
  8150.         }
  8151. -       ttm_bo_unreserve(bo);
  8152. +       lbm_ttm_bo_unreserve(bo);
  8153.  out:
  8154.         if (unlikely(ret))
  8155.                 nvbo->pin_refcnt--;
  8156.  -249,14 +249,14 @@
  8157.         if (--nvbo->pin_refcnt)
  8158.                 return 0;
  8159.  
  8160. -       ret = ttm_bo_reserve(bo, false, false, false, 0);
  8161. +       ret = lbm_ttm_bo_reserve(bo, false, false, false, 0);
  8162.         if (ret)
  8163.                 return ret;
  8164.  
  8165.         for (i = 0; i < nvbo->placement.num_placement; i++)
  8166.                 nvbo->placements[i] &= ~TTM_PL_FLAG_NO_EVICT;
  8167.  
  8168. -       ret = ttm_bo_validate(bo, &nvbo->placement, false, false);
  8169. +       ret = lbm_ttm_bo_validate(bo, &nvbo->placement, false, false);
  8170.         if (ret == 0) {
  8171.                 switch (bo->mem.mem_type) {
  8172.                 case TTM_PL_VRAM:
  8173.  -270,7 +270,7 @@
  8174.                 }
  8175.         }
  8176.  
  8177. -       ttm_bo_unreserve(bo);
  8178. +       lbm_ttm_bo_unreserve(bo);
  8179.         return ret;
  8180.  }
  8181.  
  8182.  -279,19 +279,19 @@
  8183.  {
  8184.         int ret;
  8185.  
  8186. -       ret = ttm_bo_reserve(&nvbo->bo, false, false, false, 0);
  8187. +       ret = lbm_ttm_bo_reserve(&nvbo->bo, false, false, false, 0);
  8188.         if (ret)
  8189.                 return ret;
  8190.  
  8191. -       ret = ttm_bo_kmap(&nvbo->bo, 0, nvbo->bo.mem.num_pages, &nvbo->kmap);
  8192. -       ttm_bo_unreserve(&nvbo->bo);
  8193. +       ret = lbm_ttm_bo_kmap(&nvbo->bo, 0, nvbo->bo.mem.num_pages, &nvbo->kmap);
  8194. +       lbm_ttm_bo_unreserve(&nvbo->bo);
  8195.         return ret;
  8196.  }
  8197.  
  8198.  void
  8199.  nouveau_bo_unmap(struct nouveau_bo *nvbo)
  8200.  {
  8201. -       ttm_bo_kunmap(&nvbo->kmap);
  8202. +       lbm_ttm_bo_kunmap(&nvbo->kmap);
  8203.  }
  8204.  
  8205.  u16
  8206.  -351,7 +351,7 @@
  8207.         switch (dev_priv->gart_info.type) {
  8208.  #if __OS_HAS_AGP
  8209.         case NOUVEAU_GART_AGP:
  8210. -               return ttm_agp_backend_init(bdev, dev->agp->bridge);
  8211. +               return lbm_ttm_agp_backend_init(bdev, dev->agp->bridge);
  8212.  #endif
  8213.         case NOUVEAU_GART_SGDMA:
  8214.                 return nouveau_sgdma_init_ttm(dev);
  8215.  -393,8 +393,8 @@
  8216.                 man->default_caching = TTM_PL_FLAG_WC;
  8217.  
  8218.                 man->io_addr = NULL;
  8219. -               man->io_offset = drm_get_resource_start(dev, 1);
  8220. -               man->io_size = drm_get_resource_len(dev, 1);
  8221. +               man->io_offset = lbm_drm_get_resource_start(dev, 1);
  8222. +               man->io_size = lbm_drm_get_resource_len(dev, 1);
  8223.                 if (man->io_size > nouveau_mem_fb_amount(dev))
  8224.                         man->io_size = nouveau_mem_fb_amount(dev);
  8225.  
  8226.  -467,8 +467,10 @@
  8227.         if (ret)
  8228.                 return ret;
  8229.  
  8230. -       ret = ttm_bo_move_accel_cleanup(&nvbo->bo, fence, NULL,
  8231. +       ret = lbm_ttm_bo_move_accel_cleanup(&nvbo->bo, fence, NULL,
  8232.                                         evict, no_wait, new_mem);
  8233. +       if (nvbo->channel && nvbo->channel != chan)
  8234. +               ret = nouveau_fence_wait(fence, NULL, false, false);
  8235.         nouveau_fence_unref((void *)&fence);
  8236.         return ret;
  8237.  }
  8238.  -586,11 +588,11 @@
  8239.  
  8240.         tmp_mem = *new_mem;
  8241.         tmp_mem.mm_node = NULL;
  8242. -       ret = ttm_bo_mem_space(bo, &placement, &tmp_mem, intr, no_wait);
  8243. +       ret = lbm_ttm_bo_mem_space(bo, &placement, &tmp_mem, intr, no_wait);
  8244.         if (ret)
  8245.                 return ret;
  8246.  
  8247. -       ret = ttm_tt_bind(bo->ttm, &tmp_mem);
  8248. +       ret = lbm_ttm_tt_bind(bo->ttm, &tmp_mem);
  8249.         if (ret)
  8250.                 goto out;
  8251.  
  8252.  -598,11 +600,11 @@
  8253.         if (ret)
  8254.                 goto out;
  8255.  
  8256. -       ret = ttm_bo_move_ttm(bo, evict, no_wait, new_mem);
  8257. +       ret = lbm_ttm_bo_move_ttm(bo, evict, no_wait, new_mem);
  8258.  out:
  8259.         if (tmp_mem.mm_node) {
  8260.                 spin_lock(&bo->bdev->glob->lru_lock);
  8261. -               drm_mm_put_block(tmp_mem.mm_node);
  8262. +               lbm_drm_mm_put_block(tmp_mem.mm_node);
  8263.                 spin_unlock(&bo->bdev->glob->lru_lock);
  8264.         }
  8265.  
  8266.  -624,11 +626,11 @@
  8267.  
  8268.         tmp_mem = *new_mem;
  8269.         tmp_mem.mm_node = NULL;
  8270. -       ret = ttm_bo_mem_space(bo, &placement, &tmp_mem, intr, no_wait);
  8271. +       ret = lbm_ttm_bo_mem_space(bo, &placement, &tmp_mem, intr, no_wait);
  8272.         if (ret)
  8273.                 return ret;
  8274.  
  8275. -       ret = ttm_bo_move_ttm(bo, evict, no_wait, &tmp_mem);
  8276. +       ret = lbm_ttm_bo_move_ttm(bo, evict, no_wait, &tmp_mem);
  8277.         if (ret)
  8278.                 goto out;
  8279.  
  8280.  -639,7 +641,7 @@
  8281.  out:
  8282.         if (tmp_mem.mm_node) {
  8283.                 spin_lock(&bo->bdev->glob->lru_lock);
  8284. -               drm_mm_put_block(tmp_mem.mm_node);
  8285. +               lbm_drm_mm_put_block(tmp_mem.mm_node);
  8286.                 spin_unlock(&bo->bdev->glob->lru_lock);
  8287.         }
  8288.  
  8289.  -714,7 +716,7 @@
  8290.         /* Software copy if the card isn't up and running yet. */
  8291.         if (dev_priv->init_state != NOUVEAU_CARD_INIT_DONE ||
  8292.             !dev_priv->channel) {
  8293. -               ret = ttm_bo_move_memcpy(bo, evict, no_wait, new_mem);
  8294. +               ret = lbm_ttm_bo_move_memcpy(bo, evict, no_wait, new_mem);
  8295.                 goto out;
  8296.         }
  8297.  
  8298.  -738,7 +740,7 @@
  8299.                 goto out;
  8300.  
  8301.         /* Fallback to software copy. */
  8302. -       ret = ttm_bo_move_memcpy(bo, evict, no_wait, new_mem);
  8303. +       ret = lbm_ttm_bo_move_memcpy(bo, evict, no_wait, new_mem);
  8304.  
  8305.  out:
  8306.         if (ret)
  8307. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_channel.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_channel.c
  8308. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_channel.c     2010-01-25 15:21:29.000000000 -0500
  8309. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_channel.c     2010-02-03 17:11:09.000000000 -0500
  8310.  -57,7 +57,7 @@
  8311.                  * VRAM.
  8312.                  */
  8313.                 ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY,
  8314. -                                            drm_get_resource_start(dev, 1),
  8315. +                                            lbm_drm_get_resource_start(dev, 1),
  8316.                                              dev_priv->fb_available_size,
  8317.                                              NV_DMA_ACCESS_RO,
  8318.                                              NV_DMA_TARGET_PCI, &pushbuf);
  8319.  -380,7 +380,7 @@
  8320.         init->nr_subchan = 2;
  8321.  
  8322.         /* Named memory object area */
  8323. -       ret = drm_gem_handle_create(file_priv, chan->notifier_bo->gem,
  8324. +       ret = lbm_drm_gem_handle_create(file_priv, chan->notifier_bo->gem,
  8325.                                     &init->notifier_handle);
  8326.         if (ret) {
  8327.                 nouveau_channel_free(chan);
  8328. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_connector.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_connector.c
  8329. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_connector.c   2010-01-25 15:21:29.000000000 -0500
  8330. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_connector.c   2010-02-03 17:11:09.000000000 -0500
  8331.  -24,9 +24,12 @@
  8332.   *
  8333.   */
  8334.  
  8335. +#include <acpi/button.h>
  8336. +
  8337.  #include "drmP.h"
  8338.  #include "drm_edid.h"
  8339.  #include "drm_crtc_helper.h"
  8340. +
  8341.  #include "nouveau_reg.h"
  8342.  #include "nouveau_drv.h"
  8343.  #include "nouveau_encoder.h"
  8344.  -53,7 +56,7 @@
  8345.                 if (!id)
  8346.                         break;
  8347.  
  8348. -               obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
  8349. +               obj = lbm_drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
  8350.                 if (!obj)
  8351.                         continue;
  8352.                 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
  8353.  -83,16 +86,18 @@
  8354.  static void
  8355.  nouveau_connector_destroy(struct drm_connector *drm_connector)
  8356.  {
  8357. -       struct nouveau_connector *connector = nouveau_connector(drm_connector);
  8358. -       struct drm_device *dev = connector->base.dev;
  8359. +       struct nouveau_connector *nv_connector =
  8360. +               nouveau_connector(drm_connector);
  8361. +       struct drm_device *dev = nv_connector->base.dev;
  8362.  
  8363.         NV_DEBUG_KMS(dev, "\n");
  8364.  
  8365. -       if (!connector)
  8366. +       if (!nv_connector)
  8367.                 return;
  8368.  
  8369. -       drm_sysfs_connector_remove(drm_connector);
  8370. -       drm_connector_cleanup(drm_connector);
  8371. +       kfree(nv_connector->edid);
  8372. +       lbm_drm_sysfs_connector_remove(drm_connector);
  8373. +       lbm_drm_connector_cleanup(drm_connector);
  8374.         kfree(drm_connector);
  8375.  }
  8376.  
  8377.  -161,7 +166,7 @@
  8378.                 if (!id)
  8379.                         break;
  8380.  
  8381. -               obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
  8382. +               obj = lbm_drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
  8383.                 if (!obj)
  8384.                         continue;
  8385.                 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
  8386.  -213,7 +218,7 @@
  8387.         }
  8388.  
  8389.         if (connector->connector_type == DRM_MODE_CONNECTOR_DVII) {
  8390. -               drm_connector_property_set_value(connector,
  8391. +               lbm_drm_connector_property_set_value(connector,
  8392.                         dev->mode_config.dvi_i_subconnector_property,
  8393.                         nv_encoder->dcb->type == OUTPUT_TMDS ?
  8394.                         DRM_MODE_SUBCONNECTOR_DVID :
  8395.  -233,27 +238,38 @@
  8396.         if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
  8397.                 nv_encoder = find_encoder_by_type(connector, OUTPUT_LVDS);
  8398.         if (nv_encoder && nv_connector->native_mode) {
  8399. +#ifdef CONFIG_ACPI
  8400. +               if (!nouveau_ignorelid && !acpi_lid_open())
  8401. +                       return connector_status_disconnected;
  8402. +#endif
  8403.                 nouveau_connector_set_encoder(connector, nv_encoder);
  8404.                 return connector_status_connected;
  8405.         }
  8406.  
  8407. +       /* Cleanup the previous EDID block. */
  8408. +       if (nv_connector->edid) {
  8409. +               lbm_drm_mode_connector_update_edid_property(connector, NULL);
  8410. +               kfree(nv_connector->edid);
  8411. +               nv_connector->edid = NULL;
  8412. +       }
  8413. +
  8414.         i2c = nouveau_connector_ddc_detect(connector, &nv_encoder);
  8415.         if (i2c) {
  8416.                 nouveau_connector_ddc_prepare(connector, &flags);
  8417. -               nv_connector->edid = drm_get_edid(connector, &i2c->adapter);
  8418. +               nv_connector->edid = lbm_drm_get_edid(connector, &i2c->adapter);
  8419.                 nouveau_connector_ddc_finish(connector, flags);
  8420. -               drm_mode_connector_update_edid_property(connector,
  8421. +               lbm_drm_mode_connector_update_edid_property(connector,
  8422.                                                         nv_connector->edid);
  8423.                 if (!nv_connector->edid) {
  8424.                         NV_ERROR(dev, "DDC responded, but no EDID for %s\n",
  8425. -                                drm_get_connector_name(connector));
  8426. -                       return connector_status_disconnected;
  8427. +                                lbm_drm_get_connector_name(connector));
  8428. +                       goto detect_analog;
  8429.                 }
  8430.  
  8431.                 if (nv_encoder->dcb->type == OUTPUT_DP &&
  8432.                     !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
  8433.                         NV_ERROR(dev, "Detected %s, but failed init\n",
  8434. -                                drm_get_connector_name(connector));
  8435. +                                lbm_drm_get_connector_name(connector));
  8436.                         return connector_status_disconnected;
  8437.                 }
  8438.  
  8439.  -272,7 +288,7 @@
  8440.                         if (!nv_encoder) {
  8441.                                 NV_ERROR(dev, "Detected %d encoder on %s, "
  8442.                                               "but no object!\n", type,
  8443. -                                        drm_get_connector_name(connector));
  8444. +                                        lbm_drm_get_connector_name(connector));
  8445.                                 return connector_status_disconnected;
  8446.                         }
  8447.                 }
  8448.  -281,6 +297,7 @@
  8449.                 return connector_status_connected;
  8450.         }
  8451.  
  8452. +detect_analog:
  8453.         nv_encoder = find_encoder_by_type(connector, OUTPUT_ANALOG);
  8454.         if (!nv_encoder)
  8455.                 nv_encoder = find_encoder_by_type(connector, OUTPUT_TV);
  8456.  -318,7 +335,7 @@
  8457.         nv_encoder = find_encoder_by_type(connector, type);
  8458.         if (!nv_encoder) {
  8459.                 NV_ERROR(dev, "can't find encoder to force %s on!\n",
  8460. -                        drm_get_connector_name(connector));
  8461. +                        lbm_drm_get_connector_name(connector));
  8462.                 connector->status = connector_status_disconnected;
  8463.                 return;
  8464.         }
  8465.  -369,7 +386,7 @@
  8466.                         return 0;
  8467.  
  8468.                 if (modeset || !nv_crtc->set_scale) {
  8469. -                       ret = drm_crtc_helper_set_mode(&nv_crtc->base,
  8470. +                       ret = lbm_drm_crtc_helper_set_mode(&nv_crtc->base,
  8471.                                                         &nv_crtc->base.mode,
  8472.                                                         nv_crtc->base.x,
  8473.                                                         nv_crtc->base.y, NULL);
  8474.  -421,7 +438,7 @@
  8475.         list_for_each_entry(mode, &connector->base.probed_modes, head) {
  8476.                 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
  8477.                         NV_DEBUG_KMS(dev, "native mode from preferred\n");
  8478. -                       return drm_mode_duplicate(dev, mode);
  8479. +                       return lbm_drm_mode_duplicate(dev, mode);
  8480.                 }
  8481.         }
  8482.  
  8483.  -447,7 +464,7 @@
  8484.  
  8485.         NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n",
  8486.                       high_w, high_h, high_v);
  8487. -       return largest ? drm_mode_duplicate(dev, largest) : NULL;
  8488. +       return largest ? lbm_drm_mode_duplicate(dev, largest) : NULL;
  8489.  }
  8490.  
  8491.  struct moderec {
  8492.  -488,15 +505,15 @@
  8493.         while (mode->hdisplay) {
  8494.                 if (mode->hdisplay <= native->hdisplay &&
  8495.                     mode->vdisplay <= native->vdisplay) {
  8496. -                       m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
  8497. -                                        drm_mode_vrefresh(native), false,
  8498. +                       m = lbm_drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
  8499. +                                        lbm_drm_mode_vrefresh(native), false,
  8500.                                          false, false);
  8501.                         if (!m)
  8502.                                 continue;
  8503.  
  8504.                         m->type |= DRM_MODE_TYPE_DRIVER;
  8505.  
  8506. -                       drm_mode_probed_add(connector, m);
  8507. +                       lbm_drm_mode_probed_add(connector, m);
  8508.                         modes++;
  8509.                 }
  8510.  
  8511.  -519,12 +536,12 @@
  8512.          */
  8513.         if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS &&
  8514.             nv_connector->native_mode) {
  8515. -               drm_mode_destroy(dev, nv_connector->native_mode);
  8516. +               lbm_drm_mode_destroy(dev, nv_connector->native_mode);
  8517.                 nv_connector->native_mode = NULL;
  8518.         }
  8519.  
  8520.         if (nv_connector->edid)
  8521. -               ret = drm_add_edid_modes(connector, nv_connector->edid);
  8522. +               ret = lbm_drm_add_edid_modes(connector, nv_connector->edid);
  8523.  
  8524.         /* Find the native mode if this is a digital panel, if we didn't
  8525.          * find any modes through DDC previously add the native mode to
  8526.  -536,8 +553,8 @@
  8527.         if (ret == 0 && nv_connector->native_mode) {
  8528.                 struct drm_display_mode *mode;
  8529.  
  8530. -               mode = drm_mode_duplicate(dev, nv_connector->native_mode);
  8531. -               drm_mode_probed_add(connector, mode);
  8532. +               mode = lbm_drm_mode_duplicate(dev, nv_connector->native_mode);
  8533. +               lbm_drm_mode_probed_add(connector, mode);
  8534.                 ret = 1;
  8535.         }
  8536.  
  8537.  -626,12 +643,12 @@
  8538.  
  8539.  static const struct drm_connector_funcs
  8540.  nouveau_connector_funcs = {
  8541. -       .dpms = drm_helper_connector_dpms,
  8542. +       .dpms = lbm_drm_helper_connector_dpms,
  8543.         .save = NULL,
  8544.         .restore = NULL,
  8545.         .detect = nouveau_connector_detect,
  8546.         .destroy = nouveau_connector_destroy,
  8547. -       .fill_modes = drm_helper_probe_single_connector_modes,
  8548. +       .fill_modes = lbm_drm_helper_probe_single_connector_modes,
  8549.         .set_property = nouveau_connector_set_property,
  8550.         .force = nouveau_connector_force
  8551.  };
  8552.  -667,7 +684,7 @@
  8553.  
  8554.         if (i2c) {
  8555.                 nouveau_connector_ddc_prepare(connector, &flags);
  8556. -               nv_connector->edid = drm_get_edid(connector, &i2c->adapter);
  8557. +               nv_connector->edid = lbm_drm_get_edid(connector, &i2c->adapter);
  8558.                 nouveau_connector_ddc_finish(connector, flags);
  8559.         }
  8560.  
  8561.  -678,7 +695,7 @@
  8562.         if (!nv_connector->edid && nouveau_bios_fp_mode(dev, &native) &&
  8563.              (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
  8564.               dev_priv->VBIOS.pub.fp_no_ddc)) {
  8565. -               nv_connector->native_mode = drm_mode_duplicate(dev, &native);
  8566. +               nv_connector->native_mode = lbm_drm_mode_duplicate(dev, &native);
  8567.                 goto out;
  8568.         }
  8569.  
  8570.  -687,8 +704,12 @@
  8571.          */
  8572.         if (!nv_connector->edid && !nv_connector->native_mode &&
  8573.             !dev_priv->VBIOS.pub.fp_no_ddc) {
  8574. -               nv_connector->edid =
  8575. +               struct edid *edid =
  8576.                         (struct edid *)nouveau_bios_embedded_edid(dev);
  8577. +               if (edid) {
  8578. +                       nv_connector->edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
  8579. +                       *(nv_connector->edid) = *edid;
  8580. +               }
  8581.         }
  8582.  
  8583.         if (!nv_connector->edid)
  8584.  -697,13 +718,13 @@
  8585.         /* We didn't find/use a panel mode from the VBIOS, so parse the EDID
  8586.          * block and look for the preferred mode there.
  8587.          */
  8588. -       ret = drm_add_edid_modes(connector, nv_connector->edid);
  8589. +       ret = lbm_drm_add_edid_modes(connector, nv_connector->edid);
  8590.         if (ret == 0)
  8591.                 goto out;
  8592.         nv_connector->detected_encoder = nv_encoder;
  8593.         nv_connector->native_mode = nouveau_connector_native_mode(nv_connector);
  8594.         list_for_each_entry_safe(mode, temp, &connector->probed_modes, head)
  8595. -               drm_mode_remove(connector, mode);
  8596. +               lbm_drm_mode_remove(connector, mode);
  8597.  
  8598.  out:
  8599.         if (!nv_connector->native_mode) {
  8600.  -712,7 +733,7 @@
  8601.                 return -ENODEV;
  8602.         }
  8603.  
  8604. -       drm_mode_connector_update_edid_property(connector, nv_connector->edid);
  8605. +       lbm_drm_mode_connector_update_edid_property(connector, nv_connector->edid);
  8606.         return 0;
  8607.  }
  8608.  
  8609.  -761,14 +782,14 @@
  8610.         connector->interlace_allowed = false;
  8611.         connector->doublescan_allowed = false;
  8612.  
  8613. -       drm_connector_init(dev, connector, &nouveau_connector_funcs, type);
  8614. +       lbm_drm_connector_init(dev, connector, &nouveau_connector_funcs, type);
  8615.         drm_connector_helper_add(connector, &nouveau_connector_helper_funcs);
  8616.  
  8617.         /* Init DVI-I specific properties */
  8618.         if (type == DRM_MODE_CONNECTOR_DVII) {
  8619. -               drm_mode_create_dvi_i_properties(dev);
  8620. -               drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0);
  8621. -               drm_connector_attach_property(connector, dev->mode_config.dvi_i_select_subconnector_property, 0);
  8622. +               lbm_drm_mode_create_dvi_i_properties(dev);
  8623. +               lbm_drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0);
  8624. +               lbm_drm_connector_attach_property(connector, dev->mode_config.dvi_i_select_subconnector_property, 0);
  8625.         }
  8626.  
  8627.         if (type != DRM_MODE_CONNECTOR_LVDS)
  8628.  -780,9 +801,9 @@
  8629.             type == DRM_MODE_CONNECTOR_DisplayPort) {
  8630.                 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN;
  8631.  
  8632. -               drm_connector_attach_property(connector, dev->mode_config.scaling_mode_property,
  8633. +               lbm_drm_connector_attach_property(connector, dev->mode_config.scaling_mode_property,
  8634.                                               nv_connector->scaling_mode);
  8635. -               drm_connector_attach_property(connector, dev->mode_config.dithering_mode_property,
  8636. +               lbm_drm_connector_attach_property(connector, dev->mode_config.dithering_mode_property,
  8637.                                               nv_connector->use_dithering ? DRM_MODE_DITHERING_ON
  8638.                                               : DRM_MODE_DITHERING_OFF);
  8639.  
  8640.  -791,7 +812,7 @@
  8641.  
  8642.                 if (type == DRM_MODE_CONNECTOR_VGA  &&
  8643.                                 dev_priv->card_type >= NV_50) {
  8644. -                       drm_connector_attach_property(connector,
  8645. +                       lbm_drm_connector_attach_property(connector,
  8646.                                         dev->mode_config.scaling_mode_property,
  8647.                                         nv_connector->scaling_mode);
  8648.                 }
  8649.  -807,10 +828,10 @@
  8650.                 if (get_slave_funcs(nv_encoder))
  8651.                         get_slave_funcs(nv_encoder)->create_resources(encoder, connector);
  8652.  
  8653. -               drm_mode_connector_attach_encoder(connector, encoder);
  8654. +               lbm_drm_mode_connector_attach_encoder(connector, encoder);
  8655.         }
  8656.  
  8657. -       drm_sysfs_connector_add(connector);
  8658. +       lbm_drm_sysfs_connector_add(connector);
  8659.  
  8660.         if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) {
  8661.                 ret = nouveau_connector_create_lvds(dev, connector);
  8662. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_debugfs.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_debugfs.c
  8663. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_debugfs.c     2010-01-25 15:21:29.000000000 -0500
  8664. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_debugfs.c     2010-02-03 17:11:09.000000000 -0500
  8665.  -79,7 +79,7 @@
  8666.         chan->debugfs.info.driver_features = 0;
  8667.         chan->debugfs.info.data = chan;
  8668.  
  8669. -       ret = drm_debugfs_create_files(&chan->debugfs.info, 1,
  8670. +       ret = lbm_drm_debugfs_create_files(&chan->debugfs.info, 1,
  8671.                                        dev_priv->debugfs.channel_root,
  8672.                                        chan->dev->primary);
  8673.         if (ret == 0)
  8674.  -95,7 +95,7 @@
  8675.         if (!chan->debugfs.active)
  8676.                 return;
  8677.  
  8678. -       drm_debugfs_remove_files(&chan->debugfs.info, 1, chan->dev->primary);
  8679. +       lbm_drm_debugfs_remove_files(&chan->debugfs.info, 1, chan->dev->primary);
  8680.         chan->debugfs.active = false;
  8681.  
  8682.         if (chan == dev_priv->channel) {
  8683.  -142,7 +142,7 @@
  8684.  int
  8685.  nouveau_debugfs_init(struct drm_minor *minor)
  8686.  {
  8687. -       drm_debugfs_create_files(nouveau_debugfs_list, NOUVEAU_DEBUGFS_ENTRIES,
  8688. +       lbm_drm_debugfs_create_files(nouveau_debugfs_list, NOUVEAU_DEBUGFS_ENTRIES,
  8689.                                  minor->debugfs_root, minor);
  8690.         return 0;
  8691.  }
  8692.  -150,6 +150,6 @@
  8693.  void
  8694.  nouveau_debugfs_takedown(struct drm_minor *minor)
  8695.  {
  8696. -       drm_debugfs_remove_files(nouveau_debugfs_list, NOUVEAU_DEBUGFS_ENTRIES,
  8697. +       lbm_drm_debugfs_remove_files(nouveau_debugfs_list, NOUVEAU_DEBUGFS_ENTRIES,
  8698.                                  minor);
  8699.  }
  8700. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_display.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_display.c
  8701. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_display.c     2010-01-25 15:21:29.000000000 -0500
  8702. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_display.c     2010-02-03 17:11:09.000000000 -0500
  8703.  -45,7 +45,7 @@
  8704.                 mutex_unlock(&dev->struct_mutex);
  8705.         }
  8706.  
  8707. -       drm_framebuffer_cleanup(drm_fb);
  8708. +       lbm_drm_framebuffer_cleanup(drm_fb);
  8709.         kfree(fb);
  8710.  }
  8711.  
  8712.  -56,7 +56,7 @@
  8713.  {
  8714.         struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
  8715.  
  8716. -       return drm_gem_handle_create(file_priv, fb->nvbo->gem, handle);
  8717. +       return lbm_drm_gem_handle_create(file_priv, fb->nvbo->gem, handle);
  8718.  }
  8719.  
  8720.  static const struct drm_framebuffer_funcs nouveau_framebuffer_funcs = {
  8721.  -75,13 +75,13 @@
  8722.         if (!fb)
  8723.                 return NULL;
  8724.  
  8725. -       ret = drm_framebuffer_init(dev, &fb->base, &nouveau_framebuffer_funcs);
  8726. +       ret = lbm_drm_framebuffer_init(dev, &fb->base, &nouveau_framebuffer_funcs);
  8727.         if (ret) {
  8728.                 kfree(fb);
  8729.                 return NULL;
  8730.         }
  8731.  
  8732. -       drm_helper_mode_fill_fb_struct(&fb->base, mode_cmd);
  8733. +       lbm_drm_helper_mode_fill_fb_struct(&fb->base, mode_cmd);
  8734.  
  8735.         fb->nvbo = nvbo;
  8736.         return &fb->base;
  8737.  -95,7 +95,7 @@
  8738.         struct drm_framebuffer *fb;
  8739.         struct drm_gem_object *gem;
  8740.  
  8741. -       gem = drm_gem_object_lookup(dev, file_priv, mode_cmd->handle);
  8742. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, mode_cmd->handle);
  8743.         if (!gem)
  8744.                 return NULL;
  8745.  
  8746. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dma.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dma.c
  8747. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dma.c 2010-01-25 15:21:29.000000000 -0500
  8748. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dma.c 2010-02-03 17:11:09.000000000 -0500
  8749.  -126,47 +126,52 @@
  8750.         chan->dma.cur += nr_dwords;
  8751.  }
  8752.  
  8753. -static inline bool
  8754. -READ_GET(struct nouveau_channel *chan, uint32_t *get)
  8755. +/* Fetch and adjust GPU GET pointer
  8756. + *
  8757. + * Returns:
  8758. + *  value >= 0, the adjusted GET pointer
  8759. + *  -EINVAL if GET pointer currently outside main push buffer
  8760. + *  -EBUSY if timeout exceeded
  8761. + */
  8762. +static inline int
  8763. +READ_GET(struct nouveau_channel *chan, uint32_t *prev_get, uint32_t *timeout)
  8764.  {
  8765.         uint32_t val;
  8766.  
  8767.         val = nvchan_rd32(chan, chan->user_get);
  8768. -       if (val < chan->pushbuf_base ||
  8769. -           val > chan->pushbuf_base + (chan->dma.max << 2)) {
  8770. -               /* meaningless to dma_wait() except to know whether the
  8771. -                * GPU has stalled or not
  8772. -                */
  8773. -               *get = val;
  8774. -               return false;
  8775. +
  8776. +       /* reset counter as long as GET is still advancing, this is
  8777. +        * to avoid misdetecting a GPU lockup if the GPU happens to
  8778. +        * just be processing an operation that takes a long time
  8779. +        */
  8780. +       if (val != *prev_get) {
  8781. +               *prev_get = val;
  8782. +               *timeout = 0;
  8783.         }
  8784.  
  8785. -       *get = (val - chan->pushbuf_base) >> 2;
  8786. -       return true;
  8787. +       if ((++*timeout & 0xff) == 0) {
  8788. +               DRM_UDELAY(1);
  8789. +               if (*timeout > 100000)
  8790. +                       return -EBUSY;
  8791. +       }
  8792. +
  8793. +       if (val < chan->pushbuf_base ||
  8794. +           val > chan->pushbuf_base + (chan->dma.max << 2))
  8795. +               return -EINVAL;
  8796. +
  8797. +       return (val - chan->pushbuf_base) >> 2;
  8798.  }
  8799.  
  8800.  int
  8801.  nouveau_dma_wait(struct nouveau_channel *chan, int size)
  8802.  {
  8803. -       uint32_t get, prev_get = 0, cnt = 0;
  8804. -       bool get_valid;
  8805. +       uint32_t prev_get = 0, cnt = 0;
  8806. +       int get;
  8807.  
  8808.         while (chan->dma.free < size) {
  8809. -               /* reset counter as long as GET is still advancing, this is
  8810. -                * to avoid misdetecting a GPU lockup if the GPU happens to
  8811. -                * just be processing an operation that takes a long time
  8812. -                */
  8813. -               get_valid = READ_GET(chan, &get);
  8814. -               if (get != prev_get) {
  8815. -                       prev_get = get;
  8816. -                       cnt = 0;
  8817. -               }
  8818. -
  8819. -               if ((++cnt & 0xff) == 0) {
  8820. -                       DRM_UDELAY(1);
  8821. -                       if (cnt > 100000)
  8822. -                               return -EBUSY;
  8823. -               }
  8824. +               get = READ_GET(chan, &prev_get, &cnt);
  8825. +               if (unlikely(get == -EBUSY))
  8826. +                       return -EBUSY;
  8827.  
  8828.                 /* loop until we have a usable GET pointer.  the value
  8829.                  * we read from the GPU may be outside the main ring if
  8830.  -177,7 +182,7 @@
  8831.                  * from the SKIPS area, so the code below doesn't have to deal
  8832.                  * with some fun corner cases.
  8833.                  */
  8834. -               if (!get_valid || get < NOUVEAU_DMA_SKIPS)
  8835. +               if (unlikely(get == -EINVAL) || get < NOUVEAU_DMA_SKIPS)
  8836.                         continue;
  8837.  
  8838.                 if (get <= chan->dma.cur) {
  8839.  -203,6 +208,19 @@
  8840.                          * after processing the currently pending commands.
  8841.                          */
  8842.                         OUT_RING(chan, chan->pushbuf_base | 0x20000000);
  8843. +
  8844. +                       /* wait for GET to depart from the skips area.
  8845. +                        * prevents writing GET==PUT and causing a race
  8846. +                        * condition that causes us to think the GPU is
  8847. +                        * idle when it's not.
  8848. +                        */
  8849. +                       do {
  8850. +                               get = READ_GET(chan, &prev_get, &cnt);
  8851. +                               if (unlikely(get == -EBUSY))
  8852. +                                       return -EBUSY;
  8853. +                               if (unlikely(get == -EINVAL))
  8854. +                                       continue;
  8855. +                       } while (get <= NOUVEAU_DMA_SKIPS);
  8856.                         WRITE_PUT(NOUVEAU_DMA_SKIPS);
  8857.  
  8858.                         /* we're now submitting commands at the start of
  8859. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dp.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dp.c
  8860. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dp.c  2010-01-25 15:21:29.000000000 -0500
  8861. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_dp.c  2010-02-03 17:11:09.000000000 -0500
  8862.  -490,7 +490,8 @@
  8863.                 if (!nv_wait(NV50_AUXCH_CTRL(index), 0x00010000, 0x00000000)) {
  8864.                         NV_ERROR(dev, "expected bit 16 == 0, got 0x%08x\n",
  8865.                                  nv_rd32(dev, NV50_AUXCH_CTRL(index)));
  8866. -                       return -EBUSY;
  8867. +                       ret = -EBUSY;
  8868. +                       goto out;
  8869.                 }
  8870.  
  8871.                 udelay(400);
  8872.  -501,6 +502,11 @@
  8873.                         break;
  8874.         }
  8875.  
  8876. +       if ((stat & NV50_AUXCH_STAT_COUNT) != data_nr) {
  8877. +               ret = -EREMOTEIO;
  8878. +               goto out;
  8879. +       }
  8880. +
  8881.         if (cmd & 1) {
  8882.                 for (i = 0; i < 4; i++) {
  8883.                         data32[i] = nv_rd32(dev, NV50_AUXCH_DATA_IN(index, i));
  8884. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.c
  8885. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.c 2010-01-25 15:21:29.000000000 -0500
  8886. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.c 2010-02-03 17:11:09.000000000 -0500
  8887.  -71,6 +71,10 @@
  8888.  int nouveau_uscript_tmds = -1;
  8889.  module_param_named(uscript_tmds, nouveau_uscript_tmds, int, 0400);
  8890.  
  8891. +MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
  8892. +int nouveau_ignorelid = 0;
  8893. +module_param_named(ignorelid, nouveau_ignorelid, int, 0400);
  8894. +
  8895.  MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
  8896.                  "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, NTSC-M, NTSC-J,\n"
  8897.                  "\t\t\thd480i, hd480p, hd576i, hd576p, hd720p, hd1080i.\n"
  8898.  -112,7 +116,7 @@
  8899.  static int __devinit
  8900.  nouveau_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
  8901.  {
  8902. -       return drm_get_dev(pdev, ent, &driver);
  8903. +       return lbm_drm_get_dev(pdev, ent, &driver);
  8904.  }
  8905.  
  8906.  static void
  8907.  -120,7 +124,7 @@
  8908.  {
  8909.         struct drm_device *dev = pci_get_drvdata(pdev);
  8910.  
  8911. -       drm_put_dev(dev);
  8912. +       lbm_drm_put_dev(dev);
  8913.  }
  8914.  
  8915.  static int
  8916.  -156,7 +160,7 @@
  8917.         }
  8918.  
  8919.         NV_INFO(dev, "Evicting buffers...\n");
  8920. -       ttm_bo_evict_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
  8921. +       lbm_ttm_bo_evict_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
  8922.  
  8923.         NV_INFO(dev, "Idling channels...\n");
  8924.         for (i = 0; i < pfifo->channels; i++) {
  8925.  -315,7 +319,7 @@
  8926.  
  8927.         nouveau_fbcon_zfill(dev);
  8928.  
  8929. -       drm_helper_resume_force_mode(dev);
  8930. +       lbm_drm_helper_resume_force_mode(dev);
  8931.         dev_priv->fbdev_info->flags = fbdev_flags;
  8932.         return 0;
  8933.  }
  8934.  -337,18 +341,18 @@
  8935.         .irq_postinstall = nouveau_irq_postinstall,
  8936.         .irq_uninstall = nouveau_irq_uninstall,
  8937.         .irq_handler = nouveau_irq_handler,
  8938. -       .reclaim_buffers = drm_core_reclaim_buffers,
  8939. -       .get_map_ofs = drm_core_get_map_ofs,
  8940. -       .get_reg_ofs = drm_core_get_reg_ofs,
  8941. +       .reclaim_buffers = lbm_drm_core_reclaim_buffers,
  8942. +       .get_map_ofs = lbm_drm_core_get_map_ofs,
  8943. +       .get_reg_ofs = lbm_drm_core_get_reg_ofs,
  8944.         .ioctls = nouveau_ioctls,
  8945.         .fops = {
  8946.                 .owner = THIS_MODULE,
  8947. -               .open = drm_open,
  8948. -               .release = drm_release,
  8949. -               .unlocked_ioctl = drm_ioctl,
  8950. +               .open = lbm_drm_open,
  8951. +               .release = lbm_drm_release,
  8952. +               .unlocked_ioctl = lbm_drm_ioctl,
  8953.                 .mmap = nouveau_ttm_mmap,
  8954. -               .poll = drm_poll,
  8955. -               .fasync = drm_fasync,
  8956. +               .poll = lbm_drm_poll,
  8957. +               .fasync = lbm_drm_fasync,
  8958.  #if defined(CONFIG_COMPAT)
  8959.                 .compat_ioctl = nouveau_compat_ioctl,
  8960.  #endif
  8961.  -393,12 +397,12 @@
  8962.         if (nouveau_modeset == 1)
  8963.                 driver.driver_features |= DRIVER_MODESET;
  8964.  
  8965. -       return drm_init(&driver);
  8966. +       return lbm_drm_init(&driver);
  8967.  }
  8968.  
  8969.  static void __exit nouveau_exit(void)
  8970.  {
  8971. -       drm_exit(&driver);
  8972. +       lbm_drm_exit(&driver);
  8973.  }
  8974.  
  8975.  module_init(nouveau_init);
  8976. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.h linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.h
  8977. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.h 2010-01-25 15:21:29.000000000 -0500
  8978. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_drv.h 2010-02-03 17:11:09.000000000 -0500
  8979.  -79,7 +79,7 @@
  8980.         struct ttm_bo_kmap_obj kmap;
  8981.         struct list_head head;
  8982.  
  8983. -       /* protected by ttm_bo_reserve() */
  8984. +       /* protected by lbm_ttm_bo_reserve() */
  8985.         struct drm_file *reserved_by;
  8986.         struct list_head entry;
  8987.         int pbbo_index;
  8988.  -509,6 +509,8 @@
  8989.         void __iomem *ramin;
  8990.         uint32_t ramin_size;
  8991.  
  8992. +       struct nouveau_bo *vga_ram;
  8993. +
  8994.         struct workqueue_struct *wq;
  8995.         struct work_struct irq_work;
  8996.  
  8997.  -639,7 +641,7 @@
  8998.         if (prev) {
  8999.                 struct ttm_buffer_object *bo = &prev->bo;
  9000.  
  9001. -               ttm_bo_unref(&bo);
  9002. +               lbm_ttm_bo_unref(&bo);
  9003.         }
  9004.  
  9005.         return 0;
  9006.  -675,6 +677,7 @@
  9007.  extern int nouveau_reg_debug;
  9008.  extern char *nouveau_vbios;
  9009.  extern int nouveau_ctxfw;
  9010. +extern int nouveau_ignorelid;
  9011.  
  9012.  /* nouveau_state.c */
  9013.  extern void nouveau_preclose(struct drm_device *dev, struct drm_file *);
  9014.  -1256,24 +1259,24 @@
  9015.                                         pci_name(d->pdev), ##arg)
  9016.  #ifndef NV_DEBUG_NOTRACE
  9017.  #define NV_DEBUG(d, fmt, arg...) do {                                          \
  9018. -       if (drm_debug & DRM_UT_DRIVER) {                                       \
  9019. +       if (lbm_drm_debug & DRM_UT_DRIVER) {                                       \
  9020.                 NV_PRINTK(KERN_DEBUG, d, "%s:%d - " fmt, __func__,             \
  9021.                           __LINE__, ##arg);                                    \
  9022.         }                                                                      \
  9023.  } while (0)
  9024.  #define NV_DEBUG_KMS(d, fmt, arg...) do {                                      \
  9025. -       if (drm_debug & DRM_UT_KMS) {                                          \
  9026. +       if (lbm_drm_debug & DRM_UT_KMS) {                                          \
  9027.                 NV_PRINTK(KERN_DEBUG, d, "%s:%d - " fmt, __func__,             \
  9028.                           __LINE__, ##arg);                                    \
  9029.         }                                                                      \
  9030.  } while (0)
  9031.  #else
  9032.  #define NV_DEBUG(d, fmt, arg...) do {                                          \
  9033. -       if (drm_debug & DRM_UT_DRIVER)                                         \
  9034. +       if (lbm_drm_debug & DRM_UT_DRIVER)                                         \
  9035.                 NV_PRINTK(KERN_DEBUG, d, fmt, ##arg);                          \
  9036.  } while (0)
  9037.  #define NV_DEBUG_KMS(d, fmt, arg...) do {                                      \
  9038. -       if (drm_debug & DRM_UT_KMS)                                            \
  9039. +       if (lbm_drm_debug & DRM_UT_KMS)                                            \
  9040.                 NV_PRINTK(KERN_DEBUG, d, fmt, ##arg);                          \
  9041.  } while (0)
  9042.  #endif
  9043. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_fbcon.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_fbcon.c
  9044. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_fbcon.c       2010-01-25 15:21:29.000000000 -0500
  9045. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_fbcon.c       2010-02-03 17:11:08.000000000 -0500
  9046.  -95,16 +95,16 @@
  9047.  
  9048.  static struct fb_ops nouveau_fbcon_ops = {
  9049.         .owner = THIS_MODULE,
  9050. -       .fb_check_var = drm_fb_helper_check_var,
  9051. -       .fb_set_par = drm_fb_helper_set_par,
  9052. -       .fb_setcolreg = drm_fb_helper_setcolreg,
  9053. +       .fb_check_var = lbm_drm_fb_helper_check_var,
  9054. +       .fb_set_par = lbm_drm_fb_helper_set_par,
  9055. +       .fb_setcolreg = lbm_drm_fb_helper_setcolreg,
  9056.         .fb_fillrect = cfb_fillrect,
  9057.         .fb_copyarea = cfb_copyarea,
  9058.         .fb_imageblit = cfb_imageblit,
  9059.         .fb_sync = nouveau_fbcon_sync,
  9060. -       .fb_pan_display = drm_fb_helper_pan_display,
  9061. -       .fb_blank = drm_fb_helper_blank,
  9062. -       .fb_setcmap = drm_fb_helper_setcmap,
  9063. +       .fb_pan_display = lbm_drm_fb_helper_pan_display,
  9064. +       .fb_blank = lbm_drm_fb_helper_blank,
  9065. +       .fb_setcmap = lbm_drm_fb_helper_setcmap,
  9066.  };
  9067.  
  9068.  static void nouveau_fbcon_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
  9069.  -261,7 +261,7 @@
  9070.         par = info->par;
  9071.         par->helper.funcs = &nouveau_fbcon_helper_funcs;
  9072.         par->helper.dev = dev;
  9073. -       ret = drm_fb_helper_init_crtc_count(&par->helper, 2, 4);
  9074. +       ret = lbm_drm_fb_helper_init_crtc_count(&par->helper, 2, 4);
  9075.         if (ret)
  9076.                 goto out_unref;
  9077.         dev_priv->fbdev_info = info;
  9078.  -277,8 +277,8 @@
  9079.         info->screen_base = nvbo_kmap_obj_iovirtual(nouveau_fb->nvbo);
  9080.         info->screen_size = size;
  9081.  
  9082. -       drm_fb_helper_fill_fix(info, fb->pitch, fb->depth);
  9083. -       drm_fb_helper_fill_var(info, fb, fb_width, fb_height);
  9084. +       lbm_drm_fb_helper_fill_fix(info, fb->pitch, fb->depth);
  9085. +       lbm_drm_fb_helper_fill_var(info, fb, fb_width, fb_height);
  9086.  
  9087.         /* FIXME: we really shouldn't expose mmio space at all */
  9088.         info->fix.mmio_start = pci_resource_start(dev->pdev, 1);
  9089.  -349,7 +349,7 @@
  9090.  {
  9091.         NV_DEBUG_KMS(dev, "\n");
  9092.  
  9093. -       return drm_fb_helper_single_fb_probe(dev, 32, nouveau_fbcon_create);
  9094. +       return lbm_drm_fb_helper_single_fb_probe(dev, 32, nouveau_fbcon_create);
  9095.  }
  9096.  
  9097.  int
  9098.  -372,7 +372,7 @@
  9099.                 nouveau_fb->nvbo = NULL;
  9100.                 mutex_unlock(&dev->struct_mutex);
  9101.                 if (par)
  9102. -                       drm_fb_helper_free(&par->helper);
  9103. +                       lbm_drm_fb_helper_free(&par->helper);
  9104.                 framebuffer_release(info);
  9105.         }
  9106.  
  9107. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_gem.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_gem.c
  9108. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_gem.c 2010-01-25 15:21:29.000000000 -0500
  9109. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_gem.c 2010-02-03 17:11:09.000000000 -0500
  9110.  -49,14 +49,14 @@
  9111.         nvbo->gem = NULL;
  9112.  
  9113.         if (unlikely(nvbo->cpu_filp))
  9114. -               ttm_bo_synccpu_write_release(bo);
  9115. +               lbm_ttm_bo_synccpu_write_release(bo);
  9116.  
  9117.         if (unlikely(nvbo->pin_refcnt)) {
  9118.                 nvbo->pin_refcnt = 1;
  9119.                 nouveau_bo_unpin(nvbo);
  9120.         }
  9121.  
  9122. -       ttm_bo_unref(&bo);
  9123. +       lbm_ttm_bo_unref(&bo);
  9124.  }
  9125.  
  9126.  int
  9127.  -74,7 +74,7 @@
  9128.                 return ret;
  9129.         nvbo = *pnvbo;
  9130.  
  9131. -       nvbo->gem = drm_gem_object_alloc(dev, nvbo->bo.mem.size);
  9132. +       nvbo->gem = lbm_drm_gem_object_alloc(dev, nvbo->bo.mem.size);
  9133.         if (!nvbo->gem) {
  9134.                 nouveau_bo_ref(NULL, pnvbo);
  9135.                 return -ENOMEM;
  9136.  -165,7 +165,7 @@
  9137.         if (ret)
  9138.                 goto out;
  9139.  
  9140. -       ret = drm_gem_handle_create(file_priv, nvbo->gem, &req->info.handle);
  9141. +       ret = lbm_drm_gem_handle_create(file_priv, nvbo->gem, &req->info.handle);
  9142.  out:
  9143.         mutex_lock(&dev->struct_mutex);
  9144.         drm_gem_object_handle_unreference(nvbo->gem);
  9145.  -245,7 +245,7 @@
  9146.  
  9147.                 list_del(&nvbo->entry);
  9148.                 nvbo->reserved_by = NULL;
  9149. -               ttm_bo_unreserve(&nvbo->bo);
  9150. +               lbm_ttm_bo_unreserve(&nvbo->bo);
  9151.                 drm_gem_object_unreference(nvbo->gem);
  9152.         }
  9153.  }
  9154.  -281,7 +281,7 @@
  9155.                 struct drm_gem_object *gem;
  9156.                 struct nouveau_bo *nvbo;
  9157.  
  9158. -               gem = drm_gem_object_lookup(dev, file_priv, b->handle);
  9159. +               gem = lbm_drm_gem_object_lookup(dev, file_priv, b->handle);
  9160.                 if (!gem) {
  9161.                         NV_ERROR(dev, "Unknown handle 0x%08x\n", b->handle);
  9162.                         validate_fini(op, NULL);
  9163.  -296,11 +296,11 @@
  9164.                         return -EINVAL;
  9165.                 }
  9166.  
  9167. -               ret = ttm_bo_reserve(&nvbo->bo, false, false, true, sequence);
  9168. +               ret = lbm_ttm_bo_reserve(&nvbo->bo, false, false, true, sequence);
  9169.                 if (ret) {
  9170.                         validate_fini(op, NULL);
  9171.                         if (ret == -EAGAIN)
  9172. -                               ret = ttm_bo_wait_unreserved(&nvbo->bo, false);
  9173. +                               ret = lbm_ttm_bo_wait_unreserved(&nvbo->bo, false);
  9174.                         drm_gem_object_unreference(gem);
  9175.                         if (ret)
  9176.                                 return ret;
  9177.  -321,6 +321,7 @@
  9178.                 else {
  9179.                         NV_ERROR(dev, "invalid valid domains: 0x%08x\n",
  9180.                                  b->valid_domains);
  9181. +                       list_add_tail(&nvbo->entry, &op->both_list);
  9182.                         validate_fini(op, NULL);
  9183.                         return -EINVAL;
  9184.                 }
  9185.  -334,7 +335,7 @@
  9186.                                 return -EINVAL;
  9187.                         }
  9188.  
  9189. -                       ret = ttm_bo_wait_cpu(&nvbo->bo, false);
  9190. +                       ret = lbm_ttm_bo_wait_cpu(&nvbo->bo, false);
  9191.                         if (ret)
  9192.                                 return ret;
  9193.                         goto retry;
  9194.  -359,7 +360,7 @@
  9195.  
  9196.                 if (prev_fence && nouveau_fence_channel(prev_fence) != chan) {
  9197.                         spin_lock(&nvbo->bo.lock);
  9198. -                       ret = ttm_bo_wait(&nvbo->bo, false, false, false);
  9199. +                       ret = lbm_ttm_bo_wait(&nvbo->bo, false, false, false);
  9200.                         spin_unlock(&nvbo->bo.lock);
  9201.                         if (unlikely(ret))
  9202.                                 return ret;
  9203.  -372,7 +373,7 @@
  9204.                         return ret;
  9205.  
  9206.                 nvbo->channel = chan;
  9207. -               ret = ttm_bo_validate(&nvbo->bo, &nvbo->placement,
  9208. +               ret = lbm_ttm_bo_validate(&nvbo->bo, &nvbo->placement,
  9209.                                       false, false);
  9210.                 nvbo->channel = NULL;
  9211.                 if (unlikely(ret))
  9212.  -466,13 +467,14 @@
  9213.  static int
  9214.  nouveau_gem_pushbuf_reloc_apply(struct nouveau_channel *chan, int nr_bo,
  9215.                                 struct drm_nouveau_gem_pushbuf_bo *bo,
  9216. -                               int nr_relocs, uint64_t ptr_relocs,
  9217. -                               int nr_dwords, int first_dword,
  9218. +                               unsigned nr_relocs, uint64_t ptr_relocs,
  9219. +                               unsigned nr_dwords, unsigned first_dword,
  9220.                                 uint32_t *pushbuf, bool is_iomem)
  9221.  {
  9222.         struct drm_nouveau_gem_pushbuf_reloc *reloc = NULL;
  9223.         struct drm_device *dev = chan->dev;
  9224. -       int ret = 0, i;
  9225. +       int ret = 0;
  9226. +       unsigned i;
  9227.  
  9228.         reloc = u_memcpya(ptr_relocs, nr_relocs, sizeof(*reloc));
  9229.         if (IS_ERR(reloc))
  9230.  -659,7 +661,7 @@
  9231.         }
  9232.  
  9233.         /* Validate DMA push buffer */
  9234. -       gem = drm_gem_object_lookup(dev, file_priv, req->handle);
  9235. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, req->handle);
  9236.         if (!gem) {
  9237.                 NV_ERROR(dev, "Unknown pb handle 0x%08x\n", req->handle);
  9238.                 ret = -EINVAL;
  9239.  -667,7 +669,19 @@
  9240.         }
  9241.         pbbo = nouveau_gem_object(gem);
  9242.  
  9243. -       ret = ttm_bo_reserve(&pbbo->bo, false, false, true,
  9244. +       if ((req->offset & 3) || req->nr_dwords < 2 ||
  9245. +           (unsigned long)req->offset > (unsigned long)pbbo->bo.mem.size ||
  9246. +           (unsigned long)req->nr_dwords >
  9247. +            ((unsigned long)(pbbo->bo.mem.size - req->offset ) >> 2)) {
  9248. +               NV_ERROR(dev, "pb call misaligned or out of bounds: "
  9249. +                             "%d + %d * 4 > %ld\n",
  9250. +                        req->offset, req->nr_dwords, pbbo->bo.mem.size);
  9251. +               ret = -EINVAL;
  9252. +               drm_gem_object_unreference(gem);
  9253. +               goto out;
  9254. +       }
  9255. +
  9256. +       ret = lbm_ttm_bo_reserve(&pbbo->bo, false, false, true,
  9257.                              chan->fence.sequence);
  9258.         if (ret) {
  9259.                 NV_ERROR(dev, "resv pb: %d\n", ret);
  9260.  -676,10 +690,10 @@
  9261.         }
  9262.  
  9263.         nouveau_bo_placement_set(pbbo, 1 << chan->pushbuf_bo->bo.mem.mem_type);
  9264. -       ret = ttm_bo_validate(&pbbo->bo, &pbbo->placement, false, false);
  9265. +       ret = lbm_ttm_bo_validate(&pbbo->bo, &pbbo->placement, false, false);
  9266.         if (ret) {
  9267.                 NV_ERROR(dev, "validate pb: %d\n", ret);
  9268. -               ttm_bo_unreserve(&pbbo->bo);
  9269. +               lbm_ttm_bo_unreserve(&pbbo->bo);
  9270.                 drm_gem_object_unreference(gem);
  9271.                 goto out;
  9272.         }
  9273.  -712,7 +726,7 @@
  9274.         if (do_reloc) {
  9275.                 void *pbvirt;
  9276.                 bool is_iomem;
  9277. -               ret = ttm_bo_kmap(&pbbo->bo, 0, pbbo->bo.mem.num_pages,
  9278. +               ret = lbm_ttm_bo_kmap(&pbbo->bo, 0, pbbo->bo.mem.num_pages,
  9279.                                   &pbbo->kmap);
  9280.                 if (ret) {
  9281.                         NV_ERROR(dev, "kmap pb: %d\n", ret);
  9282.  -733,7 +747,7 @@
  9283.                                         req->suffix0);
  9284.                 }
  9285.  
  9286. -               ttm_bo_kunmap(&pbbo->kmap);
  9287. +               lbm_ttm_bo_kunmap(&pbbo->kmap);
  9288.                 if (ret) {
  9289.                         NV_ERROR(dev, "reloc apply: %d\n", ret);
  9290.                         goto out;
  9291.  -835,7 +849,7 @@
  9292.         if (!DRM_SUSER(DRM_CURPROC))
  9293.                 return -EPERM;
  9294.  
  9295. -       gem = drm_gem_object_lookup(dev, file_priv, req->handle);
  9296. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, req->handle);
  9297.         if (!gem)
  9298.                 return -EINVAL;
  9299.         nvbo = nouveau_gem_object(gem);
  9300.  -871,7 +885,7 @@
  9301.         if (drm_core_check_feature(dev, DRIVER_MODESET))
  9302.                 return -EINVAL;
  9303.  
  9304. -       gem = drm_gem_object_lookup(dev, file_priv, req->handle);
  9305. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, req->handle);
  9306.         if (!gem)
  9307.                 return -EINVAL;
  9308.  
  9309.  -896,7 +910,7 @@
  9310.  
  9311.         NOUVEAU_CHECK_INITIALISED_WITH_RETURN;
  9312.  
  9313. -       gem = drm_gem_object_lookup(dev, file_priv, req->handle);
  9314. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, req->handle);
  9315.         if (!gem)
  9316.                 return ret;
  9317.         nvbo = nouveau_gem_object(gem);
  9318.  -905,15 +919,15 @@
  9319.                 if (nvbo->cpu_filp == file_priv)
  9320.                         goto out;
  9321.  
  9322. -               ret = ttm_bo_wait_cpu(&nvbo->bo, no_wait);
  9323. +               ret = lbm_ttm_bo_wait_cpu(&nvbo->bo, no_wait);
  9324.                 if (ret)
  9325.                         goto out;
  9326.         }
  9327.  
  9328.         if (req->flags & NOUVEAU_GEM_CPU_PREP_NOBLOCK) {
  9329. -               ret = ttm_bo_wait(&nvbo->bo, false, false, no_wait);
  9330. +               ret = lbm_ttm_bo_wait(&nvbo->bo, false, false, no_wait);
  9331.         } else {
  9332. -               ret = ttm_bo_synccpu_write_grab(&nvbo->bo, no_wait);
  9333. +               ret = lbm_ttm_bo_synccpu_write_grab(&nvbo->bo, no_wait);
  9334.                 if (ret == 0)
  9335.                         nvbo->cpu_filp = file_priv;
  9336.         }
  9337.  -936,7 +950,7 @@
  9338.  
  9339.         NOUVEAU_CHECK_INITIALISED_WITH_RETURN;
  9340.  
  9341. -       gem = drm_gem_object_lookup(dev, file_priv, req->handle);
  9342. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, req->handle);
  9343.         if (!gem)
  9344.                 return ret;
  9345.         nvbo = nouveau_gem_object(gem);
  9346.  -945,7 +959,7 @@
  9347.                 goto out;
  9348.         nvbo->cpu_filp = NULL;
  9349.  
  9350. -       ttm_bo_synccpu_write_release(&nvbo->bo);
  9351. +       lbm_ttm_bo_synccpu_write_release(&nvbo->bo);
  9352.         ret = 0;
  9353.  
  9354.  out:
  9355.  -965,7 +979,7 @@
  9356.  
  9357.         NOUVEAU_CHECK_INITIALISED_WITH_RETURN;
  9358.  
  9359. -       gem = drm_gem_object_lookup(dev, file_priv, req->handle);
  9360. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, req->handle);
  9361.         if (!gem)
  9362.                 return -EINVAL;
  9363.  
  9364. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_i2c.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_i2c.c
  9365. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_i2c.c 2010-01-25 15:21:29.000000000 -0500
  9366. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_i2c.c 2010-02-03 17:11:08.000000000 -0500
  9367.  -226,7 +226,7 @@
  9368.                 i2c->algo.dp.running = false;
  9369.                 i2c->algo.dp.address = 0;
  9370.                 i2c->algo.dp.aux_ch = nouveau_dp_i2c_aux_ch;
  9371. -               ret = i2c_dp_aux_add_bus(&i2c->adapter);
  9372. +               ret = lbm_i2c_dp_aux_add_bus(&i2c->adapter);
  9373.         }
  9374.  
  9375.         if (ret) {
  9376. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ioc32.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ioc32.c
  9377. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ioc32.c       2010-01-25 15:21:29.000000000 -0500
  9378. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ioc32.c       2010-02-03 17:11:09.000000000 -0500
  9379.  -55,7 +55,7 @@
  9380.         int ret;
  9381.  
  9382.         if (nr < DRM_COMMAND_BASE)
  9383. -               return drm_compat_ioctl(filp, cmd, arg);
  9384. +               return lbm_drm_compat_ioctl(filp, cmd, arg);
  9385.  
  9386.  #if 0
  9387.         if (nr < DRM_COMMAND_BASE + DRM_ARRAY_SIZE(mga_compat_ioctls))
  9388.  -64,7 +64,7 @@
  9389.         if (fn != NULL)
  9390.                 ret = (*fn)(filp, cmd, arg);
  9391.         else
  9392. -               ret = drm_ioctl(filp, cmd, arg);
  9393. +               ret = lbm_drm_ioctl(filp, cmd, arg);
  9394.  
  9395.         return ret;
  9396.  }
  9397. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_irq.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_irq.c
  9398. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_irq.c 2010-01-25 15:21:29.000000000 -0500
  9399. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_irq.c 2010-02-03 17:11:08.000000000 -0500
  9400.  -483,6 +483,13 @@
  9401.         if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
  9402.                 if (nouveau_pgraph_intr_swmthd(dev, &trap))
  9403.                         unhandled = 1;
  9404. +       } else if (nsource & NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION) {
  9405. +               uint32_t v = nv_rd32(dev, 0x402000);
  9406. +               nv_wr32(dev, 0x402000, v);
  9407. +
  9408. +               /* dump the error anyway for now: it's useful for
  9409. +                  Gallium development */
  9410. +               unhandled = 1;
  9411.         } else {
  9412.                 unhandled = 1;
  9413.         }
  9414. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_mem.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_mem.c
  9415. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_mem.c 2010-01-25 15:21:29.000000000 -0500
  9416. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_mem.c 2010-02-03 17:11:09.000000000 -0500
  9417.  -383,11 +383,10 @@
  9418.  {
  9419.         struct drm_nouveau_private *dev_priv = dev->dev_private;
  9420.  
  9421. -       if (dev_priv->ttm.bdev.man[TTM_PL_PRIV0].has_type)
  9422. -               ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_PRIV0);
  9423. -       ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
  9424. +       nouveau_bo_unpin(dev_priv->vga_ram);
  9425. +       nouveau_bo_ref(NULL, &dev_priv->vga_ram);
  9426.  
  9427. -       ttm_bo_device_release(&dev_priv->ttm.bdev);
  9428. +       lbm_ttm_bo_device_release(&dev_priv->ttm.bdev);
  9429.  
  9430.         nouveau_ttm_global_release(dev_priv);
  9431.  
  9432.  -399,22 +398,22 @@
  9433.                    intact until drv_cleanup is called. */
  9434.                 list_for_each_entry_safe(entry, tempe, &dev->agp->memory, head) {
  9435.                         if (entry->bound)
  9436. -                               drm_unbind_agp(entry->memory);
  9437. -                       drm_free_agp(entry->memory, entry->pages);
  9438. +                               lbm_drm_unbind_agp(entry->memory);
  9439. +                       lbm_drm_free_agp(entry->memory, entry->pages);
  9440.                         kfree(entry);
  9441.                 }
  9442.                 INIT_LIST_HEAD(&dev->agp->memory);
  9443.  
  9444.                 if (dev->agp->acquired)
  9445. -                       drm_agp_release(dev);
  9446. +                       lbm_drm_agp_release(dev);
  9447.  
  9448.                 dev->agp->acquired = 0;
  9449.                 dev->agp->enabled = 0;
  9450.         }
  9451.  
  9452.         if (dev_priv->fb_mtrr) {
  9453. -               drm_mtrr_del(dev_priv->fb_mtrr, drm_get_resource_start(dev, 1),
  9454. -                            drm_get_resource_len(dev, 1), DRM_MTRR_WC);
  9455. +               drm_mtrr_del(dev_priv->fb_mtrr, lbm_drm_get_resource_start(dev, 1),
  9456. +                            lbm_drm_get_resource_len(dev, 1), DRM_MTRR_WC);
  9457.                 dev_priv->fb_mtrr = 0;
  9458.         }
  9459.  }
  9460.  -526,7 +525,7 @@
  9461.  {
  9462.  #if __OS_HAS_AGP
  9463.         struct drm_nouveau_private *dev_priv = dev->dev_private;
  9464. -       struct drm_agp_info info;
  9465. +       struct lbm_drm_agp_info info;
  9466.         struct drm_agp_mode mode;
  9467.         int ret;
  9468.  
  9469.  -536,14 +535,14 @@
  9470.         nouveau_mem_reset_agp(dev);
  9471.  
  9472.         if (!dev->agp->acquired) {
  9473. -               ret = drm_agp_acquire(dev);
  9474. +               ret = lbm_drm_agp_acquire(dev);
  9475.                 if (ret) {
  9476.                         NV_ERROR(dev, "Unable to acquire AGP: %d\n", ret);
  9477.                         return ret;
  9478.                 }
  9479.         }
  9480.  
  9481. -       ret = drm_agp_info(dev, &info);
  9482. +       ret = lbm_drm_agp_info(dev, &info);
  9483.         if (ret) {
  9484.                 NV_ERROR(dev, "Unable to get AGP info: %d\n", ret);
  9485.                 return ret;
  9486.  -551,7 +550,7 @@
  9487.  
  9488.         /* see agp.h for the AGPSTAT_* modes available */
  9489.         mode.mode = info.mode;
  9490. -       ret = drm_agp_enable(dev, mode);
  9491. +       ret = lbm_drm_agp_enable(dev, mode);
  9492.         if (ret) {
  9493.                 NV_ERROR(dev, "Unable to enable AGP: %d\n", ret);
  9494.                 return ret;
  9495.  -571,7 +570,7 @@
  9496.         struct ttm_bo_device *bdev = &dev_priv->ttm.bdev;
  9497.         int ret, dma_bits = 32;
  9498.  
  9499. -       dev_priv->fb_phys = drm_get_resource_start(dev, 1);
  9500. +       dev_priv->fb_phys = lbm_drm_get_resource_start(dev, 1);
  9501.         dev_priv->gart_info.type = NOUVEAU_GART_NONE;
  9502.  
  9503.         if (dev_priv->card_type >= NV_50 &&
  9504.  -588,7 +587,7 @@
  9505.         if (ret)
  9506.                 return ret;
  9507.  
  9508. -       ret = ttm_bo_device_init(&dev_priv->ttm.bdev,
  9509. +       ret = lbm_ttm_bo_device_init(&dev_priv->ttm.bdev,
  9510.                                  dev_priv->ttm.bo_global_ref.ref.object,
  9511.                                  &nouveau_bo_driver, DRM_FILE_PAGE_OFFSET,
  9512.                                  dma_bits <= 32 ? true : false);
  9513.  -604,8 +603,8 @@
  9514.         dev_priv->fb_available_size = nouveau_mem_fb_amount(dev);
  9515.  
  9516.         dev_priv->fb_mappable_pages = dev_priv->fb_available_size;
  9517. -       if (dev_priv->fb_mappable_pages > drm_get_resource_len(dev, 1))
  9518. -               dev_priv->fb_mappable_pages = drm_get_resource_len(dev, 1);
  9519. +       if (dev_priv->fb_mappable_pages > lbm_drm_get_resource_len(dev, 1))
  9520. +               dev_priv->fb_mappable_pages = lbm_drm_get_resource_len(dev, 1);
  9521.         dev_priv->fb_mappable_pages >>= PAGE_SHIFT;
  9522.  
  9523.         NV_INFO(dev, "%d MiB VRAM\n", (int)(dev_priv->fb_available_size >> 20));
  9524.  -615,13 +614,22 @@
  9525.         dev_priv->fb_aper_free = dev_priv->fb_available_size;
  9526.  
  9527.         /* mappable vram */
  9528. -       ret = ttm_bo_init_mm(bdev, TTM_PL_VRAM,
  9529. +       ret = lbm_ttm_bo_init_mm(bdev, TTM_PL_VRAM,
  9530.                              dev_priv->fb_available_size >> PAGE_SHIFT);
  9531.         if (ret) {
  9532.                 NV_ERROR(dev, "Failed VRAM mm init: %d\n", ret);
  9533.                 return ret;
  9534.         }
  9535.  
  9536. +       ret = nouveau_bo_new(dev, NULL, 256*1024, 0, TTM_PL_FLAG_VRAM,
  9537. +                            0, 0, true, true, &dev_priv->vga_ram);
  9538. +       if (ret == 0)
  9539. +               ret = nouveau_bo_pin(dev_priv->vga_ram, TTM_PL_FLAG_VRAM);
  9540. +       if (ret) {
  9541. +               NV_WARN(dev, "failed to reserve VGA memory\n");
  9542. +               nouveau_bo_ref(NULL, &dev_priv->vga_ram);
  9543. +       }
  9544. +
  9545.         /* GART */
  9546.  #if !defined(__powerpc__) && !defined(__ia64__)
  9547.         if (drm_device_is_agp(dev) && dev->agp) {
  9548.  -643,16 +651,17 @@
  9549.                 (int)(dev_priv->gart_info.aper_size >> 20));
  9550.         dev_priv->gart_info.aper_free = dev_priv->gart_info.aper_size;
  9551.  
  9552. -       ret = ttm_bo_init_mm(bdev, TTM_PL_TT,
  9553. +       ret = lbm_ttm_bo_init_mm(bdev, TTM_PL_TT,
  9554.                              dev_priv->gart_info.aper_size >> PAGE_SHIFT);
  9555.         if (ret) {
  9556.                 NV_ERROR(dev, "Failed TT mm init: %d\n", ret);
  9557.                 return ret;
  9558.         }
  9559.  
  9560. -       dev_priv->fb_mtrr = drm_mtrr_add(drm_get_resource_start(dev, 1),
  9561. -                                        drm_get_resource_len(dev, 1),
  9562. +       dev_priv->fb_mtrr = drm_mtrr_add(lbm_drm_get_resource_start(dev, 1),
  9563. +                                        lbm_drm_get_resource_len(dev, 1),
  9564.                                          DRM_MTRR_WC);
  9565. +
  9566.         return 0;
  9567.  }
  9568.  
  9569. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_object.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_object.c
  9570. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_object.c      2010-01-25 15:21:29.000000000 -0500
  9571. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_object.c      2010-02-03 17:11:09.000000000 -0500
  9572.  -261,7 +261,7 @@
  9573.  
  9574.         /* Allocate a chunk of the PRAMIN aperture */
  9575.         gpuobj->im_pramin = nouveau_mem_alloc_block(pramin, size,
  9576. -                                                   drm_order(align),
  9577. +                                                   lbm_drm_order(align),
  9578.                                                     (struct drm_file *)-2, 0);
  9579.         if (!gpuobj->im_pramin) {
  9580.                 nouveau_gpuobj_del(dev, &gpuobj);
  9581. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_state.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_state.c
  9582. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_state.c       2010-01-25 15:21:29.000000000 -0500
  9583. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_state.c       2010-02-03 17:11:08.000000000 -0500
  9584.  -440,11 +440,11 @@
  9585.         /* this call irq_preinstall, register irq handler and
  9586.          * call irq_postinstall
  9587.          */
  9588. -       ret = drm_irq_install(dev);
  9589. +       ret = lbm_drm_irq_install(dev);
  9590.         if (ret)
  9591.                 goto out_fifo;
  9592.  
  9593. -       ret = drm_vblank_init(dev, 0);
  9594. +       ret = lbm_drm_vblank_init(dev, 0);
  9595.         if (ret)
  9596.                 goto out_irq;
  9597.  
  9598.  -472,12 +472,12 @@
  9599.         dev_priv->init_state = NOUVEAU_CARD_INIT_DONE;
  9600.  
  9601.         if (drm_core_check_feature(dev, DRIVER_MODESET))
  9602. -               drm_helper_initial_config(dev);
  9603. +               lbm_drm_helper_initial_config(dev);
  9604.  
  9605.         return 0;
  9606.  
  9607.  out_irq:
  9608. -       drm_irq_uninstall(dev);
  9609. +       lbm_drm_irq_uninstall(dev);
  9610.  out_fifo:
  9611.         engine->fifo.takedown(dev);
  9612.  out_graph:
  9613.  -525,7 +525,8 @@
  9614.                 engine->mc.takedown(dev);
  9615.  
  9616.                 mutex_lock(&dev->struct_mutex);
  9617. -               ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_TT);
  9618. +               lbm_ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
  9619. +               lbm_ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_TT);
  9620.                 mutex_unlock(&dev->struct_mutex);
  9621.                 nouveau_sgdma_takedown(dev);
  9622.  
  9623.  -534,7 +535,7 @@
  9624.                 engine->instmem.takedown(dev);
  9625.  
  9626.                 if (drm_core_check_feature(dev, DRIVER_MODESET))
  9627. -                       drm_irq_uninstall(dev);
  9628. +                       lbm_drm_irq_uninstall(dev);
  9629.  
  9630.                 nouveau_gpuobj_late_takedown(dev);
  9631.                 nouveau_bios_takedown(dev);
  9632. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ttm.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ttm.c
  9633. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ttm.c 2010-01-25 15:21:29.000000000 -0500
  9634. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nouveau_ttm.c 2010-02-03 17:11:08.000000000 -0500
  9635.  -36,21 +36,21 @@
  9636.                 file_priv->minor->dev->dev_private;
  9637.  
  9638.         if (unlikely(vma->vm_pgoff < DRM_FILE_PAGE_OFFSET))
  9639. -               return drm_mmap(filp, vma);
  9640. +               return lbm_drm_mmap(filp, vma);
  9641.  
  9642. -       return ttm_bo_mmap(filp, vma, &dev_priv->ttm.bdev);
  9643. +       return lbm_ttm_bo_mmap(filp, vma, &dev_priv->ttm.bdev);
  9644.  }
  9645.  
  9646.  static int
  9647.  nouveau_ttm_mem_global_init(struct ttm_global_reference *ref)
  9648.  {
  9649. -       return ttm_mem_global_init(ref->object);
  9650. +       return lbm_ttm_mem_global_init(ref->object);
  9651.  }
  9652.  
  9653.  static void
  9654.  nouveau_ttm_mem_global_release(struct ttm_global_reference *ref)
  9655.  {
  9656. -       ttm_mem_global_release(ref->object);
  9657. +       lbm_ttm_mem_global_release(ref->object);
  9658.  }
  9659.  
  9660.  int
  9661.  -65,7 +65,7 @@
  9662.         global_ref->init = &nouveau_ttm_mem_global_init;
  9663.         global_ref->release = &nouveau_ttm_mem_global_release;
  9664.  
  9665. -       ret = ttm_global_item_ref(global_ref);
  9666. +       ret = lbm_ttm_global_item_ref(global_ref);
  9667.         if (unlikely(ret != 0)) {
  9668.                 DRM_ERROR("Failed setting up TTM memory accounting\n");
  9669.                 dev_priv->ttm.mem_global_ref.release = NULL;
  9670.  -76,13 +76,13 @@
  9671.         global_ref = &dev_priv->ttm.bo_global_ref.ref;
  9672.         global_ref->global_type = TTM_GLOBAL_TTM_BO;
  9673.         global_ref->size = sizeof(struct ttm_bo_global);
  9674. -       global_ref->init = &ttm_bo_global_init;
  9675. -       global_ref->release = &ttm_bo_global_release;
  9676. +       global_ref->init = &lbm_ttm_bo_global_init;
  9677. +       global_ref->release = &lbm_ttm_bo_global_release;
  9678.  
  9679. -       ret = ttm_global_item_ref(global_ref);
  9680. +       ret = lbm_ttm_global_item_ref(global_ref);
  9681.         if (unlikely(ret != 0)) {
  9682.                 DRM_ERROR("Failed setting up TTM BO subsystem\n");
  9683. -               ttm_global_item_unref(&dev_priv->ttm.mem_global_ref);
  9684. +               lbm_ttm_global_item_unref(&dev_priv->ttm.mem_global_ref);
  9685.                 dev_priv->ttm.mem_global_ref.release = NULL;
  9686.                 return ret;
  9687.         }
  9688.  -96,8 +96,8 @@
  9689.         if (dev_priv->ttm.mem_global_ref.release == NULL)
  9690.                 return;
  9691.  
  9692. -       ttm_global_item_unref(&dev_priv->ttm.bo_global_ref.ref);
  9693. -       ttm_global_item_unref(&dev_priv->ttm.mem_global_ref);
  9694. +       lbm_ttm_global_item_unref(&dev_priv->ttm.bo_global_ref.ref);
  9695. +       lbm_ttm_global_item_unref(&dev_priv->ttm.mem_global_ref);
  9696.         dev_priv->ttm.mem_global_ref.release = NULL;
  9697.  }
  9698.  
  9699. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_crtc.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_crtc.c
  9700. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_crtc.c   2010-01-25 15:21:29.000000000 -0500
  9701. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_crtc.c   2010-02-03 17:11:09.000000000 -0500
  9702.  -604,7 +604,7 @@
  9703.         struct drm_nouveau_private *dev_priv = dev->dev_private;
  9704.  
  9705.         NV_DEBUG_KMS(dev, "CTRC mode on CRTC %d:\n", nv_crtc->index);
  9706. -       drm_mode_debug_printmodeline(adjusted_mode);
  9707. +       lbm_drm_mode_debug_printmodeline(adjusted_mode);
  9708.  
  9709.         /* unlock must come after turning off FP_TG_CONTROL in output_prepare */
  9710.         nv_lock_vga_crtc_shadow(dev, nv_crtc->index, -1);
  9711.  -708,7 +708,7 @@
  9712.         if (!nv_crtc)
  9713.                 return;
  9714.  
  9715. -       drm_crtc_cleanup(crtc);
  9716. +       lbm_drm_crtc_cleanup(crtc);
  9717.  
  9718.         nouveau_bo_ref(NULL, &nv_crtc->cursor.nvbo);
  9719.         kfree(nv_crtc);
  9720.  -907,7 +907,7 @@
  9721.                 return 0;
  9722.         }
  9723.  
  9724. -       gem = drm_gem_object_lookup(dev, file_priv, buffer_handle);
  9725. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, buffer_handle);
  9726.         if (!gem)
  9727.                 return -EINVAL;
  9728.         cursor = nouveau_gem_object(gem);
  9729.  -947,7 +947,7 @@
  9730.         .cursor_set = nv04_crtc_cursor_set,
  9731.         .cursor_move = nv04_crtc_cursor_move,
  9732.         .gamma_set = nv_crtc_gamma_set,
  9733. -       .set_config = drm_crtc_helper_set_config,
  9734. +       .set_config = lbm_drm_crtc_helper_set_config,
  9735.         .destroy = nv_crtc_destroy,
  9736.  };
  9737.  
  9738.  -981,9 +981,9 @@
  9739.         nv_crtc->index = crtc_num;
  9740.         nv_crtc->last_dpms = NV_DPMS_CLEARED;
  9741.  
  9742. -       drm_crtc_init(dev, &nv_crtc->base, &nv04_crtc_funcs);
  9743. +       lbm_drm_crtc_init(dev, &nv_crtc->base, &nv04_crtc_funcs);
  9744.         drm_crtc_helper_add(&nv_crtc->base, &nv04_crtc_helper_funcs);
  9745. -       drm_mode_crtc_set_gamma_size(&nv_crtc->base, 256);
  9746. +       lbm_drm_mode_crtc_set_gamma_size(&nv_crtc->base, 256);
  9747.  
  9748.         ret = nouveau_bo_new(dev, NULL, 64*64*4, 0x100, TTM_PL_FLAG_VRAM,
  9749.                              0, 0x0000, false, true, &nv_crtc->cursor.nvbo);
  9750. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dac.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dac.c
  9751. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dac.c    2010-01-25 15:21:29.000000000 -0500
  9752. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dac.c    2010-02-03 17:11:09.000000000 -0500
  9753.  -396,7 +396,7 @@
  9754.         helper->dpms(encoder, DRM_MODE_DPMS_ON);
  9755.  
  9756.         NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
  9757. -               drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
  9758. +               lbm_drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
  9759.                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
  9760.  }
  9761.  
  9762.  -467,7 +467,7 @@
  9763.  
  9764.         NV_DEBUG_KMS(encoder->dev, "\n");
  9765.  
  9766. -       drm_encoder_cleanup(encoder);
  9767. +       lbm_drm_encoder_cleanup(encoder);
  9768.         kfree(nv_encoder);
  9769.  }
  9770.  
  9771.  -517,7 +517,7 @@
  9772.         else
  9773.                 helper = &nv04_dac_helper_funcs;
  9774.  
  9775. -       drm_encoder_init(dev, encoder, &nv04_dac_funcs, DRM_MODE_ENCODER_DAC);
  9776. +       lbm_drm_encoder_init(dev, encoder, &nv04_dac_funcs, DRM_MODE_ENCODER_DAC);
  9777.         drm_encoder_helper_add(encoder, helper);
  9778.  
  9779.         encoder->possible_crtcs = entry->heads;
  9780. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dfp.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dfp.c
  9781. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dfp.c    2010-01-25 15:21:29.000000000 -0500
  9782. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_dfp.c    2010-02-03 17:11:08.000000000 -0500
  9783.  -262,7 +262,7 @@
  9784.         uint32_t mode_ratio, panel_ratio;
  9785.  
  9786.         NV_DEBUG_KMS(dev, "Output mode on CRTC %d:\n", nv_crtc->index);
  9787. -       drm_mode_debug_printmodeline(output_mode);
  9788. +       lbm_drm_mode_debug_printmodeline(output_mode);
  9789.  
  9790.         /* Initialize the FP registers in this CRTC. */
  9791.         regp->fp_horiz_regs[FP_DISPLAY_END] = output_mode->hdisplay - 1;
  9792.  -414,7 +414,7 @@
  9793.         int head = nouveau_crtc(encoder->crtc)->index;
  9794.  
  9795.         NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
  9796. -               drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
  9797. +               lbm_drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
  9798.                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
  9799.  
  9800.         if (dcbe->type == OUTPUT_TMDS)
  9801.  -436,7 +436,7 @@
  9802.         helper->dpms(encoder, DRM_MODE_DPMS_ON);
  9803.  
  9804.         NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
  9805. -               drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
  9806. +               lbm_drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
  9807.                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
  9808.  }
  9809.  
  9810.  -554,7 +554,7 @@
  9811.  
  9812.         NV_DEBUG_KMS(encoder->dev, "\n");
  9813.  
  9814. -       drm_encoder_cleanup(encoder);
  9815. +       lbm_drm_encoder_cleanup(encoder);
  9816.         kfree(nv_encoder);
  9817.  }
  9818.  
  9819.  -613,7 +613,7 @@
  9820.         nv_encoder->dcb = entry;
  9821.         nv_encoder->or = ffs(entry->or) - 1;
  9822.  
  9823. -       drm_encoder_init(dev, encoder, &nv04_dfp_funcs, type);
  9824. +       lbm_drm_encoder_init(dev, encoder, &nv04_dfp_funcs, type);
  9825.         drm_encoder_helper_add(encoder, helper);
  9826.  
  9827.         encoder->possible_crtcs = entry->heads;
  9828. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_display.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_display.c
  9829. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_display.c        2010-01-25 15:21:29.000000000 -0500
  9830. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_display.c        2010-02-03 17:11:08.000000000 -0500
  9831.  -105,9 +105,9 @@
  9832.                 nv04_display_store_initial_head_owner(dev);
  9833.         nouveau_hw_save_vga_fonts(dev, 1);
  9834.  
  9835. -       drm_mode_config_init(dev);
  9836. -       drm_mode_create_scaling_mode_property(dev);
  9837. -       drm_mode_create_dithering_property(dev);
  9838. +       lbm_drm_mode_config_init(dev);
  9839. +       lbm_drm_mode_create_scaling_mode_property(dev);
  9840. +       lbm_drm_mode_create_dithering_property(dev);
  9841.  
  9842.         dev->mode_config.funcs = (void *)&nouveau_mode_config_funcs;
  9843.  
  9844.  -245,7 +245,7 @@
  9845.         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
  9846.                 crtc->funcs->restore(crtc);
  9847.  
  9848. -       drm_mode_config_cleanup(dev);
  9849. +       lbm_drm_mode_config_cleanup(dev);
  9850.  
  9851.         nouveau_hw_save_vga_fonts(dev, 0);
  9852.  }
  9853. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_instmem.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_instmem.c
  9854. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_instmem.c        2010-01-25 15:21:29.000000000 -0500
  9855. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_instmem.c        2010-02-03 17:11:08.000000000 -0500
  9856.  -30,7 +30,7 @@
  9857.                  * of vram.  For now, only reserve a small piece until we know
  9858.                  * more about what each chipset requires.
  9859.                  */
  9860. -               switch (dev_priv->chipset & 0xf0) {
  9861. +               switch (dev_priv->chipset) {
  9862.                 case 0x40:
  9863.                 case 0x47:
  9864.                 case 0x49:
  9865. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_tv.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_tv.c
  9866. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_tv.c     2010-01-25 15:21:29.000000000 -0500
  9867. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv04_tv.c     2010-02-03 17:11:09.000000000 -0500
  9868.  -208,7 +208,7 @@
  9869.         helper->dpms(encoder, DRM_MODE_DPMS_ON);
  9870.  
  9871.         NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
  9872. -                     drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base), nv_crtc->index,
  9873. +                     lbm_drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base), nv_crtc->index,
  9874.                       '@' + ffs(nv_encoder->dcb->or));
  9875.  }
  9876.  
  9877.  -218,7 +218,7 @@
  9878.  
  9879.         to_encoder_slave(encoder)->slave_funcs->destroy(encoder);
  9880.  
  9881. -       drm_encoder_cleanup(encoder);
  9882. +       lbm_drm_encoder_cleanup(encoder);
  9883.  
  9884.         kfree(nv_encoder);
  9885.  }
  9886.  -252,7 +252,7 @@
  9887.         funcs = &nv04_tv_encoder_info[type].funcs;
  9888.         hfuncs = &nv04_tv_encoder_info[type].hfuncs;
  9889.  
  9890. -       drm_encoder_init(dev, encoder, funcs, DRM_MODE_ENCODER_TVDAC);
  9891. +       lbm_drm_encoder_init(dev, encoder, funcs, DRM_MODE_ENCODER_TVDAC);
  9892.         drm_encoder_helper_add(encoder, hfuncs);
  9893.  
  9894.         encoder->possible_crtcs = entry->heads;
  9895.  -266,7 +266,7 @@
  9896.  
  9897.         was_locked = NVLockVgaCrtcs(dev, false);
  9898.  
  9899. -       ret = drm_i2c_encoder_init(encoder->dev, to_encoder_slave(encoder), adap,
  9900. +       ret = lbm_drm_i2c_encoder_init(encoder->dev, to_encoder_slave(encoder), adap,
  9901.                                    &nv04_tv_encoder_info[type].board_info);
  9902.  
  9903.         NVLockVgaCrtcs(dev, was_locked);
  9904.  -298,7 +298,7 @@
  9905.         return 0;
  9906.  
  9907.  fail:
  9908. -       drm_encoder_cleanup(encoder);
  9909. +       lbm_drm_encoder_cleanup(encoder);
  9910.  
  9911.         kfree(nv_encoder);
  9912.         return ret;
  9913. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv17_tv.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv17_tv.c
  9914. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv17_tv.c     2010-01-25 15:21:29.000000000 -0500
  9915. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv17_tv.c     2010-02-03 17:11:09.000000000 -0500
  9916.  -150,7 +150,7 @@
  9917.                 break;
  9918.         }
  9919.  
  9920. -       drm_connector_property_set_value(connector,
  9921. +       lbm_drm_connector_property_set_value(connector,
  9922.                                          conf->tv_subconnector_property,
  9923.                                          tv_enc->subconnector);
  9924.  
  9925.  -191,7 +191,7 @@
  9926.                 struct drm_display_mode *tv_mode;
  9927.  
  9928.                 for (tv_mode = nv17_tv_modes; tv_mode->hdisplay; tv_mode++) {
  9929. -                       mode = drm_mode_duplicate(encoder->dev, tv_mode);
  9930. +                       mode = lbm_drm_mode_duplicate(encoder->dev, tv_mode);
  9931.  
  9932.                         mode->clock = tv_norm->tv_enc_mode.vrefresh *
  9933.                                                 mode->htotal / 1000 *
  9934.  -204,7 +204,7 @@
  9935.                             mode->vdisplay == tv_norm->tv_enc_mode.vdisplay)
  9936.                                 mode->type |= DRM_MODE_TYPE_PREFERRED;
  9937.  
  9938. -                       drm_mode_probed_add(connector, mode);
  9939. +                       lbm_drm_mode_probed_add(connector, mode);
  9940.                         n++;
  9941.                 }
  9942.                 return n;
  9943.  -219,10 +219,10 @@
  9944.  
  9945.                 if (modes[i].hdisplay == output_mode->hdisplay &&
  9946.                     modes[i].vdisplay == output_mode->vdisplay) {
  9947. -                       mode = drm_mode_duplicate(encoder->dev, output_mode);
  9948. +                       mode = lbm_drm_mode_duplicate(encoder->dev, output_mode);
  9949.                         mode->type |= DRM_MODE_TYPE_PREFERRED;
  9950.                 } else {
  9951. -                       mode = drm_cvt_mode(encoder->dev, modes[i].hdisplay,
  9952. +                       mode = lbm_drm_cvt_mode(encoder->dev, modes[i].hdisplay,
  9953.                                 modes[i].vdisplay, 60, false,
  9954.                                 output_mode->flags & DRM_MODE_FLAG_INTERLACE,
  9955.                                 false);
  9956.  -243,7 +243,7 @@
  9957.                 }
  9958.  
  9959.                 mode->type |= DRM_MODE_TYPE_DRIVER;
  9960. -               drm_mode_probed_add(connector, mode);
  9961. +               lbm_drm_mode_probed_add(connector, mode);
  9962.                 n++;
  9963.         }
  9964.         return n;
  9965.  -278,7 +278,7 @@
  9966.                 if (mode->clock > 70000)
  9967.                         return MODE_CLOCK_HIGH;
  9968.  
  9969. -               if (abs(drm_mode_vrefresh(mode) * 1000 -
  9970. +               if (abs(lbm_drm_mode_vrefresh(mode) * 1000 -
  9971.                         tv_norm->tv_enc_mode.vrefresh) > vsync_tolerance)
  9972.                         return MODE_VSYNC;
  9973.  
  9974.  -550,7 +550,7 @@
  9975.         helper->dpms(encoder, DRM_MODE_DPMS_ON);
  9976.  
  9977.         NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
  9978. -               drm_get_connector_name(
  9979. +               lbm_drm_get_connector_name(
  9980.                         &nouveau_encoder_connector_get(nv_encoder)->base),
  9981.                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
  9982.  }
  9983.  -605,27 +605,27 @@
  9984.                                 nouveau_tv_norm);
  9985.         }
  9986.  
  9987. -       drm_mode_create_tv_properties(dev, num_tv_norms, nv17_tv_norm_names);
  9988. +       lbm_drm_mode_create_tv_properties(dev, num_tv_norms, nv17_tv_norm_names);
  9989.  
  9990. -       drm_connector_attach_property(connector,
  9991. +       lbm_drm_connector_attach_property(connector,
  9992.                                         conf->tv_select_subconnector_property,
  9993.                                         tv_enc->select_subconnector);
  9994. -       drm_connector_attach_property(connector,
  9995. +       lbm_drm_connector_attach_property(connector,
  9996.                                         conf->tv_subconnector_property,
  9997.                                         tv_enc->subconnector);
  9998. -       drm_connector_attach_property(connector,
  9999. +       lbm_drm_connector_attach_property(connector,
  10000.                                         conf->tv_mode_property,
  10001.                                         tv_enc->tv_norm);
  10002. -       drm_connector_attach_property(connector,
  10003. +       lbm_drm_connector_attach_property(connector,
  10004.                                         conf->tv_flicker_reduction_property,
  10005.                                         tv_enc->flicker);
  10006. -       drm_connector_attach_property(connector,
  10007. +       lbm_drm_connector_attach_property(connector,
  10008.                                         conf->tv_saturation_property,
  10009.                                         tv_enc->saturation);
  10010. -       drm_connector_attach_property(connector,
  10011. +       lbm_drm_connector_attach_property(connector,
  10012.                                         conf->tv_hue_property,
  10013.                                         tv_enc->hue);
  10014. -       drm_connector_attach_property(connector,
  10015. +       lbm_drm_connector_attach_property(connector,
  10016.                                         conf->tv_overscan_property,
  10017.                                         tv_enc->overscan);
  10018.  
  10019.  -694,7 +694,7 @@
  10020.         }
  10021.  
  10022.         if (modes_changed) {
  10023. -               drm_helper_probe_single_connector_modes(connector, 0, 0);
  10024. +               lbm_drm_helper_probe_single_connector_modes(connector, 0, 0);
  10025.  
  10026.                 /* Disable the crtc to ensure a full modeset is
  10027.                  * performed whenever it's turned on again. */
  10028.  -716,7 +716,7 @@
  10029.  
  10030.         NV_DEBUG_KMS(encoder->dev, "\n");
  10031.  
  10032. -       drm_encoder_cleanup(encoder);
  10033. +       lbm_drm_encoder_cleanup(encoder);
  10034.         kfree(tv_enc);
  10035.  }
  10036.  
  10037.  -765,7 +765,7 @@
  10038.         tv_enc->base.dcb = entry;
  10039.         tv_enc->base.or = ffs(entry->or) - 1;
  10040.  
  10041. -       drm_encoder_init(dev, encoder, &nv17_tv_funcs, DRM_MODE_ENCODER_TVDAC);
  10042. +       lbm_drm_encoder_init(dev, encoder, &nv17_tv_funcs, DRM_MODE_ENCODER_TVDAC);
  10043.         drm_encoder_helper_add(encoder, &nv17_tv_helper_funcs);
  10044.         to_encoder_slave(encoder)->slave_funcs = &nv17_tv_slave_funcs;
  10045.  
  10046. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv20_graph.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv20_graph.c
  10047. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv20_graph.c  2010-01-25 15:21:29.000000000 -0500
  10048. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv20_graph.c  2010-02-03 17:11:09.000000000 -0500
  10049.  -616,7 +616,7 @@
  10050.         nv_wr32(dev, NV10_PGRAPH_SURFACE, tmp);
  10051.  
  10052.         /* begin RAM config */
  10053. -       vramsz = drm_get_resource_len(dev, 0) - 1;
  10054. +       vramsz = lbm_drm_get_resource_len(dev, 0) - 1;
  10055.         nv_wr32(dev, 0x4009A4, nv_rd32(dev, NV04_PFB_CFG0));
  10056.         nv_wr32(dev, 0x4009A8, nv_rd32(dev, NV04_PFB_CFG1));
  10057.         nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0000);
  10058.  -717,7 +717,7 @@
  10059.         nv_wr32(dev, 0x0040075c             , 0x00000001);
  10060.  
  10061.         /* begin RAM config */
  10062. -       /* vramsz = drm_get_resource_len(dev, 0) - 1; */
  10063. +       /* vramsz = lbm_drm_get_resource_len(dev, 0) - 1; */
  10064.         nv_wr32(dev, 0x4009A4, nv_rd32(dev, NV04_PFB_CFG0));
  10065.         nv_wr32(dev, 0x4009A8, nv_rd32(dev, NV04_PFB_CFG1));
  10066.         if (dev_priv->chipset != 0x34) {
  10067. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv40_graph.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv40_graph.c
  10068. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv40_graph.c  2010-01-25 15:21:29.000000000 -0500
  10069. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv40_graph.c  2010-02-03 17:11:09.000000000 -0500
  10070.  -340,7 +340,7 @@
  10071.                 nv40_graph_set_region_tiling(dev, i, 0, 0, 0);
  10072.  
  10073.         /* begin RAM config */
  10074. -       vramsz = drm_get_resource_len(dev, 0) - 1;
  10075. +       vramsz = lbm_drm_get_resource_len(dev, 0) - 1;
  10076.         switch (dev_priv->chipset) {
  10077.         case 0x40:
  10078.                 nv_wr32(dev, 0x4009A4, nv_rd32(dev, NV04_PFB_CFG0));
  10079. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_crtc.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_crtc.c
  10080. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_crtc.c   2010-01-25 15:21:29.000000000 -0500
  10081. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_crtc.c   2010-02-03 17:11:09.000000000 -0500
  10082.  -306,7 +306,7 @@
  10083.         if (!crtc)
  10084.                 return;
  10085.  
  10086. -       drm_crtc_cleanup(&nv_crtc->base);
  10087. +       lbm_drm_crtc_cleanup(&nv_crtc->base);
  10088.  
  10089.         nv50_cursor_fini(nv_crtc);
  10090.  
  10091.  -335,7 +335,7 @@
  10092.                 return 0;
  10093.         }
  10094.  
  10095. -       gem = drm_gem_object_lookup(dev, file_priv, buffer_handle);
  10096. +       gem = lbm_drm_gem_object_lookup(dev, file_priv, buffer_handle);
  10097.         if (!gem)
  10098.                 return -EINVAL;
  10099.         cursor = nouveau_gem_object(gem);
  10100.  -417,7 +417,7 @@
  10101.         .cursor_set = nv50_crtc_cursor_set,
  10102.         .cursor_move = nv50_crtc_cursor_move,
  10103.         .gamma_set = nv50_crtc_gamma_set,
  10104. -       .set_config = drm_crtc_helper_set_config,
  10105. +       .set_config = lbm_drm_crtc_helper_set_config,
  10106.         .destroy = nv50_crtc_destroy,
  10107.  };
  10108.  
  10109.  -432,6 +432,7 @@
  10110.         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
  10111.         struct drm_device *dev = crtc->dev;
  10112.         struct drm_encoder *encoder;
  10113. +       uint32_t dac = 0, sor = 0;
  10114.  
  10115.         NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
  10116.  
  10117.  -439,9 +440,28 @@
  10118.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  10119.                 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
  10120.  
  10121. -               if (drm_helper_encoder_in_use(encoder))
  10122. +               if (!lbm_drm_helper_encoder_in_use(encoder))
  10123.                         continue;
  10124.  
  10125. +               if (nv_encoder->dcb->type == OUTPUT_ANALOG ||
  10126. +                   nv_encoder->dcb->type == OUTPUT_TV)
  10127. +                       dac |= (1 << nv_encoder->or);
  10128. +               else
  10129. +                       sor |= (1 << nv_encoder->or);
  10130. +       }
  10131. +
  10132. +       list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  10133. +               struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
  10134. +
  10135. +               if (nv_encoder->dcb->type == OUTPUT_ANALOG ||
  10136. +                   nv_encoder->dcb->type == OUTPUT_TV) {
  10137. +                       if (dac & (1 << nv_encoder->or))
  10138. +                               continue;
  10139. +               } else {
  10140. +                       if (sor & (1 << nv_encoder->or))
  10141. +                               continue;
  10142. +               }
  10143. +
  10144.                 nv_encoder->disconnect(nv_encoder);
  10145.         }
  10146.  
  10147.  -464,7 +484,7 @@
  10148.  
  10149.         /* Explicitly blank all unused crtc's. */
  10150.         list_for_each_entry(crtc2, &dev->mode_config.crtc_list, head) {
  10151. -               if (!drm_helper_crtc_in_use(crtc2))
  10152. +               if (!lbm_drm_helper_crtc_in_use(crtc2))
  10153.                         nv50_crtc_blank(nouveau_crtc(crtc2), true);
  10154.         }
  10155.  
  10156.  -750,9 +770,9 @@
  10157.         nv_crtc->set_dither = nv50_crtc_set_dither;
  10158.         nv_crtc->set_scale = nv50_crtc_set_scale;
  10159.  
  10160. -       drm_crtc_init(dev, &nv_crtc->base, &nv50_crtc_funcs);
  10161. +       lbm_drm_crtc_init(dev, &nv_crtc->base, &nv50_crtc_funcs);
  10162.         drm_crtc_helper_add(&nv_crtc->base, &nv50_crtc_helper_funcs);
  10163. -       drm_mode_crtc_set_gamma_size(&nv_crtc->base, 256);
  10164. +       lbm_drm_mode_crtc_set_gamma_size(&nv_crtc->base, 256);
  10165.  
  10166.         ret = nouveau_bo_new(dev, NULL, 64*64*4, 0x100, TTM_PL_FLAG_VRAM,
  10167.                              0, 0x0000, false, true, &nv_crtc->cursor.nvbo);
  10168. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_dac.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_dac.c
  10169. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_dac.c    2010-01-25 15:21:29.000000000 -0500
  10170. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_dac.c    2010-02-03 17:11:09.000000000 -0500
  10171.  -266,7 +266,7 @@
  10172.  
  10173.         NV_DEBUG_KMS(encoder->dev, "\n");
  10174.  
  10175. -       drm_encoder_cleanup(encoder);
  10176. +       lbm_drm_encoder_cleanup(encoder);
  10177.         kfree(nv_encoder);
  10178.  }
  10179.  
  10180.  -293,7 +293,7 @@
  10181.  
  10182.         nv_encoder->disconnect = nv50_dac_disconnect;
  10183.  
  10184. -       drm_encoder_init(dev, encoder, &nv50_dac_encoder_funcs,
  10185. +       lbm_drm_encoder_init(dev, encoder, &nv50_dac_encoder_funcs,
  10186.                          DRM_MODE_ENCODER_DAC);
  10187.         drm_encoder_helper_add(encoder, &nv50_dac_helper_funcs);
  10188.  
  10189. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_display.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_display.c
  10190. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_display.c        2010-01-25 15:21:29.000000000 -0500
  10191. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_display.c        2010-02-03 17:11:08.000000000 -0500
  10192.  -472,11 +472,11 @@
  10193.         NV_DEBUG_KMS(dev, "\n");
  10194.  
  10195.         /* init basic kernel modesetting */
  10196. -       drm_mode_config_init(dev);
  10197. +       lbm_drm_mode_config_init(dev);
  10198.  
  10199.         /* Initialise some optional connector properties. */
  10200. -       drm_mode_create_scaling_mode_property(dev);
  10201. -       drm_mode_create_dithering_property(dev);
  10202. +       lbm_drm_mode_create_scaling_mode_property(dev);
  10203. +       lbm_drm_mode_create_dithering_property(dev);
  10204.  
  10205.         dev->mode_config.min_width = 0;
  10206.         dev->mode_config.min_height = 0;
  10207.  -575,7 +575,7 @@
  10208.  
  10209.         NV_DEBUG_KMS(dev, "\n");
  10210.  
  10211. -       drm_mode_config_cleanup(dev);
  10212. +       lbm_drm_mode_config_cleanup(dev);
  10213.  
  10214.         nv50_display_disable(dev);
  10215.         nv50_evo_channel_del(&dev_priv->evo);
  10216.  -955,7 +955,7 @@
  10217.                 reg = nv_rd32(dev, gpio_reg[gpio->line >> 3]);
  10218.                 plugged = !!(reg & (4 << ((gpio->line & 7) << 2)));
  10219.                 NV_INFO(dev, "%splugged %s\n", plugged ? "" : "un",
  10220. -                       drm_get_connector_name(connector)) ;
  10221. +                       lbm_drm_get_connector_name(connector)) ;
  10222.  
  10223.                 if (!connector->encoder || !connector->encoder->crtc ||
  10224.                     !connector->encoder->crtc->enabled)
  10225. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_fifo.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_fifo.c
  10226. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_fifo.c   2010-01-25 15:21:29.000000000 -0500
  10227. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_fifo.c   2010-02-03 17:11:09.000000000 -0500
  10228.  -272,7 +272,7 @@
  10229.                         return ret;
  10230.                 ramfc = chan->ramfc->gpuobj;
  10231.  
  10232. -               ret = nouveau_gpuobj_new_ref(dev, chan, NULL, 0, 4096, 256,
  10233. +               ret = nouveau_gpuobj_new_ref(dev, chan, NULL, 0, 4096, 1024,
  10234.                                              0, &chan->cache);
  10235.                 if (ret)
  10236.                         return ret;
  10237. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_graph.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_graph.c
  10238. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_graph.c  2010-01-25 15:21:29.000000000 -0500
  10239. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_graph.c  2010-02-03 17:11:08.000000000 -0500
  10240.  -84,7 +84,7 @@
  10241.         nv_wr32(dev, 0x400804, 0xc0000000);
  10242.         nv_wr32(dev, 0x406800, 0xc0000000);
  10243.         nv_wr32(dev, 0x400c04, 0xc0000000);
  10244. -       nv_wr32(dev, 0x401804, 0xc0000000);
  10245. +       nv_wr32(dev, 0x401800, 0xc0000000);
  10246.         nv_wr32(dev, 0x405018, 0xc0000000);
  10247.         nv_wr32(dev, 0x402000, 0xc0000000);
  10248.  
  10249.  -282,6 +282,7 @@
  10250.                 return 0;
  10251.         inst &= NV50_PGRAPH_CTXCTL_CUR_INSTANCE;
  10252.  
  10253. +       nouveau_wait_for_idle(dev);
  10254.         nv_wr32(dev, 0x400500, fifo & ~1);
  10255.         nv_wr32(dev, 0x400784, inst);
  10256.         nv_wr32(dev, 0x400824, nv_rd32(dev, 0x400824) | 0x20);
  10257. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_instmem.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_instmem.c
  10258. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_instmem.c        2010-01-25 15:21:29.000000000 -0500
  10259. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_instmem.c        2010-02-03 17:11:09.000000000 -0500
  10260.  -228,7 +228,7 @@
  10261.                 return ret;
  10262.         BAR0_WI32(priv->fb_bar->gpuobj, 0x00, 0x7fc00000);
  10263.         BAR0_WI32(priv->fb_bar->gpuobj, 0x04, 0x40000000 +
  10264. -                                             drm_get_resource_len(dev, 1) - 1);
  10265. +                                             lbm_drm_get_resource_len(dev, 1) - 1);
  10266.         BAR0_WI32(priv->fb_bar->gpuobj, 0x08, 0x40000000);
  10267.         BAR0_WI32(priv->fb_bar->gpuobj, 0x0c, 0x00000000);
  10268.         BAR0_WI32(priv->fb_bar->gpuobj, 0x10, 0x00000000);
  10269. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_sor.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_sor.c
  10270. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_sor.c    2010-01-25 15:21:29.000000000 -0500
  10271. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/nouveau/nv50_sor.c    2010-02-03 17:11:08.000000000 -0500
  10272.  -90,11 +90,24 @@
  10273.  {
  10274.         struct drm_device *dev = encoder->dev;
  10275.         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
  10276. +       struct drm_encoder *enc;
  10277.         uint32_t val;
  10278.         int or = nv_encoder->or;
  10279.  
  10280.         NV_DEBUG_KMS(dev, "or %d mode %d\n", or, mode);
  10281.  
  10282. +       nv_encoder->last_dpms = mode;
  10283. +       list_for_each_entry(enc, &dev->mode_config.encoder_list, head) {
  10284. +               struct nouveau_encoder *nvenc = nouveau_encoder(enc);
  10285. +
  10286. +               if (nvenc == nv_encoder ||
  10287. +                   nvenc->dcb->or != nv_encoder->dcb->or)
  10288. +                       continue;
  10289. +
  10290. +               if (nvenc->last_dpms == DRM_MODE_DPMS_ON)
  10291. +                       return;
  10292. +       }
  10293. +
  10294.         /* wait for it to be done */
  10295.         if (!nv_wait(NV50_PDISPLAY_SOR_DPMS_CTRL(or),
  10296.                      NV50_PDISPLAY_SOR_DPMS_CTRL_PENDING, 0)) {
  10297.  -248,7 +261,7 @@
  10298.  
  10299.         NV_DEBUG_KMS(encoder->dev, "\n");
  10300.  
  10301. -       drm_encoder_cleanup(encoder);
  10302. +       lbm_drm_encoder_cleanup(encoder);
  10303.  
  10304.         kfree(nv_encoder);
  10305.  }
  10306.  -299,7 +312,7 @@
  10307.  
  10308.         nv_encoder->disconnect = nv50_sor_disconnect;
  10309.  
  10310. -       drm_encoder_init(dev, encoder, &nv50_sor_encoder_funcs, type);
  10311. +       lbm_drm_encoder_init(dev, encoder, &nv50_sor_encoder_funcs, type);
  10312.         drm_encoder_helper_add(encoder, &nv50_sor_helper_funcs);
  10313.  
  10314.         encoder->possible_crtcs = entry->heads;
  10315. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/Makefile linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/Makefile
  10316. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/Makefile  2010-01-25 15:21:29.000000000 -0500
  10317. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/Makefile  2010-02-03 17:11:08.000000000 -0500
  10318.  -1,9 +1,9 @@
  10319.  #
  10320.  # Makefile for the drm device driver.  This driver provides support for the
  10321.  
  10322. -ccflags-y := -Iinclude/drm
  10323. -ttm-y := ttm_agp_backend.o ttm_memory.o ttm_tt.o ttm_bo.o \
  10324. +ccflags-y := -I$(M)/nouveau/include/drm -I$(src)/include
  10325. +lbm_ttm-y := ttm_agp_backend.o ttm_memory.o ttm_tt.o ttm_bo.o \
  10326.         ttm_bo_util.o ttm_bo_vm.o ttm_module.o ttm_global.o \
  10327.         ttm_object.o ttm_lock.o ttm_execbuf_util.o
  10328.  
  10329. -obj-$(CONFIG_DRM_TTM) += ttm.o
  10330. +obj-$(CONFIG_DRM_TTM) += lbm_ttm.o
  10331. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_agp_backend.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_agp_backend.c
  10332. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_agp_backend.c 2010-01-25 15:21:29.000000000 -0500
  10333. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_agp_backend.c 2010-02-03 17:11:09.000000000 -0500
  10334.  -129,7 +129,7 @@
  10335.         .destroy = ttm_agp_destroy,
  10336.  };
  10337.  
  10338. -struct ttm_backend *ttm_agp_backend_init(struct ttm_bo_device *bdev,
  10339. +struct ttm_backend *lbm_ttm_agp_backend_init(struct ttm_bo_device *bdev,
  10340.                                          struct agp_bridge_data *bridge)
  10341.  {
  10342.         struct ttm_agp_backend *agp_be;
  10343.  -144,6 +144,6 @@
  10344.         agp_be->backend.bdev = bdev;
  10345.         return &agp_be->backend;
  10346.  }
  10347. -EXPORT_SYMBOL(ttm_agp_backend_init);
  10348. +EXPORT_SYMBOL(lbm_ttm_agp_backend_init);
  10349.  
  10350.  #endif
  10351. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo.c
  10352. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo.c  2010-01-25 15:21:29.000000000 -0500
  10353. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo.c  2010-02-03 17:11:09.000000000 -0500
  10354.  -88,7 +88,7 @@
  10355.                 man->default_caching);
  10356.         if (mem_type != TTM_PL_SYSTEM) {
  10357.                 spin_lock(&bdev->glob->lru_lock);
  10358. -               drm_mm_debug_table(&man->manager, TTM_PFX);
  10359. +               lbm_drm_mm_debug_table(&man->manager, TTM_PFX);
  10360.                 spin_unlock(&bdev->glob->lru_lock);
  10361.         }
  10362.  }
  10363.  -164,12 +164,12 @@
  10364.         if (bo->destroy)
  10365.                 bo->destroy(bo);
  10366.         else {
  10367. -               ttm_mem_global_free(bdev->glob->mem_glob, bo->acc_size);
  10368. +               lbm_ttm_mem_global_free(bdev->glob->mem_glob, bo->acc_size);
  10369.                 kfree(bo);
  10370.         }
  10371.  }
  10372.  
  10373. -int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo, bool interruptible)
  10374. +int lbm_ttm_bo_wait_unreserved(struct ttm_buffer_object *bo, bool interruptible)
  10375.  {
  10376.  
  10377.         if (interruptible) {
  10378.  -184,7 +184,7 @@
  10379.         }
  10380.         return 0;
  10381.  }
  10382. -EXPORT_SYMBOL(ttm_bo_wait_unreserved);
  10383. +EXPORT_SYMBOL(lbm_ttm_bo_wait_unreserved);
  10384.  
  10385.  static void ttm_bo_add_to_lru(struct ttm_buffer_object *bo)
  10386.  {
  10387.  -250,7 +250,7 @@
  10388.                         return -EBUSY;
  10389.  
  10390.                 spin_unlock(&glob->lru_lock);
  10391. -               ret = ttm_bo_wait_unreserved(bo, interruptible);
  10392. +               ret = lbm_ttm_bo_wait_unreserved(bo, interruptible);
  10393.                 spin_lock(&glob->lru_lock);
  10394.  
  10395.                 if (unlikely(ret))
  10396.  -266,14 +266,14 @@
  10397.  
  10398.         return 0;
  10399.  }
  10400. -EXPORT_SYMBOL(ttm_bo_reserve);
  10401. +EXPORT_SYMBOL(lbm_ttm_bo_reserve);
  10402.  
  10403.  static void ttm_bo_ref_bug(struct kref *list_kref)
  10404.  {
  10405.         BUG();
  10406.  }
  10407.  
  10408. -int ttm_bo_reserve(struct ttm_buffer_object *bo,
  10409. +int lbm_ttm_bo_reserve(struct ttm_buffer_object *bo,
  10410.                    bool interruptible,
  10411.                    bool no_wait, bool use_sequence, uint32_t sequence)
  10412.  {
  10413.  -294,7 +294,7 @@
  10414.         return ret;
  10415.  }
  10416.  
  10417. -void ttm_bo_unreserve(struct ttm_buffer_object *bo)
  10418. +void lbm_ttm_bo_unreserve(struct ttm_buffer_object *bo)
  10419.  {
  10420.         struct ttm_bo_global *glob = bo->glob;
  10421.  
  10422.  -304,7 +304,7 @@
  10423.         wake_up_all(&bo->event_queue);
  10424.         spin_unlock(&glob->lru_lock);
  10425.  }
  10426. -EXPORT_SYMBOL(ttm_bo_unreserve);
  10427. +EXPORT_SYMBOL(lbm_ttm_bo_unreserve);
  10428.  
  10429.  /*
  10430.   * Call bo->mutex locked.
  10431.  -368,7 +368,7 @@
  10432.  
  10433.         if (old_is_pci || new_is_pci ||
  10434.             ((mem->placement & bo->mem.placement & TTM_PL_MASK_CACHING) == 0))
  10435. -               ttm_bo_unmap_virtual(bo);
  10436. +               lbm_ttm_bo_unmap_virtual(bo);
  10437.  
  10438.         /*
  10439.          * Create and bind a ttm if required.
  10440.  -379,12 +379,12 @@
  10441.                 if (ret)
  10442.                         goto out_err;
  10443.  
  10444. -               ret = ttm_tt_set_placement_caching(bo->ttm, mem->placement);
  10445. +               ret = lbm_ttm_tt_set_placement_caching(bo->ttm, mem->placement);
  10446.                 if (ret)
  10447.                         goto out_err;
  10448.  
  10449.                 if (mem->mem_type != TTM_PL_SYSTEM) {
  10450. -                       ret = ttm_tt_bind(bo->ttm, mem);
  10451. +                       ret = lbm_ttm_tt_bind(bo->ttm, mem);
  10452.                         if (ret)
  10453.                                 goto out_err;
  10454.                 }
  10455.  -402,12 +402,12 @@
  10456.  
  10457.         if (!(old_man->flags & TTM_MEMTYPE_FLAG_FIXED) &&
  10458.             !(new_man->flags & TTM_MEMTYPE_FLAG_FIXED))
  10459. -               ret = ttm_bo_move_ttm(bo, evict, no_wait, mem);
  10460. +               ret = lbm_ttm_bo_move_ttm(bo, evict, no_wait, mem);
  10461.         else if (bdev->driver->move)
  10462.                 ret = bdev->driver->move(bo, evict, interruptible,
  10463.                                          no_wait, mem);
  10464.         else
  10465. -               ret = ttm_bo_move_memcpy(bo, evict, no_wait, mem);
  10466. +               ret = lbm_ttm_bo_move_memcpy(bo, evict, no_wait, mem);
  10467.  
  10468.         if (ret)
  10469.                 goto out_err;
  10470.  -426,7 +426,8 @@
  10471.                     bdev->man[bo->mem.mem_type].gpu_offset;
  10472.                 bo->cur_placement = bo->mem.placement;
  10473.                 spin_unlock(&bo->lock);
  10474. -       }
  10475. +       } else
  10476. +               bo->offset = 0;
  10477.  
  10478.         return 0;
  10479.  
  10480.  -456,7 +457,7 @@
  10481.         int ret;
  10482.  
  10483.         spin_lock(&bo->lock);
  10484. -       (void) ttm_bo_wait(bo, false, false, !remove_all);
  10485. +       (void) lbm_ttm_bo_wait(bo, false, false, !remove_all);
  10486.  
  10487.         if (!bo->sync_obj) {
  10488.                 int put_count;
  10489.  -477,7 +478,7 @@
  10490.                 }
  10491.                 if (bo->mem.mm_node) {
  10492.                         bo->mem.mm_node->private = NULL;
  10493. -                       drm_mm_put_block(bo->mem.mm_node);
  10494. +                       lbm_drm_mm_put_block(bo->mem.mm_node);
  10495.                         bo->mem.mm_node = NULL;
  10496.                 }
  10497.                 spin_unlock(&glob->lru_lock);
  10498.  -523,52 +524,44 @@
  10499.  static int ttm_bo_delayed_delete(struct ttm_bo_device *bdev, bool remove_all)
  10500.  {
  10501.         struct ttm_bo_global *glob = bdev->glob;
  10502. -       struct ttm_buffer_object *entry, *nentry;
  10503. -       struct list_head *list, *next;
  10504. -       int ret;
  10505. +       struct ttm_buffer_object *entry = NULL;
  10506. +       int ret = 0;
  10507.  
  10508.         spin_lock(&glob->lru_lock);
  10509. -       list_for_each_safe(list, next, &bdev->ddestroy) {
  10510. -               entry = list_entry(list, struct ttm_buffer_object, ddestroy);
  10511. -               nentry = NULL;
  10512. -
  10513. -               /*
  10514. -                * Protect the next list entry from destruction while we
  10515. -                * unlock the lru_lock.
  10516. -                */
  10517. +       if (list_empty(&bdev->ddestroy))
  10518. +               goto out_unlock;
  10519.  
  10520. -               if (next != &bdev->ddestroy) {
  10521. -                       nentry = list_entry(next, struct ttm_buffer_object,
  10522. -                                           ddestroy);
  10523. +       entry = list_first_entry(&bdev->ddestroy,
  10524. +               struct ttm_buffer_object, ddestroy);
  10525. +       kref_get(&entry->list_kref);
  10526. +
  10527. +       for (;;) {
  10528. +               struct ttm_buffer_object *nentry = NULL;
  10529. +
  10530. +               if (entry->ddestroy.next != &bdev->ddestroy) {
  10531. +                       nentry = list_first_entry(&entry->ddestroy,
  10532. +                               struct ttm_buffer_object, ddestroy);
  10533.                         kref_get(&nentry->list_kref);
  10534.                 }
  10535. -               kref_get(&entry->list_kref);
  10536.  
  10537.                 spin_unlock(&glob->lru_lock);
  10538.                 ret = ttm_bo_cleanup_refs(entry, remove_all);
  10539.                 kref_put(&entry->list_kref, ttm_bo_release_list);
  10540. +               entry = nentry;
  10541.  
  10542. -               spin_lock(&glob->lru_lock);
  10543. -               if (nentry) {
  10544. -                       bool next_onlist = !list_empty(next);
  10545. -                       spin_unlock(&glob->lru_lock);
  10546. -                       kref_put(&nentry->list_kref, ttm_bo_release_list);
  10547. -                       spin_lock(&glob->lru_lock);
  10548. -                       /*
  10549. -                        * Someone might have raced us and removed the
  10550. -                        * next entry from the list. We don't bother restarting
  10551. -                        * list traversal.
  10552. -                        */
  10553. +               if (ret || !entry)
  10554. +                       goto out;
  10555.  
  10556. -                       if (!next_onlist)
  10557. -                               break;
  10558. -               }
  10559. -               if (ret)
  10560. +               spin_lock(&glob->lru_lock);
  10561. +               if (list_empty(&entry->ddestroy))
  10562.                         break;
  10563.         }
  10564. -       ret = !list_empty(&bdev->ddestroy);
  10565. -       spin_unlock(&glob->lru_lock);
  10566.  
  10567. +out_unlock:
  10568. +       spin_unlock(&glob->lru_lock);
  10569. +out:
  10570. +       if (entry)
  10571. +               kref_put(&entry->list_kref, ttm_bo_release_list);
  10572.         return ret;
  10573.  }
  10574.  
  10575.  -591,7 +584,7 @@
  10576.  
  10577.         if (likely(bo->vm_node != NULL)) {
  10578.                 rb_erase(&bo->vm_rb, &bdev->addr_space_rb);
  10579. -               drm_mm_put_block(bo->vm_node);
  10580. +               lbm_drm_mm_put_block(bo->vm_node);
  10581.                 bo->vm_node = NULL;
  10582.         }
  10583.         write_unlock(&bdev->vm_lock);
  10584.  -600,7 +593,7 @@
  10585.         write_lock(&bdev->vm_lock);
  10586.  }
  10587.  
  10588. -void ttm_bo_unref(struct ttm_buffer_object **p_bo)
  10589. +void lbm_ttm_bo_unref(struct ttm_buffer_object **p_bo)
  10590.  {
  10591.         struct ttm_buffer_object *bo = *p_bo;
  10592.         struct ttm_bo_device *bdev = bo->bdev;
  10593.  -610,7 +603,7 @@
  10594.         kref_put(&bo->kref, ttm_bo_release);
  10595.         write_unlock(&bdev->vm_lock);
  10596.  }
  10597. -EXPORT_SYMBOL(ttm_bo_unref);
  10598. +EXPORT_SYMBOL(lbm_ttm_bo_unref);
  10599.  
  10600.  static int ttm_bo_evict(struct ttm_buffer_object *bo, bool interruptible,
  10601.                         bool no_wait)
  10602.  -622,7 +615,7 @@
  10603.         int ret = 0;
  10604.  
  10605.         spin_lock(&bo->lock);
  10606. -       ret = ttm_bo_wait(bo, false, interruptible, no_wait);
  10607. +       ret = lbm_ttm_bo_wait(bo, false, interruptible, no_wait);
  10608.         spin_unlock(&bo->lock);
  10609.  
  10610.         if (unlikely(ret != 0)) {
  10611.  -644,7 +637,7 @@
  10612.         placement.num_placement = 0;
  10613.         placement.num_busy_placement = 0;
  10614.         bdev->driver->evict_flags(bo, &placement);
  10615. -       ret = ttm_bo_mem_space(bo, &placement, &evict_mem, interruptible,
  10616. +       ret = lbm_ttm_bo_mem_space(bo, &placement, &evict_mem, interruptible,
  10617.                                 no_wait);
  10618.         if (ret) {
  10619.                 if (ret != -ERESTARTSYS) {
  10620.  -664,7 +657,7 @@
  10621.                 spin_lock(&glob->lru_lock);
  10622.                 if (evict_mem.mm_node) {
  10623.                         evict_mem.mm_node->private = NULL;
  10624. -                       drm_mm_put_block(evict_mem.mm_node);
  10625. +                       lbm_drm_mm_put_block(evict_mem.mm_node);
  10626.                         evict_mem.mm_node = NULL;
  10627.                 }
  10628.                 spin_unlock(&glob->lru_lock);
  10629.  -699,7 +692,7 @@
  10630.         if (unlikely(ret == -EBUSY)) {
  10631.                 spin_unlock(&glob->lru_lock);
  10632.                 if (likely(!no_wait))
  10633. -                       ret = ttm_bo_wait_unreserved(bo, interruptible);
  10634. +                       ret = lbm_ttm_bo_wait_unreserved(bo, interruptible);
  10635.  
  10636.                 kref_put(&bo->list_kref, ttm_bo_release_list);
  10637.  
  10638.  -721,7 +714,7 @@
  10639.                 kref_put(&bo->list_kref, ttm_bo_ref_bug);
  10640.  
  10641.         ret = ttm_bo_evict(bo, interruptible, no_wait);
  10642. -       ttm_bo_unreserve(bo);
  10643. +       lbm_ttm_bo_unreserve(bo);
  10644.  
  10645.         kref_put(&bo->list_kref, ttm_bo_release_list);
  10646.         return ret;
  10647.  -742,12 +735,12 @@
  10648.                 lpfn = man->size;
  10649.         *node = NULL;
  10650.         do {
  10651. -               ret = drm_mm_pre_get(&man->manager);
  10652. +               ret = lbm_drm_mm_pre_get(&man->manager);
  10653.                 if (unlikely(ret))
  10654.                         return ret;
  10655.  
  10656.                 spin_lock(&glob->lru_lock);
  10657. -               *node = drm_mm_search_free_in_range(&man->manager,
  10658. +               *node = lbm_drm_mm_search_free_in_range(&man->manager,
  10659.                                         mem->num_pages, mem->page_alignment,
  10660.                                         placement->fpfn, lpfn, 1);
  10661.                 if (unlikely(*node == NULL)) {
  10662.  -859,7 +852,7 @@
  10663.   * ttm_bo_mem_force_space is attempted in priority order to evict and find
  10664.   * space.
  10665.   */
  10666. -int ttm_bo_mem_space(struct ttm_buffer_object *bo,
  10667. +int lbm_ttm_bo_mem_space(struct ttm_buffer_object *bo,
  10668.                         struct ttm_placement *placement,
  10669.                         struct ttm_mem_reg *mem,
  10670.                         bool interruptible, bool no_wait)
  10671.  -950,6 +943,14 @@
  10672.                 ttm_flag_masked(&cur_flags, placement->busy_placement[i],
  10673.                                 ~TTM_PL_MASK_MEMTYPE);
  10674.  
  10675. +
  10676. +               if (mem_type == TTM_PL_SYSTEM) {
  10677. +                       mem->mem_type = mem_type;
  10678. +                       mem->placement = cur_flags;
  10679. +                       mem->mm_node = NULL;
  10680. +                       return 0;
  10681. +               }
  10682. +
  10683.                 ret = ttm_bo_mem_force_space(bo, mem_type, placement, mem,
  10684.                                                 interruptible, no_wait);
  10685.                 if (ret == 0 && mem->mm_node) {
  10686.  -963,9 +964,9 @@
  10687.         ret = (has_erestartsys) ? -ERESTARTSYS : -ENOMEM;
  10688.         return ret;
  10689.  }
  10690. -EXPORT_SYMBOL(ttm_bo_mem_space);
  10691. +EXPORT_SYMBOL(lbm_ttm_bo_mem_space);
  10692.  
  10693. -int ttm_bo_wait_cpu(struct ttm_buffer_object *bo, bool no_wait)
  10694. +int lbm_ttm_bo_wait_cpu(struct ttm_buffer_object *bo, bool no_wait)
  10695.  {
  10696.         if ((atomic_read(&bo->cpu_writers) > 0) && no_wait)
  10697.                 return -EBUSY;
  10698.  -973,7 +974,7 @@
  10699.         return wait_event_interruptible(bo->event_queue,
  10700.                                         atomic_read(&bo->cpu_writers) == 0);
  10701.  }
  10702. -EXPORT_SYMBOL(ttm_bo_wait_cpu);
  10703. +EXPORT_SYMBOL(lbm_ttm_bo_wait_cpu);
  10704.  
  10705.  int ttm_bo_move_buffer(struct ttm_buffer_object *bo,
  10706.                         struct ttm_placement *placement,
  10707.  -991,7 +992,7 @@
  10708.          * instead of doing it here.
  10709.          */
  10710.         spin_lock(&bo->lock);
  10711. -       ret = ttm_bo_wait(bo, false, interruptible, no_wait);
  10712. +       ret = lbm_ttm_bo_wait(bo, false, interruptible, no_wait);
  10713.         spin_unlock(&bo->lock);
  10714.         if (ret)
  10715.                 return ret;
  10716.  -1001,7 +1002,7 @@
  10717.         /*
  10718.          * Determine where to move the buffer.
  10719.          */
  10720. -       ret = ttm_bo_mem_space(bo, placement, &mem, interruptible, no_wait);
  10721. +       ret = lbm_ttm_bo_mem_space(bo, placement, &mem, interruptible, no_wait);
  10722.         if (ret)
  10723.                 goto out_unlock;
  10724.         ret = ttm_bo_handle_move_mem(bo, &mem, false, interruptible, no_wait);
  10725.  -1009,7 +1010,7 @@
  10726.         if (ret && mem.mm_node) {
  10727.                 spin_lock(&glob->lru_lock);
  10728.                 mem.mm_node->private = NULL;
  10729. -               drm_mm_put_block(mem.mm_node);
  10730. +               lbm_drm_mm_put_block(mem.mm_node);
  10731.                 spin_unlock(&glob->lru_lock);
  10732.         }
  10733.         return ret;
  10734.  -1030,7 +1031,7 @@
  10735.         return -1;
  10736.  }
  10737.  
  10738. -int ttm_bo_validate(struct ttm_buffer_object *bo,
  10739. +int lbm_ttm_bo_validate(struct ttm_buffer_object *bo,
  10740.                         struct ttm_placement *placement,
  10741.                         bool interruptible, bool no_wait)
  10742.  {
  10743.  -1068,7 +1069,7 @@
  10744.         }
  10745.         return 0;
  10746.  }
  10747. -EXPORT_SYMBOL(ttm_bo_validate);
  10748. +EXPORT_SYMBOL(lbm_ttm_bo_validate);
  10749.  
  10750.  int ttm_bo_check_placement(struct ttm_buffer_object *bo,
  10751.                                 struct ttm_placement *placement)
  10752.  -1105,7 +1106,7 @@
  10753.         return 0;
  10754.  }
  10755.  
  10756. -int ttm_bo_init(struct ttm_bo_device *bdev,
  10757. +int lbm_ttm_bo_init(struct ttm_bo_device *bdev,
  10758.                 struct ttm_buffer_object *bo,
  10759.                 unsigned long size,
  10760.                 enum ttm_bo_type type,
  10761.  -1168,20 +1169,20 @@
  10762.                         goto out_err;
  10763.         }
  10764.  
  10765. -       ret = ttm_bo_validate(bo, placement, interruptible, false);
  10766. +       ret = lbm_ttm_bo_validate(bo, placement, interruptible, false);
  10767.         if (ret)
  10768.                 goto out_err;
  10769.  
  10770. -       ttm_bo_unreserve(bo);
  10771. +       lbm_ttm_bo_unreserve(bo);
  10772.         return 0;
  10773.  
  10774.  out_err:
  10775. -       ttm_bo_unreserve(bo);
  10776. -       ttm_bo_unref(&bo);
  10777. +       lbm_ttm_bo_unreserve(bo);
  10778. +       lbm_ttm_bo_unref(&bo);
  10779.  
  10780.         return ret;
  10781.  }
  10782. -EXPORT_SYMBOL(ttm_bo_init);
  10783. +EXPORT_SYMBOL(lbm_ttm_bo_init);
  10784.  
  10785.  static inline size_t ttm_bo_size(struct ttm_bo_global *glob,
  10786.                                  unsigned long num_pages)
  10787.  -1208,18 +1209,18 @@
  10788.  
  10789.         size_t acc_size =
  10790.             ttm_bo_size(bdev->glob, (size + PAGE_SIZE - 1) >> PAGE_SHIFT);
  10791. -       ret = ttm_mem_global_alloc(mem_glob, acc_size, false, false);
  10792. +       ret = lbm_ttm_mem_global_alloc(mem_glob, acc_size, false, false);
  10793.         if (unlikely(ret != 0))
  10794.                 return ret;
  10795.  
  10796.         bo = kzalloc(sizeof(*bo), GFP_KERNEL);
  10797.  
  10798.         if (unlikely(bo == NULL)) {
  10799. -               ttm_mem_global_free(mem_glob, acc_size);
  10800. +               lbm_ttm_mem_global_free(mem_glob, acc_size);
  10801.                 return -ENOMEM;
  10802.         }
  10803.  
  10804. -       ret = ttm_bo_init(bdev, bo, size, type, placement, page_alignment,
  10805. +       ret = lbm_ttm_bo_init(bdev, bo, size, type, placement, page_alignment,
  10806.                                 buffer_start, interruptible,
  10807.                                 persistant_swap_storage, acc_size, NULL);
  10808.         if (likely(ret == 0))
  10809.  -1257,7 +1258,7 @@
  10810.         return 0;
  10811.  }
  10812.  
  10813. -int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type)
  10814. +int lbm_ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type)
  10815.  {
  10816.         struct ttm_bo_global *glob = bdev->glob;
  10817.         struct ttm_mem_type_manager *man;
  10818.  -1283,8 +1284,8 @@
  10819.                 ttm_bo_force_list_clean(bdev, mem_type, false);
  10820.  
  10821.                 spin_lock(&glob->lru_lock);
  10822. -               if (drm_mm_clean(&man->manager))
  10823. -                       drm_mm_takedown(&man->manager);
  10824. +               if (lbm_drm_mm_clean(&man->manager))
  10825. +                       lbm_drm_mm_takedown(&man->manager);
  10826.                 else
  10827.                         ret = -EBUSY;
  10828.  
  10829.  -1293,9 +1294,9 @@
  10830.  
  10831.         return ret;
  10832.  }
  10833. -EXPORT_SYMBOL(ttm_bo_clean_mm);
  10834. +EXPORT_SYMBOL(lbm_ttm_bo_clean_mm);
  10835.  
  10836. -int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type)
  10837. +int lbm_ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type)
  10838.  {
  10839.         struct ttm_mem_type_manager *man = &bdev->man[mem_type];
  10840.  
  10841.  -1315,9 +1316,9 @@
  10842.  
  10843.         return ttm_bo_force_list_clean(bdev, mem_type, true);
  10844.  }
  10845. -EXPORT_SYMBOL(ttm_bo_evict_mm);
  10846. +EXPORT_SYMBOL(lbm_ttm_bo_evict_mm);
  10847.  
  10848. -int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
  10849. +int lbm_ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
  10850.                         unsigned long p_size)
  10851.  {
  10852.         int ret = -EINVAL;
  10853.  -1348,7 +1349,7 @@
  10854.                                type);
  10855.                         return ret;
  10856.                 }
  10857. -               ret = drm_mm_init(&man->manager, 0, p_size);
  10858. +               ret = lbm_drm_mm_init(&man->manager, 0, p_size);
  10859.                 if (ret)
  10860.                         return ret;
  10861.         }
  10862.  -1360,7 +1361,7 @@
  10863.  
  10864.         return 0;
  10865.  }
  10866. -EXPORT_SYMBOL(ttm_bo_init_mm);
  10867. +EXPORT_SYMBOL(lbm_ttm_bo_init_mm);
  10868.  
  10869.  static void ttm_bo_global_kobj_release(struct kobject *kobj)
  10870.  {
  10871.  -1372,16 +1373,16 @@
  10872.         kfree(glob);
  10873.  }
  10874.  
  10875. -void ttm_bo_global_release(struct ttm_global_reference *ref)
  10876. +void lbm_ttm_bo_global_release(struct ttm_global_reference *ref)
  10877.  {
  10878.         struct ttm_bo_global *glob = ref->object;
  10879.  
  10880.         kobject_del(&glob->kobj);
  10881.         kobject_put(&glob->kobj);
  10882.  }
  10883. -EXPORT_SYMBOL(ttm_bo_global_release);
  10884. +EXPORT_SYMBOL(lbm_ttm_bo_global_release);
  10885.  
  10886. -int ttm_bo_global_init(struct ttm_global_reference *ref)
  10887. +int lbm_ttm_bo_global_init(struct ttm_global_reference *ref)
  10888.  {
  10889.         struct ttm_bo_global_ref *bo_ref =
  10890.                 container_of(ref, struct ttm_bo_global_ref, ref);
  10891.  -1410,11 +1411,11 @@
  10892.         }
  10893.  
  10894.         glob->ttm_bo_extra_size =
  10895. -               ttm_round_pot(sizeof(struct ttm_tt)) +
  10896. -               ttm_round_pot(sizeof(struct ttm_backend));
  10897. +               lbm_ttm_round_pot(sizeof(struct ttm_tt)) +
  10898. +               lbm_ttm_round_pot(sizeof(struct ttm_backend));
  10899.  
  10900.         glob->ttm_bo_size = glob->ttm_bo_extra_size +
  10901. -               ttm_round_pot(sizeof(struct ttm_buffer_object));
  10902. +               lbm_ttm_round_pot(sizeof(struct ttm_buffer_object));
  10903.  
  10904.         atomic_set(&glob->bo_count, 0);
  10905.  
  10906.  -1429,10 +1430,10 @@
  10907.         kfree(glob);
  10908.         return ret;
  10909.  }
  10910. -EXPORT_SYMBOL(ttm_bo_global_init);
  10911. +EXPORT_SYMBOL(lbm_ttm_bo_global_init);
  10912.  
  10913.  
  10914. -int ttm_bo_device_release(struct ttm_bo_device *bdev)
  10915. +int lbm_ttm_bo_device_release(struct ttm_bo_device *bdev)
  10916.  {
  10917.         int ret = 0;
  10918.         unsigned i = TTM_NUM_MEM_TYPES;
  10919.  -1443,7 +1444,7 @@
  10920.                 man = &bdev->man[i];
  10921.                 if (man->has_type) {
  10922.                         man->use_type = false;
  10923. -                       if ((i != TTM_PL_SYSTEM) && ttm_bo_clean_mm(bdev, i)) {
  10924. +                       if ((i != TTM_PL_SYSTEM) && lbm_ttm_bo_clean_mm(bdev, i)) {
  10925.                                 ret = -EBUSY;
  10926.                                 printk(KERN_ERR TTM_PFX
  10927.                                        "DRM memory manager type %d "
  10928.  -1471,16 +1472,16 @@
  10929.                 TTM_DEBUG("Swap list was clean\n");
  10930.         spin_unlock(&glob->lru_lock);
  10931.  
  10932. -       BUG_ON(!drm_mm_clean(&bdev->addr_space_mm));
  10933. +       BUG_ON(!lbm_drm_mm_clean(&bdev->addr_space_mm));
  10934.         write_lock(&bdev->vm_lock);
  10935. -       drm_mm_takedown(&bdev->addr_space_mm);
  10936. +       lbm_drm_mm_takedown(&bdev->addr_space_mm);
  10937.         write_unlock(&bdev->vm_lock);
  10938.  
  10939.         return ret;
  10940.  }
  10941. -EXPORT_SYMBOL(ttm_bo_device_release);
  10942. +EXPORT_SYMBOL(lbm_ttm_bo_device_release);
  10943.  
  10944. -int ttm_bo_device_init(struct ttm_bo_device *bdev,
  10945. +int lbm_ttm_bo_device_init(struct ttm_bo_device *bdev,
  10946.                        struct ttm_bo_global *glob,
  10947.                        struct ttm_bo_driver *driver,
  10948.                        uint64_t file_page_offset,
  10949.  -1497,12 +1498,12 @@
  10950.          * Initialize the system memory buffer type.
  10951.          * Other types need to be driver / IOCTL initialized.
  10952.          */
  10953. -       ret = ttm_bo_init_mm(bdev, TTM_PL_SYSTEM, 0);
  10954. +       ret = lbm_ttm_bo_init_mm(bdev, TTM_PL_SYSTEM, 0);
  10955.         if (unlikely(ret != 0))
  10956.                 goto out_no_sys;
  10957.  
  10958.         bdev->addr_space_rb = RB_ROOT;
  10959. -       ret = drm_mm_init(&bdev->addr_space_mm, file_page_offset, 0x10000000);
  10960. +       ret = lbm_drm_mm_init(&bdev->addr_space_mm, file_page_offset, 0x10000000);
  10961.         if (unlikely(ret != 0))
  10962.                 goto out_no_addr_mm;
  10963.  
  10964.  -1519,11 +1520,11 @@
  10965.  
  10966.         return 0;
  10967.  out_no_addr_mm:
  10968. -       ttm_bo_clean_mm(bdev, 0);
  10969. +       lbm_ttm_bo_clean_mm(bdev, 0);
  10970.  out_no_sys:
  10971.         return ret;
  10972.  }
  10973. -EXPORT_SYMBOL(ttm_bo_device_init);
  10974. +EXPORT_SYMBOL(lbm_ttm_bo_device_init);
  10975.  
  10976.  /*
  10977.   * buffer object vm functions.
  10978.  -1566,7 +1567,7 @@
  10979.         return 0;
  10980.  }
  10981.  
  10982. -void ttm_bo_unmap_virtual(struct ttm_buffer_object *bo)
  10983. +void lbm_ttm_bo_unmap_virtual(struct ttm_buffer_object *bo)
  10984.  {
  10985.         struct ttm_bo_device *bdev = bo->bdev;
  10986.         loff_t offset = (loff_t) bo->addr_space_offset;
  10987.  -1577,7 +1578,7 @@
  10988.  
  10989.         unmap_mapping_range(bdev->dev_mapping, offset, holelen, 1);
  10990.  }
  10991. -EXPORT_SYMBOL(ttm_bo_unmap_virtual);
  10992. +EXPORT_SYMBOL(lbm_ttm_bo_unmap_virtual);
  10993.  
  10994.  static void ttm_bo_vm_insert_rb(struct ttm_buffer_object *bo)
  10995.  {
  10996.  -1621,12 +1622,12 @@
  10997.         int ret;
  10998.  
  10999.  retry_pre_get:
  11000. -       ret = drm_mm_pre_get(&bdev->addr_space_mm);
  11001. +       ret = lbm_drm_mm_pre_get(&bdev->addr_space_mm);
  11002.         if (unlikely(ret != 0))
  11003.                 return ret;
  11004.  
  11005.         write_lock(&bdev->vm_lock);
  11006. -       bo->vm_node = drm_mm_search_free(&bdev->addr_space_mm,
  11007. +       bo->vm_node = lbm_drm_mm_search_free(&bdev->addr_space_mm,
  11008.                                          bo->mem.num_pages, 0, 0);
  11009.  
  11010.         if (unlikely(bo->vm_node == NULL)) {
  11011.  -1652,7 +1653,7 @@
  11012.         return ret;
  11013.  }
  11014.  
  11015. -int ttm_bo_wait(struct ttm_buffer_object *bo,
  11016. +int lbm_ttm_bo_wait(struct ttm_buffer_object *bo,
  11017.                 bool lazy, bool interruptible, bool no_wait)
  11018.  {
  11019.         struct ttm_bo_driver *driver = bo->bdev->driver;
  11020.  -1707,7 +1708,7 @@
  11021.         }
  11022.         return 0;
  11023.  }
  11024. -EXPORT_SYMBOL(ttm_bo_wait);
  11025. +EXPORT_SYMBOL(lbm_ttm_bo_wait);
  11026.  
  11027.  void ttm_bo_unblock_reservation(struct ttm_buffer_object *bo)
  11028.  {
  11029.  -1736,34 +1737,34 @@
  11030.         return 0;
  11031.  }
  11032.  
  11033. -int ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait)
  11034. +int lbm_ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait)
  11035.  {
  11036.         int ret = 0;
  11037.  
  11038.         /*
  11039. -        * Using ttm_bo_reserve instead of ttm_bo_block_reservation
  11040. +        * Using lbm_ttm_bo_reserve instead of ttm_bo_block_reservation
  11041.          * makes sure the lru lists are updated.
  11042.          */
  11043.  
  11044. -       ret = ttm_bo_reserve(bo, true, no_wait, false, 0);
  11045. +       ret = lbm_ttm_bo_reserve(bo, true, no_wait, false, 0);
  11046.         if (unlikely(ret != 0))
  11047.                 return ret;
  11048.         spin_lock(&bo->lock);
  11049. -       ret = ttm_bo_wait(bo, false, true, no_wait);
  11050. +       ret = lbm_ttm_bo_wait(bo, false, true, no_wait);
  11051.         spin_unlock(&bo->lock);
  11052.         if (likely(ret == 0))
  11053.                 atomic_inc(&bo->cpu_writers);
  11054. -       ttm_bo_unreserve(bo);
  11055. +       lbm_ttm_bo_unreserve(bo);
  11056.         return ret;
  11057.  }
  11058. -EXPORT_SYMBOL(ttm_bo_synccpu_write_grab);
  11059. +EXPORT_SYMBOL(lbm_ttm_bo_synccpu_write_grab);
  11060.  
  11061. -void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo)
  11062. +void lbm_ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo)
  11063.  {
  11064.         if (atomic_dec_and_test(&bo->cpu_writers))
  11065.                 wake_up_all(&bo->event_queue);
  11066.  }
  11067. -EXPORT_SYMBOL(ttm_bo_synccpu_write_release);
  11068. +EXPORT_SYMBOL(lbm_ttm_bo_synccpu_write_release);
  11069.  
  11070.  /**
  11071.   * A buffer object shrink method that tries to swap out the first
  11072.  -1799,7 +1800,7 @@
  11073.                 ret = ttm_bo_reserve_locked(bo, false, true, false, 0);
  11074.                 if (unlikely(ret == -EBUSY)) {
  11075.                         spin_unlock(&glob->lru_lock);
  11076. -                       ttm_bo_wait_unreserved(bo, false);
  11077. +                       lbm_ttm_bo_wait_unreserved(bo, false);
  11078.                         kref_put(&bo->list_kref, ttm_bo_release_list);
  11079.                         spin_lock(&glob->lru_lock);
  11080.                 }
  11081.  -1817,7 +1818,7 @@
  11082.          */
  11083.  
  11084.         spin_lock(&bo->lock);
  11085. -       ret = ttm_bo_wait(bo, false, false, false);
  11086. +       ret = lbm_ttm_bo_wait(bo, false, false, false);
  11087.         spin_unlock(&bo->lock);
  11088.  
  11089.         if (unlikely(ret != 0))
  11090.  -1837,13 +1838,16 @@
  11091.                         goto out;
  11092.         }
  11093.  
  11094. -       ttm_bo_unmap_virtual(bo);
  11095. +       lbm_ttm_bo_unmap_virtual(bo);
  11096.  
  11097.         /**
  11098.          * Swap out. Buffer will be swapped in again as soon as
  11099.          * anyone tries to access a ttm page.
  11100.          */
  11101.  
  11102. +       if (bo->bdev->driver->swap_notify)
  11103. +               bo->bdev->driver->swap_notify(bo);
  11104. +
  11105.         ret = ttm_tt_swapout(bo->ttm, bo->persistant_swap_storage);
  11106.  out:
  11107.  
  11108.  -1859,8 +1863,9 @@
  11109.         return ret;
  11110.  }
  11111.  
  11112. -void ttm_bo_swapout_all(struct ttm_bo_device *bdev)
  11113. +void lbm_ttm_bo_swapout_all(struct ttm_bo_device *bdev)
  11114.  {
  11115.         while (ttm_bo_swapout(&bdev->glob->shrink) == 0)
  11116.                 ;
  11117.  }
  11118. +EXPORT_SYMBOL(lbm_ttm_bo_swapout_all);
  11119. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_util.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_util.c
  11120. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_util.c     2010-01-25 15:21:29.000000000 -0500
  11121. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_util.c     2010-02-03 17:11:09.000000000 -0500
  11122.  -42,18 +42,17 @@
  11123.  
  11124.         if (old_mem->mm_node) {
  11125.                 spin_lock(&bo->glob->lru_lock);
  11126. -               drm_mm_put_block(old_mem->mm_node);
  11127. +               lbm_drm_mm_put_block(old_mem->mm_node);
  11128.                 spin_unlock(&bo->glob->lru_lock);
  11129.         }
  11130.         old_mem->mm_node = NULL;
  11131.  }
  11132.  
  11133. -int ttm_bo_move_ttm(struct ttm_buffer_object *bo,
  11134. +int lbm_ttm_bo_move_ttm(struct ttm_buffer_object *bo,
  11135.                     bool evict, bool no_wait, struct ttm_mem_reg *new_mem)
  11136.  {
  11137.         struct ttm_tt *ttm = bo->ttm;
  11138.         struct ttm_mem_reg *old_mem = &bo->mem;
  11139. -       uint32_t save_flags = old_mem->placement;
  11140.         int ret;
  11141.  
  11142.         if (old_mem->mem_type != TTM_PL_SYSTEM) {
  11143.  -62,25 +61,24 @@
  11144.                 ttm_flag_masked(&old_mem->placement, TTM_PL_FLAG_SYSTEM,
  11145.                                 TTM_PL_MASK_MEM);
  11146.                 old_mem->mem_type = TTM_PL_SYSTEM;
  11147. -               save_flags = old_mem->placement;
  11148.         }
  11149.  
  11150. -       ret = ttm_tt_set_placement_caching(ttm, new_mem->placement);
  11151. +       ret = lbm_ttm_tt_set_placement_caching(ttm, new_mem->placement);
  11152.         if (unlikely(ret != 0))
  11153.                 return ret;
  11154.  
  11155.         if (new_mem->mem_type != TTM_PL_SYSTEM) {
  11156. -               ret = ttm_tt_bind(ttm, new_mem);
  11157. +               ret = lbm_ttm_tt_bind(ttm, new_mem);
  11158.                 if (unlikely(ret != 0))
  11159.                         return ret;
  11160.         }
  11161.  
  11162.         *old_mem = *new_mem;
  11163.         new_mem->mm_node = NULL;
  11164. -       ttm_flag_masked(&save_flags, new_mem->placement, TTM_PL_MASK_MEMTYPE);
  11165. +
  11166.         return 0;
  11167.  }
  11168. -EXPORT_SYMBOL(ttm_bo_move_ttm);
  11169. +EXPORT_SYMBOL(lbm_ttm_bo_move_ttm);
  11170.  
  11171.  int ttm_mem_reg_ioremap(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem,
  11172.                         void **virtual)
  11173.  -208,7 +206,7 @@
  11174.         return 0;
  11175.  }
  11176.  
  11177. -int ttm_bo_move_memcpy(struct ttm_buffer_object *bo,
  11178. +int lbm_ttm_bo_move_memcpy(struct ttm_buffer_object *bo,
  11179.                        bool evict, bool no_wait, struct ttm_mem_reg *new_mem)
  11180.  {
  11181.         struct ttm_bo_device *bdev = bo->bdev;
  11182.  -219,7 +217,6 @@
  11183.         void *old_iomap;
  11184.         void *new_iomap;
  11185.         int ret;
  11186. -       uint32_t save_flags = old_mem->placement;
  11187.         unsigned long i;
  11188.         unsigned long page;
  11189.         unsigned long add = 0;
  11190.  -250,12 +247,12 @@
  11191.         for (i = 0; i < new_mem->num_pages; ++i) {
  11192.                 page = i * dir + add;
  11193.                 if (old_iomap == NULL) {
  11194. -                       pgprot_t prot = ttm_io_prot(old_mem->placement,
  11195. +                       pgprot_t prot = lbm_ttm_io_prot(old_mem->placement,
  11196.                                                     PAGE_KERNEL);
  11197.                         ret = ttm_copy_ttm_io_page(ttm, new_iomap, page,
  11198.                                                    prot);
  11199.                 } else if (new_iomap == NULL) {
  11200. -                       pgprot_t prot = ttm_io_prot(new_mem->placement,
  11201. +                       pgprot_t prot = lbm_ttm_io_prot(new_mem->placement,
  11202.                                                     PAGE_KERNEL);
  11203.                         ret = ttm_copy_io_ttm_page(ttm, old_iomap, page,
  11204.                                                    prot);
  11205.  -270,7 +267,6 @@
  11206.  
  11207.         *old_mem = *new_mem;
  11208.         new_mem->mm_node = NULL;
  11209. -       ttm_flag_masked(&save_flags, new_mem->placement, TTM_PL_MASK_MEMTYPE);
  11210.  
  11211.         if ((man->flags & TTM_MEMTYPE_FLAG_FIXED) && (ttm != NULL)) {
  11212.                 ttm_tt_unbind(ttm);
  11213.  -284,7 +280,7 @@
  11214.         ttm_mem_reg_iounmap(bdev, &old_copy, old_iomap);
  11215.         return ret;
  11216.  }
  11217. -EXPORT_SYMBOL(ttm_bo_move_memcpy);
  11218. +EXPORT_SYMBOL(lbm_ttm_bo_move_memcpy);
  11219.  
  11220.  static void ttm_transfered_destroy(struct ttm_buffer_object *bo)
  11221.  {
  11222.  -342,7 +338,7 @@
  11223.         return 0;
  11224.  }
  11225.  
  11226. -pgprot_t ttm_io_prot(uint32_t caching_flags, pgprot_t tmp)
  11227. +pgprot_t lbm_ttm_io_prot(uint32_t caching_flags, pgprot_t tmp)
  11228.  {
  11229.  #if defined(__i386__) || defined(__x86_64__)
  11230.         if (caching_flags & TTM_PL_FLAG_WC)
  11231.  -369,7 +365,7 @@
  11232.  #endif
  11233.         return tmp;
  11234.  }
  11235. -EXPORT_SYMBOL(ttm_io_prot);
  11236. +EXPORT_SYMBOL(lbm_ttm_io_prot);
  11237.  
  11238.  static int ttm_bo_ioremap(struct ttm_buffer_object *bo,
  11239.                           unsigned long bus_base,
  11240.  -432,7 +428,7 @@
  11241.                  */
  11242.                 prot = (mem->placement & TTM_PL_FLAG_CACHED) ?
  11243.                         PAGE_KERNEL :
  11244. -                       ttm_io_prot(mem->placement, PAGE_KERNEL);
  11245. +                       lbm_ttm_io_prot(mem->placement, PAGE_KERNEL);
  11246.                 map->bo_kmap_type = ttm_bo_map_vmap;
  11247.                 map->virtual = vmap(ttm->pages + start_page, num_pages,
  11248.                                     0, prot);
  11249.  -440,7 +436,7 @@
  11250.         return (!map->virtual) ? -ENOMEM : 0;
  11251.  }
  11252.  
  11253. -int ttm_bo_kmap(struct ttm_buffer_object *bo,
  11254. +int lbm_ttm_bo_kmap(struct ttm_buffer_object *bo,
  11255.                 unsigned long start_page, unsigned long num_pages,
  11256.                 struct ttm_bo_kmap_obj *map)
  11257.  {
  11258.  -471,9 +467,9 @@
  11259.                 return ttm_bo_ioremap(bo, bus_base, bus_offset, bus_size, map);
  11260.         }
  11261.  }
  11262. -EXPORT_SYMBOL(ttm_bo_kmap);
  11263. +EXPORT_SYMBOL(lbm_ttm_bo_kmap);
  11264.  
  11265. -void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
  11266. +void lbm_ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
  11267.  {
  11268.         if (!map->virtual)
  11269.                 return;
  11270.  -495,7 +491,7 @@
  11271.         map->virtual = NULL;
  11272.         map->page = NULL;
  11273.  }
  11274. -EXPORT_SYMBOL(ttm_bo_kunmap);
  11275. +EXPORT_SYMBOL(lbm_ttm_bo_kunmap);
  11276.  
  11277.  int ttm_bo_pfn_prot(struct ttm_buffer_object *bo,
  11278.                     unsigned long dst_offset,
  11279.  -521,12 +517,12 @@
  11280.                                                            dst_offset >>
  11281.                                                            PAGE_SHIFT));
  11282.         *prot = (mem->placement & TTM_PL_FLAG_CACHED) ?
  11283. -               PAGE_KERNEL : ttm_io_prot(mem->placement, PAGE_KERNEL);
  11284. +               PAGE_KERNEL : lbm_ttm_io_prot(mem->placement, PAGE_KERNEL);
  11285.  
  11286.         return 0;
  11287.  }
  11288.  
  11289. -int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
  11290. +int lbm_ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
  11291.                               void *sync_obj,
  11292.                               void *sync_obj_arg,
  11293.                               bool evict, bool no_wait,
  11294.  -537,7 +533,6 @@
  11295.         struct ttm_mem_type_manager *man = &bdev->man[new_mem->mem_type];
  11296.         struct ttm_mem_reg *old_mem = &bo->mem;
  11297.         int ret;
  11298. -       uint32_t save_flags = old_mem->placement;
  11299.         struct ttm_buffer_object *ghost_obj;
  11300.         void *tmp_obj = NULL;
  11301.  
  11302.  -549,7 +544,7 @@
  11303.         bo->sync_obj = driver->sync_obj_ref(sync_obj);
  11304.         bo->sync_obj_arg = sync_obj_arg;
  11305.         if (evict) {
  11306. -               ret = ttm_bo_wait(bo, false, false, false);
  11307. +               ret = lbm_ttm_bo_wait(bo, false, false, false);
  11308.                 spin_unlock(&bo->lock);
  11309.                 if (tmp_obj)
  11310.                         driver->sync_obj_unref(&tmp_obj);
  11311.  -592,13 +587,13 @@
  11312.                 else
  11313.                         bo->ttm = NULL;
  11314.  
  11315. -               ttm_bo_unreserve(ghost_obj);
  11316. -               ttm_bo_unref(&ghost_obj);
  11317. +               lbm_ttm_bo_unreserve(ghost_obj);
  11318. +               lbm_ttm_bo_unref(&ghost_obj);
  11319.         }
  11320.  
  11321.         *old_mem = *new_mem;
  11322.         new_mem->mm_node = NULL;
  11323. -       ttm_flag_masked(&save_flags, new_mem->placement, TTM_PL_MASK_MEMTYPE);
  11324. +
  11325.         return 0;
  11326.  }
  11327. -EXPORT_SYMBOL(ttm_bo_move_accel_cleanup);
  11328. +EXPORT_SYMBOL(lbm_ttm_bo_move_accel_cleanup);
  11329. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_vm.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_vm.c
  11330. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_vm.c       2010-01-25 15:21:29.000000000 -0500
  11331. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_bo_vm.c       2010-02-03 17:11:09.000000000 -0500
  11332.  -94,7 +94,7 @@
  11333.          * for reserve, and if it fails, retry the fault after scheduling.
  11334.          */
  11335.  
  11336. -       ret = ttm_bo_reserve(bo, true, true, false, 0);
  11337. +       ret = lbm_ttm_bo_reserve(bo, true, true, false, 0);
  11338.         if (unlikely(ret != 0)) {
  11339.                 if (ret == -EBUSY)
  11340.                         set_need_resched();
  11341.  -111,7 +111,7 @@
  11342.  
  11343.         spin_lock(&bo->lock);
  11344.         if (test_bit(TTM_BO_PRIV_FLAG_MOVING, &bo->priv_flags)) {
  11345. -               ret = ttm_bo_wait(bo, false, true, false);
  11346. +               ret = lbm_ttm_bo_wait(bo, false, true, false);
  11347.                 spin_unlock(&bo->lock);
  11348.                 if (unlikely(ret != 0)) {
  11349.                         retval = (ret != -ERESTARTSYS) ?
  11350.  -156,13 +156,13 @@
  11351.          */
  11352.  
  11353.         if (is_iomem) {
  11354. -               vma->vm_page_prot = ttm_io_prot(bo->mem.placement,
  11355. +               vma->vm_page_prot = lbm_ttm_io_prot(bo->mem.placement,
  11356.                                                 vma->vm_page_prot);
  11357.         } else {
  11358.                 ttm = bo->ttm;
  11359.                 vma->vm_page_prot = (bo->mem.placement & TTM_PL_FLAG_CACHED) ?
  11360.                     vm_get_page_prot(vma->vm_flags) :
  11361. -                   ttm_io_prot(bo->mem.placement, vma->vm_page_prot);
  11362. +                   lbm_ttm_io_prot(bo->mem.placement, vma->vm_page_prot);
  11363.         }
  11364.  
  11365.         /*
  11366.  -207,7 +207,7 @@
  11367.         }
  11368.  
  11369.  out_unlock:
  11370. -       ttm_bo_unreserve(bo);
  11371. +       lbm_ttm_bo_unreserve(bo);
  11372.         return retval;
  11373.  }
  11374.  
  11375.  -224,7 +224,7 @@
  11376.         struct ttm_buffer_object *bo =
  11377.             (struct ttm_buffer_object *)vma->vm_private_data;
  11378.  
  11379. -       ttm_bo_unref(&bo);
  11380. +       lbm_ttm_bo_unref(&bo);
  11381.         vma->vm_private_data = NULL;
  11382.  }
  11383.  
  11384.  -234,7 +234,7 @@
  11385.         .close = ttm_bo_vm_close
  11386.  };
  11387.  
  11388. -int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
  11389. +int lbm_ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
  11390.                 struct ttm_bo_device *bdev)
  11391.  {
  11392.         struct ttm_bo_driver *driver;
  11393.  -274,12 +274,12 @@
  11394.         vma->vm_flags |= VM_RESERVED | VM_IO | VM_MIXEDMAP | VM_DONTEXPAND;
  11395.         return 0;
  11396.  out_unref:
  11397. -       ttm_bo_unref(&bo);
  11398. +       lbm_ttm_bo_unref(&bo);
  11399.         return ret;
  11400.  }
  11401. -EXPORT_SYMBOL(ttm_bo_mmap);
  11402. +EXPORT_SYMBOL(lbm_ttm_bo_mmap);
  11403.  
  11404. -int ttm_fbdev_mmap(struct vm_area_struct *vma, struct ttm_buffer_object *bo)
  11405. +int lbm_ttm_fbdev_mmap(struct vm_area_struct *vma, struct ttm_buffer_object *bo)
  11406.  {
  11407.         if (vma->vm_pgoff != 0)
  11408.                 return -EACCES;
  11409.  -289,7 +289,7 @@
  11410.         vma->vm_flags |= VM_RESERVED | VM_IO | VM_MIXEDMAP | VM_DONTEXPAND;
  11411.         return 0;
  11412.  }
  11413. -EXPORT_SYMBOL(ttm_fbdev_mmap);
  11414. +EXPORT_SYMBOL(lbm_ttm_fbdev_mmap);
  11415.  
  11416.  
  11417.  ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp,
  11418.  -344,7 +344,7 @@
  11419.         kmap_end = (*f_pos + count - 1) >> PAGE_SHIFT;
  11420.         kmap_num = kmap_end - kmap_offset + 1;
  11421.  
  11422. -       ret = ttm_bo_reserve(bo, true, no_wait, false, 0);
  11423. +       ret = lbm_ttm_bo_reserve(bo, true, no_wait, false, 0);
  11424.  
  11425.         switch (ret) {
  11426.         case 0:
  11427.  -356,9 +356,9 @@
  11428.                 goto out_unref;
  11429.         }
  11430.  
  11431. -       ret = ttm_bo_kmap(bo, kmap_offset, kmap_num, &map);
  11432. +       ret = lbm_ttm_bo_kmap(bo, kmap_offset, kmap_num, &map);
  11433.         if (unlikely(ret != 0)) {
  11434. -               ttm_bo_unreserve(bo);
  11435. +               lbm_ttm_bo_unreserve(bo);
  11436.                 goto out_unref;
  11437.         }
  11438.  
  11439.  -370,9 +370,9 @@
  11440.         else
  11441.                 ret = copy_to_user(rbuf, virtual, io_size);
  11442.  
  11443. -       ttm_bo_kunmap(&map);
  11444. -       ttm_bo_unreserve(bo);
  11445. -       ttm_bo_unref(&bo);
  11446. +       lbm_ttm_bo_kunmap(&map);
  11447. +       lbm_ttm_bo_unreserve(bo);
  11448. +       lbm_ttm_bo_unref(&bo);
  11449.  
  11450.         if (unlikely(ret != 0))
  11451.                 return -EFBIG;
  11452.  -381,7 +381,7 @@
  11453.  
  11454.         return io_size;
  11455.  out_unref:
  11456. -       ttm_bo_unref(&bo);
  11457. +       lbm_ttm_bo_unref(&bo);
  11458.         return ret;
  11459.  }
  11460.  
  11461.  -413,7 +413,7 @@
  11462.         kmap_end = (*f_pos + count - 1) >> PAGE_SHIFT;
  11463.         kmap_num = kmap_end - kmap_offset + 1;
  11464.  
  11465. -       ret = ttm_bo_reserve(bo, true, no_wait, false, 0);
  11466. +       ret = lbm_ttm_bo_reserve(bo, true, no_wait, false, 0);
  11467.  
  11468.         switch (ret) {
  11469.         case 0:
  11470.  -424,9 +424,9 @@
  11471.                 return ret;
  11472.         }
  11473.  
  11474. -       ret = ttm_bo_kmap(bo, kmap_offset, kmap_num, &map);
  11475. +       ret = lbm_ttm_bo_kmap(bo, kmap_offset, kmap_num, &map);
  11476.         if (unlikely(ret != 0)) {
  11477. -               ttm_bo_unreserve(bo);
  11478. +               lbm_ttm_bo_unreserve(bo);
  11479.                 return ret;
  11480.         }
  11481.  
  11482.  -438,9 +438,9 @@
  11483.         else
  11484.                 ret = copy_to_user(rbuf, virtual, io_size);
  11485.  
  11486. -       ttm_bo_kunmap(&map);
  11487. -       ttm_bo_unreserve(bo);
  11488. -       ttm_bo_unref(&bo);
  11489. +       lbm_ttm_bo_kunmap(&map);
  11490. +       lbm_ttm_bo_unreserve(bo);
  11491. +       lbm_ttm_bo_unref(&bo);
  11492.  
  11493.         if (unlikely(ret != 0))
  11494.                 return ret;
  11495. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_execbuf_util.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_execbuf_util.c
  11496. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_execbuf_util.c        2010-01-25 15:21:29.000000000 -0500
  11497. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_execbuf_util.c        2010-02-03 17:11:09.000000000 -0500
  11498.  -32,7 +32,7 @@
  11499.  #include <linux/sched.h>
  11500.  #include <linux/module.h>
  11501.  
  11502. -void ttm_eu_backoff_reservation(struct list_head *list)
  11503. +void lbm_ttm_eu_backoff_reservation(struct list_head *list)
  11504.  {
  11505.         struct ttm_validate_buffer *entry;
  11506.  
  11507.  -42,10 +42,10 @@
  11508.                         continue;
  11509.  
  11510.                 entry->reserved = false;
  11511. -               ttm_bo_unreserve(bo);
  11512. +               lbm_ttm_bo_unreserve(bo);
  11513.         }
  11514.  }
  11515. -EXPORT_SYMBOL(ttm_eu_backoff_reservation);
  11516. +EXPORT_SYMBOL(lbm_ttm_eu_backoff_reservation);
  11517.  
  11518.  /*
  11519.   * Reserve buffers for validation.
  11520.  -59,7 +59,7 @@
  11521.   * buffers in different orders.
  11522.   */
  11523.  
  11524. -int ttm_eu_reserve_buffers(struct list_head *list, uint32_t val_seq)
  11525. +int lbm_ttm_eu_reserve_buffers(struct list_head *list, uint32_t val_seq)
  11526.  {
  11527.         struct ttm_validate_buffer *entry;
  11528.         int ret;
  11529.  -69,11 +69,11 @@
  11530.                 struct ttm_buffer_object *bo = entry->bo;
  11531.  
  11532.                 entry->reserved = false;
  11533. -               ret = ttm_bo_reserve(bo, true, false, true, val_seq);
  11534. +               ret = lbm_ttm_bo_reserve(bo, true, false, true, val_seq);
  11535.                 if (ret != 0) {
  11536. -                       ttm_eu_backoff_reservation(list);
  11537. +                       lbm_ttm_eu_backoff_reservation(list);
  11538.                         if (ret == -EAGAIN) {
  11539. -                               ret = ttm_bo_wait_unreserved(bo, true);
  11540. +                               ret = lbm_ttm_bo_wait_unreserved(bo, true);
  11541.                                 if (unlikely(ret != 0))
  11542.                                         return ret;
  11543.                                 goto retry;
  11544.  -83,8 +83,8 @@
  11545.  
  11546.                 entry->reserved = true;
  11547.                 if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
  11548. -                       ttm_eu_backoff_reservation(list);
  11549. -                       ret = ttm_bo_wait_cpu(bo, false);
  11550. +                       lbm_ttm_eu_backoff_reservation(list);
  11551. +                       ret = lbm_ttm_bo_wait_cpu(bo, false);
  11552.                         if (ret)
  11553.                                 return ret;
  11554.                         goto retry;
  11555.  -92,9 +92,9 @@
  11556.         }
  11557.         return 0;
  11558.  }
  11559. -EXPORT_SYMBOL(ttm_eu_reserve_buffers);
  11560. +EXPORT_SYMBOL(lbm_ttm_eu_reserve_buffers);
  11561.  
  11562. -void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj)
  11563. +void lbm_ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj)
  11564.  {
  11565.         struct ttm_validate_buffer *entry;
  11566.  
  11567.  -108,10 +108,10 @@
  11568.                 bo->sync_obj = driver->sync_obj_ref(sync_obj);
  11569.                 bo->sync_obj_arg = entry->new_sync_obj_arg;
  11570.                 spin_unlock(&bo->lock);
  11571. -               ttm_bo_unreserve(bo);
  11572. +               lbm_ttm_bo_unreserve(bo);
  11573.                 entry->reserved = false;
  11574.                 if (old_sync_obj)
  11575.                         driver->sync_obj_unref(&old_sync_obj);
  11576.         }
  11577.  }
  11578. -EXPORT_SYMBOL(ttm_eu_fence_buffer_objects);
  11579. +EXPORT_SYMBOL(lbm_ttm_eu_fence_buffer_objects);
  11580. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_global.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_global.c
  11581. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_global.c      2010-01-25 15:21:29.000000000 -0500
  11582. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_global.c      2010-02-03 17:11:09.000000000 -0500
  11583.  -63,7 +63,7 @@
  11584.         }
  11585.  }
  11586.  
  11587. -int ttm_global_item_ref(struct ttm_global_reference *ref)
  11588. +int lbm_ttm_global_item_ref(struct ttm_global_reference *ref)
  11589.  {
  11590.         int ret;
  11591.         struct ttm_global_item *item = &glob[ref->global_type];
  11592.  -93,9 +93,9 @@
  11593.         item->object = NULL;
  11594.         return ret;
  11595.  }
  11596. -EXPORT_SYMBOL(ttm_global_item_ref);
  11597. +EXPORT_SYMBOL(lbm_ttm_global_item_ref);
  11598.  
  11599. -void ttm_global_item_unref(struct ttm_global_reference *ref)
  11600. +void lbm_ttm_global_item_unref(struct ttm_global_reference *ref)
  11601.  {
  11602.         struct ttm_global_item *item = &glob[ref->global_type];
  11603.  
  11604.  -108,5 +108,5 @@
  11605.         }
  11606.         mutex_unlock(&item->mutex);
  11607.  }
  11608. -EXPORT_SYMBOL(ttm_global_item_unref);
  11609. +EXPORT_SYMBOL(lbm_ttm_global_item_unref);
  11610.  
  11611. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_lock.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_lock.c
  11612. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_lock.c        2010-01-25 15:21:29.000000000 -0500
  11613. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_lock.c        2010-02-03 17:11:09.000000000 -0500
  11614.  -42,7 +42,7 @@
  11615.  #define TTM_VT_LOCK               (1 << 3)
  11616.  #define TTM_SUSPEND_LOCK          (1 << 4)
  11617.  
  11618. -void ttm_lock_init(struct ttm_lock *lock)
  11619. +void lbm_ttm_lock_init(struct ttm_lock *lock)
  11620.  {
  11621.         spin_lock_init(&lock->lock);
  11622.         init_waitqueue_head(&lock->queue);
  11623.  -51,16 +51,16 @@
  11624.         lock->kill_takers = false;
  11625.         lock->signal = SIGKILL;
  11626.  }
  11627. -EXPORT_SYMBOL(ttm_lock_init);
  11628. +EXPORT_SYMBOL(lbm_ttm_lock_init);
  11629.  
  11630. -void ttm_read_unlock(struct ttm_lock *lock)
  11631. +void lbm_ttm_read_unlock(struct ttm_lock *lock)
  11632.  {
  11633.         spin_lock(&lock->lock);
  11634.         if (--lock->rw == 0)
  11635.                 wake_up_all(&lock->queue);
  11636.         spin_unlock(&lock->lock);
  11637.  }
  11638. -EXPORT_SYMBOL(ttm_read_unlock);
  11639. +EXPORT_SYMBOL(lbm_ttm_read_unlock);
  11640.  
  11641.  static bool __ttm_read_lock(struct ttm_lock *lock)
  11642.  {
  11643.  -80,7 +80,7 @@
  11644.         return locked;
  11645.  }
  11646.  
  11647. -int ttm_read_lock(struct ttm_lock *lock, bool interruptible)
  11648. +int lbm_ttm_read_lock(struct ttm_lock *lock, bool interruptible)
  11649.  {
  11650.         int ret = 0;
  11651.  
  11652.  -91,7 +91,7 @@
  11653.                 wait_event(lock->queue, __ttm_read_lock(lock));
  11654.         return ret;
  11655.  }
  11656. -EXPORT_SYMBOL(ttm_read_lock);
  11657. +EXPORT_SYMBOL(lbm_ttm_read_lock);
  11658.  
  11659.  static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
  11660.  {
  11661.  -136,14 +136,14 @@
  11662.         return (locked) ? 0 : -EBUSY;
  11663.  }
  11664.  
  11665. -void ttm_write_unlock(struct ttm_lock *lock)
  11666. +void lbm_ttm_write_unlock(struct ttm_lock *lock)
  11667.  {
  11668.         spin_lock(&lock->lock);
  11669.         lock->rw = 0;
  11670.         wake_up_all(&lock->queue);
  11671.         spin_unlock(&lock->lock);
  11672.  }
  11673. -EXPORT_SYMBOL(ttm_write_unlock);
  11674. +EXPORT_SYMBOL(lbm_ttm_write_unlock);
  11675.  
  11676.  static bool __ttm_write_lock(struct ttm_lock *lock)
  11677.  {
  11678.  -166,7 +166,7 @@
  11679.         return locked;
  11680.  }
  11681.  
  11682. -int ttm_write_lock(struct ttm_lock *lock, bool interruptible)
  11683. +int lbm_ttm_write_lock(struct ttm_lock *lock, bool interruptible)
  11684.  {
  11685.         int ret = 0;
  11686.  
  11687.  -184,7 +184,7 @@
  11688.  
  11689.         return ret;
  11690.  }
  11691. -EXPORT_SYMBOL(ttm_write_lock);
  11692. +EXPORT_SYMBOL(lbm_ttm_write_lock);
  11693.  
  11694.  void ttm_write_lock_downgrade(struct ttm_lock *lock)
  11695.  {
  11696.  -236,7 +236,7 @@
  11697.         return locked;
  11698.  }
  11699.  
  11700. -int ttm_vt_lock(struct ttm_lock *lock,
  11701. +int lbm_ttm_vt_lock(struct ttm_lock *lock,
  11702.                 bool interruptible,
  11703.                 struct ttm_object_file *tfile)
  11704.  {
  11705.  -261,7 +261,7 @@
  11706.          * while holding it.
  11707.          */
  11708.  
  11709. -       ret = ttm_base_object_init(tfile, &lock->base, false,
  11710. +       ret = lbm_ttm_base_object_init(tfile, &lock->base, false,
  11711.                                    ttm_lock_type, &ttm_vt_lock_remove, NULL);
  11712.         if (ret)
  11713.                 (void)__ttm_vt_unlock(lock);
  11714.  -272,22 +272,23 @@
  11715.  
  11716.         return ret;
  11717.  }
  11718. -EXPORT_SYMBOL(ttm_vt_lock);
  11719. +EXPORT_SYMBOL(lbm_ttm_vt_lock);
  11720.  
  11721. -int ttm_vt_unlock(struct ttm_lock *lock)
  11722. +int lbm_ttm_vt_unlock(struct ttm_lock *lock)
  11723.  {
  11724. -       return ttm_ref_object_base_unref(lock->vt_holder,
  11725. +       return lbm_ttm_ref_object_base_unref(lock->vt_holder,
  11726.                                          lock->base.hash.key, TTM_REF_USAGE);
  11727.  }
  11728. -EXPORT_SYMBOL(ttm_vt_unlock);
  11729. +EXPORT_SYMBOL(lbm_ttm_vt_unlock);
  11730.  
  11731. -void ttm_suspend_unlock(struct ttm_lock *lock)
  11732. +void lbm_ttm_suspend_unlock(struct ttm_lock *lock)
  11733.  {
  11734.         spin_lock(&lock->lock);
  11735.         lock->flags &= ~TTM_SUSPEND_LOCK;
  11736.         wake_up_all(&lock->queue);
  11737.         spin_unlock(&lock->lock);
  11738.  }
  11739. +EXPORT_SYMBOL(lbm_ttm_suspend_unlock);
  11740.  
  11741.  static bool __ttm_suspend_lock(struct ttm_lock *lock)
  11742.  {
  11743.  -305,7 +306,8 @@
  11744.         return locked;
  11745.  }
  11746.  
  11747. -void ttm_suspend_lock(struct ttm_lock *lock)
  11748. +void lbm_ttm_suspend_lock(struct ttm_lock *lock)
  11749.  {
  11750.         wait_event(lock->queue, __ttm_suspend_lock(lock));
  11751.  }
  11752. +EXPORT_SYMBOL(lbm_ttm_suspend_lock);
  11753. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_memory.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_memory.c
  11754. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_memory.c      2010-01-25 15:21:29.000000000 -0500
  11755. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_memory.c      2010-02-03 17:11:09.000000000 -0500
  11756.  -354,7 +354,7 @@
  11757.  }
  11758.  #endif
  11759.  
  11760. -int ttm_mem_global_init(struct ttm_mem_global *glob)
  11761. +int lbm_ttm_mem_global_init(struct ttm_mem_global *glob)
  11762.  {
  11763.         struct sysinfo si;
  11764.         int ret;
  11765.  -396,12 +396,12 @@
  11766.         }
  11767.         return 0;
  11768.  out_no_zone:
  11769. -       ttm_mem_global_release(glob);
  11770. +       lbm_ttm_mem_global_release(glob);
  11771.         return ret;
  11772.  }
  11773. -EXPORT_SYMBOL(ttm_mem_global_init);
  11774. +EXPORT_SYMBOL(lbm_ttm_mem_global_init);
  11775.  
  11776. -void ttm_mem_global_release(struct ttm_mem_global *glob)
  11777. +void lbm_ttm_mem_global_release(struct ttm_mem_global *glob)
  11778.  {
  11779.         unsigned int i;
  11780.         struct ttm_mem_zone *zone;
  11781.  -417,7 +417,7 @@
  11782.         kobject_del(&glob->kobj);
  11783.         kobject_put(&glob->kobj);
  11784.  }
  11785. -EXPORT_SYMBOL(ttm_mem_global_release);
  11786. +EXPORT_SYMBOL(lbm_ttm_mem_global_release);
  11787.  
  11788.  static void ttm_check_swapping(struct ttm_mem_global *glob)
  11789.  {
  11790.  -458,12 +458,12 @@
  11791.         spin_unlock(&glob->lock);
  11792.  }
  11793.  
  11794. -void ttm_mem_global_free(struct ttm_mem_global *glob,
  11795. +void lbm_ttm_mem_global_free(struct ttm_mem_global *glob,
  11796.                          uint64_t amount)
  11797.  {
  11798.         return ttm_mem_global_free_zone(glob, NULL, amount);
  11799.  }
  11800. -EXPORT_SYMBOL(ttm_mem_global_free);
  11801. +EXPORT_SYMBOL(lbm_ttm_mem_global_free);
  11802.  
  11803.  static int ttm_mem_global_reserve(struct ttm_mem_global *glob,
  11804.                                   struct ttm_mem_zone *single_zone,
  11805.  -526,7 +526,7 @@
  11806.         return 0;
  11807.  }
  11808.  
  11809. -int ttm_mem_global_alloc(struct ttm_mem_global *glob, uint64_t memory,
  11810. +int lbm_ttm_mem_global_alloc(struct ttm_mem_global *glob, uint64_t memory,
  11811.                          bool no_wait, bool interruptible)
  11812.  {
  11813.         /**
  11814.  -537,7 +537,7 @@
  11815.         return ttm_mem_global_alloc_zone(glob, NULL, memory, no_wait,
  11816.                                          interruptible);
  11817.  }
  11818. -EXPORT_SYMBOL(ttm_mem_global_alloc);
  11819. +EXPORT_SYMBOL(lbm_ttm_mem_global_alloc);
  11820.  
  11821.  int ttm_mem_global_alloc_page(struct ttm_mem_global *glob,
  11822.                               struct page *page,
  11823.  -577,7 +577,7 @@
  11824.  }
  11825.  
  11826.  
  11827. -size_t ttm_round_pot(size_t size)
  11828. +size_t lbm_ttm_round_pot(size_t size)
  11829.  {
  11830.         if ((size & (size - 1)) == 0)
  11831.                 return size;
  11832.  -593,4 +593,4 @@
  11833.         }
  11834.         return 0;
  11835.  }
  11836. -EXPORT_SYMBOL(ttm_round_pot);
  11837. +EXPORT_SYMBOL(lbm_ttm_round_pot);
  11838. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_module.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_module.c
  11839. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_module.c      2010-01-25 15:21:29.000000000 -0500
  11840. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_module.c      2010-02-03 17:11:09.000000000 -0500
  11841.  -73,7 +73,7 @@
  11842.         ttm_global_init();
  11843.  
  11844.         atomic_set(&device_released, 0);
  11845. -       ret = drm_class_device_register(&ttm_drm_class_device);
  11846. +       ret = lbm_drm_class_device_register(&ttm_drm_class_device);
  11847.         if (unlikely(ret != 0))
  11848.                 goto out_no_dev_reg;
  11849.  
  11850.  -87,7 +87,7 @@
  11851.  
  11852.  static void __exit ttm_exit(void)
  11853.  {
  11854. -       drm_class_device_unregister(&ttm_drm_class_device);
  11855. +       lbm_drm_class_device_unregister(&ttm_drm_class_device);
  11856.  
  11857.         /**
  11858.          * Refuse to unload until the TTM device is released.
  11859. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_object.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_object.c
  11860. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_object.c      2010-01-25 15:21:29.000000000 -0500
  11861. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_object.c      2010-02-03 17:11:09.000000000 -0500
  11862.  -109,8 +109,8 @@
  11863.         struct drm_hash_item hash;
  11864.         struct list_head head;
  11865.         struct kref kref;
  11866. -       struct ttm_base_object *obj;
  11867.         enum ttm_ref_type ref_type;
  11868. +       struct ttm_base_object *obj;
  11869.         struct ttm_object_file *tfile;
  11870.  };
  11871.  
  11872.  -139,7 +139,7 @@
  11873.  }
  11874.  
  11875.  
  11876. -int ttm_base_object_init(struct ttm_object_file *tfile,
  11877. +int lbm_ttm_base_object_init(struct ttm_object_file *tfile,
  11878.                          struct ttm_base_object *base,
  11879.                          bool shareable,
  11880.                          enum ttm_object_type object_type,
  11881.  -157,26 +157,26 @@
  11882.         base->object_type = object_type;
  11883.         write_lock(&tdev->object_lock);
  11884.         kref_init(&base->refcount);
  11885. -       ret = drm_ht_just_insert_please(&tdev->object_hash,
  11886. +       ret = lbm_drm_ht_just_insert_please(&tdev->object_hash,
  11887.                                         &base->hash,
  11888.                                         (unsigned long)base, 31, 0, 0);
  11889.         write_unlock(&tdev->object_lock);
  11890.         if (unlikely(ret != 0))
  11891.                 goto out_err0;
  11892.  
  11893. -       ret = ttm_ref_object_add(tfile, base, TTM_REF_USAGE, NULL);
  11894. +       ret = lbm_ttm_ref_object_add(tfile, base, TTM_REF_USAGE, NULL);
  11895.         if (unlikely(ret != 0))
  11896.                 goto out_err1;
  11897.  
  11898. -       ttm_base_object_unref(&base);
  11899. +       lbm_ttm_base_object_unref(&base);
  11900.  
  11901.         return 0;
  11902.  out_err1:
  11903. -       (void)drm_ht_remove_item(&tdev->object_hash, &base->hash);
  11904. +       (void)lbm_drm_ht_remove_item(&tdev->object_hash, &base->hash);
  11905.  out_err0:
  11906.         return ret;
  11907.  }
  11908. -EXPORT_SYMBOL(ttm_base_object_init);
  11909. +EXPORT_SYMBOL(lbm_ttm_base_object_init);
  11910.  
  11911.  static void ttm_release_base(struct kref *kref)
  11912.  {
  11913.  -184,7 +184,7 @@
  11914.             container_of(kref, struct ttm_base_object, refcount);
  11915.         struct ttm_object_device *tdev = base->tfile->tdev;
  11916.  
  11917. -       (void)drm_ht_remove_item(&tdev->object_hash, &base->hash);
  11918. +       (void)lbm_drm_ht_remove_item(&tdev->object_hash, &base->hash);
  11919.         write_unlock(&tdev->object_lock);
  11920.         if (base->refcount_release) {
  11921.                 ttm_object_file_unref(&base->tfile);
  11922.  -193,7 +193,7 @@
  11923.         write_lock(&tdev->object_lock);
  11924.  }
  11925.  
  11926. -void ttm_base_object_unref(struct ttm_base_object **p_base)
  11927. +void lbm_ttm_base_object_unref(struct ttm_base_object **p_base)
  11928.  {
  11929.         struct ttm_base_object *base = *p_base;
  11930.         struct ttm_object_device *tdev = base->tfile->tdev;
  11931.  -209,9 +209,9 @@
  11932.         (void)kref_put(&base->refcount, &ttm_release_base);
  11933.         write_unlock(&tdev->object_lock);
  11934.  }
  11935. -EXPORT_SYMBOL(ttm_base_object_unref);
  11936. +EXPORT_SYMBOL(lbm_ttm_base_object_unref);
  11937.  
  11938. -struct ttm_base_object *ttm_base_object_lookup(struct ttm_object_file *tfile,
  11939. +struct ttm_base_object *lbm_ttm_base_object_lookup(struct ttm_object_file *tfile,
  11940.                                                uint32_t key)
  11941.  {
  11942.         struct ttm_object_device *tdev = tfile->tdev;
  11943.  -220,7 +220,7 @@
  11944.         int ret;
  11945.  
  11946.         read_lock(&tdev->object_lock);
  11947. -       ret = drm_ht_find_item(&tdev->object_hash, key, &hash);
  11948. +       ret = lbm_drm_ht_find_item(&tdev->object_hash, key, &hash);
  11949.  
  11950.         if (likely(ret == 0)) {
  11951.                 base = drm_hash_entry(hash, struct ttm_base_object, hash);
  11952.  -234,15 +234,15 @@
  11953.         if (tfile != base->tfile && !base->shareable) {
  11954.                 printk(KERN_ERR TTM_PFX
  11955.                        "Attempted access of non-shareable object.\n");
  11956. -               ttm_base_object_unref(&base);
  11957. +               lbm_ttm_base_object_unref(&base);
  11958.                 return NULL;
  11959.         }
  11960.  
  11961.         return base;
  11962.  }
  11963. -EXPORT_SYMBOL(ttm_base_object_lookup);
  11964. +EXPORT_SYMBOL(lbm_ttm_base_object_lookup);
  11965.  
  11966. -int ttm_ref_object_add(struct ttm_object_file *tfile,
  11967. +int lbm_ttm_ref_object_add(struct ttm_object_file *tfile,
  11968.                        struct ttm_base_object *base,
  11969.                        enum ttm_ref_type ref_type, bool *existed)
  11970.  {
  11971.  -257,7 +257,7 @@
  11972.  
  11973.         while (ret == -EINVAL) {
  11974.                 read_lock(&tfile->lock);
  11975. -               ret = drm_ht_find_item(ht, base->hash.key, &hash);
  11976. +               ret = lbm_drm_ht_find_item(ht, base->hash.key, &hash);
  11977.  
  11978.                 if (ret == 0) {
  11979.                         ref = drm_hash_entry(hash, struct ttm_ref_object, hash);
  11980.  -267,13 +267,13 @@
  11981.                 }
  11982.  
  11983.                 read_unlock(&tfile->lock);
  11984. -               ret = ttm_mem_global_alloc(mem_glob, sizeof(*ref),
  11985. +               ret = lbm_ttm_mem_global_alloc(mem_glob, sizeof(*ref),
  11986.                                            false, false);
  11987.                 if (unlikely(ret != 0))
  11988.                         return ret;
  11989.                 ref = kmalloc(sizeof(*ref), GFP_KERNEL);
  11990.                 if (unlikely(ref == NULL)) {
  11991. -                       ttm_mem_global_free(mem_glob, sizeof(*ref));
  11992. +                       lbm_ttm_mem_global_free(mem_glob, sizeof(*ref));
  11993.                         return -ENOMEM;
  11994.                 }
  11995.  
  11996.  -284,7 +284,7 @@
  11997.                 kref_init(&ref->kref);
  11998.  
  11999.                 write_lock(&tfile->lock);
  12000. -               ret = drm_ht_insert_item(ht, &ref->hash);
  12001. +               ret = lbm_drm_ht_insert_item(ht, &ref->hash);
  12002.  
  12003.                 if (likely(ret == 0)) {
  12004.                         list_add_tail(&ref->head, &tfile->ref_list);
  12005.  -298,13 +298,13 @@
  12006.                 write_unlock(&tfile->lock);
  12007.                 BUG_ON(ret != -EINVAL);
  12008.  
  12009. -               ttm_mem_global_free(mem_glob, sizeof(*ref));
  12010. +               lbm_ttm_mem_global_free(mem_glob, sizeof(*ref));
  12011.                 kfree(ref);
  12012.         }
  12013.  
  12014.         return ret;
  12015.  }
  12016. -EXPORT_SYMBOL(ttm_ref_object_add);
  12017. +EXPORT_SYMBOL(lbm_ttm_ref_object_add);
  12018.  
  12019.  static void ttm_ref_object_release(struct kref *kref)
  12020.  {
  12021.  -316,20 +316,20 @@
  12022.         struct ttm_mem_global *mem_glob = tfile->tdev->mem_glob;
  12023.  
  12024.         ht = &tfile->ref_hash[ref->ref_type];
  12025. -       (void)drm_ht_remove_item(ht, &ref->hash);
  12026. +       (void)lbm_drm_ht_remove_item(ht, &ref->hash);
  12027.         list_del(&ref->head);
  12028.         write_unlock(&tfile->lock);
  12029.  
  12030.         if (ref->ref_type != TTM_REF_USAGE && base->ref_obj_release)
  12031.                 base->ref_obj_release(base, ref->ref_type);
  12032.  
  12033. -       ttm_base_object_unref(&ref->obj);
  12034. -       ttm_mem_global_free(mem_glob, sizeof(*ref));
  12035. +       lbm_ttm_base_object_unref(&ref->obj);
  12036. +       lbm_ttm_mem_global_free(mem_glob, sizeof(*ref));
  12037.         kfree(ref);
  12038.         write_lock(&tfile->lock);
  12039.  }
  12040.  
  12041. -int ttm_ref_object_base_unref(struct ttm_object_file *tfile,
  12042. +int lbm_ttm_ref_object_base_unref(struct ttm_object_file *tfile,
  12043.                               unsigned long key, enum ttm_ref_type ref_type)
  12044.  {
  12045.         struct drm_open_hash *ht = &tfile->ref_hash[ref_type];
  12046.  -338,7 +338,7 @@
  12047.         int ret;
  12048.  
  12049.         write_lock(&tfile->lock);
  12050. -       ret = drm_ht_find_item(ht, key, &hash);
  12051. +       ret = lbm_drm_ht_find_item(ht, key, &hash);
  12052.         if (unlikely(ret != 0)) {
  12053.                 write_unlock(&tfile->lock);
  12054.                 return -EINVAL;
  12055.  -348,9 +348,9 @@
  12056.         write_unlock(&tfile->lock);
  12057.         return 0;
  12058.  }
  12059. -EXPORT_SYMBOL(ttm_ref_object_base_unref);
  12060. +EXPORT_SYMBOL(lbm_ttm_ref_object_base_unref);
  12061.  
  12062. -void ttm_object_file_release(struct ttm_object_file **p_tfile)
  12063. +void lbm_ttm_object_file_release(struct ttm_object_file **p_tfile)
  12064.  {
  12065.         struct ttm_ref_object *ref;
  12066.         struct list_head *list;
  12067.  -372,14 +372,14 @@
  12068.         }
  12069.  
  12070.         for (i = 0; i < TTM_REF_NUM; ++i)
  12071. -               drm_ht_remove(&tfile->ref_hash[i]);
  12072. +               lbm_drm_ht_remove(&tfile->ref_hash[i]);
  12073.  
  12074.         write_unlock(&tfile->lock);
  12075.         ttm_object_file_unref(&tfile);
  12076.  }
  12077. -EXPORT_SYMBOL(ttm_object_file_release);
  12078. +EXPORT_SYMBOL(lbm_ttm_object_file_release);
  12079.  
  12080. -struct ttm_object_file *ttm_object_file_init(struct ttm_object_device *tdev,
  12081. +struct ttm_object_file *lbm_ttm_object_file_init(struct ttm_object_device *tdev,
  12082.                                              unsigned int hash_order)
  12083.  {
  12084.         struct ttm_object_file *tfile = kmalloc(sizeof(*tfile), GFP_KERNEL);
  12085.  -396,7 +396,7 @@
  12086.         INIT_LIST_HEAD(&tfile->ref_list);
  12087.  
  12088.         for (i = 0; i < TTM_REF_NUM; ++i) {
  12089. -               ret = drm_ht_create(&tfile->ref_hash[i], hash_order);
  12090. +               ret = lbm_drm_ht_create(&tfile->ref_hash[i], hash_order);
  12091.                 if (ret) {
  12092.                         j = i;
  12093.                         goto out_err;
  12094.  -406,15 +406,15 @@
  12095.         return tfile;
  12096.  out_err:
  12097.         for (i = 0; i < j; ++i)
  12098. -               drm_ht_remove(&tfile->ref_hash[i]);
  12099. +               lbm_drm_ht_remove(&tfile->ref_hash[i]);
  12100.  
  12101.         kfree(tfile);
  12102.  
  12103.         return NULL;
  12104.  }
  12105. -EXPORT_SYMBOL(ttm_object_file_init);
  12106. +EXPORT_SYMBOL(lbm_ttm_object_file_init);
  12107.  
  12108. -struct ttm_object_device *ttm_object_device_init(struct ttm_mem_global
  12109. +struct ttm_object_device *lbm_ttm_object_device_init(struct ttm_mem_global
  12110.                                                  *mem_glob,
  12111.                                                  unsigned int hash_order)
  12112.  {
  12113.  -427,7 +427,7 @@
  12114.         tdev->mem_glob = mem_glob;
  12115.         rwlock_init(&tdev->object_lock);
  12116.         atomic_set(&tdev->object_count, 0);
  12117. -       ret = drm_ht_create(&tdev->object_hash, hash_order);
  12118. +       ret = lbm_drm_ht_create(&tdev->object_hash, hash_order);
  12119.  
  12120.         if (likely(ret == 0))
  12121.                 return tdev;
  12122.  -435,18 +435,18 @@
  12123.         kfree(tdev);
  12124.         return NULL;
  12125.  }
  12126. -EXPORT_SYMBOL(ttm_object_device_init);
  12127. +EXPORT_SYMBOL(lbm_ttm_object_device_init);
  12128.  
  12129. -void ttm_object_device_release(struct ttm_object_device **p_tdev)
  12130. +void lbm_ttm_object_device_release(struct ttm_object_device **p_tdev)
  12131.  {
  12132.         struct ttm_object_device *tdev = *p_tdev;
  12133.  
  12134.         *p_tdev = NULL;
  12135.  
  12136.         write_lock(&tdev->object_lock);
  12137. -       drm_ht_remove(&tdev->object_hash);
  12138. +       lbm_drm_ht_remove(&tdev->object_hash);
  12139.         write_unlock(&tdev->object_lock);
  12140.  
  12141.         kfree(tdev);
  12142.  }
  12143. -EXPORT_SYMBOL(ttm_object_device_release);
  12144. +EXPORT_SYMBOL(lbm_ttm_object_device_release);
  12145. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_tt.c linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_tt.c
  12146. --- linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_tt.c  2010-01-25 15:21:29.000000000 -0500
  12147. +++ linux-backports-modules-2.6.32-2.6.32/updates/nouveau/ttm/ttm_tt.c  2010-02-03 17:11:09.000000000 -0500
  12148.  -116,7 +116,7 @@
  12149.                         set_page_dirty_lock(page);
  12150.  
  12151.                 ttm->pages[i] = NULL;
  12152. -               ttm_mem_global_free(ttm->glob->mem_glob, PAGE_SIZE);
  12153. +               lbm_ttm_mem_global_free(ttm->glob->mem_glob, PAGE_SIZE);
  12154.                 put_page(page);
  12155.         }
  12156.         ttm->state = tt_unpopulated;
  12157.  -163,7 +163,7 @@
  12158.         return __ttm_tt_get_page(ttm, index);
  12159.  }
  12160.  
  12161. -int ttm_tt_populate(struct ttm_tt *ttm)
  12162. +int lbm_ttm_tt_populate(struct ttm_tt *ttm)
  12163.  {
  12164.         struct page *page;
  12165.         unsigned long i;
  12166.  -192,23 +192,32 @@
  12167.         ttm->state = tt_unbound;
  12168.         return 0;
  12169.  }
  12170. -EXPORT_SYMBOL(ttm_tt_populate);
  12171. +EXPORT_SYMBOL(lbm_ttm_tt_populate);
  12172.  
  12173.  #ifdef CONFIG_X86
  12174.  static inline int ttm_tt_set_page_caching(struct page *p,
  12175.                                           enum ttm_caching_state c_state)
  12176.  {
  12177. +       int ret = 0;
  12178. +
  12179.         if (PageHighMem(p))
  12180.                 return 0;
  12181.  
  12182. -       switch (c_state) {
  12183. -       case tt_cached:
  12184. -               return set_pages_wb(p, 1);
  12185. -       case tt_wc:
  12186. -           return set_memory_wc((unsigned long) page_address(p), 1);
  12187. -       default:
  12188. -               return set_pages_uc(p, 1);
  12189. +       if (get_page_memtype(p) != -1) {
  12190. +               /* p isn't in the default caching state, set it to
  12191. +                * writeback first to free its current memtype. */
  12192. +
  12193. +               ret = set_pages_wb(p, 1);
  12194. +               if (ret)
  12195. +                       return ret;
  12196.         }
  12197. +
  12198. +       if (c_state == tt_wc)
  12199. +               ret = set_memory_wc((unsigned long) page_address(p), 1);
  12200. +       else if (c_state == tt_uncached)
  12201. +               ret = set_pages_uc(p, 1);
  12202. +
  12203. +       return ret;
  12204.  }
  12205.  #else /* CONFIG_X86 */
  12206.  static inline int ttm_tt_set_page_caching(struct page *p,
  12207.  -234,13 +243,13 @@
  12208.                 return 0;
  12209.  
  12210.         if (c_state != tt_cached) {
  12211. -               ret = ttm_tt_populate(ttm);
  12212. +               ret = lbm_ttm_tt_populate(ttm);
  12213.                 if (unlikely(ret != 0))
  12214.                         return ret;
  12215.         }
  12216.  
  12217.         if (ttm->caching_state == tt_cached)
  12218. -               drm_clflush_pages(ttm->pages, ttm->num_pages);
  12219. +               lbm_drm_clflush_pages(ttm->pages, ttm->num_pages);
  12220.  
  12221.         for (i = 0; i < ttm->num_pages; ++i) {
  12222.                 cur_page = ttm->pages[i];
  12223.  -267,7 +276,7 @@
  12224.         return ret;
  12225.  }
  12226.  
  12227. -int ttm_tt_set_placement_caching(struct ttm_tt *ttm, uint32_t placement)
  12228. +int lbm_ttm_tt_set_placement_caching(struct ttm_tt *ttm, uint32_t placement)
  12229.  {
  12230.         enum ttm_caching_state state;
  12231.  
  12232.  -280,7 +289,7 @@
  12233.  
  12234.         return ttm_tt_set_caching(ttm, state);
  12235.  }
  12236. -EXPORT_SYMBOL(ttm_tt_set_placement_caching);
  12237. +EXPORT_SYMBOL(lbm_ttm_tt_set_placement_caching);
  12238.  
  12239.  static void ttm_tt_free_alloced_pages(struct ttm_tt *ttm)
  12240.  {
  12241.  -354,7 +363,7 @@
  12242.          * Account user pages as lowmem pages for now.
  12243.          */
  12244.  
  12245. -       ret = ttm_mem_global_alloc(mem_glob, num_pages * PAGE_SIZE,
  12246. +       ret = lbm_ttm_mem_global_alloc(mem_glob, num_pages * PAGE_SIZE,
  12247.                                    false, false);
  12248.         if (unlikely(ret != 0))
  12249.                 return ret;
  12250.  -366,7 +375,7 @@
  12251.  
  12252.         if (ret != num_pages && write) {
  12253.                 ttm_tt_free_user_pages(ttm);
  12254. -               ttm_mem_global_free(mem_glob, num_pages * PAGE_SIZE);
  12255. +               lbm_ttm_mem_global_free(mem_glob, num_pages * PAGE_SIZE);
  12256.                 return -ENOMEM;
  12257.         }
  12258.  
  12259.  -427,7 +436,7 @@
  12260.         }
  12261.  }
  12262.  
  12263. -int ttm_tt_bind(struct ttm_tt *ttm, struct ttm_mem_reg *bo_mem)
  12264. +int lbm_ttm_tt_bind(struct ttm_tt *ttm, struct ttm_mem_reg *bo_mem)
  12265.  {
  12266.         int ret = 0;
  12267.         struct ttm_backend *be;
  12268.  -440,7 +449,7 @@
  12269.  
  12270.         be = ttm->be;
  12271.  
  12272. -       ret = ttm_tt_populate(ttm);
  12273. +       ret = lbm_ttm_tt_populate(ttm);
  12274.         if (ret)
  12275.                 return ret;
  12276.  
  12277.  -456,7 +465,7 @@
  12278.                 ttm->page_flags |= TTM_PAGE_FLAG_USER_DIRTY;
  12279.         return 0;
  12280.  }
  12281. -EXPORT_SYMBOL(ttm_tt_bind);
  12282. +EXPORT_SYMBOL(lbm_ttm_tt_bind);
  12283.  
  12284.  static int ttm_tt_swapin(struct ttm_tt *ttm)
  12285.  {
  12286. diff -Nru linux-backports-modules-2.6.32-2.6.32/updates/UPDATE-NOUVEAU linux-backports-modules-2.6.32-2.6.32/updates/UPDATE-NOUVEAU
  12287. --- linux-backports-modules-2.6.32-2.6.32/updates/UPDATE-NOUVEAU        2010-01-25 15:21:29.000000000 -0500
  12288. +++ linux-backports-modules-2.6.32-2.6.32/updates/UPDATE-NOUVEAU        2010-02-03 17:07:13.000000000 -0500
  12289.  -2,7 +2,7 @@
  12290.  #
  12291.  #
  12292.  #
  12293. -src="$HOME/git2/linux-2.6"
  12294. +src="$HOME/source/linux-2.6"
  12295.  drm="$src/drivers/gpu/drm/"
  12296.  rm -rf nouveau
  12297.  mkdir nouveau nouveau/include
  12298.  -14,5 +14,5 @@
  12299.  cp -rp "$src"/include/drm/ nouveau/include
  12300.  
  12301.  mkdir nouveau/include/linux
  12302. -cp /home/apw/git2/linux-2.6/include/linux/list_sort.h nouveau/include/linux/
  12303. -cp /home/apw/git2/linux-2.6/lib/list_sort.c nouveau/
  12304. +cp /home/sarvatt/source/linux-2.6/include/linux/list_sort.h nouveau/include/linux/
  12305. +cp /home/sarvatt/source/linux-2.6/lib/list_sort.c nouveau/
RAW Paste Data
Top