paddr_t drm_mmap(dev_t kdev, off_t offset, int prot)
{
DRM_DEVICE;
drm_local_map_t *map;
drm_file_t *priv;
drm_map_type_t type;
paddr_t phys;
uintptr_t roffset;
DRM_LOCK();
priv = drm_find_file_by_proc(dev, DRM_CURPROC);
DRM_UNLOCK();
if (priv == NULL) {
DRM_ERROR("can't find authenticator\n");
return -1;
}
if (!priv->authenticated)
return -1;
if (dev->dma && offset >= 0 && offset < ptoa(dev->dma->page_count)) {
drm_device_dma_t *dma = dev->dma;
DRM_SPINLOCK(&dev->dma_lock);
if (dma->pagelist != NULL) {
unsigned long page = offset >> PAGE_SHIFT;
unsigned long pphys = dma->pagelist[page];
#ifdef macppc
return pphys;
#else
return atop(pphys);
#endif
} else {
int drm_mmap(struct dev_mmap_args *ap)
{
struct cdev *kdev = ap->a_head.a_dev;
vm_offset_t offset = ap->a_offset;
struct drm_device *dev = drm_get_device_from_kdev(kdev);
struct drm_file *file_priv = NULL;
drm_local_map_t *map;
enum drm_map_type type;
vm_paddr_t phys;
DRM_LOCK();
file_priv = drm_find_file_by_proc(dev, DRM_CURPROC);
DRM_UNLOCK();
if (file_priv == NULL) {
DRM_ERROR("can't find authenticator\n");
return EINVAL;
}
if (!file_priv->authenticated)
return EACCES;
if (dev->dma && offset < ptoa(dev->dma->page_count)) {
drm_device_dma_t *dma = dev->dma;
DRM_SPINLOCK(&dev->dma_lock);
if (dma->pagelist != NULL) {
unsigned long page = offset >> PAGE_SHIFT;
unsigned long phys = dma->pagelist[page];
ap->a_result = atop(phys);
DRM_SPINUNLOCK(&dev->dma_lock);
return 0;
} else {
/* drm_open_helper is called whenever a process opens /dev/drm. */
int drm_open_helper(struct cdev *kdev, int flags, int fmt, DRM_STRUCTPROC *p,
drm_device_t *dev)
{
int m = minor(kdev);
drm_file_t *priv;
int retcode;
if (flags & O_EXCL)
return EBUSY; /* No exclusive opens */
dev->flags = flags;
DRM_DEBUG("pid = %d, minor = %d\n", DRM_CURRENTPID, m);
DRM_LOCK();
priv = drm_find_file_by_proc(dev, p);
if (priv) {
priv->refs++;
} else {
priv = malloc(sizeof(*priv), M_DRM, M_NOWAIT | M_ZERO);
if (priv == NULL) {
DRM_UNLOCK();
return DRM_ERR(ENOMEM);
}
#if __FreeBSD_version >= 500000
priv->uid = p->td_ucred->cr_svuid;
priv->pid = p->td_proc->p_pid;
#else
priv->uid = p->p_cred->p_svuid;
priv->pid = p->p_pid;
#endif
priv->refs = 1;
priv->minor = m;
priv->ioctl_count = 0;
/* for compatibility root is always authenticated */
priv->authenticated = DRM_SUSER(p);
if (dev->driver.open) {
retcode = dev->driver.open(dev, priv);
if (retcode != 0) {
free(priv, M_DRM);
DRM_UNLOCK();
return retcode;
}
}
/* first opener automatically becomes master */
priv->master = TAILQ_EMPTY(&dev->files);
TAILQ_INSERT_TAIL(&dev->files, priv, link);
}
DRM_UNLOCK();
#ifdef __FreeBSD__
kdev->si_drv1 = dev;
#endif
return 0;
}
static bool
radeondrm_resume(device_t self, const pmf_qual_t *qual)
{
struct drm_device *dev = device_private(self);
bool rv = true;
DRM_LOCK();
if (drm_find_file_by_proc(dev, curlwp->l_proc) &&
radeon_cp_resume(dev, NULL, NULL) != 0)
rv = false;
DRM_UNLOCK();
return rv;
}
static bool
radeondrm_suspend(device_t self, const pmf_qual_t *qual)
{
struct drm_device *dev = device_private(self);
drm_radeon_cp_stop_t stop_args;
bool rv = true;
stop_args.flush = stop_args.idle = 0;
DRM_LOCK();
if (drm_find_file_by_proc(dev, curlwp->l_proc) &&
radeon_cp_stop(dev, &stop_args, dev->lock.file_priv) != 0)
rv = false;
DRM_UNLOCK();
return rv;
}
int drm_mmap(struct dev_mmap_args *ap)
{
struct cdev *kdev = ap->a_head.a_dev;
vm_offset_t offset = ap->a_offset;
struct drm_device *dev = drm_get_device_from_kdev(kdev);
struct drm_file *file_priv = NULL;
struct drm_local_map *map = NULL;
struct drm_map_list *r_list;
enum drm_map_type type;
vm_paddr_t phys;
/* d_mmap gets called twice, we can only reference file_priv during
* the first call. We need to assume that if error is EBADF the
* call was succesful and the client is authenticated.
*/
DRM_LOCK(dev);
file_priv = drm_find_file_by_proc(dev, curthread);
DRM_UNLOCK(dev);
if (!file_priv) {
DRM_ERROR("Could not find authenticator!\n");
return EINVAL;
}
if (!file_priv->authenticated)
return EACCES;
DRM_DEBUG("called with offset %016jx\n", (uintmax_t)offset);
if (dev->dma && offset < ptoa(dev->dma->page_count)) {
drm_device_dma_t *dma = dev->dma;
spin_lock(&dev->dma_lock);
if (dma->pagelist != NULL) {
unsigned long page = offset >> PAGE_SHIFT;
unsigned long phys = dma->pagelist[page];
spin_unlock(&dev->dma_lock);
// XXX *paddr = phys;
ap->a_result = phys;
return 0;
} else {
int drm_getmagic(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
static drm_magic_t sequence = 0;
drm_auth_t auth;
drm_file_t *priv;
DRM_LOCK();
priv = drm_find_file_by_proc(dev, p);
DRM_UNLOCK();
if (priv == NULL) {
DRM_ERROR("can't find authenticator\n");
return EINVAL;
}
/* Find unique magic */
if (priv->magic) {
auth.magic = priv->magic;
} else {
do {
int old = sequence;
auth.magic = old+1;
if (!atomic_cmpset_int(&sequence, old, auth.magic))
continue;
} while (drm_find_file(dev, auth.magic));
priv->magic = auth.magic;
drm_add_magic(dev, priv, auth.magic);
}
DRM_DEBUG("%u\n", auth.magic);
DRM_COPY_TO_USER_IOCTL((drm_auth_t *)data, auth, sizeof(auth));
return 0;
}
