diff options
Diffstat (limited to 'drivers')
30 files changed, 330 insertions, 484 deletions
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h index 3dc3c9d79ae4..d842cce11448 100644 --- a/drivers/char/drm/drmP.h +++ b/drivers/char/drm/drmP.h | |||
@@ -544,16 +544,14 @@ typedef struct ati_pcigart_info { | |||
544 | struct drm_device; | 544 | struct drm_device; |
545 | 545 | ||
546 | struct drm_driver { | 546 | struct drm_driver { |
547 | int (*preinit) (struct drm_device *, unsigned long flags); | 547 | int (*load) (struct drm_device *, unsigned long flags); |
548 | void (*prerelease) (struct drm_device *, struct file * filp); | 548 | int (*firstopen) (struct drm_device *); |
549 | void (*pretakedown) (struct drm_device *); | 549 | int (*open) (struct drm_device *, drm_file_t *); |
550 | int (*postcleanup) (struct drm_device *); | 550 | void (*preclose) (struct drm_device *, struct file * filp); |
551 | int (*presetup) (struct drm_device *); | 551 | void (*postclose) (struct drm_device *, drm_file_t *); |
552 | int (*postsetup) (struct drm_device *); | 552 | void (*lastclose) (struct drm_device *); |
553 | int (*unload) (struct drm_device *); | ||
553 | int (*dma_ioctl) (DRM_IOCTL_ARGS); | 554 | int (*dma_ioctl) (DRM_IOCTL_ARGS); |
554 | int (*open_helper) (struct drm_device *, drm_file_t *); | ||
555 | void (*free_filp_priv) (struct drm_device *, drm_file_t *); | ||
556 | void (*release) (struct drm_device *, struct file * filp); | ||
557 | void (*dma_ready) (struct drm_device *); | 555 | void (*dma_ready) (struct drm_device *); |
558 | int (*dma_quiescent) (struct drm_device *); | 556 | int (*dma_quiescent) (struct drm_device *); |
559 | int (*context_ctor) (struct drm_device * dev, int context); | 557 | int (*context_ctor) (struct drm_device * dev, int context); |
@@ -579,16 +577,25 @@ struct drm_driver { | |||
579 | 577 | ||
580 | /* these have to be filled in */ | 578 | /* these have to be filled in */ |
581 | 579 | ||
582 | int (*postinit) (struct drm_device *, unsigned long flags); | 580 | irqreturn_t(*irq_handler) (DRM_IRQ_ARGS); |
583 | irqreturn_t(*irq_handler) (DRM_IRQ_ARGS); | ||
584 | void (*irq_preinstall) (struct drm_device * dev); | 581 | void (*irq_preinstall) (struct drm_device * dev); |
585 | void (*irq_postinstall) (struct drm_device * dev); | 582 | void (*irq_postinstall) (struct drm_device * dev); |
586 | void (*irq_uninstall) (struct drm_device * dev); | 583 | void (*irq_uninstall) (struct drm_device * dev); |
587 | void (*reclaim_buffers) (struct drm_device * dev, struct file * filp); | 584 | void (*reclaim_buffers) (struct drm_device * dev, struct file * filp); |
585 | void (*reclaim_buffers_locked) (struct drm_device *drv, | ||
586 | struct file *filp); | ||
588 | unsigned long (*get_map_ofs) (drm_map_t * map); | 587 | unsigned long (*get_map_ofs) (drm_map_t * map); |
589 | unsigned long (*get_reg_ofs) (struct drm_device * dev); | 588 | unsigned long (*get_reg_ofs) (struct drm_device * dev); |
590 | void (*set_version) (struct drm_device * dev, drm_set_version_t * sv); | 589 | void (*set_version) (struct drm_device * dev, drm_set_version_t * sv); |
591 | int (*version) (drm_version_t * version); | 590 | int (*version) (drm_version_t * version); |
591 | |||
592 | int major; | ||
593 | int minor; | ||
594 | int patchlevel; | ||
595 | char *name; | ||
596 | char *desc; | ||
597 | char *date; | ||
598 | |||
592 | u32 driver_features; | 599 | u32 driver_features; |
593 | int dev_priv_size; | 600 | int dev_priv_size; |
594 | drm_ioctl_desc_t *ioctls; | 601 | drm_ioctl_desc_t *ioctls; |
@@ -772,7 +779,7 @@ extern int drm_ioctl(struct inode *inode, struct file *filp, | |||
772 | unsigned int cmd, unsigned long arg); | 779 | unsigned int cmd, unsigned long arg); |
773 | extern long drm_compat_ioctl(struct file *filp, | 780 | extern long drm_compat_ioctl(struct file *filp, |
774 | unsigned int cmd, unsigned long arg); | 781 | unsigned int cmd, unsigned long arg); |
775 | extern int drm_takedown(drm_device_t * dev); | 782 | extern int drm_lastclose(drm_device_t *dev); |
776 | 783 | ||
777 | /* Device support (drm_fops.h) */ | 784 | /* Device support (drm_fops.h) */ |
778 | extern int drm_open(struct inode *inode, struct file *filp); | 785 | extern int drm_open(struct inode *inode, struct file *filp); |
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c index 4dff7554eb08..d8ff84bdc3e7 100644 --- a/drivers/char/drm/drm_drv.c +++ b/drivers/char/drm/drm_drv.c | |||
@@ -129,7 +129,7 @@ static drm_ioctl_desc_t drm_ioctls[] = { | |||
129 | * | 129 | * |
130 | * \sa drm_device | 130 | * \sa drm_device |
131 | */ | 131 | */ |
132 | int drm_takedown(drm_device_t * dev) | 132 | int drm_lastclose(drm_device_t * dev) |
133 | { | 133 | { |
134 | drm_magic_entry_t *pt, *next; | 134 | drm_magic_entry_t *pt, *next; |
135 | drm_map_list_t *r_list; | 135 | drm_map_list_t *r_list; |
@@ -138,9 +138,9 @@ int drm_takedown(drm_device_t * dev) | |||
138 | 138 | ||
139 | DRM_DEBUG("\n"); | 139 | DRM_DEBUG("\n"); |
140 | 140 | ||
141 | if (dev->driver->pretakedown) | 141 | if (dev->driver->lastclose) |
142 | dev->driver->pretakedown(dev); | 142 | dev->driver->lastclose(dev); |
143 | DRM_DEBUG("driver pretakedown completed\n"); | 143 | DRM_DEBUG("driver lastclose completed\n"); |
144 | 144 | ||
145 | if (dev->unique) { | 145 | if (dev->unique) { |
146 | drm_free(dev->unique, strlen(dev->unique) + 1, DRM_MEM_DRIVER); | 146 | drm_free(dev->unique, strlen(dev->unique) + 1, DRM_MEM_DRIVER); |
@@ -233,7 +233,7 @@ int drm_takedown(drm_device_t * dev) | |||
233 | } | 233 | } |
234 | up(&dev->struct_sem); | 234 | up(&dev->struct_sem); |
235 | 235 | ||
236 | DRM_DEBUG("takedown completed\n"); | 236 | DRM_DEBUG("lastclose completed\n"); |
237 | return 0; | 237 | return 0; |
238 | } | 238 | } |
239 | 239 | ||
@@ -281,7 +281,7 @@ EXPORT_SYMBOL(drm_init); | |||
281 | /** | 281 | /** |
282 | * Called via cleanup_module() at module unload time. | 282 | * Called via cleanup_module() at module unload time. |
283 | * | 283 | * |
284 | * Cleans up all DRM device, calling takedown(). | 284 | * Cleans up all DRM device, calling drm_lastclose(). |
285 | * | 285 | * |
286 | * \sa drm_init | 286 | * \sa drm_init |
287 | */ | 287 | */ |
@@ -294,7 +294,7 @@ static void drm_cleanup(drm_device_t * dev) | |||
294 | return; | 294 | return; |
295 | } | 295 | } |
296 | 296 | ||
297 | drm_takedown(dev); | 297 | drm_lastclose(dev); |
298 | 298 | ||
299 | if (dev->maplist) { | 299 | if (dev->maplist) { |
300 | drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS); | 300 | drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS); |
@@ -317,8 +317,8 @@ static void drm_cleanup(drm_device_t * dev) | |||
317 | dev->agp = NULL; | 317 | dev->agp = NULL; |
318 | } | 318 | } |
319 | 319 | ||
320 | if (dev->driver->postcleanup) | 320 | if (dev->driver->unload) |
321 | dev->driver->postcleanup(dev); | 321 | dev->driver->unload(dev); |
322 | 322 | ||
323 | drm_put_head(&dev->primary); | 323 | drm_put_head(&dev->primary); |
324 | if (drm_put_dev(dev)) | 324 | if (drm_put_dev(dev)) |
@@ -432,14 +432,17 @@ static int drm_version(struct inode *inode, struct file *filp, | |||
432 | drm_device_t *dev = priv->head->dev; | 432 | drm_device_t *dev = priv->head->dev; |
433 | drm_version_t __user *argp = (void __user *)arg; | 433 | drm_version_t __user *argp = (void __user *)arg; |
434 | drm_version_t version; | 434 | drm_version_t version; |
435 | int ret; | 435 | int len; |
436 | 436 | ||
437 | if (copy_from_user(&version, argp, sizeof(version))) | 437 | if (copy_from_user(&version, argp, sizeof(version))) |
438 | return -EFAULT; | 438 | return -EFAULT; |
439 | 439 | ||
440 | /* version is a required function to return the personality module version */ | 440 | version.version_major = dev->driver->major; |
441 | if ((ret = dev->driver->version(&version))) | 441 | version.version_minor = dev->driver->minor; |
442 | return ret; | 442 | version.version_patchlevel = dev->driver->patchlevel; |
443 | DRM_COPY(version.name, dev->driver->name); | ||
444 | DRM_COPY(version.date, dev->driver->date); | ||
445 | DRM_COPY(version.desc, dev->driver->desc); | ||
443 | 446 | ||
444 | if (copy_to_user(argp, &version, sizeof(version))) | 447 | if (copy_to_user(argp, &version, sizeof(version))) |
445 | return -EFAULT; | 448 | return -EFAULT; |
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c index bf0a740122bf..f57f7d1a281e 100644 --- a/drivers/char/drm/drm_fops.c +++ b/drivers/char/drm/drm_fops.c | |||
@@ -45,8 +45,8 @@ static int drm_setup(drm_device_t * dev) | |||
45 | int i; | 45 | int i; |
46 | int ret; | 46 | int ret; |
47 | 47 | ||
48 | if (dev->driver->presetup) { | 48 | if (dev->driver->firstopen) { |
49 | ret = dev->driver->presetup(dev); | 49 | ret = dev->driver->firstopen(dev); |
50 | if (ret != 0) | 50 | if (ret != 0) |
51 | return ret; | 51 | return ret; |
52 | } | 52 | } |
@@ -109,8 +109,6 @@ static int drm_setup(drm_device_t * dev) | |||
109 | * drm_select_queue fails between the time the interrupt is | 109 | * drm_select_queue fails between the time the interrupt is |
110 | * initialized and the time the queues are initialized. | 110 | * initialized and the time the queues are initialized. |
111 | */ | 111 | */ |
112 | if (dev->driver->postsetup) | ||
113 | dev->driver->postsetup(dev); | ||
114 | 112 | ||
115 | return 0; | 113 | return 0; |
116 | } | 114 | } |
@@ -167,7 +165,7 @@ EXPORT_SYMBOL(drm_open); | |||
167 | * If the hardware lock is held then free it, and take it again for the kernel | 165 | * If the hardware lock is held then free it, and take it again for the kernel |
168 | * context since it's necessary to reclaim buffers. Unlink the file private | 166 | * context since it's necessary to reclaim buffers. Unlink the file private |
169 | * data from its list and free it. Decreases the open count and if it reaches | 167 | * data from its list and free it. Decreases the open count and if it reaches |
170 | * zero calls takedown(). | 168 | * zero calls drm_lastclose(). |
171 | */ | 169 | */ |
172 | int drm_release(struct inode *inode, struct file *filp) | 170 | int drm_release(struct inode *inode, struct file *filp) |
173 | { | 171 | { |
@@ -180,8 +178,8 @@ int drm_release(struct inode *inode, struct file *filp) | |||
180 | 178 | ||
181 | DRM_DEBUG("open_count = %d\n", dev->open_count); | 179 | DRM_DEBUG("open_count = %d\n", dev->open_count); |
182 | 180 | ||
183 | if (dev->driver->prerelease) | 181 | if (dev->driver->preclose) |
184 | dev->driver->prerelease(dev, filp); | 182 | dev->driver->preclose(dev, filp); |
185 | 183 | ||
186 | /* ======================================================== | 184 | /* ======================================================== |
187 | * Begin inline drm_release | 185 | * Begin inline drm_release |
@@ -197,8 +195,8 @@ int drm_release(struct inode *inode, struct file *filp) | |||
197 | DRM_DEBUG("File %p released, freeing lock for context %d\n", | 195 | DRM_DEBUG("File %p released, freeing lock for context %d\n", |
198 | filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock)); | 196 | filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock)); |
199 | 197 | ||
200 | if (dev->driver->release) | 198 | if (dev->driver->reclaim_buffers_locked) |
201 | dev->driver->release(dev, filp); | 199 | dev->driver->reclaim_buffers_locked(dev, filp); |
202 | 200 | ||
203 | drm_lock_free(dev, &dev->lock.hw_lock->lock, | 201 | drm_lock_free(dev, &dev->lock.hw_lock->lock, |
204 | _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock)); | 202 | _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock)); |
@@ -207,7 +205,7 @@ int drm_release(struct inode *inode, struct file *filp) | |||
207 | hardware at this point, possibly | 205 | hardware at this point, possibly |
208 | processed via a callback to the X | 206 | processed via a callback to the X |
209 | server. */ | 207 | server. */ |
210 | } else if (dev->driver->release && priv->lock_count | 208 | } else if (dev->driver->reclaim_buffers_locked && priv->lock_count |
211 | && dev->lock.hw_lock) { | 209 | && dev->lock.hw_lock) { |
212 | /* The lock is required to reclaim buffers */ | 210 | /* The lock is required to reclaim buffers */ |
213 | DECLARE_WAITQUEUE(entry, current); | 211 | DECLARE_WAITQUEUE(entry, current); |
@@ -237,15 +235,14 @@ int drm_release(struct inode *inode, struct file *filp) | |||
237 | __set_current_state(TASK_RUNNING); | 235 | __set_current_state(TASK_RUNNING); |
238 | remove_wait_queue(&dev->lock.lock_queue, &entry); | 236 | remove_wait_queue(&dev->lock.lock_queue, &entry); |
239 | if (!retcode) { | 237 | if (!retcode) { |
240 | if (dev->driver->release) | 238 | dev->driver->reclaim_buffers_locked(dev, filp); |
241 | dev->driver->release(dev, filp); | ||
242 | drm_lock_free(dev, &dev->lock.hw_lock->lock, | 239 | drm_lock_free(dev, &dev->lock.hw_lock->lock, |
243 | DRM_KERNEL_CONTEXT); | 240 | DRM_KERNEL_CONTEXT); |
244 | } | 241 | } |
245 | } | 242 | } |
246 | 243 | ||
247 | if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) | 244 | if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) && |
248 | && !dev->driver->release) { | 245 | !dev->driver->reclaim_buffers_locked) { |
249 | dev->driver->reclaim_buffers(dev, filp); | 246 | dev->driver->reclaim_buffers(dev, filp); |
250 | } | 247 | } |
251 | 248 | ||
@@ -292,8 +289,8 @@ int drm_release(struct inode *inode, struct file *filp) | |||
292 | } | 289 | } |
293 | up(&dev->struct_sem); | 290 | up(&dev->struct_sem); |
294 | 291 | ||
295 | if (dev->driver->free_filp_priv) | 292 | if (dev->driver->postclose) |
296 | dev->driver->free_filp_priv(dev, priv); | 293 | dev->driver->postclose(dev, priv); |
297 | 294 | ||
298 | drm_free(priv, sizeof(*priv), DRM_MEM_FILES); | 295 | drm_free(priv, sizeof(*priv), DRM_MEM_FILES); |
299 | 296 | ||
@@ -313,7 +310,7 @@ int drm_release(struct inode *inode, struct file *filp) | |||
313 | } | 310 | } |
314 | spin_unlock(&dev->count_lock); | 311 | spin_unlock(&dev->count_lock); |
315 | unlock_kernel(); | 312 | unlock_kernel(); |
316 | return drm_takedown(dev); | 313 | return drm_lastclose(dev); |
317 | } | 314 | } |
318 | spin_unlock(&dev->count_lock); | 315 | spin_unlock(&dev->count_lock); |
319 | 316 | ||
@@ -363,8 +360,8 @@ static int drm_open_helper(struct inode *inode, struct file *filp, | |||
363 | priv->authenticated = capable(CAP_SYS_ADMIN); | 360 | priv->authenticated = capable(CAP_SYS_ADMIN); |
364 | priv->lock_count = 0; | 361 | priv->lock_count = 0; |
365 | 362 | ||
366 | if (dev->driver->open_helper) { | 363 | if (dev->driver->open) { |
367 | ret = dev->driver->open_helper(dev, priv); | 364 | ret = dev->driver->open(dev, priv); |
368 | if (ret < 0) | 365 | if (ret < 0) |
369 | goto out_free; | 366 | goto out_free; |
370 | } | 367 | } |
diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c index 9b0feba6b063..a654ac17a900 100644 --- a/drivers/char/drm/drm_ioctl.c +++ b/drivers/char/drm/drm_ioctl.c | |||
@@ -325,17 +325,13 @@ int drm_setversion(DRM_IOCTL_ARGS) | |||
325 | drm_set_version_t retv; | 325 | drm_set_version_t retv; |
326 | int if_version; | 326 | int if_version; |
327 | drm_set_version_t __user *argp = (void __user *)data; | 327 | drm_set_version_t __user *argp = (void __user *)data; |
328 | drm_version_t version; | ||
329 | 328 | ||
330 | DRM_COPY_FROM_USER_IOCTL(sv, argp, sizeof(sv)); | 329 | DRM_COPY_FROM_USER_IOCTL(sv, argp, sizeof(sv)); |
331 | 330 | ||
332 | memset(&version, 0, sizeof(version)); | ||
333 | |||
334 | dev->driver->version(&version); | ||
335 | retv.drm_di_major = DRM_IF_MAJOR; | 331 | retv.drm_di_major = DRM_IF_MAJOR; |
336 | retv.drm_di_minor = DRM_IF_MINOR; | 332 | retv.drm_di_minor = DRM_IF_MINOR; |
337 | retv.drm_dd_major = version.version_major; | 333 | retv.drm_dd_major = dev->driver->major; |
338 | retv.drm_dd_minor = version.version_minor; | 334 | retv.drm_dd_minor = dev->driver->minor; |
339 | 335 | ||
340 | DRM_COPY_TO_USER_IOCTL(argp, retv, sizeof(sv)); | 336 | DRM_COPY_TO_USER_IOCTL(argp, retv, sizeof(sv)); |
341 | 337 | ||
@@ -354,9 +350,9 @@ int drm_setversion(DRM_IOCTL_ARGS) | |||
354 | } | 350 | } |
355 | 351 | ||
356 | if (sv.drm_dd_major != -1) { | 352 | if (sv.drm_dd_major != -1) { |
357 | if (sv.drm_dd_major != version.version_major || | 353 | if (sv.drm_dd_major != dev->driver->major || |
358 | sv.drm_dd_minor < 0 | 354 | sv.drm_dd_minor < 0 |
359 | || sv.drm_dd_minor > version.version_minor) | 355 | || sv.drm_dd_minor > dev->driver->minor) |
360 | return EINVAL; | 356 | return EINVAL; |
361 | 357 | ||
362 | if (dev->driver->set_version) | 358 | if (dev->driver->set_version) |
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c index 60b6f8e8bf69..8568a6b373a0 100644 --- a/drivers/char/drm/drm_stub.c +++ b/drivers/char/drm/drm_stub.c | |||
@@ -93,8 +93,8 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev, | |||
93 | 93 | ||
94 | dev->driver = driver; | 94 | dev->driver = driver; |
95 | 95 | ||
96 | if (dev->driver->preinit) | 96 | if (dev->driver->load) |
97 | if ((retcode = dev->driver->preinit(dev, ent->driver_data))) | 97 | if ((retcode = dev->driver->load(dev, ent->driver_data))) |
98 | goto error_out_unreg; | 98 | goto error_out_unreg; |
99 | 99 | ||
100 | if (drm_core_has_AGP(dev)) { | 100 | if (drm_core_has_AGP(dev)) { |
@@ -124,7 +124,7 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev, | |||
124 | return 0; | 124 | return 0; |
125 | 125 | ||
126 | error_out_unreg: | 126 | error_out_unreg: |
127 | drm_takedown(dev); | 127 | drm_lastclose(dev); |
128 | return retcode; | 128 | return retcode; |
129 | } | 129 | } |
130 | 130 | ||
@@ -258,11 +258,10 @@ int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent, | |||
258 | } | 258 | } |
259 | if ((ret = drm_get_head(dev, &dev->primary))) | 259 | if ((ret = drm_get_head(dev, &dev->primary))) |
260 | goto err_g1; | 260 | goto err_g1; |
261 | 261 | ||
262 | /* postinit is a required function to display the signon banner */ | 262 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", |
263 | /* drivers add secondary heads here if needed */ | 263 | driver->name, driver->major, driver->minor, driver->patchlevel, |
264 | if ((ret = dev->driver->postinit(dev, ent->driver_data))) | 264 | driver->date, dev->primary.minor); |
265 | goto err_g1; | ||
266 | 265 | ||
267 | return 0; | 266 | return 0; |
268 | 267 | ||
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c index dba502373da1..c3178a89615d 100644 --- a/drivers/char/drm/i810_dma.c +++ b/drivers/char/drm/i810_dma.c | |||
@@ -1319,12 +1319,24 @@ static int i810_flip_bufs(struct inode *inode, struct file *filp, | |||
1319 | return 0; | 1319 | return 0; |
1320 | } | 1320 | } |
1321 | 1321 | ||
1322 | void i810_driver_pretakedown(drm_device_t * dev) | 1322 | int i810_driver_load(drm_device_t *dev, unsigned long flags) |
1323 | { | ||
1324 | /* i810 has 4 more counters */ | ||
1325 | dev->counters += 4; | ||
1326 | dev->types[6] = _DRM_STAT_IRQ; | ||
1327 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
1328 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
1329 | dev->types[9] = _DRM_STAT_DMA; | ||
1330 | |||
1331 | return 0; | ||
1332 | } | ||
1333 | |||
1334 | void i810_driver_lastclose(drm_device_t * dev) | ||
1323 | { | 1335 | { |
1324 | i810_dma_cleanup(dev); | 1336 | i810_dma_cleanup(dev); |
1325 | } | 1337 | } |
1326 | 1338 | ||
1327 | void i810_driver_prerelease(drm_device_t * dev, DRMFILE filp) | 1339 | void i810_driver_preclose(drm_device_t * dev, DRMFILE filp) |
1328 | { | 1340 | { |
1329 | if (dev->dev_private) { | 1341 | if (dev->dev_private) { |
1330 | drm_i810_private_t *dev_priv = dev->dev_private; | 1342 | drm_i810_private_t *dev_priv = dev->dev_private; |
@@ -1334,7 +1346,7 @@ void i810_driver_prerelease(drm_device_t * dev, DRMFILE filp) | |||
1334 | } | 1346 | } |
1335 | } | 1347 | } |
1336 | 1348 | ||
1337 | void i810_driver_release(drm_device_t * dev, struct file *filp) | 1349 | void i810_driver_reclaim_buffers_locked(drm_device_t * dev, struct file *filp) |
1338 | { | 1350 | { |
1339 | i810_reclaim_buffers(dev, filp); | 1351 | i810_reclaim_buffers(dev, filp); |
1340 | } | 1352 | } |
diff --git a/drivers/char/drm/i810_drv.c b/drivers/char/drm/i810_drv.c index 070cef6c2b46..e73b731c3be9 100644 --- a/drivers/char/drm/i810_drv.c +++ b/drivers/char/drm/i810_drv.c | |||
@@ -38,38 +38,6 @@ | |||
38 | 38 | ||
39 | #include "drm_pciids.h" | 39 | #include "drm_pciids.h" |
40 | 40 | ||
41 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
42 | { | ||
43 | /* i810 has 4 more counters */ | ||
44 | dev->counters += 4; | ||
45 | dev->types[6] = _DRM_STAT_IRQ; | ||
46 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
47 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
48 | dev->types[9] = _DRM_STAT_DMA; | ||
49 | |||
50 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
51 | DRIVER_NAME, | ||
52 | DRIVER_MAJOR, | ||
53 | DRIVER_MINOR, | ||
54 | DRIVER_PATCHLEVEL, | ||
55 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
56 | ); | ||
57 | return 0; | ||
58 | } | ||
59 | |||
60 | static int version(drm_version_t * version) | ||
61 | { | ||
62 | int len; | ||
63 | |||
64 | version->version_major = DRIVER_MAJOR; | ||
65 | version->version_minor = DRIVER_MINOR; | ||
66 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
67 | DRM_COPY(version->name, DRIVER_NAME); | ||
68 | DRM_COPY(version->date, DRIVER_DATE); | ||
69 | DRM_COPY(version->desc, DRIVER_DESC); | ||
70 | return 0; | ||
71 | } | ||
72 | |||
73 | static struct pci_device_id pciidlist[] = { | 41 | static struct pci_device_id pciidlist[] = { |
74 | i810_PCI_IDS | 42 | i810_PCI_IDS |
75 | }; | 43 | }; |
@@ -79,16 +47,15 @@ static struct drm_driver driver = { | |||
79 | DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | | 47 | DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | |
80 | DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE, | 48 | DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE, |
81 | .dev_priv_size = sizeof(drm_i810_buf_priv_t), | 49 | .dev_priv_size = sizeof(drm_i810_buf_priv_t), |
82 | .pretakedown = i810_driver_pretakedown, | 50 | .load = i810_driver_load, |
83 | .prerelease = i810_driver_prerelease, | 51 | .lastclose = i810_driver_lastclose, |
52 | .preclose = i810_driver_preclose, | ||
84 | .device_is_agp = i810_driver_device_is_agp, | 53 | .device_is_agp = i810_driver_device_is_agp, |
85 | .release = i810_driver_release, | 54 | .reclaim_buffers_locked = i810_driver_reclaim_buffers_locked, |
86 | .dma_quiescent = i810_driver_dma_quiescent, | 55 | .dma_quiescent = i810_driver_dma_quiescent, |
87 | .reclaim_buffers = i810_reclaim_buffers, | 56 | .reclaim_buffers = i810_reclaim_buffers, |
88 | .get_map_ofs = drm_core_get_map_ofs, | 57 | .get_map_ofs = drm_core_get_map_ofs, |
89 | .get_reg_ofs = drm_core_get_reg_ofs, | 58 | .get_reg_ofs = drm_core_get_reg_ofs, |
90 | .postinit = postinit, | ||
91 | .version = version, | ||
92 | .ioctls = i810_ioctls, | 59 | .ioctls = i810_ioctls, |
93 | .fops = { | 60 | .fops = { |
94 | .owner = THIS_MODULE, | 61 | .owner = THIS_MODULE, |
@@ -98,13 +65,19 @@ static struct drm_driver driver = { | |||
98 | .mmap = drm_mmap, | 65 | .mmap = drm_mmap, |
99 | .poll = drm_poll, | 66 | .poll = drm_poll, |
100 | .fasync = drm_fasync, | 67 | .fasync = drm_fasync, |
101 | } | 68 | }, |
102 | , | 69 | |
103 | .pci_driver = { | 70 | .pci_driver = { |
104 | .name = DRIVER_NAME, | 71 | .name = DRIVER_NAME, |
105 | .id_table = pciidlist, | 72 | .id_table = pciidlist, |
106 | } | 73 | }, |
107 | , | 74 | |
75 | .name = DRIVER_NAME, | ||
76 | .desc = DRIVER_DESC, | ||
77 | .date = DRIVER_DATE, | ||
78 | .major = DRIVER_MAJOR, | ||
79 | .minor = DRIVER_MINOR, | ||
80 | .patchlevel = DRIVER_PATCHLEVEL, | ||
108 | }; | 81 | }; |
109 | 82 | ||
110 | static int __init i810_init(void) | 83 | static int __init i810_init(void) |
diff --git a/drivers/char/drm/i810_drv.h b/drivers/char/drm/i810_drv.h index c78f36aaa2f0..a18b80d91920 100644 --- a/drivers/char/drm/i810_drv.h +++ b/drivers/char/drm/i810_drv.h | |||
@@ -116,9 +116,13 @@ typedef struct drm_i810_private { | |||
116 | extern void i810_reclaim_buffers(drm_device_t * dev, struct file *filp); | 116 | extern void i810_reclaim_buffers(drm_device_t * dev, struct file *filp); |
117 | 117 | ||
118 | extern int i810_driver_dma_quiescent(drm_device_t * dev); | 118 | extern int i810_driver_dma_quiescent(drm_device_t * dev); |
119 | extern void i810_driver_release(drm_device_t * dev, struct file *filp); | 119 | extern void i810_driver_reclaim_buffers_locked(drm_device_t * dev, |
120 | extern void i810_driver_pretakedown(drm_device_t * dev); | 120 | struct file *filp); |
121 | extern void i810_driver_prerelease(drm_device_t * dev, DRMFILE filp); | 121 | extern int i810_driver_load(struct drm_device *, unsigned long flags); |
122 | extern void i810_driver_lastclose(drm_device_t * dev); | ||
123 | extern void i810_driver_preclose(drm_device_t * dev, DRMFILE filp); | ||
124 | extern void i810_driver_reclaim_buffers_locked(drm_device_t * dev, | ||
125 | struct file *filp); | ||
122 | extern int i810_driver_device_is_agp(drm_device_t * dev); | 126 | extern int i810_driver_device_is_agp(drm_device_t * dev); |
123 | 127 | ||
124 | extern drm_ioctl_desc_t i810_ioctls[]; | 128 | extern drm_ioctl_desc_t i810_ioctls[]; |
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c index dc94f1914425..01dfdb944e1f 100644 --- a/drivers/char/drm/i830_dma.c +++ b/drivers/char/drm/i830_dma.c | |||
@@ -1517,12 +1517,24 @@ static int i830_setparam(struct inode *inode, struct file *filp, | |||
1517 | return 0; | 1517 | return 0; |
1518 | } | 1518 | } |
1519 | 1519 | ||
1520 | void i830_driver_pretakedown(drm_device_t * dev) | 1520 | int i830_driver_load(drm_device_t *dev, unsigned long flags) |
1521 | { | ||
1522 | /* i830 has 4 more counters */ | ||
1523 | dev->counters += 4; | ||
1524 | dev->types[6] = _DRM_STAT_IRQ; | ||
1525 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
1526 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
1527 | dev->types[9] = _DRM_STAT_DMA; | ||
1528 | |||
1529 | return 0; | ||
1530 | } | ||
1531 | |||
1532 | void i830_driver_lastclose(drm_device_t * dev) | ||
1521 | { | 1533 | { |
1522 | i830_dma_cleanup(dev); | 1534 | i830_dma_cleanup(dev); |
1523 | } | 1535 | } |
1524 | 1536 | ||
1525 | void i830_driver_prerelease(drm_device_t * dev, DRMFILE filp) | 1537 | void i830_driver_preclose(drm_device_t * dev, DRMFILE filp) |
1526 | { | 1538 | { |
1527 | if (dev->dev_private) { | 1539 | if (dev->dev_private) { |
1528 | drm_i830_private_t *dev_priv = dev->dev_private; | 1540 | drm_i830_private_t *dev_priv = dev->dev_private; |
@@ -1532,7 +1544,7 @@ void i830_driver_prerelease(drm_device_t * dev, DRMFILE filp) | |||
1532 | } | 1544 | } |
1533 | } | 1545 | } |
1534 | 1546 | ||
1535 | void i830_driver_release(drm_device_t * dev, struct file *filp) | 1547 | void i830_driver_reclaim_buffers_locked(drm_device_t * dev, struct file *filp) |
1536 | { | 1548 | { |
1537 | i830_reclaim_buffers(dev, filp); | 1549 | i830_reclaim_buffers(dev, filp); |
1538 | } | 1550 | } |
diff --git a/drivers/char/drm/i830_drv.c b/drivers/char/drm/i830_drv.c index acd821e8fe4d..49fd2816de95 100644 --- a/drivers/char/drm/i830_drv.c +++ b/drivers/char/drm/i830_drv.c | |||
@@ -40,37 +40,6 @@ | |||
40 | 40 | ||
41 | #include "drm_pciids.h" | 41 | #include "drm_pciids.h" |
42 | 42 | ||
43 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
44 | { | ||
45 | dev->counters += 4; | ||
46 | dev->types[6] = _DRM_STAT_IRQ; | ||
47 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
48 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
49 | dev->types[9] = _DRM_STAT_DMA; | ||
50 | |||
51 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
52 | DRIVER_NAME, | ||
53 | DRIVER_MAJOR, | ||
54 | DRIVER_MINOR, | ||
55 | DRIVER_PATCHLEVEL, | ||
56 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
57 | ); | ||
58 | return 0; | ||
59 | } | ||
60 | |||
61 | static int version(drm_version_t * version) | ||
62 | { | ||
63 | int len; | ||
64 | |||
65 | version->version_major = DRIVER_MAJOR; | ||
66 | version->version_minor = DRIVER_MINOR; | ||
67 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
68 | DRM_COPY(version->name, DRIVER_NAME); | ||
69 | DRM_COPY(version->date, DRIVER_DATE); | ||
70 | DRM_COPY(version->desc, DRIVER_DESC); | ||
71 | return 0; | ||
72 | } | ||
73 | |||
74 | static struct pci_device_id pciidlist[] = { | 43 | static struct pci_device_id pciidlist[] = { |
75 | i830_PCI_IDS | 44 | i830_PCI_IDS |
76 | }; | 45 | }; |
@@ -83,10 +52,11 @@ static struct drm_driver driver = { | |||
83 | .driver_features |= DRIVER_HAVE_IRQ | DRIVER_SHARED_IRQ, | 52 | .driver_features |= DRIVER_HAVE_IRQ | DRIVER_SHARED_IRQ, |
84 | #endif | 53 | #endif |
85 | .dev_priv_size = sizeof(drm_i830_buf_priv_t), | 54 | .dev_priv_size = sizeof(drm_i830_buf_priv_t), |
86 | .pretakedown = i830_driver_pretakedown, | 55 | .load = i830_driver_load, |
87 | .prerelease = i830_driver_prerelease, | 56 | .lastclose = i830_driver_lastclose, |
57 | .preclose = i830_driver_preclose, | ||
88 | .device_is_agp = i830_driver_device_is_agp, | 58 | .device_is_agp = i830_driver_device_is_agp, |
89 | .release = i830_driver_release, | 59 | .reclaim_buffers_locked = i830_driver_reclaim_buffers_locked, |
90 | .dma_quiescent = i830_driver_dma_quiescent, | 60 | .dma_quiescent = i830_driver_dma_quiescent, |
91 | .reclaim_buffers = i830_reclaim_buffers, | 61 | .reclaim_buffers = i830_reclaim_buffers, |
92 | .get_map_ofs = drm_core_get_map_ofs, | 62 | .get_map_ofs = drm_core_get_map_ofs, |
@@ -97,8 +67,6 @@ static struct drm_driver driver = { | |||
97 | .irq_uninstall = i830_driver_irq_uninstall, | 67 | .irq_uninstall = i830_driver_irq_uninstall, |
98 | .irq_handler = i830_driver_irq_handler, | 68 | .irq_handler = i830_driver_irq_handler, |
99 | #endif | 69 | #endif |
100 | .postinit = postinit, | ||
101 | .version = version, | ||
102 | .ioctls = i830_ioctls, | 70 | .ioctls = i830_ioctls, |
103 | .fops = { | 71 | .fops = { |
104 | .owner = THIS_MODULE, | 72 | .owner = THIS_MODULE, |
@@ -108,13 +76,19 @@ static struct drm_driver driver = { | |||
108 | .mmap = drm_mmap, | 76 | .mmap = drm_mmap, |
109 | .poll = drm_poll, | 77 | .poll = drm_poll, |
110 | .fasync = drm_fasync, | 78 | .fasync = drm_fasync, |
111 | } | 79 | }, |
112 | , | 80 | |
113 | .pci_driver = { | 81 | .pci_driver = { |
114 | .name = DRIVER_NAME, | 82 | .name = DRIVER_NAME, |
115 | .id_table = pciidlist, | 83 | .id_table = pciidlist, |
116 | } | 84 | }, |
117 | 85 | ||
86 | .name = DRIVER_NAME, | ||
87 | .desc = DRIVER_DESC, | ||
88 | .date = DRIVER_DATE, | ||
89 | .major = DRIVER_MAJOR, | ||
90 | .minor = DRIVER_MINOR, | ||
91 | .patchlevel = DRIVER_PATCHLEVEL, | ||
118 | }; | 92 | }; |
119 | 93 | ||
120 | static int __init i830_init(void) | 94 | static int __init i830_init(void) |
diff --git a/drivers/char/drm/i830_drv.h b/drivers/char/drm/i830_drv.h index bc4bd49fb0cc..bf9075b576bd 100644 --- a/drivers/char/drm/i830_drv.h +++ b/drivers/char/drm/i830_drv.h | |||
@@ -136,10 +136,12 @@ extern irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS); | |||
136 | extern void i830_driver_irq_preinstall(drm_device_t * dev); | 136 | extern void i830_driver_irq_preinstall(drm_device_t * dev); |
137 | extern void i830_driver_irq_postinstall(drm_device_t * dev); | 137 | extern void i830_driver_irq_postinstall(drm_device_t * dev); |
138 | extern void i830_driver_irq_uninstall(drm_device_t * dev); | 138 | extern void i830_driver_irq_uninstall(drm_device_t * dev); |
139 | extern void i830_driver_pretakedown(drm_device_t * dev); | 139 | extern int i830_driver_load(struct drm_device *, unsigned long flags); |
140 | extern void i830_driver_release(drm_device_t * dev, struct file *filp); | 140 | extern void i830_driver_preclose(drm_device_t * dev, DRMFILE filp); |
141 | extern void i830_driver_lastclose(drm_device_t * dev); | ||
142 | extern void i830_driver_reclaim_buffers_locked(drm_device_t * dev, | ||
143 | struct file *filp); | ||
141 | extern int i830_driver_dma_quiescent(drm_device_t * dev); | 144 | extern int i830_driver_dma_quiescent(drm_device_t * dev); |
142 | extern void i830_driver_prerelease(drm_device_t * dev, DRMFILE filp); | ||
143 | extern int i830_driver_device_is_agp(drm_device_t * dev); | 145 | extern int i830_driver_device_is_agp(drm_device_t * dev); |
144 | 146 | ||
145 | #define I830_READ(reg) DRM_READ32(dev_priv->mmio_map, reg) | 147 | #define I830_READ(reg) DRM_READ32(dev_priv->mmio_map, reg) |
diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c index f3aa0c370127..9ef3be31a812 100644 --- a/drivers/char/drm/i915_dma.c +++ b/drivers/char/drm/i915_dma.c | |||
@@ -699,7 +699,19 @@ static int i915_setparam(DRM_IOCTL_ARGS) | |||
699 | return 0; | 699 | return 0; |
700 | } | 700 | } |
701 | 701 | ||
702 | void i915_driver_pretakedown(drm_device_t * dev) | 702 | int i915_driver_load(drm_device_t *dev, unsigned long flags) |
703 | { | ||
704 | /* i915 has 4 more counters */ | ||
705 | dev->counters += 4; | ||
706 | dev->types[6] = _DRM_STAT_IRQ; | ||
707 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
708 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
709 | dev->types[9] = _DRM_STAT_DMA; | ||
710 | |||
711 | return 0; | ||
712 | } | ||
713 | |||
714 | void i915_driver_lastclose(drm_device_t * dev) | ||
703 | { | 715 | { |
704 | if (dev->dev_private) { | 716 | if (dev->dev_private) { |
705 | drm_i915_private_t *dev_priv = dev->dev_private; | 717 | drm_i915_private_t *dev_priv = dev->dev_private; |
@@ -708,7 +720,7 @@ void i915_driver_pretakedown(drm_device_t * dev) | |||
708 | i915_dma_cleanup(dev); | 720 | i915_dma_cleanup(dev); |
709 | } | 721 | } |
710 | 722 | ||
711 | void i915_driver_prerelease(drm_device_t * dev, DRMFILE filp) | 723 | void i915_driver_preclose(drm_device_t * dev, DRMFILE filp) |
712 | { | 724 | { |
713 | if (dev->dev_private) { | 725 | if (dev->dev_private) { |
714 | drm_i915_private_t *dev_priv = dev->dev_private; | 726 | drm_i915_private_t *dev_priv = dev->dev_private; |
diff --git a/drivers/char/drm/i915_drv.c b/drivers/char/drm/i915_drv.c index 0508240f4e3b..32b7f8bb420d 100644 --- a/drivers/char/drm/i915_drv.c +++ b/drivers/char/drm/i915_drv.c | |||
@@ -34,37 +34,6 @@ | |||
34 | 34 | ||
35 | #include "drm_pciids.h" | 35 | #include "drm_pciids.h" |
36 | 36 | ||
37 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
38 | { | ||
39 | dev->counters += 4; | ||
40 | dev->types[6] = _DRM_STAT_IRQ; | ||
41 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
42 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
43 | dev->types[9] = _DRM_STAT_DMA; | ||
44 | |||
45 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
46 | DRIVER_NAME, | ||
47 | DRIVER_MAJOR, | ||
48 | DRIVER_MINOR, | ||
49 | DRIVER_PATCHLEVEL, | ||
50 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
51 | ); | ||
52 | return 0; | ||
53 | } | ||
54 | |||
55 | static int version(drm_version_t * version) | ||
56 | { | ||
57 | int len; | ||
58 | |||
59 | version->version_major = DRIVER_MAJOR; | ||
60 | version->version_minor = DRIVER_MINOR; | ||
61 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
62 | DRM_COPY(version->name, DRIVER_NAME); | ||
63 | DRM_COPY(version->date, DRIVER_DATE); | ||
64 | DRM_COPY(version->desc, DRIVER_DESC); | ||
65 | return 0; | ||
66 | } | ||
67 | |||
68 | static struct pci_device_id pciidlist[] = { | 37 | static struct pci_device_id pciidlist[] = { |
69 | i915_PCI_IDS | 38 | i915_PCI_IDS |
70 | }; | 39 | }; |
@@ -73,8 +42,9 @@ static struct drm_driver driver = { | |||
73 | .driver_features = | 42 | .driver_features = |
74 | DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | | 43 | DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | |
75 | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED, | 44 | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED, |
76 | .pretakedown = i915_driver_pretakedown, | 45 | .load = i915_driver_load, |
77 | .prerelease = i915_driver_prerelease, | 46 | .lastclose = i915_driver_lastclose, |
47 | .preclose = i915_driver_preclose, | ||
78 | .device_is_agp = i915_driver_device_is_agp, | 48 | .device_is_agp = i915_driver_device_is_agp, |
79 | .irq_preinstall = i915_driver_irq_preinstall, | 49 | .irq_preinstall = i915_driver_irq_preinstall, |
80 | .irq_postinstall = i915_driver_irq_postinstall, | 50 | .irq_postinstall = i915_driver_irq_postinstall, |
@@ -83,8 +53,6 @@ static struct drm_driver driver = { | |||
83 | .reclaim_buffers = drm_core_reclaim_buffers, | 53 | .reclaim_buffers = drm_core_reclaim_buffers, |
84 | .get_map_ofs = drm_core_get_map_ofs, | 54 | .get_map_ofs = drm_core_get_map_ofs, |
85 | .get_reg_ofs = drm_core_get_reg_ofs, | 55 | .get_reg_ofs = drm_core_get_reg_ofs, |
86 | .postinit = postinit, | ||
87 | .version = version, | ||
88 | .ioctls = i915_ioctls, | 56 | .ioctls = i915_ioctls, |
89 | .fops = { | 57 | .fops = { |
90 | .owner = THIS_MODULE, | 58 | .owner = THIS_MODULE, |
@@ -97,11 +65,19 @@ static struct drm_driver driver = { | |||
97 | #ifdef CONFIG_COMPAT | 65 | #ifdef CONFIG_COMPAT |
98 | .compat_ioctl = i915_compat_ioctl, | 66 | .compat_ioctl = i915_compat_ioctl, |
99 | #endif | 67 | #endif |
100 | }, | 68 | }, |
69 | |||
101 | .pci_driver = { | 70 | .pci_driver = { |
102 | .name = DRIVER_NAME, | 71 | .name = DRIVER_NAME, |
103 | .id_table = pciidlist, | 72 | .id_table = pciidlist, |
104 | } | 73 | }, |
74 | |||
75 | .name = DRIVER_NAME, | ||
76 | .desc = DRIVER_DESC, | ||
77 | .date = DRIVER_DATE, | ||
78 | .major = DRIVER_MAJOR, | ||
79 | .minor = DRIVER_MINOR, | ||
80 | .patchlevel = DRIVER_PATCHLEVEL, | ||
105 | }; | 81 | }; |
106 | 82 | ||
107 | static int __init i915_init(void) | 83 | static int __init i915_init(void) |
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h index 17e457c73dc7..cd4f5227d0ea 100644 --- a/drivers/char/drm/i915_drv.h +++ b/drivers/char/drm/i915_drv.h | |||
@@ -104,8 +104,9 @@ extern int i915_max_ioctl; | |||
104 | 104 | ||
105 | /* i915_dma.c */ | 105 | /* i915_dma.c */ |
106 | extern void i915_kernel_lost_context(drm_device_t * dev); | 106 | extern void i915_kernel_lost_context(drm_device_t * dev); |
107 | extern void i915_driver_pretakedown(drm_device_t * dev); | 107 | extern int i915_driver_load(struct drm_device *, unsigned long flags); |
108 | extern void i915_driver_prerelease(drm_device_t * dev, DRMFILE filp); | 108 | extern void i915_driver_lastclose(drm_device_t * dev); |
109 | extern void i915_driver_preclose(drm_device_t * dev, DRMFILE filp); | ||
109 | extern int i915_driver_device_is_agp(drm_device_t * dev); | 110 | extern int i915_driver_device_is_agp(drm_device_t * dev); |
110 | 111 | ||
111 | /* i915_irq.c */ | 112 | /* i915_irq.c */ |
diff --git a/drivers/char/drm/mga_dma.c b/drivers/char/drm/mga_dma.c index 70dc7f64b7b9..9b09d786b158 100644 --- a/drivers/char/drm/mga_dma.c +++ b/drivers/char/drm/mga_dma.c | |||
@@ -391,7 +391,7 @@ int mga_freelist_put(drm_device_t * dev, drm_buf_t * buf) | |||
391 | * DMA initialization, cleanup | 391 | * DMA initialization, cleanup |
392 | */ | 392 | */ |
393 | 393 | ||
394 | int mga_driver_preinit(drm_device_t * dev, unsigned long flags) | 394 | int mga_driver_load(drm_device_t * dev, unsigned long flags) |
395 | { | 395 | { |
396 | drm_mga_private_t *dev_priv; | 396 | drm_mga_private_t *dev_priv; |
397 | 397 | ||
@@ -405,6 +405,14 @@ int mga_driver_preinit(drm_device_t * dev, unsigned long flags) | |||
405 | dev_priv->usec_timeout = MGA_DEFAULT_USEC_TIMEOUT; | 405 | dev_priv->usec_timeout = MGA_DEFAULT_USEC_TIMEOUT; |
406 | dev_priv->chipset = flags; | 406 | dev_priv->chipset = flags; |
407 | 407 | ||
408 | dev_priv->mmio_base = drm_get_resource_start(dev, 1); | ||
409 | dev_priv->mmio_size = drm_get_resource_len(dev, 1); | ||
410 | |||
411 | dev->counters += 3; | ||
412 | dev->types[6] = _DRM_STAT_IRQ; | ||
413 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
414 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
415 | |||
408 | return 0; | 416 | return 0; |
409 | } | 417 | } |
410 | 418 | ||
@@ -1118,7 +1126,7 @@ int mga_dma_buffers(DRM_IOCTL_ARGS) | |||
1118 | /** | 1126 | /** |
1119 | * Called just before the module is unloaded. | 1127 | * Called just before the module is unloaded. |
1120 | */ | 1128 | */ |
1121 | int mga_driver_postcleanup(drm_device_t * dev) | 1129 | int mga_driver_unload(drm_device_t * dev) |
1122 | { | 1130 | { |
1123 | drm_free(dev->dev_private, sizeof(drm_mga_private_t), DRM_MEM_DRIVER); | 1131 | drm_free(dev->dev_private, sizeof(drm_mga_private_t), DRM_MEM_DRIVER); |
1124 | dev->dev_private = NULL; | 1132 | dev->dev_private = NULL; |
@@ -1129,7 +1137,7 @@ int mga_driver_postcleanup(drm_device_t * dev) | |||
1129 | /** | 1137 | /** |
1130 | * Called when the last opener of the device is closed. | 1138 | * Called when the last opener of the device is closed. |
1131 | */ | 1139 | */ |
1132 | void mga_driver_pretakedown(drm_device_t * dev) | 1140 | void mga_driver_lastclose(drm_device_t * dev) |
1133 | { | 1141 | { |
1134 | mga_do_cleanup_dma(dev); | 1142 | mga_do_cleanup_dma(dev); |
1135 | } | 1143 | } |
diff --git a/drivers/char/drm/mga_drv.c b/drivers/char/drm/mga_drv.c index 0cc7c305a7f6..eae2f91994ec 100644 --- a/drivers/char/drm/mga_drv.c +++ b/drivers/char/drm/mga_drv.c | |||
@@ -38,41 +38,6 @@ | |||
38 | #include "drm_pciids.h" | 38 | #include "drm_pciids.h" |
39 | 39 | ||
40 | static int mga_driver_device_is_agp(drm_device_t * dev); | 40 | static int mga_driver_device_is_agp(drm_device_t * dev); |
41 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
42 | { | ||
43 | drm_mga_private_t *const dev_priv = | ||
44 | (drm_mga_private_t *) dev->dev_private; | ||
45 | |||
46 | dev_priv->mmio_base = pci_resource_start(dev->pdev, 1); | ||
47 | dev_priv->mmio_size = pci_resource_len(dev->pdev, 1); | ||
48 | |||
49 | dev->counters += 3; | ||
50 | dev->types[6] = _DRM_STAT_IRQ; | ||
51 | dev->types[7] = _DRM_STAT_PRIMARY; | ||
52 | dev->types[8] = _DRM_STAT_SECONDARY; | ||
53 | |||
54 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
55 | DRIVER_NAME, | ||
56 | DRIVER_MAJOR, | ||
57 | DRIVER_MINOR, | ||
58 | DRIVER_PATCHLEVEL, | ||
59 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
60 | ); | ||
61 | return 0; | ||
62 | } | ||
63 | |||
64 | static int version(drm_version_t * version) | ||
65 | { | ||
66 | int len; | ||
67 | |||
68 | version->version_major = DRIVER_MAJOR; | ||
69 | version->version_minor = DRIVER_MINOR; | ||
70 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
71 | DRM_COPY(version->name, DRIVER_NAME); | ||
72 | DRM_COPY(version->date, DRIVER_DATE); | ||
73 | DRM_COPY(version->desc, DRIVER_DESC); | ||
74 | return 0; | ||
75 | } | ||
76 | 41 | ||
77 | static struct pci_device_id pciidlist[] = { | 42 | static struct pci_device_id pciidlist[] = { |
78 | mga_PCI_IDS | 43 | mga_PCI_IDS |
@@ -83,9 +48,9 @@ static struct drm_driver driver = { | |||
83 | DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | | 48 | DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | |
84 | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | | 49 | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | |
85 | DRIVER_IRQ_VBL, | 50 | DRIVER_IRQ_VBL, |
86 | .preinit = mga_driver_preinit, | 51 | .load = mga_driver_load, |
87 | .postcleanup = mga_driver_postcleanup, | 52 | .unload = mga_driver_unload, |
88 | .pretakedown = mga_driver_pretakedown, | 53 | .lastclose = mga_driver_lastclose, |
89 | .dma_quiescent = mga_driver_dma_quiescent, | 54 | .dma_quiescent = mga_driver_dma_quiescent, |
90 | .device_is_agp = mga_driver_device_is_agp, | 55 | .device_is_agp = mga_driver_device_is_agp, |
91 | .vblank_wait = mga_driver_vblank_wait, | 56 | .vblank_wait = mga_driver_vblank_wait, |
@@ -96,8 +61,6 @@ static struct drm_driver driver = { | |||
96 | .reclaim_buffers = drm_core_reclaim_buffers, | 61 | .reclaim_buffers = drm_core_reclaim_buffers, |
97 | .get_map_ofs = drm_core_get_map_ofs, | 62 | .get_map_ofs = drm_core_get_map_ofs, |
98 | .get_reg_ofs = drm_core_get_reg_ofs, | 63 | .get_reg_ofs = drm_core_get_reg_ofs, |
99 | .postinit = postinit, | ||
100 | .version = version, | ||
101 | .ioctls = mga_ioctls, | 64 | .ioctls = mga_ioctls, |
102 | .dma_ioctl = mga_dma_buffers, | 65 | .dma_ioctl = mga_dma_buffers, |
103 | .fops = { | 66 | .fops = { |
@@ -113,9 +76,16 @@ static struct drm_driver driver = { | |||
113 | #endif | 76 | #endif |
114 | }, | 77 | }, |
115 | .pci_driver = { | 78 | .pci_driver = { |
116 | .name = DRIVER_NAME, | 79 | .name = DRIVER_NAME, |
117 | .id_table = pciidlist, | 80 | .id_table = pciidlist, |
118 | } | 81 | }, |
82 | |||
83 | .name = DRIVER_NAME, | ||
84 | .desc = DRIVER_DESC, | ||
85 | .date = DRIVER_DATE, | ||
86 | .major = DRIVER_MAJOR, | ||
87 | .minor = DRIVER_MINOR, | ||
88 | .patchlevel = DRIVER_PATCHLEVEL, | ||
119 | }; | 89 | }; |
120 | 90 | ||
121 | static int __init mga_init(void) | 91 | static int __init mga_init(void) |
diff --git a/drivers/char/drm/mga_drv.h b/drivers/char/drm/mga_drv.h index 461728e6a58a..137bfdd5e92b 100644 --- a/drivers/char/drm/mga_drv.h +++ b/drivers/char/drm/mga_drv.h | |||
@@ -152,14 +152,14 @@ extern drm_ioctl_desc_t mga_ioctls[]; | |||
152 | extern int mga_max_ioctl; | 152 | extern int mga_max_ioctl; |
153 | 153 | ||
154 | /* mga_dma.c */ | 154 | /* mga_dma.c */ |
155 | extern int mga_driver_preinit(drm_device_t * dev, unsigned long flags); | ||
156 | extern int mga_dma_bootstrap(DRM_IOCTL_ARGS); | 155 | extern int mga_dma_bootstrap(DRM_IOCTL_ARGS); |
157 | extern int mga_dma_init(DRM_IOCTL_ARGS); | 156 | extern int mga_dma_init(DRM_IOCTL_ARGS); |
158 | extern int mga_dma_flush(DRM_IOCTL_ARGS); | 157 | extern int mga_dma_flush(DRM_IOCTL_ARGS); |
159 | extern int mga_dma_reset(DRM_IOCTL_ARGS); | 158 | extern int mga_dma_reset(DRM_IOCTL_ARGS); |
160 | extern int mga_dma_buffers(DRM_IOCTL_ARGS); | 159 | extern int mga_dma_buffers(DRM_IOCTL_ARGS); |
161 | extern int mga_driver_postcleanup(drm_device_t * dev); | 160 | extern int mga_driver_load(drm_device_t *dev, unsigned long flags); |
162 | extern void mga_driver_pretakedown(drm_device_t * dev); | 161 | extern int mga_driver_unload(drm_device_t * dev); |
162 | extern void mga_driver_lastclose(drm_device_t * dev); | ||
163 | extern int mga_driver_dma_quiescent(drm_device_t * dev); | 163 | extern int mga_driver_dma_quiescent(drm_device_t * dev); |
164 | 164 | ||
165 | extern int mga_do_wait_for_idle(drm_mga_private_t * dev_priv); | 165 | extern int mga_do_wait_for_idle(drm_mga_private_t * dev_priv); |
diff --git a/drivers/char/drm/r128_drv.c b/drivers/char/drm/r128_drv.c index 1661e7351402..e20450ae220e 100644 --- a/drivers/char/drm/r128_drv.c +++ b/drivers/char/drm/r128_drv.c | |||
@@ -37,31 +37,6 @@ | |||
37 | 37 | ||
38 | #include "drm_pciids.h" | 38 | #include "drm_pciids.h" |
39 | 39 | ||
40 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
41 | { | ||
42 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
43 | DRIVER_NAME, | ||
44 | DRIVER_MAJOR, | ||
45 | DRIVER_MINOR, | ||
46 | DRIVER_PATCHLEVEL, | ||
47 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
48 | ); | ||
49 | return 0; | ||
50 | } | ||
51 | |||
52 | static int version(drm_version_t * version) | ||
53 | { | ||
54 | int len; | ||
55 | |||
56 | version->version_major = DRIVER_MAJOR; | ||
57 | version->version_minor = DRIVER_MINOR; | ||
58 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
59 | DRM_COPY(version->name, DRIVER_NAME); | ||
60 | DRM_COPY(version->date, DRIVER_DATE); | ||
61 | DRM_COPY(version->desc, DRIVER_DESC); | ||
62 | return 0; | ||
63 | } | ||
64 | |||
65 | static struct pci_device_id pciidlist[] = { | 40 | static struct pci_device_id pciidlist[] = { |
66 | r128_PCI_IDS | 41 | r128_PCI_IDS |
67 | }; | 42 | }; |
@@ -72,8 +47,8 @@ static struct drm_driver driver = { | |||
72 | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | | 47 | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | |
73 | DRIVER_IRQ_VBL, | 48 | DRIVER_IRQ_VBL, |
74 | .dev_priv_size = sizeof(drm_r128_buf_priv_t), | 49 | .dev_priv_size = sizeof(drm_r128_buf_priv_t), |
75 | .prerelease = r128_driver_prerelease, | 50 | .preclose = r128_driver_preclose, |
76 | .pretakedown = r128_driver_pretakedown, | 51 | .lastclose = r128_driver_lastclose, |
77 | .vblank_wait = r128_driver_vblank_wait, | 52 | .vblank_wait = r128_driver_vblank_wait, |
78 | .irq_preinstall = r128_driver_irq_preinstall, | 53 | .irq_preinstall = r128_driver_irq_preinstall, |
79 | .irq_postinstall = r128_driver_irq_postinstall, | 54 | .irq_postinstall = r128_driver_irq_postinstall, |
@@ -82,8 +57,6 @@ static struct drm_driver driver = { | |||
82 | .reclaim_buffers = drm_core_reclaim_buffers, | 57 | .reclaim_buffers = drm_core_reclaim_buffers, |
83 | .get_map_ofs = drm_core_get_map_ofs, | 58 | .get_map_ofs = drm_core_get_map_ofs, |
84 | .get_reg_ofs = drm_core_get_reg_ofs, | 59 | .get_reg_ofs = drm_core_get_reg_ofs, |
85 | .postinit = postinit, | ||
86 | .version = version, | ||
87 | .ioctls = r128_ioctls, | 60 | .ioctls = r128_ioctls, |
88 | .dma_ioctl = r128_cce_buffers, | 61 | .dma_ioctl = r128_cce_buffers, |
89 | .fops = { | 62 | .fops = { |
@@ -97,12 +70,19 @@ static struct drm_driver driver = { | |||
97 | #ifdef CONFIG_COMPAT | 70 | #ifdef CONFIG_COMPAT |
98 | .compat_ioctl = r128_compat_ioctl, | 71 | .compat_ioctl = r128_compat_ioctl, |
99 | #endif | 72 | #endif |
100 | } | 73 | }, |
101 | , | 74 | |
102 | .pci_driver = { | 75 | .pci_driver = { |
103 | .name = DRIVER_NAME, | 76 | .name = DRIVER_NAME, |
104 | .id_table = pciidlist, | 77 | .id_table = pciidlist, |
105 | } | 78 | }, |
79 | |||
80 | .name = DRIVER_NAME, | ||
81 | .desc = DRIVER_DESC, | ||
82 | .date = DRIVER_DATE, | ||
83 | .major = DRIVER_MAJOR, | ||
84 | .minor = DRIVER_MINOR, | ||
85 | .patchlevel = DRIVER_PATCHLEVEL, | ||
106 | }; | 86 | }; |
107 | 87 | ||
108 | static int __init r128_init(void) | 88 | static int __init r128_init(void) |
diff --git a/drivers/char/drm/r128_drv.h b/drivers/char/drm/r128_drv.h index 5c79e40eb88f..9a779bad3da3 100644 --- a/drivers/char/drm/r128_drv.h +++ b/drivers/char/drm/r128_drv.h | |||
@@ -154,8 +154,8 @@ extern irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS); | |||
154 | extern void r128_driver_irq_preinstall(drm_device_t * dev); | 154 | extern void r128_driver_irq_preinstall(drm_device_t * dev); |
155 | extern void r128_driver_irq_postinstall(drm_device_t * dev); | 155 | extern void r128_driver_irq_postinstall(drm_device_t * dev); |
156 | extern void r128_driver_irq_uninstall(drm_device_t * dev); | 156 | extern void r128_driver_irq_uninstall(drm_device_t * dev); |
157 | extern void r128_driver_pretakedown(drm_device_t * dev); | 157 | extern void r128_driver_lastclose(drm_device_t * dev); |
158 | extern void r128_driver_prerelease(drm_device_t * dev, DRMFILE filp); | 158 | extern void r128_driver_preclose(drm_device_t * dev, DRMFILE filp); |
159 | 159 | ||
160 | extern long r128_compat_ioctl(struct file *filp, unsigned int cmd, | 160 | extern long r128_compat_ioctl(struct file *filp, unsigned int cmd, |
161 | unsigned long arg); | 161 | unsigned long arg); |
diff --git a/drivers/char/drm/r128_state.c b/drivers/char/drm/r128_state.c index 14479cc08a57..1f04e3372206 100644 --- a/drivers/char/drm/r128_state.c +++ b/drivers/char/drm/r128_state.c | |||
@@ -1674,7 +1674,7 @@ static int r128_getparam(DRM_IOCTL_ARGS) | |||
1674 | return 0; | 1674 | return 0; |
1675 | } | 1675 | } |
1676 | 1676 | ||
1677 | void r128_driver_prerelease(drm_device_t * dev, DRMFILE filp) | 1677 | void r128_driver_preclose(drm_device_t * dev, DRMFILE filp) |
1678 | { | 1678 | { |
1679 | if (dev->dev_private) { | 1679 | if (dev->dev_private) { |
1680 | drm_r128_private_t *dev_priv = dev->dev_private; | 1680 | drm_r128_private_t *dev_priv = dev->dev_private; |
@@ -1684,7 +1684,7 @@ void r128_driver_prerelease(drm_device_t * dev, DRMFILE filp) | |||
1684 | } | 1684 | } |
1685 | } | 1685 | } |
1686 | 1686 | ||
1687 | void r128_driver_pretakedown(drm_device_t * dev) | 1687 | void r128_driver_lastclose(drm_device_t * dev) |
1688 | { | 1688 | { |
1689 | r128_do_cleanup_cce(dev); | 1689 | r128_do_cleanup_cce(dev); |
1690 | } | 1690 | } |
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c index 03839ea31092..dc3a15a1819a 100644 --- a/drivers/char/drm/radeon_cp.c +++ b/drivers/char/drm/radeon_cp.c | |||
@@ -2103,7 +2103,7 @@ int radeon_cp_buffers(DRM_IOCTL_ARGS) | |||
2103 | return ret; | 2103 | return ret; |
2104 | } | 2104 | } |
2105 | 2105 | ||
2106 | int radeon_driver_preinit(struct drm_device *dev, unsigned long flags) | 2106 | int radeon_driver_load(struct drm_device *dev, unsigned long flags) |
2107 | { | 2107 | { |
2108 | drm_radeon_private_t *dev_priv; | 2108 | drm_radeon_private_t *dev_priv; |
2109 | int ret = 0; | 2109 | int ret = 0; |
@@ -2140,7 +2140,10 @@ int radeon_driver_preinit(struct drm_device *dev, unsigned long flags) | |||
2140 | return ret; | 2140 | return ret; |
2141 | } | 2141 | } |
2142 | 2142 | ||
2143 | int radeon_presetup(struct drm_device *dev) | 2143 | /* Create mappings for registers and framebuffer so userland doesn't necessarily |
2144 | * have to find them. | ||
2145 | */ | ||
2146 | int radeon_driver_firstopen(struct drm_device *dev) | ||
2144 | { | 2147 | { |
2145 | int ret; | 2148 | int ret; |
2146 | drm_local_map_t *map; | 2149 | drm_local_map_t *map; |
@@ -2161,7 +2164,7 @@ int radeon_presetup(struct drm_device *dev) | |||
2161 | return 0; | 2164 | return 0; |
2162 | } | 2165 | } |
2163 | 2166 | ||
2164 | int radeon_driver_postcleanup(struct drm_device *dev) | 2167 | int radeon_driver_unload(struct drm_device *dev) |
2165 | { | 2168 | { |
2166 | drm_radeon_private_t *dev_priv = dev->dev_private; | 2169 | drm_radeon_private_t *dev_priv = dev->dev_private; |
2167 | 2170 | ||
diff --git a/drivers/char/drm/radeon_drv.c b/drivers/char/drm/radeon_drv.c index ee49670d8162..999d74512362 100644 --- a/drivers/char/drm/radeon_drv.c +++ b/drivers/char/drm/radeon_drv.c | |||
@@ -42,30 +42,6 @@ int radeon_no_wb; | |||
42 | MODULE_PARM_DESC(no_wb, "Disable AGP writeback for scratch registers\n"); | 42 | MODULE_PARM_DESC(no_wb, "Disable AGP writeback for scratch registers\n"); |
43 | module_param_named(no_wb, radeon_no_wb, int, 0444); | 43 | module_param_named(no_wb, radeon_no_wb, int, 0444); |
44 | 44 | ||
45 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
46 | { | ||
47 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
48 | DRIVER_NAME, | ||
49 | DRIVER_MAJOR, | ||
50 | DRIVER_MINOR, | ||
51 | DRIVER_PATCHLEVEL, | ||
52 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
53 | ); | ||
54 | return 0; | ||
55 | } | ||
56 | |||
57 | static int version(drm_version_t * version) | ||
58 | { | ||
59 | int len; | ||
60 | |||
61 | version->version_major = DRIVER_MAJOR; | ||
62 | version->version_minor = DRIVER_MINOR; | ||
63 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
64 | DRM_COPY(version->name, DRIVER_NAME); | ||
65 | DRM_COPY(version->date, DRIVER_DATE); | ||
66 | DRM_COPY(version->desc, DRIVER_DESC); | ||
67 | return 0; | ||
68 | } | ||
69 | 45 | ||
70 | static struct pci_device_id pciidlist[] = { | 46 | static struct pci_device_id pciidlist[] = { |
71 | radeon_PCI_IDS | 47 | radeon_PCI_IDS |
@@ -77,23 +53,21 @@ static struct drm_driver driver = { | |||
77 | DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED | | 53 | DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED | |
78 | DRIVER_IRQ_VBL, | 54 | DRIVER_IRQ_VBL, |
79 | .dev_priv_size = sizeof(drm_radeon_buf_priv_t), | 55 | .dev_priv_size = sizeof(drm_radeon_buf_priv_t), |
80 | .preinit = radeon_driver_preinit, | 56 | .load = radeon_driver_load, |
81 | .presetup = radeon_presetup, | 57 | .firstopen = radeon_driver_firstopen, |
82 | .postcleanup = radeon_driver_postcleanup, | 58 | .open = radeon_driver_open, |
83 | .prerelease = radeon_driver_prerelease, | 59 | .preclose = radeon_driver_preclose, |
84 | .pretakedown = radeon_driver_pretakedown, | 60 | .postclose = radeon_driver_postclose, |
85 | .open_helper = radeon_driver_open_helper, | 61 | .lastclose = radeon_driver_lastclose, |
62 | .unload = radeon_driver_unload, | ||
86 | .vblank_wait = radeon_driver_vblank_wait, | 63 | .vblank_wait = radeon_driver_vblank_wait, |
87 | .irq_preinstall = radeon_driver_irq_preinstall, | 64 | .irq_preinstall = radeon_driver_irq_preinstall, |
88 | .irq_postinstall = radeon_driver_irq_postinstall, | 65 | .irq_postinstall = radeon_driver_irq_postinstall, |
89 | .irq_uninstall = radeon_driver_irq_uninstall, | 66 | .irq_uninstall = radeon_driver_irq_uninstall, |
90 | .irq_handler = radeon_driver_irq_handler, | 67 | .irq_handler = radeon_driver_irq_handler, |
91 | .free_filp_priv = radeon_driver_free_filp_priv, | ||
92 | .reclaim_buffers = drm_core_reclaim_buffers, | 68 | .reclaim_buffers = drm_core_reclaim_buffers, |
93 | .get_map_ofs = drm_core_get_map_ofs, | 69 | .get_map_ofs = drm_core_get_map_ofs, |
94 | .get_reg_ofs = drm_core_get_reg_ofs, | 70 | .get_reg_ofs = drm_core_get_reg_ofs, |
95 | .postinit = postinit, | ||
96 | .version = version, | ||
97 | .ioctls = radeon_ioctls, | 71 | .ioctls = radeon_ioctls, |
98 | .dma_ioctl = radeon_cp_buffers, | 72 | .dma_ioctl = radeon_cp_buffers, |
99 | .fops = { | 73 | .fops = { |
@@ -107,12 +81,19 @@ static struct drm_driver driver = { | |||
107 | #ifdef CONFIG_COMPAT | 81 | #ifdef CONFIG_COMPAT |
108 | .compat_ioctl = radeon_compat_ioctl, | 82 | .compat_ioctl = radeon_compat_ioctl, |
109 | #endif | 83 | #endif |
110 | } | 84 | }, |
111 | , | 85 | |
112 | .pci_driver = { | 86 | .pci_driver = { |
113 | .name = DRIVER_NAME, | 87 | .name = DRIVER_NAME, |
114 | .id_table = pciidlist, | 88 | .id_table = pciidlist, |
115 | } | 89 | }, |
90 | |||
91 | .name = DRIVER_NAME, | ||
92 | .desc = DRIVER_DESC, | ||
93 | .date = DRIVER_DATE, | ||
94 | .major = DRIVER_MAJOR, | ||
95 | .minor = DRIVER_MINOR, | ||
96 | .patchlevel = DRIVER_PATCHLEVEL, | ||
116 | }; | 97 | }; |
117 | 98 | ||
118 | static int __init radeon_init(void) | 99 | static int __init radeon_init(void) |
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h index 120ee5a8ebcc..3a91d5fc597e 100644 --- a/drivers/char/drm/radeon_drv.h +++ b/drivers/char/drm/radeon_drv.h | |||
@@ -331,17 +331,14 @@ extern irqreturn_t radeon_driver_irq_handler(DRM_IRQ_ARGS); | |||
331 | extern void radeon_driver_irq_preinstall(drm_device_t * dev); | 331 | extern void radeon_driver_irq_preinstall(drm_device_t * dev); |
332 | extern void radeon_driver_irq_postinstall(drm_device_t * dev); | 332 | extern void radeon_driver_irq_postinstall(drm_device_t * dev); |
333 | extern void radeon_driver_irq_uninstall(drm_device_t * dev); | 333 | extern void radeon_driver_irq_uninstall(drm_device_t * dev); |
334 | extern void radeon_driver_prerelease(drm_device_t * dev, DRMFILE filp); | ||
335 | extern void radeon_driver_pretakedown(drm_device_t * dev); | ||
336 | extern int radeon_driver_open_helper(drm_device_t * dev, | ||
337 | drm_file_t * filp_priv); | ||
338 | extern void radeon_driver_free_filp_priv(drm_device_t * dev, | ||
339 | drm_file_t * filp_priv); | ||
340 | |||
341 | extern int radeon_preinit(struct drm_device *dev, unsigned long flags); | ||
342 | extern int radeon_postinit(struct drm_device *dev, unsigned long flags); | ||
343 | extern int radeon_postcleanup(struct drm_device *dev); | ||
344 | 334 | ||
335 | extern int radeon_driver_load(struct drm_device *dev, unsigned long flags); | ||
336 | extern int radeon_driver_unload(struct drm_device *dev); | ||
337 | extern int radeon_driver_firstopen(struct drm_device *dev); | ||
338 | extern void radeon_driver_preclose(drm_device_t * dev, DRMFILE filp); | ||
339 | extern void radeon_driver_postclose(drm_device_t * dev, drm_file_t * filp); | ||
340 | extern void radeon_driver_lastclose(drm_device_t * dev); | ||
341 | extern int radeon_driver_open(drm_device_t * dev, drm_file_t * filp_priv); | ||
345 | extern long radeon_compat_ioctl(struct file *filp, unsigned int cmd, | 342 | extern long radeon_compat_ioctl(struct file *filp, unsigned int cmd, |
346 | unsigned long arg); | 343 | unsigned long arg); |
347 | 344 | ||
diff --git a/drivers/char/drm/radeon_state.c b/drivers/char/drm/radeon_state.c index 231ac1438c69..717f546cc448 100644 --- a/drivers/char/drm/radeon_state.c +++ b/drivers/char/drm/radeon_state.c | |||
@@ -3069,7 +3069,7 @@ static int radeon_cp_setparam(DRM_IOCTL_ARGS) | |||
3069 | * | 3069 | * |
3070 | * DRM infrastructure takes care of reclaiming dma buffers. | 3070 | * DRM infrastructure takes care of reclaiming dma buffers. |
3071 | */ | 3071 | */ |
3072 | void radeon_driver_prerelease(drm_device_t * dev, DRMFILE filp) | 3072 | void radeon_driver_preclose(drm_device_t * dev, DRMFILE filp) |
3073 | { | 3073 | { |
3074 | if (dev->dev_private) { | 3074 | if (dev->dev_private) { |
3075 | drm_radeon_private_t *dev_priv = dev->dev_private; | 3075 | drm_radeon_private_t *dev_priv = dev->dev_private; |
@@ -3082,12 +3082,12 @@ void radeon_driver_prerelease(drm_device_t * dev, DRMFILE filp) | |||
3082 | } | 3082 | } |
3083 | } | 3083 | } |
3084 | 3084 | ||
3085 | void radeon_driver_pretakedown(drm_device_t * dev) | 3085 | void radeon_driver_lastclose(drm_device_t * dev) |
3086 | { | 3086 | { |
3087 | radeon_do_release(dev); | 3087 | radeon_do_release(dev); |
3088 | } | 3088 | } |
3089 | 3089 | ||
3090 | int radeon_driver_open_helper(drm_device_t * dev, drm_file_t * filp_priv) | 3090 | int radeon_driver_open(drm_device_t * dev, drm_file_t * filp_priv) |
3091 | { | 3091 | { |
3092 | drm_radeon_private_t *dev_priv = dev->dev_private; | 3092 | drm_radeon_private_t *dev_priv = dev->dev_private; |
3093 | struct drm_radeon_driver_file_fields *radeon_priv; | 3093 | struct drm_radeon_driver_file_fields *radeon_priv; |
@@ -3107,7 +3107,7 @@ int radeon_driver_open_helper(drm_device_t * dev, drm_file_t * filp_priv) | |||
3107 | return 0; | 3107 | return 0; |
3108 | } | 3108 | } |
3109 | 3109 | ||
3110 | void radeon_driver_free_filp_priv(drm_device_t * dev, drm_file_t * filp_priv) | 3110 | void radeon_driver_postclose(drm_device_t * dev, drm_file_t * filp_priv) |
3111 | { | 3111 | { |
3112 | struct drm_radeon_driver_file_fields *radeon_priv = | 3112 | struct drm_radeon_driver_file_fields *radeon_priv = |
3113 | filp_priv->driver_priv; | 3113 | filp_priv->driver_priv; |
diff --git a/drivers/char/drm/savage_bci.c b/drivers/char/drm/savage_bci.c index 6d10515795cc..c3101702a1fe 100644 --- a/drivers/char/drm/savage_bci.c +++ b/drivers/char/drm/savage_bci.c | |||
@@ -533,16 +533,32 @@ static void savage_fake_dma_flush(drm_savage_private_t * dev_priv) | |||
533 | dev_priv->first_dma_page = dev_priv->current_dma_page = 0; | 533 | dev_priv->first_dma_page = dev_priv->current_dma_page = 0; |
534 | } | 534 | } |
535 | 535 | ||
536 | int savage_driver_load(drm_device_t *dev, unsigned long chipset) | ||
537 | { | ||
538 | drm_savage_private_t *dev_priv; | ||
539 | |||
540 | dev_priv = drm_alloc(sizeof(drm_savage_private_t), DRM_MEM_DRIVER); | ||
541 | if (dev_priv == NULL) | ||
542 | return DRM_ERR(ENOMEM); | ||
543 | |||
544 | memset(dev_priv, 0, sizeof(drm_savage_private_t)); | ||
545 | dev->dev_private = (void *)dev_priv; | ||
546 | |||
547 | dev_priv->chipset = (enum savage_family)chipset; | ||
548 | |||
549 | return 0; | ||
550 | } | ||
551 | |||
552 | |||
536 | /* | 553 | /* |
537 | * Initalize mappings. On Savage4 and SavageIX the alignment | 554 | * Initalize mappings. On Savage4 and SavageIX the alignment |
538 | * and size of the aperture is not suitable for automatic MTRR setup | 555 | * and size of the aperture is not suitable for automatic MTRR setup |
539 | * in drm_addmap. Therefore we do it manually before the maps are | 556 | * in drm_addmap. Therefore we add them manually before the maps are |
540 | * initialized. We also need to take care of deleting the MTRRs in | 557 | * initialized, and tear them down on last close. |
541 | * postcleanup. | ||
542 | */ | 558 | */ |
543 | int savage_preinit(drm_device_t * dev, unsigned long chipset) | 559 | int savage_driver_firstopen(drm_device_t *dev) |
544 | { | 560 | { |
545 | drm_savage_private_t *dev_priv; | 561 | drm_savage_private_t *dev_priv = dev->dev_private; |
546 | unsigned long mmio_base, fb_base, fb_size, aperture_base; | 562 | unsigned long mmio_base, fb_base, fb_size, aperture_base; |
547 | /* fb_rsrc and aper_rsrc aren't really used currently, but still exist | 563 | /* fb_rsrc and aper_rsrc aren't really used currently, but still exist |
548 | * in case we decide we need information on the BAR for BSD in the | 564 | * in case we decide we need information on the BAR for BSD in the |
@@ -551,14 +567,6 @@ int savage_preinit(drm_device_t * dev, unsigned long chipset) | |||
551 | unsigned int fb_rsrc, aper_rsrc; | 567 | unsigned int fb_rsrc, aper_rsrc; |
552 | int ret = 0; | 568 | int ret = 0; |
553 | 569 | ||
554 | dev_priv = drm_alloc(sizeof(drm_savage_private_t), DRM_MEM_DRIVER); | ||
555 | if (dev_priv == NULL) | ||
556 | return DRM_ERR(ENOMEM); | ||
557 | |||
558 | memset(dev_priv, 0, sizeof(drm_savage_private_t)); | ||
559 | dev->dev_private = (void *)dev_priv; | ||
560 | dev_priv->chipset = (enum savage_family)chipset; | ||
561 | |||
562 | dev_priv->mtrr[0].handle = -1; | 570 | dev_priv->mtrr[0].handle = -1; |
563 | dev_priv->mtrr[1].handle = -1; | 571 | dev_priv->mtrr[1].handle = -1; |
564 | dev_priv->mtrr[2].handle = -1; | 572 | dev_priv->mtrr[2].handle = -1; |
@@ -595,7 +603,8 @@ int savage_preinit(drm_device_t * dev, unsigned long chipset) | |||
595 | DRM_ERROR("strange pci_resource_len %08lx\n", | 603 | DRM_ERROR("strange pci_resource_len %08lx\n", |
596 | drm_get_resource_len(dev, 0)); | 604 | drm_get_resource_len(dev, 0)); |
597 | } | 605 | } |
598 | } else if (chipset != S3_SUPERSAVAGE && chipset != S3_SAVAGE2000) { | 606 | } else if (dev_priv->chipset != S3_SUPERSAVAGE && |
607 | dev_priv->chipset != S3_SAVAGE2000) { | ||
599 | mmio_base = drm_get_resource_start(dev, 0); | 608 | mmio_base = drm_get_resource_start(dev, 0); |
600 | fb_rsrc = 1; | 609 | fb_rsrc = 1; |
601 | fb_base = drm_get_resource_start(dev, 1); | 610 | fb_base = drm_get_resource_start(dev, 1); |
@@ -648,7 +657,7 @@ int savage_preinit(drm_device_t * dev, unsigned long chipset) | |||
648 | /* | 657 | /* |
649 | * Delete MTRRs and free device-private data. | 658 | * Delete MTRRs and free device-private data. |
650 | */ | 659 | */ |
651 | int savage_postcleanup(drm_device_t * dev) | 660 | void savage_driver_lastclose(drm_device_t *dev) |
652 | { | 661 | { |
653 | drm_savage_private_t *dev_priv = dev->dev_private; | 662 | drm_savage_private_t *dev_priv = dev->dev_private; |
654 | int i; | 663 | int i; |
@@ -658,6 +667,11 @@ int savage_postcleanup(drm_device_t * dev) | |||
658 | mtrr_del(dev_priv->mtrr[i].handle, | 667 | mtrr_del(dev_priv->mtrr[i].handle, |
659 | dev_priv->mtrr[i].base, | 668 | dev_priv->mtrr[i].base, |
660 | dev_priv->mtrr[i].size); | 669 | dev_priv->mtrr[i].size); |
670 | } | ||
671 | |||
672 | int savage_driver_unload(drm_device_t *dev) | ||
673 | { | ||
674 | drm_savage_private_t *dev_priv = dev->dev_private; | ||
661 | 675 | ||
662 | drm_free(dev_priv, sizeof(drm_savage_private_t), DRM_MEM_DRIVER); | 676 | drm_free(dev_priv, sizeof(drm_savage_private_t), DRM_MEM_DRIVER); |
663 | 677 | ||
diff --git a/drivers/char/drm/savage_drv.c b/drivers/char/drm/savage_drv.c index 22d799cde41c..aa6c0d1a82f8 100644 --- a/drivers/char/drm/savage_drv.c +++ b/drivers/char/drm/savage_drv.c | |||
@@ -30,31 +30,6 @@ | |||
30 | 30 | ||
31 | #include "drm_pciids.h" | 31 | #include "drm_pciids.h" |
32 | 32 | ||
33 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
34 | { | ||
35 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
36 | DRIVER_NAME, | ||
37 | DRIVER_MAJOR, | ||
38 | DRIVER_MINOR, | ||
39 | DRIVER_PATCHLEVEL, | ||
40 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
41 | ); | ||
42 | return 0; | ||
43 | } | ||
44 | |||
45 | static int version(drm_version_t * version) | ||
46 | { | ||
47 | int len; | ||
48 | |||
49 | version->version_major = DRIVER_MAJOR; | ||
50 | version->version_minor = DRIVER_MINOR; | ||
51 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
52 | DRM_COPY(version->name, DRIVER_NAME); | ||
53 | DRM_COPY(version->date, DRIVER_DATE); | ||
54 | DRM_COPY(version->desc, DRIVER_DESC); | ||
55 | return 0; | ||
56 | } | ||
57 | |||
58 | static struct pci_device_id pciidlist[] = { | 33 | static struct pci_device_id pciidlist[] = { |
59 | savage_PCI_IDS | 34 | savage_PCI_IDS |
60 | }; | 35 | }; |
@@ -63,13 +38,13 @@ static struct drm_driver driver = { | |||
63 | .driver_features = | 38 | .driver_features = |
64 | DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_PCI_DMA, | 39 | DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_PCI_DMA, |
65 | .dev_priv_size = sizeof(drm_savage_buf_priv_t), | 40 | .dev_priv_size = sizeof(drm_savage_buf_priv_t), |
66 | .preinit = savage_preinit, | 41 | .load = savage_driver_load, |
67 | .postinit = postinit, | 42 | .firstopen = savage_driver_firstopen, |
68 | .postcleanup = savage_postcleanup, | 43 | .lastclose = savage_driver_lastclose, |
44 | .unload = savage_driver_unload, | ||
69 | .reclaim_buffers = savage_reclaim_buffers, | 45 | .reclaim_buffers = savage_reclaim_buffers, |
70 | .get_map_ofs = drm_core_get_map_ofs, | 46 | .get_map_ofs = drm_core_get_map_ofs, |
71 | .get_reg_ofs = drm_core_get_reg_ofs, | 47 | .get_reg_ofs = drm_core_get_reg_ofs, |
72 | .version = version, | ||
73 | .ioctls = savage_ioctls, | 48 | .ioctls = savage_ioctls, |
74 | .dma_ioctl = savage_bci_buffers, | 49 | .dma_ioctl = savage_bci_buffers, |
75 | .fops = { | 50 | .fops = { |
@@ -80,12 +55,19 @@ static struct drm_driver driver = { | |||
80 | .mmap = drm_mmap, | 55 | .mmap = drm_mmap, |
81 | .poll = drm_poll, | 56 | .poll = drm_poll, |
82 | .fasync = drm_fasync, | 57 | .fasync = drm_fasync, |
83 | } | 58 | }, |
84 | , | 59 | |
85 | .pci_driver = { | 60 | .pci_driver = { |
86 | .name = DRIVER_NAME, | 61 | .name = DRIVER_NAME, |
87 | .id_table = pciidlist, | 62 | .id_table = pciidlist, |
88 | } | 63 | }, |
64 | |||
65 | .name = DRIVER_NAME, | ||
66 | .desc = DRIVER_DESC, | ||
67 | .date = DRIVER_DATE, | ||
68 | .major = DRIVER_MAJOR, | ||
69 | .minor = DRIVER_MINOR, | ||
70 | .patchlevel = DRIVER_PATCHLEVEL, | ||
89 | }; | 71 | }; |
90 | 72 | ||
91 | static int __init savage_init(void) | 73 | static int __init savage_init(void) |
diff --git a/drivers/char/drm/savage_drv.h b/drivers/char/drm/savage_drv.h index a4b0fa998a95..2f73558fb9cf 100644 --- a/drivers/char/drm/savage_drv.h +++ b/drivers/char/drm/savage_drv.h | |||
@@ -208,8 +208,10 @@ extern void savage_dma_reset(drm_savage_private_t * dev_priv); | |||
208 | extern void savage_dma_wait(drm_savage_private_t * dev_priv, unsigned int page); | 208 | extern void savage_dma_wait(drm_savage_private_t * dev_priv, unsigned int page); |
209 | extern uint32_t *savage_dma_alloc(drm_savage_private_t * dev_priv, | 209 | extern uint32_t *savage_dma_alloc(drm_savage_private_t * dev_priv, |
210 | unsigned int n); | 210 | unsigned int n); |
211 | extern int savage_preinit(drm_device_t * dev, unsigned long chipset); | 211 | extern int savage_driver_load(drm_device_t *dev, unsigned long chipset); |
212 | extern int savage_postcleanup(drm_device_t * dev); | 212 | extern int savage_driver_firstopen(drm_device_t *dev); |
213 | extern void savage_driver_lastclose(drm_device_t *dev); | ||
214 | extern int savage_driver_unload(drm_device_t *dev); | ||
213 | extern int savage_do_cleanup_bci(drm_device_t * dev); | 215 | extern int savage_do_cleanup_bci(drm_device_t * dev); |
214 | extern void savage_reclaim_buffers(drm_device_t * dev, DRMFILE filp); | 216 | extern void savage_reclaim_buffers(drm_device_t * dev, DRMFILE filp); |
215 | 217 | ||
diff --git a/drivers/char/drm/sis_drv.c b/drivers/char/drm/sis_drv.c index 3cef10643a8f..6f6d7d613ede 100644 --- a/drivers/char/drm/sis_drv.c +++ b/drivers/char/drm/sis_drv.c | |||
@@ -32,31 +32,6 @@ | |||
32 | 32 | ||
33 | #include "drm_pciids.h" | 33 | #include "drm_pciids.h" |
34 | 34 | ||
35 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
36 | { | ||
37 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
38 | DRIVER_NAME, | ||
39 | DRIVER_MAJOR, | ||
40 | DRIVER_MINOR, | ||
41 | DRIVER_PATCHLEVEL, | ||
42 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
43 | ); | ||
44 | return 0; | ||
45 | } | ||
46 | |||
47 | static int version(drm_version_t * version) | ||
48 | { | ||
49 | int len; | ||
50 | |||
51 | version->version_major = DRIVER_MAJOR; | ||
52 | version->version_minor = DRIVER_MINOR; | ||
53 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
54 | DRM_COPY(version->name, DRIVER_NAME); | ||
55 | DRM_COPY(version->date, DRIVER_DATE); | ||
56 | DRM_COPY(version->desc, DRIVER_DESC); | ||
57 | return 0; | ||
58 | } | ||
59 | |||
60 | static struct pci_device_id pciidlist[] = { | 35 | static struct pci_device_id pciidlist[] = { |
61 | sisdrv_PCI_IDS | 36 | sisdrv_PCI_IDS |
62 | }; | 37 | }; |
@@ -68,8 +43,6 @@ static struct drm_driver driver = { | |||
68 | .reclaim_buffers = drm_core_reclaim_buffers, | 43 | .reclaim_buffers = drm_core_reclaim_buffers, |
69 | .get_map_ofs = drm_core_get_map_ofs, | 44 | .get_map_ofs = drm_core_get_map_ofs, |
70 | .get_reg_ofs = drm_core_get_reg_ofs, | 45 | .get_reg_ofs = drm_core_get_reg_ofs, |
71 | .postinit = postinit, | ||
72 | .version = version, | ||
73 | .ioctls = sis_ioctls, | 46 | .ioctls = sis_ioctls, |
74 | .fops = { | 47 | .fops = { |
75 | .owner = THIS_MODULE, | 48 | .owner = THIS_MODULE, |
@@ -79,11 +52,18 @@ static struct drm_driver driver = { | |||
79 | .mmap = drm_mmap, | 52 | .mmap = drm_mmap, |
80 | .poll = drm_poll, | 53 | .poll = drm_poll, |
81 | .fasync = drm_fasync, | 54 | .fasync = drm_fasync, |
82 | }, | 55 | }, |
83 | .pci_driver = { | 56 | .pci_driver = { |
84 | .name = DRIVER_NAME, | 57 | .name = DRIVER_NAME, |
85 | .id_table = pciidlist, | 58 | .id_table = pciidlist, |
86 | } | 59 | }, |
60 | |||
61 | .name = DRIVER_NAME, | ||
62 | .desc = DRIVER_DESC, | ||
63 | .date = DRIVER_DATE, | ||
64 | .major = DRIVER_MAJOR, | ||
65 | .minor = DRIVER_MINOR, | ||
66 | .patchlevel = DRIVER_PATCHLEVEL, | ||
87 | }; | 67 | }; |
88 | 68 | ||
89 | static int __init sis_init(void) | 69 | static int __init sis_init(void) |
diff --git a/drivers/char/drm/tdfx_drv.c b/drivers/char/drm/tdfx_drv.c index c275cbb6e9ce..baa4416032a8 100644 --- a/drivers/char/drm/tdfx_drv.c +++ b/drivers/char/drm/tdfx_drv.c | |||
@@ -36,31 +36,6 @@ | |||
36 | 36 | ||
37 | #include "drm_pciids.h" | 37 | #include "drm_pciids.h" |
38 | 38 | ||
39 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
40 | { | ||
41 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
42 | DRIVER_NAME, | ||
43 | DRIVER_MAJOR, | ||
44 | DRIVER_MINOR, | ||
45 | DRIVER_PATCHLEVEL, | ||
46 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
47 | ); | ||
48 | return 0; | ||
49 | } | ||
50 | |||
51 | static int version(drm_version_t * version) | ||
52 | { | ||
53 | int len; | ||
54 | |||
55 | version->version_major = DRIVER_MAJOR; | ||
56 | version->version_minor = DRIVER_MINOR; | ||
57 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
58 | DRM_COPY(version->name, DRIVER_NAME); | ||
59 | DRM_COPY(version->date, DRIVER_DATE); | ||
60 | DRM_COPY(version->desc, DRIVER_DESC); | ||
61 | return 0; | ||
62 | } | ||
63 | |||
64 | static struct pci_device_id pciidlist[] = { | 39 | static struct pci_device_id pciidlist[] = { |
65 | tdfx_PCI_IDS | 40 | tdfx_PCI_IDS |
66 | }; | 41 | }; |
@@ -70,8 +45,6 @@ static struct drm_driver driver = { | |||
70 | .reclaim_buffers = drm_core_reclaim_buffers, | 45 | .reclaim_buffers = drm_core_reclaim_buffers, |
71 | .get_map_ofs = drm_core_get_map_ofs, | 46 | .get_map_ofs = drm_core_get_map_ofs, |
72 | .get_reg_ofs = drm_core_get_reg_ofs, | 47 | .get_reg_ofs = drm_core_get_reg_ofs, |
73 | .postinit = postinit, | ||
74 | .version = version, | ||
75 | .fops = { | 48 | .fops = { |
76 | .owner = THIS_MODULE, | 49 | .owner = THIS_MODULE, |
77 | .open = drm_open, | 50 | .open = drm_open, |
@@ -80,11 +53,18 @@ static struct drm_driver driver = { | |||
80 | .mmap = drm_mmap, | 53 | .mmap = drm_mmap, |
81 | .poll = drm_poll, | 54 | .poll = drm_poll, |
82 | .fasync = drm_fasync, | 55 | .fasync = drm_fasync, |
83 | }, | 56 | }, |
84 | .pci_driver = { | 57 | .pci_driver = { |
85 | .name = DRIVER_NAME, | 58 | .name = DRIVER_NAME, |
86 | .id_table = pciidlist, | 59 | .id_table = pciidlist, |
87 | } | 60 | }, |
61 | |||
62 | .name = DRIVER_NAME, | ||
63 | .desc = DRIVER_DESC, | ||
64 | .date = DRIVER_DATE, | ||
65 | .major = DRIVER_MAJOR, | ||
66 | .minor = DRIVER_MINOR, | ||
67 | .patchlevel = DRIVER_PATCHLEVEL, | ||
88 | }; | 68 | }; |
89 | 69 | ||
90 | static int __init tdfx_init(void) | 70 | static int __init tdfx_init(void) |
diff --git a/drivers/char/drm/via_drv.c b/drivers/char/drm/via_drv.c index 016665e0c69f..6f3e6b32fa81 100644 --- a/drivers/char/drm/via_drv.c +++ b/drivers/char/drm/via_drv.c | |||
@@ -29,30 +29,6 @@ | |||
29 | 29 | ||
30 | #include "drm_pciids.h" | 30 | #include "drm_pciids.h" |
31 | 31 | ||
32 | static int postinit(struct drm_device *dev, unsigned long flags) | ||
33 | { | ||
34 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n", | ||
35 | DRIVER_NAME, | ||
36 | DRIVER_MAJOR, | ||
37 | DRIVER_MINOR, | ||
38 | DRIVER_PATCHLEVEL, | ||
39 | DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev) | ||
40 | ); | ||
41 | return 0; | ||
42 | } | ||
43 | |||
44 | static int version(drm_version_t * version) | ||
45 | { | ||
46 | int len; | ||
47 | |||
48 | version->version_major = DRIVER_MAJOR; | ||
49 | version->version_minor = DRIVER_MINOR; | ||
50 | version->version_patchlevel = DRIVER_PATCHLEVEL; | ||
51 | DRM_COPY(version->name, DRIVER_NAME); | ||
52 | DRM_COPY(version->date, DRIVER_DATE); | ||
53 | DRM_COPY(version->desc, DRIVER_DESC); | ||
54 | return 0; | ||
55 | } | ||
56 | 32 | ||
57 | static struct pci_device_id pciidlist[] = { | 33 | static struct pci_device_id pciidlist[] = { |
58 | viadrv_PCI_IDS | 34 | viadrv_PCI_IDS |
@@ -88,8 +64,6 @@ static struct drm_driver driver = { | |||
88 | .reclaim_buffers = drm_core_reclaim_buffers, | 64 | .reclaim_buffers = drm_core_reclaim_buffers, |
89 | .get_map_ofs = drm_core_get_map_ofs, | 65 | .get_map_ofs = drm_core_get_map_ofs, |
90 | .get_reg_ofs = drm_core_get_reg_ofs, | 66 | .get_reg_ofs = drm_core_get_reg_ofs, |
91 | .postinit = postinit, | ||
92 | .version = version, | ||
93 | .ioctls = ioctls, | 67 | .ioctls = ioctls, |
94 | .num_ioctls = DRM_ARRAY_SIZE(ioctls), | 68 | .num_ioctls = DRM_ARRAY_SIZE(ioctls), |
95 | .fops = { | 69 | .fops = { |
@@ -100,11 +74,18 @@ static struct drm_driver driver = { | |||
100 | .mmap = drm_mmap, | 74 | .mmap = drm_mmap, |
101 | .poll = drm_poll, | 75 | .poll = drm_poll, |
102 | .fasync = drm_fasync, | 76 | .fasync = drm_fasync, |
103 | }, | 77 | }, |
104 | .pci_driver = { | 78 | .pci_driver = { |
105 | .name = DRIVER_NAME, | 79 | .name = DRIVER_NAME, |
106 | .id_table = pciidlist, | 80 | .id_table = pciidlist, |
107 | } | 81 | }, |
82 | |||
83 | .name = DRIVER_NAME, | ||
84 | .desc = DRIVER_DESC, | ||
85 | .date = DRIVER_DATE, | ||
86 | .major = DRIVER_MAJOR, | ||
87 | .minor = DRIVER_MINOR, | ||
88 | .patchlevel = DRIVER_PATCHLEVEL, | ||
108 | }; | 89 | }; |
109 | 90 | ||
110 | static int __init via_init(void) | 91 | static int __init via_init(void) |