agpsupport.c:	if (!dev->agp->acquired || !drm_agp->copy_info) return -EINVAL;
agpsupport.c:	kern                   = &dev->agp->agp_info;
agpsupport.c:	if (dev->agp->acquired || !drm_agp->acquire) return -EINVAL;
agpsupport.c:	dev->agp->acquired = 1;
agpsupport.c:	if (!dev->agp->acquired || !drm_agp->release) return -EINVAL;
agpsupport.c:	dev->agp->acquired = 0;
agpsupport.c:	if (!dev->agp->acquired || !drm_agp->enable) return -EINVAL;
agpsupport.c:	dev->agp->mode    = mode.mode;
agpsupport.c:	dev->agp->base    = dev->agp->agp_info.aper_base;
agpsupport.c:	dev->agp->enabled = 1;
agpsupport.c:	if (!dev->agp->acquired) return -EINVAL;
agpsupport.c:	entry->next      = dev->agp->memory;
agpsupport.c:	if (dev->agp->memory) dev->agp->memory->prev = entry;
agpsupport.c:	dev->agp->memory = entry;
agpsupport.c:		dev->agp->memory       = entry->next;
agpsupport.c:		dev->agp->memory->prev = NULL;
agpsupport.c:	for (entry = dev->agp->memory; entry; entry = entry->next) {
agpsupport.c:	if (!dev->agp->acquired) return -EINVAL;
agpsupport.c:	if (!dev->agp->acquired || !drm_agp->bind_memory) return -EINVAL;
agpsupport.c:	entry->bound = dev->agp->base + (page << PAGE_SHIFT);
agpsupport.c:		  dev->agp->base, entry->bound);
agpsupport.c:	if (!dev->agp->acquired) return -EINVAL;
agpsupport.c:	else             dev->agp->memory  = entry->next;
auth.c:	down(&dev->struct_sem);
auth.c:	for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
auth.c:	up(&dev->struct_sem);
auth.c:	down(&dev->struct_sem);
auth.c:	if (dev->magiclist[hash].tail) {
auth.c:		dev->magiclist[hash].tail->next = entry;
auth.c:		dev->magiclist[hash].tail	= entry;
auth.c:		dev->magiclist[hash].head	= entry;
auth.c:		dev->magiclist[hash].tail	= entry;
auth.c:	up(&dev->struct_sem);
auth.c:	down(&dev->struct_sem);
auth.c:	for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
auth.c:			if (dev->magiclist[hash].head == pt) {
auth.c:				dev->magiclist[hash].head = pt->next;
auth.c:			if (dev->magiclist[hash].tail == pt) {
auth.c:				dev->magiclist[hash].tail = prev;
auth.c:			up(&dev->struct_sem);
auth.c:	up(&dev->struct_sem);
bufs.c:			dev->lock.hw_lock = map->handle; /* Pointer to lock */
bufs.c:		map->offset = map->offset + dev->agp->base;
bufs.c:	down(&dev->struct_sem);
bufs.c:	if (dev->maplist) {
bufs.c:		++dev->map_count;
bufs.c:		dev->maplist = drm_realloc(dev->maplist,
bufs.c:					   (dev->map_count-1)
bufs.c:					   * sizeof(*dev->maplist),
bufs.c:					   dev->map_count
bufs.c:					   * sizeof(*dev->maplist),
bufs.c:		dev->map_count = 1;
bufs.c:		dev->maplist = drm_alloc(dev->map_count*sizeof(*dev->maplist),
bufs.c:	dev->maplist[dev->map_count-1] = map;
bufs.c:	up(&dev->struct_sem);
bufs.c:	drm_device_dma_t *dma	 = dev->dma;
bufs.c:		  request.count, request.size, size, order, dev->queue_count);
bufs.c:	if (dev->queue_count) return -EBUSY; /* Not while in use */
bufs.c:	spin_lock(&dev->count_lock);
bufs.c:	if (dev->buf_use) {
bufs.c:		spin_unlock(&dev->count_lock);
bufs.c:	atomic_inc(&dev->buf_alloc);
bufs.c:	spin_unlock(&dev->count_lock);
bufs.c:	down(&dev->struct_sem);
bufs.c:		up(&dev->struct_sem);
bufs.c:		atomic_dec(&dev->buf_alloc);
bufs.c:		up(&dev->struct_sem);
bufs.c:		atomic_dec(&dev->buf_alloc);
bufs.c:		up(&dev->struct_sem);
bufs.c:		atomic_dec(&dev->buf_alloc);
bufs.c:	up(&dev->struct_sem);
bufs.c:	atomic_dec(&dev->buf_alloc);
bufs.c:	drm_device_dma_t *dma	 = dev->dma;
bufs.c:	spin_lock(&dev->count_lock);
bufs.c:	if (atomic_read(&dev->buf_alloc)) {
bufs.c:		spin_unlock(&dev->count_lock);
bufs.c:	++dev->buf_use;		/* Can't allocate more after this call */
bufs.c:	spin_unlock(&dev->count_lock);
bufs.c:	drm_device_dma_t *dma	 = dev->dma;
bufs.c:	drm_device_dma_t *dma	 = dev->dma;
bufs.c:	drm_device_dma_t *dma	 = dev->dma;
bufs.c:	spin_lock(&dev->count_lock);
bufs.c:	if (atomic_read(&dev->buf_alloc)) {
bufs.c:		spin_unlock(&dev->count_lock);
bufs.c:	++dev->buf_use;		/* Can't allocate more after this call */
bufs.c:	spin_unlock(&dev->count_lock);
context.c:	drm_waitlist_create(&q->waitlist, dev->dma->buf_count);
context.c:PRE: 1) dev->queuelist[0..dev->queue_count] is allocated and will not
context.c:     2) dev->queue_count < dev->queue_slots
context.c:     3) dev->queuelist[i].use_count == 0 and
context.c:	dev->queuelist[i].finalization == 0 if i not in use 
context.c:POST: 1) dev->queuelist[i].use_count == 1
context.c:      2) dev->queue_count < dev->queue_slots */
context.c:	for (i = 0; i < dev->queue_count; i++) {
context.c:		atomic_inc(&dev->queuelist[i]->use_count);
context.c:		if (atomic_read(&dev->queuelist[i]->use_count) == 1
context.c:		    && !atomic_read(&dev->queuelist[i]->finalization)) {
context.c:		atomic_dec(&dev->queuelist[i]->use_count);
context.c:	down(&dev->struct_sem);
context.c:	++dev->queue_count;
context.c:	if (dev->queue_count >= dev->queue_slots) {
context.c:		oldslots = dev->queue_slots * sizeof(*dev->queuelist);
context.c:		if (!dev->queue_slots) dev->queue_slots = 1;
context.c:		dev->queue_slots *= 2;
context.c:		newslots = dev->queue_slots * sizeof(*dev->queuelist);
context.c:		dev->queuelist = drm_realloc(dev->queuelist,
context.c:		if (!dev->queuelist) {
context.c:			up(&dev->struct_sem);
context.c:	dev->queuelist[dev->queue_count-1] = queue;
context.c:	up(&dev->struct_sem);
context.c:	DRM_DEBUG("%d (new)\n", dev->queue_count - 1);
context.c:	return dev->queue_count - 1;
context.c:		drm_init_queue(dev, dev->queuelist[ctx.handle], &ctx);
context.c:	drm_init_queue(dev, dev->queuelist[ctx.handle], &ctx);
context.c:	if (ctx.handle < 0 || ctx.handle >= dev->queue_count) return -EINVAL;
context.c:	q = dev->queuelist[ctx.handle];
context.c:	if (ctx.handle >= dev->queue_count) return -EINVAL;
context.c:	q = dev->queuelist[ctx.handle];
context.c:	return drm_context_switch(dev, dev->last_context, ctx.handle);
context.c:	if (ctx.handle >= dev->queue_count) return -EINVAL;
context.c:	q = dev->queuelist[ctx.handle];
context.c:	while (test_and_set_bit(0, &dev->interrupt_flag)) {
context.c:			clear_bit(0, &dev->interrupt_flag);
context.c:	clear_bit(0, &dev->interrupt_flag);
ctxbitmap.c:		clear_bit(ctx_handle, dev->ctx_bitmap);
ctxbitmap.c:	bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
ctxbitmap.c:		set_bit(bit, dev->ctx_bitmap);
ctxbitmap.c:	dev->ctx_bitmap = (unsigned long *) drm_alloc(PAGE_SIZE, 
ctxbitmap.c:	if(dev->ctx_bitmap == NULL) {
ctxbitmap.c:	memset((void *) dev->ctx_bitmap, 0, PAGE_SIZE);
ctxbitmap.c:	drm_free((void *)dev->ctx_bitmap, PAGE_SIZE,
dma.c:	dev->dma = drm_alloc(sizeof(*dev->dma), DRM_MEM_DRIVER);
dma.c:	memset(dev->dma, 0, sizeof(*dev->dma));
dma.c:		memset(&dev->dma->bufs[i], 0, sizeof(dev->dma->bufs[0]));
dma.c:	drm_device_dma_t  *dma = dev->dma;
dma.c:	drm_free(dev->dma, sizeof(*dev->dma), DRM_MEM_DRIVER);
dma.c:	dev->dma = NULL;
dma.c:		atomic_inc(&dev->histo.total);
dma.c:		atomic_inc(&dev->histo.queued_to_dispatched[q2d]);
dma.c:		atomic_inc(&dev->histo.dispatched_to_completed[d2c]);
dma.c:		atomic_inc(&dev->histo.completed_to_freed[c2f]);
dma.c:		atomic_inc(&dev->histo.queued_to_completed[q2c]);
dma.c:		atomic_inc(&dev->histo.queued_to_freed[q2f]);
dma.c:	drm_device_dma_t *dma = dev->dma;
dma.c:	drm_device_dma_t *dma = dev->dma;
dma.c:	atomic_inc(&dev->total_ctx);
dma.c:	if (test_and_set_bit(0, &dev->context_flag)) {
dma.c:	dev->ctx_start = get_cycles();
dma.c:	if (new >= dev->queue_count) {
dma.c:		clear_bit(0, &dev->context_flag);
dma.c:	if (new == dev->last_context) {
dma.c:		clear_bit(0, &dev->context_flag);
dma.c:	q = dev->queuelist[new];
dma.c:		clear_bit(0, &dev->context_flag);
dma.c:	drm_device_dma_t *dma = dev->dma;
dma.c:	dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
dma.c:	dev->last_switch  = jiffies;
dma.c:	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
dma.c:		if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
dma.c:	atomic_inc(&dev->histo.ctx[drm_histogram_slot(get_cycles()
dma.c:						      - dev->ctx_start)]);
dma.c:	clear_bit(0, &dev->context_flag);
dma.c:	wake_up_interruptible(&dev->context_wait);
dma.c:	drm_device_dma_t *dma = dev->dma;
dma.c:	if (!dev->queuelist || !dev->queuelist[DRM_KERNEL_CONTEXT]) {
dma.c:	if (dev->last_switch <= j
dma.c:	    && dev->last_switch + DRM_TIME_SLICE > j
dma.c:	    && DRM_WAITCOUNT(dev, dev->last_context)) {
dma.c:		return dev->last_context;
dma.c:	for (i = dev->last_checked + 1; i < dev->queue_count; i++) {
dma.c:			candidate = dev->last_checked = i;
dma.c:		for (i = 0; i < dev->queue_count; i++) {
dma.c:				candidate = dev->last_checked = i;
dma.c:	    && candidate != dev->last_context
dma.c:	    && dev->last_switch <= j
dma.c:	    && dev->last_switch + DRM_TIME_SLICE > j) {
dma.c:		if (dev->timer.expires != dev->last_switch + DRM_TIME_SLICE) {
dma.c:			del_timer(&dev->timer);
dma.c:			dev->timer.function = wrapper;
dma.c:			dev->timer.data	    = (unsigned long)dev;
dma.c:			dev->timer.expires  = dev->last_switch+DRM_TIME_SLICE;
dma.c:			add_timer(&dev->timer);
dma.c:	drm_device_dma_t  *dma = dev->dma;
dma.c:		int context = dev->lock.hw_lock->lock;
dma.c:		q = dev->queuelist[DRM_KERNEL_CONTEXT];
dma.c:		q = dev->queuelist[d->context];
dma.c:	drm_device_dma_t  *dma = dev->dma;
fops.c:	down(&dev->struct_sem);
fops.c:	if (!dev->file_last) {
fops.c:		dev->file_first = priv;
fops.c:		dev->file_last	= priv;
fops.c:		priv->prev	     = dev->file_last;
fops.c:		dev->file_last->next = priv;
fops.c:		dev->file_last	     = priv;
fops.c:	up(&dev->struct_sem);
fops.c:		  current->pid, dev->device, dev->open_count);
fops.c:		  current->pid, dev->device, dev->open_count);
fops.c:	if (dev->lock.hw_lock
fops.c:	    && _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)
fops.c:	    && dev->lock.pid == current->pid) {
fops.c:			  _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
fops.c:			      &dev->lock.hw_lock->lock,
fops.c:			      _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
fops.c:	down(&dev->struct_sem);
fops.c:	else		dev->file_first	 = priv->next;
fops.c:	else		dev->file_last	 = priv->prev;
fops.c:	up(&dev->struct_sem);
fops.c:	DRM_DEBUG("fd = %d, device = 0x%x\n", fd, dev->device);
fops.c:	retcode = fasync_helper(fd, filp, on, &dev->buf_async);
fops.c:	DRM_DEBUG("%p, %p\n", dev->buf_rp, dev->buf_wp);
fops.c:	while (dev->buf_rp == dev->buf_wp) {
fops.c:		interruptible_sleep_on(&dev->buf_readers);
fops.c:	left  = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
fops.c:		if (dev->buf_wp > dev->buf_rp) {
fops.c:			cur = DRM_MIN(send, dev->buf_wp - dev->buf_rp);
fops.c:			cur = DRM_MIN(send, dev->buf_end - dev->buf_rp);
fops.c:		if (copy_to_user(buf, dev->buf_rp, cur))
fops.c:		dev->buf_rp += cur;
fops.c:		if (dev->buf_rp == dev->buf_end) dev->buf_rp = dev->buf;
fops.c:	wake_up_interruptible(&dev->buf_writers);
fops.c:	int left   = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
fops.c:		  left, send, dev->buf_rp, dev->buf_wp);
fops.c:	if (left == 1 || dev->buf_wp != dev->buf_rp) {
fops.c:			  dev->buf_wp,
fops.c:			  dev->buf_rp);
fops.c:		if (dev->buf_wp >= dev->buf_rp) {
fops.c:			count = DRM_MIN(send, dev->buf_end - dev->buf_wp);
fops.c:			count = DRM_MIN(send, dev->buf_rp - dev->buf_wp - 1);
fops.c:		strncpy(dev->buf_wp, s, count);
fops.c:		dev->buf_wp += count;
fops.c:		if (dev->buf_wp == dev->buf_end) dev->buf_wp = dev->buf;
fops.c:	if (dev->buf_async) kill_fasync(dev->buf_async, SIGIO);
fops.c:	if (dev->buf_async) kill_fasync(dev->buf_async, SIGIO, POLL_IN);
fops.c:	if (dev->buf_async) kill_fasync(&dev->buf_async, SIGIO, POLL_IN);
fops.c:	wake_up_interruptible(&dev->buf_readers);
fops.c:	poll_wait(filp, &dev->buf_readers, wait);
fops.c:	if (dev->buf_wp != dev->buf_rp) return POLLIN | POLLRDNORM;
ioctl.c:	if (dev) p.irq = dev->irq;
ioctl.c:	if (u.unique_len >= dev->unique_len) {
ioctl.c:		if (copy_to_user(u.unique, dev->unique, dev->unique_len))
ioctl.c:	u.unique_len = dev->unique_len;
ioctl.c:	if (dev->unique_len || dev->unique)
ioctl.c:	dev->unique_len = u.unique_len;
ioctl.c:	dev->unique	= drm_alloc(u.unique_len + 1, DRM_MEM_DRIVER);
ioctl.c:	if (copy_from_user(dev->unique, u.unique, dev->unique_len))
ioctl.c:	dev->unique[dev->unique_len] = '\0';
ioctl.c:	dev->devname = drm_alloc(strlen(dev->name) + strlen(dev->unique) + 2,
ioctl.c:	sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
lists.c:	drm_device_dma_t *dma  = dev->dma;
lock.c:	dev->lock.pid = 0;
lock.c:	pid_t        pid = dev->lock.pid;
lock.c:	dev->lock.pid = 0;
lock.c:	wake_up_interruptible(&dev->lock.lock_queue);
lock.c:	drm_queue_t	  *q	= dev->queuelist[context];
lock.c:	drm_queue_t	  *q	= dev->queuelist[context];
lock.c:		for (i = 0; !ret && i < dev->queue_count; i++) {
lock.c:		for (i = 0; !ret && i < dev->queue_count; i++) {
proc.c:	if (dev->unique) {
proc.c:			       dev->name, dev->device, dev->unique);
proc.c:		DRM_PROC_PRINT("%s 0x%x\n", dev->name, dev->device);
proc.c:	for (i = 0; i < dev->map_count; i++) {
proc.c:		map = dev->maplist[i];
proc.c:	down(&dev->struct_sem);
proc.c:	up(&dev->struct_sem);
proc.c:	for (i = 0; i < dev->queue_count; i++) {
proc.c:		q = dev->queuelist[i];
proc.c:	down(&dev->struct_sem);
proc.c:	up(&dev->struct_sem);
proc.c:	drm_device_dma_t *dma = dev->dma;
proc.c:	down(&dev->struct_sem);
proc.c:	up(&dev->struct_sem);
proc.c:	for (priv = dev->file_first; priv; priv = priv->next) {
proc.c:	down(&dev->struct_sem);
proc.c:	up(&dev->struct_sem);
proc.c:		       atomic_read(&dev->vma_count),
proc.c:	for (pt = dev->vmalist; pt; pt = pt->next) {
proc.c:	down(&dev->struct_sem);
proc.c:	up(&dev->struct_sem);
proc.c:	drm_device_dma_t *dma = dev->dma;
proc.c:	DRM_PROC_PRINT("total	 %10u\n", atomic_read(&dev->histo.total));
proc.c:	DRM_PROC_PRINT("open	 %10u\n", atomic_read(&dev->total_open));
proc.c:	DRM_PROC_PRINT("close	 %10u\n", atomic_read(&dev->total_close));
proc.c:	DRM_PROC_PRINT("ioctl	 %10u\n", atomic_read(&dev->total_ioctl));
proc.c:	DRM_PROC_PRINT("irq	 %10u\n", atomic_read(&dev->total_irq));
proc.c:	DRM_PROC_PRINT("ctx	 %10u\n", atomic_read(&dev->total_ctx));
proc.c:	DRM_PROC_PRINT("locks	 %10u\n", atomic_read(&dev->total_locks));
proc.c:	DRM_PROC_PRINT("unlocks	 %10u\n", atomic_read(&dev->total_unlocks));
proc.c:	DRM_PROC_PRINT("contends %10u\n", atomic_read(&dev->total_contends));
proc.c:	DRM_PROC_PRINT("sleeps	 %10u\n", atomic_read(&dev->total_sleeps));
proc.c:	if (dev->lock.hw_lock) {
proc.c:			       dev->lock.hw_lock->lock);
proc.c:	DRM_PROC_PRINT("context_flag   0x%08lx\n", dev->context_flag);
proc.c:	DRM_PROC_PRINT("interrupt_flag 0x%08lx\n", dev->interrupt_flag);
proc.c:	DRM_PROC_PRINT("dma_flag       0x%08lx\n", dev->dma_flag);
proc.c:	DRM_PROC_PRINT("queue_count    %10d\n",	 dev->queue_count);
proc.c:	DRM_PROC_PRINT("last_context   %10d\n",	 dev->last_context);
proc.c:	DRM_PROC_PRINT("last_switch    %10lu\n", dev->last_switch);
proc.c:	DRM_PROC_PRINT("last_checked   %10d\n",	 dev->last_checked);
proc.c:			       atomic_read(&dev->histo
proc.c:			       atomic_read(&dev->histo
proc.c:			       atomic_read(&dev->histo
proc.c:			       atomic_read(&dev->histo
proc.c:			       atomic_read(&dev->histo
proc.c:			       atomic_read(&dev->histo.dma[i]),
proc.c:			       atomic_read(&dev->histo.schedule[i]),
proc.c:			       atomic_read(&dev->histo.ctx[i]),
proc.c:			       atomic_read(&dev->histo.lacq[i]),
proc.c:			       atomic_read(&dev->histo.lhld[i]));
proc.c:	down(&dev->struct_sem);
proc.c:	up(&dev->struct_sem);
radeon_bufs.c:	drm_device_dma_t *dma  = dev->dma;
radeon_bufs.c:	agp_offset = dev->agp->base + request.agp_start;
radeon_bufs.c:	if (dev->queue_count) 
radeon_bufs.c:	spin_lock(&dev->count_lock);
radeon_bufs.c:	if (dev->buf_use) {
radeon_bufs.c:		spin_unlock(&dev->count_lock);
radeon_bufs.c:	atomic_inc(&dev->buf_alloc);
radeon_bufs.c:	spin_unlock(&dev->count_lock);
radeon_bufs.c:	down(&dev->struct_sem);
radeon_bufs.c:		up(&dev->struct_sem);
radeon_bufs.c:		atomic_dec(&dev->buf_alloc);
radeon_bufs.c:		up(&dev->struct_sem);
radeon_bufs.c:		atomic_dec(&dev->buf_alloc);
radeon_bufs.c:	up(&dev->struct_sem);
radeon_bufs.c:	atomic_dec(&dev->buf_alloc);
radeon_bufs.c:	drm_radeon_private_t	*dev_priv	= dev->dev_private;
radeon_bufs.c:	drm_radeon_private_t	*dev_priv	= dev->dev_private;
radeon_bufs.c:	drm_device_dma_t	*dma		= dev->dma;
radeon_bufs.c:	spin_lock(&dev->count_lock);
radeon_bufs.c:	if (atomic_read(&dev->buf_alloc)) {
radeon_bufs.c:		spin_unlock(&dev->count_lock);
radeon_bufs.c:	++dev->buf_use;		/* Can't allocate more after this call */
radeon_bufs.c:	spin_unlock(&dev->count_lock);
radeon_bufs.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_bufs.c:	drm_radeon_private_t *dev_priv = dev->dev_private;	
radeon_bufs.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_bufs.c:	     dev->lock.pid != current->pid ) {
radeon_bufs.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_bufs.c:	     dev->lock.pid != current->pid ) {
radeon_context.c:        atomic_inc(&dev->total_ctx);
radeon_context.c:        if (test_and_set_bit(0, &dev->context_flag)) {
radeon_context.c:        dev->ctx_start = get_cycles();
radeon_context.c:        if (new == dev->last_context) {
radeon_context.c:                clear_bit(0, &dev->context_flag);
radeon_context.c:        dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
radeon_context.c:        dev->last_switch  = jiffies;
radeon_context.c:        if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
radeon_context.c:        atomic_inc(&dev->histo.ctx[drm_histogram_slot(get_cycles()
radeon_context.c:                                                      - dev->ctx_start)]);
radeon_context.c:        clear_bit(0, &dev->context_flag);
radeon_context.c:        wake_up(&dev->context_wait);
radeon_context.c:	return radeon_context_switch(dev, dev->last_context, ctx.handle);
radeon_cp.c:		for (_i = 0; _i < dev->map_count; _i++) {		\
radeon_cp.c:			if (dev->maplist[_i]->offset == _o) {		\
radeon_cp.c:				_m = dev->maplist[_i];			\
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	RADEON_WRITE( RADEON_AGP_BASE, dev->agp->agp_info.aper_base);	
radeon_cp.c:		      - dev->agp->base
radeon_cp.c:	dev->dev_private = (void *)dev_priv;
radeon_cp.c:		dev->dev_private = NULL;
radeon_cp.c:		dev->dev_private = NULL;
radeon_cp.c:		dev->dev_private = NULL;
radeon_cp.c:		dev->dev_private = NULL;
radeon_cp.c:		dev->dev_private = NULL;
radeon_cp.c:	for ( i = 0 ; i < dev->map_count ; i++ ) {
radeon_cp.c:		if ( dev->maplist[i]->type == _DRM_SHM ) {
radeon_cp.c:			dev_priv->sarea = dev->maplist[i];
radeon_cp.c:					- dev->agp->base
radeon_cp.c:	if ( dev->dev_private ) {
radeon_cp.c:		drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:		drm_free( dev->dev_private, sizeof(drm_radeon_private_t),
radeon_cp.c:		dev->dev_private = NULL;
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid ) {
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid ) {
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid ) {
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid ) {
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid ) {
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	drm_device_dma_t *dma = dev->dma;
radeon_cp.c:	drm_device_dma_t *dma = dev->dma;
radeon_cp.c:	drm_device_dma_t *dma = dev->dma;
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid ) {
radeon_cp.c:	drm_device_dma_t *dma = dev->dma;
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid )
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:	     dev->lock.pid != current->pid ) {
radeon_cp.c:    drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:    drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_cp.c:    drm_device_dma_t *dma = dev->dma;
radeon_cp.c:    if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
radeon_cp.c:         dev->lock.pid != current->pid )
radeon_drv.c:	atomic_set(&dev->ioctl_count, 0);
radeon_drv.c:	atomic_set(&dev->vma_count, 0);
radeon_drv.c:	dev->buf_use	  = 0;
radeon_drv.c:	atomic_set(&dev->buf_alloc, 0);
radeon_drv.c:	atomic_set(&dev->total_open, 0);
radeon_drv.c:	atomic_set(&dev->total_close, 0);
radeon_drv.c:	atomic_set(&dev->total_ioctl, 0);
radeon_drv.c:	atomic_set(&dev->total_irq, 0);
radeon_drv.c:	atomic_set(&dev->total_ctx, 0);
radeon_drv.c:	atomic_set(&dev->total_locks, 0);
radeon_drv.c:	atomic_set(&dev->total_unlocks, 0);
radeon_drv.c:	atomic_set(&dev->total_contends, 0);
radeon_drv.c:	atomic_set(&dev->total_sleeps, 0);
radeon_drv.c:		dev->magiclist[i].head = NULL;
radeon_drv.c:		dev->magiclist[i].tail = NULL;
radeon_drv.c:	dev->maplist	    = NULL;
radeon_drv.c:	dev->map_count	    = 0;
radeon_drv.c:	dev->vmalist	    = NULL;
radeon_drv.c:	dev->lock.hw_lock   = NULL;
radeon_drv.c:	init_waitqueue_head(&dev->lock.lock_queue);
radeon_drv.c:	dev->queue_count    = 0;
radeon_drv.c:	dev->queue_reserved = 0;
radeon_drv.c:	dev->queue_slots    = 0;
radeon_drv.c:	dev->queuelist	    = NULL;
radeon_drv.c:	dev->irq	    = 0;
radeon_drv.c:	dev->context_flag   = 0;
radeon_drv.c:	dev->interrupt_flag = 0;
radeon_drv.c:	dev->dma_flag	    = 0;
radeon_drv.c:	dev->last_context   = 0;
radeon_drv.c:	dev->last_switch    = 0;
radeon_drv.c:	dev->last_checked   = 0;
radeon_drv.c:	init_timer(&dev->timer);
radeon_drv.c:	init_waitqueue_head(&dev->context_wait);
radeon_drv.c:	dev->ctx_start	    = 0;
radeon_drv.c:	dev->lck_start	    = 0;
radeon_drv.c:	dev->buf_rp	    = dev->buf;
radeon_drv.c:	dev->buf_wp	    = dev->buf;
radeon_drv.c:	dev->buf_end	    = dev->buf + DRM_BSZ;
radeon_drv.c:	dev->buf_async	    = NULL;
radeon_drv.c:	init_waitqueue_head(&dev->buf_readers);
radeon_drv.c:	init_waitqueue_head(&dev->buf_writers);
radeon_drv.c:	dev->dev_private = NULL;
radeon_drv.c:	down(&dev->struct_sem);
radeon_drv.c:	del_timer(&dev->timer);
radeon_drv.c:	if (dev->devname) {
radeon_drv.c:		drm_free(dev->devname, strlen(dev->devname)+1, DRM_MEM_DRIVER);
radeon_drv.c:		dev->devname = NULL;
radeon_drv.c:	if (dev->unique) {
radeon_drv.c:		drm_free(dev->unique, strlen(dev->unique)+1, DRM_MEM_DRIVER);
radeon_drv.c:		dev->unique = NULL;
radeon_drv.c:		dev->unique_len = 0;
radeon_drv.c:		for (pt = dev->magiclist[i].head; pt; pt = next) {
radeon_drv.c:		dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
radeon_drv.c:	if (dev->agp) {
radeon_drv.c:				/* Remove AGP resources, but leave dev->agp
radeon_drv.c:		for (entry = dev->agp->memory; entry; entry = nexte) {
radeon_drv.c:		dev->agp->memory = NULL;
radeon_drv.c:		if (dev->agp->acquired)	_drm_agp_release();
radeon_drv.c:		dev->agp->acquired = 0;
radeon_drv.c:		dev->agp->enabled  = 0;
radeon_drv.c:	if (dev->vmalist) {
radeon_drv.c:		for (vma = dev->vmalist; vma; vma = vma_next) {
radeon_drv.c:		dev->vmalist = NULL;
radeon_drv.c:	if (dev->maplist) {
radeon_drv.c:		for (i = 0; i < dev->map_count; i++) {
radeon_drv.c:			map = dev->maplist[i];
radeon_drv.c:		drm_free(dev->maplist,
radeon_drv.c:			 dev->map_count * sizeof(*dev->maplist),
radeon_drv.c:		dev->maplist   = NULL;
radeon_drv.c:		dev->map_count = 0;
radeon_drv.c:	dev->queue_count     = 0;
radeon_drv.c:	if (dev->lock.hw_lock) {
radeon_drv.c:		dev->lock.hw_lock    = NULL; /* SHM removed */
radeon_drv.c:		dev->lock.pid	     = 0;
radeon_drv.c:		wake_up_interruptible(&dev->lock.lock_queue);
radeon_drv.c:	up(&dev->struct_sem);
radeon_drv.c:	dev->count_lock	  = SPIN_LOCK_UNLOCKED;
radeon_drv.c:	sema_init(&dev->struct_sem, 1);
radeon_drv.c:	dev->device = MKDEV(MISC_MAJOR, radeon_misc.minor);
radeon_drv.c:	dev->name   = RADEON_NAME;
radeon_drv.c:	dev->agp    = drm_agp_init();
radeon_drv.c:      	if (dev->agp == NULL) {
radeon_drv.c:	dev->agp->agp_mtrr = mtrr_add(dev->agp->agp_info.aper_base,
radeon_drv.c:				      dev->agp->agp_info.aper_size*1024*1024,
radeon_drv.c:	if (dev->agp) {
radeon_drv.c:		drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS);
radeon_drv.c:		dev->agp = NULL;
radeon_drv.c:	DRM_DEBUG("open_count = %d\n", dev->open_count);
radeon_drv.c:		atomic_inc(&dev->total_open);
radeon_drv.c:		spin_lock(&dev->count_lock);
radeon_drv.c:		if (!dev->open_count++) {
radeon_drv.c:			spin_unlock(&dev->count_lock);
radeon_drv.c:		spin_unlock(&dev->count_lock);
radeon_drv.c:	DRM_DEBUG("open_count = %d\n", dev->open_count);
radeon_drv.c:		atomic_inc(&dev->total_close);
radeon_drv.c:		spin_lock(&dev->count_lock);
radeon_drv.c:		if (!--dev->open_count) {
radeon_drv.c:			if (atomic_read(&dev->ioctl_count) || dev->blocked) {
radeon_drv.c:					  atomic_read(&dev->ioctl_count),
radeon_drv.c:					  dev->blocked);
radeon_drv.c:				spin_unlock(&dev->count_lock);
radeon_drv.c:			spin_unlock(&dev->count_lock);
radeon_drv.c:		spin_unlock(&dev->count_lock);
radeon_drv.c:	atomic_inc(&dev->ioctl_count);
radeon_drv.c:	atomic_inc(&dev->total_ioctl);
radeon_drv.c:		  current->pid, cmd, nr, dev->device, priv->authenticated);
radeon_drv.c:	atomic_dec(&dev->ioctl_count);
radeon_drv.c:                  lock.context, current->pid, dev->lock.hw_lock->lock,
radeon_drv.c:        if (lock.context < 0 /* || lock.context >= dev->queue_count */)
radeon_drv.c:                add_wait_queue(&dev->lock.lock_queue, &entry);
radeon_drv.c:                        if (!dev->lock.hw_lock) 
radeon_drv.c:                        if (drm_lock_take(&dev->lock.hw_lock->lock,
radeon_drv.c:                                dev->lock.pid       = current->pid;
radeon_drv.c:                                dev->lock.lock_time = jiffies;
radeon_drv.c:                                atomic_inc(&dev->total_locks);
radeon_drv.c:                        atomic_inc(&dev->total_sleeps);
radeon_drv.c:                remove_wait_queue(&dev->lock.lock_queue, &entry);
radeon_drv.c:		sigemptyset(&dev->sigmask);
radeon_drv.c:		sigaddset(&dev->sigmask, SIGSTOP);
radeon_drv.c:		sigaddset(&dev->sigmask, SIGTSTP);
radeon_drv.c:		sigaddset(&dev->sigmask, SIGTTIN);
radeon_drv.c:		sigaddset(&dev->sigmask, SIGTTOU);
radeon_drv.c:		dev->sigdata.context = lock.context;
radeon_drv.c:		dev->sigdata.lock    = dev->lock.hw_lock;
radeon_drv.c:		block_all_signals(drm_notifier, &dev->sigdata, &dev->sigmask);
radeon_drv.c:		  _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
radeon_drv.c:	atomic_inc(&dev->total_unlocks);
radeon_drv.c:	if (_DRM_LOCK_IS_CONT(dev->lock.hw_lock->lock))
radeon_drv.c:		atomic_inc(&dev->total_contends);
radeon_drv.c:	drm_lock_transfer(dev, &dev->lock.hw_lock->lock, DRM_KERNEL_CONTEXT);
radeon_drv.c:	if (!dev->context_flag) 
radeon_drv.c:		if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
radeon_drv.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_drv.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_drv.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_drv.c: 	drm_radeon_private_t *dev_priv = dev->dev_private;
radeon_drv.c:	drm_radeon_private_t *dev_priv = dev->dev_private;
vm.c:	if (!dev->lock.hw_lock)    return NOPAGE_OOM;  /* Nothing allocated */
vm.c:	physical = (unsigned long)dev->lock.hw_lock + offset;
vm.c:	drm_device_dma_t *dma	 = dev->dma;
vm.c:	atomic_inc(&dev->vma_count);
vm.c:		down(&dev->struct_sem);
vm.c:		vma_entry->next = dev->vmalist;
vm.c:		dev->vmalist	= vma_entry;
vm.c:		up(&dev->struct_sem);
vm.c:	atomic_dec(&dev->vma_count);
vm.c:	down(&dev->struct_sem);
vm.c:	for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
vm.c:				dev->vmalist = pt->next;
vm.c:	up(&dev->struct_sem);
vm.c:	dma	 = dev->dma;
vm.c:	for (i = 0; i < dev->map_count; i++) {
vm.c:		map = dev->maplist[i];
vm.c:	if (i >= dev->map_count) return -EINVAL;
