1da177e4c3
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
365 lines
8.6 KiB
C
365 lines
8.6 KiB
C
/* $Id: ffb_drv.c,v 1.16 2001/10/18 16:00:24 davem Exp $
|
|
* ffb_drv.c: Creator/Creator3D direct rendering driver.
|
|
*
|
|
* Copyright (C) 2000 David S. Miller (davem@redhat.com)
|
|
*/
|
|
|
|
#include <linux/config.h>
|
|
#include "ffb.h"
|
|
#include "drmP.h"
|
|
|
|
#include "ffb_drv.h"
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <asm/shmparam.h>
|
|
#include <asm/oplib.h>
|
|
#include <asm/upa.h>
|
|
|
|
#define DRIVER_AUTHOR "David S. Miller"
|
|
|
|
#define DRIVER_NAME "ffb"
|
|
#define DRIVER_DESC "Creator/Creator3D"
|
|
#define DRIVER_DATE "20000517"
|
|
|
|
#define DRIVER_MAJOR 0
|
|
#define DRIVER_MINOR 0
|
|
#define DRIVER_PATCHLEVEL 1
|
|
|
|
typedef struct _ffb_position_t {
|
|
int node;
|
|
int root;
|
|
} ffb_position_t;
|
|
|
|
static ffb_position_t *ffb_position;
|
|
|
|
static void get_ffb_type(ffb_dev_priv_t *ffb_priv, int instance)
|
|
{
|
|
volatile unsigned char *strap_bits;
|
|
unsigned char val;
|
|
|
|
strap_bits = (volatile unsigned char *)
|
|
(ffb_priv->card_phys_base + 0x00200000UL);
|
|
|
|
/* Don't ask, you have to read the value twice for whatever
|
|
* reason to get correct contents.
|
|
*/
|
|
val = upa_readb(strap_bits);
|
|
val = upa_readb(strap_bits);
|
|
switch (val & 0x78) {
|
|
case (0x0 << 5) | (0x0 << 3):
|
|
ffb_priv->ffb_type = ffb1_prototype;
|
|
printk("ffb%d: Detected FFB1 pre-FCS prototype\n", instance);
|
|
break;
|
|
case (0x0 << 5) | (0x1 << 3):
|
|
ffb_priv->ffb_type = ffb1_standard;
|
|
printk("ffb%d: Detected FFB1\n", instance);
|
|
break;
|
|
case (0x0 << 5) | (0x3 << 3):
|
|
ffb_priv->ffb_type = ffb1_speedsort;
|
|
printk("ffb%d: Detected FFB1-SpeedSort\n", instance);
|
|
break;
|
|
case (0x1 << 5) | (0x0 << 3):
|
|
ffb_priv->ffb_type = ffb2_prototype;
|
|
printk("ffb%d: Detected FFB2/vertical pre-FCS prototype\n", instance);
|
|
break;
|
|
case (0x1 << 5) | (0x1 << 3):
|
|
ffb_priv->ffb_type = ffb2_vertical;
|
|
printk("ffb%d: Detected FFB2/vertical\n", instance);
|
|
break;
|
|
case (0x1 << 5) | (0x2 << 3):
|
|
ffb_priv->ffb_type = ffb2_vertical_plus;
|
|
printk("ffb%d: Detected FFB2+/vertical\n", instance);
|
|
break;
|
|
case (0x2 << 5) | (0x0 << 3):
|
|
ffb_priv->ffb_type = ffb2_horizontal;
|
|
printk("ffb%d: Detected FFB2/horizontal\n", instance);
|
|
break;
|
|
case (0x2 << 5) | (0x2 << 3):
|
|
ffb_priv->ffb_type = ffb2_horizontal;
|
|
printk("ffb%d: Detected FFB2+/horizontal\n", instance);
|
|
break;
|
|
default:
|
|
ffb_priv->ffb_type = ffb2_vertical;
|
|
printk("ffb%d: Unknown boardID[%08x], assuming FFB2\n", instance, val);
|
|
break;
|
|
};
|
|
}
|
|
|
|
static void ffb_apply_upa_parent_ranges(int parent,
|
|
struct linux_prom64_registers *regs)
|
|
{
|
|
struct linux_prom64_ranges ranges[PROMREG_MAX];
|
|
char name[128];
|
|
int len, i;
|
|
|
|
prom_getproperty(parent, "name", name, sizeof(name));
|
|
if (strcmp(name, "upa") != 0)
|
|
return;
|
|
|
|
len = prom_getproperty(parent, "ranges", (void *) ranges, sizeof(ranges));
|
|
if (len <= 0)
|
|
return;
|
|
|
|
len /= sizeof(struct linux_prom64_ranges);
|
|
for (i = 0; i < len; i++) {
|
|
struct linux_prom64_ranges *rng = &ranges[i];
|
|
u64 phys_addr = regs->phys_addr;
|
|
|
|
if (phys_addr >= rng->ot_child_base &&
|
|
phys_addr < (rng->ot_child_base + rng->or_size)) {
|
|
regs->phys_addr -= rng->ot_child_base;
|
|
regs->phys_addr += rng->ot_parent_base;
|
|
return;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static int ffb_init_one(drm_device_t *dev, int prom_node, int parent_node,
|
|
int instance)
|
|
{
|
|
struct linux_prom64_registers regs[2*PROMREG_MAX];
|
|
ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
|
|
int i;
|
|
|
|
ffb_priv->prom_node = prom_node;
|
|
if (prom_getproperty(ffb_priv->prom_node, "reg",
|
|
(void *)regs, sizeof(regs)) <= 0) {
|
|
return -EINVAL;
|
|
}
|
|
ffb_apply_upa_parent_ranges(parent_node, ®s[0]);
|
|
ffb_priv->card_phys_base = regs[0].phys_addr;
|
|
ffb_priv->regs = (ffb_fbcPtr)
|
|
(regs[0].phys_addr + 0x00600000UL);
|
|
get_ffb_type(ffb_priv, instance);
|
|
for (i = 0; i < FFB_MAX_CTXS; i++)
|
|
ffb_priv->hw_state[i] = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static drm_map_t *ffb_find_map(struct file *filp, unsigned long off)
|
|
{
|
|
drm_file_t *priv = filp->private_data;
|
|
drm_device_t *dev;
|
|
drm_map_list_t *r_list;
|
|
struct list_head *list;
|
|
drm_map_t *map;
|
|
|
|
if (!priv || (dev = priv->dev) == NULL)
|
|
return NULL;
|
|
|
|
list_for_each(list, &dev->maplist->head) {
|
|
unsigned long uoff;
|
|
|
|
r_list = (drm_map_list_t *)list;
|
|
map = r_list->map;
|
|
if (!map)
|
|
continue;
|
|
uoff = (map->offset & 0xffffffff);
|
|
if (uoff == off)
|
|
return map;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
unsigned long ffb_get_unmapped_area(struct file *filp,
|
|
unsigned long hint,
|
|
unsigned long len,
|
|
unsigned long pgoff,
|
|
unsigned long flags)
|
|
{
|
|
drm_map_t *map = ffb_find_map(filp, pgoff << PAGE_SHIFT);
|
|
unsigned long addr = -ENOMEM;
|
|
|
|
if (!map)
|
|
return get_unmapped_area(NULL, hint, len, pgoff, flags);
|
|
|
|
if (map->type == _DRM_FRAME_BUFFER ||
|
|
map->type == _DRM_REGISTERS) {
|
|
#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
|
|
addr = get_fb_unmapped_area(filp, hint, len, pgoff, flags);
|
|
#else
|
|
addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
|
|
#endif
|
|
} else if (map->type == _DRM_SHM && SHMLBA > PAGE_SIZE) {
|
|
unsigned long slack = SHMLBA - PAGE_SIZE;
|
|
|
|
addr = get_unmapped_area(NULL, hint, len + slack, pgoff, flags);
|
|
if (!(addr & ~PAGE_MASK)) {
|
|
unsigned long kvirt = (unsigned long) map->handle;
|
|
|
|
if ((kvirt & (SHMLBA - 1)) != (addr & (SHMLBA - 1))) {
|
|
unsigned long koff, aoff;
|
|
|
|
koff = kvirt & (SHMLBA - 1);
|
|
aoff = addr & (SHMLBA - 1);
|
|
if (koff < aoff)
|
|
koff += SHMLBA;
|
|
|
|
addr += (koff - aoff);
|
|
}
|
|
}
|
|
} else {
|
|
addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
|
|
}
|
|
|
|
return addr;
|
|
}
|
|
|
|
static int ffb_presetup(drm_device_t *dev)
|
|
{
|
|
ffb_dev_priv_t *ffb_priv;
|
|
int ret = 0;
|
|
int i = 0;
|
|
|
|
/* Check for the case where no device was found. */
|
|
if (ffb_position == NULL)
|
|
return -ENODEV;
|
|
|
|
/* code used to use numdevs no numdevs anymore */
|
|
ffb_priv = kmalloc(sizeof(ffb_dev_priv_t), GFP_KERNEL);
|
|
if (!ffb_priv)
|
|
return -ENOMEM;
|
|
memset(ffb_priv, 0, sizeof(*ffb_priv));
|
|
dev->dev_private = ffb_priv;
|
|
|
|
ret = ffb_init_one(dev,
|
|
ffb_position[i].node,
|
|
ffb_position[i].root,
|
|
i);
|
|
return ret;
|
|
}
|
|
|
|
static void ffb_driver_release(drm_device_t *dev, struct file *filp)
|
|
{
|
|
ffb_dev_priv_t *fpriv = (ffb_dev_priv_t *) dev->dev_private;
|
|
int context = _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock);
|
|
int idx;
|
|
|
|
idx = context - 1;
|
|
if (fpriv &&
|
|
context != DRM_KERNEL_CONTEXT &&
|
|
fpriv->hw_state[idx] != NULL) {
|
|
kfree(fpriv->hw_state[idx]);
|
|
fpriv->hw_state[idx] = NULL;
|
|
}
|
|
}
|
|
|
|
static void ffb_driver_pretakedown(drm_device_t *dev)
|
|
{
|
|
if (dev->dev_private) kfree(dev->dev_private);
|
|
}
|
|
|
|
static int ffb_driver_postcleanup(drm_device_t *dev)
|
|
{
|
|
if (ffb_position != NULL) kfree(ffb_position);
|
|
return 0;
|
|
}
|
|
|
|
static void ffb_driver_kernel_context_switch_unlock(struct drm_device *dev, drm_lock_t *lock)
|
|
{
|
|
dev->lock.filp = 0;
|
|
{
|
|
__volatile__ unsigned int *plock = &dev->lock.hw_lock->lock;
|
|
unsigned int old, new, prev, ctx;
|
|
|
|
ctx = lock->context;
|
|
do {
|
|
old = *plock;
|
|
new = ctx;
|
|
prev = cmpxchg(plock, old, new);
|
|
} while (prev != old);
|
|
}
|
|
wake_up_interruptible(&dev->lock.lock_queue);
|
|
}
|
|
|
|
static unsigned long ffb_driver_get_map_ofs(drm_map_t *map)
|
|
{
|
|
return (map->offset & 0xffffffff);
|
|
}
|
|
|
|
static unsigned long ffb_driver_get_reg_ofs(drm_device_t *dev)
|
|
{
|
|
ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
|
|
|
|
if (ffb_priv)
|
|
return ffb_priv->card_phys_base;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int postinit( struct drm_device *dev, unsigned long flags )
|
|
{
|
|
DRM_INFO( "Initialized %s %d.%d.%d %s on minor %d\n",
|
|
DRIVER_NAME,
|
|
DRIVER_MAJOR,
|
|
DRIVER_MINOR,
|
|
DRIVER_PATCHLEVEL,
|
|
DRIVER_DATE,
|
|
dev->minor
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
static int version( drm_version_t *version )
|
|
{
|
|
int len;
|
|
|
|
version->version_major = DRIVER_MAJOR;
|
|
version->version_minor = DRIVER_MINOR;
|
|
version->version_patchlevel = DRIVER_PATCHLEVEL;
|
|
DRM_COPY( version->name, DRIVER_NAME );
|
|
DRM_COPY( version->date, DRIVER_DATE );
|
|
DRM_COPY( version->desc, DRIVER_DESC );
|
|
return 0;
|
|
}
|
|
|
|
static drm_ioctl_desc_t ioctls[] = {
|
|
|
|
};
|
|
|
|
static struct drm_driver driver = {
|
|
.driver_features = 0,
|
|
.dev_priv_size = sizeof(u32),
|
|
.release = ffb_driver_release,
|
|
.presetup = ffb_presetup,
|
|
.pretakedown = ffb_driver_pretakedown,
|
|
.postcleanup = ffb_driver_postcleanup,
|
|
.kernel_context_switch = ffb_driver_context_switch,
|
|
.kernel_context_switch_unlock = ffb_driver_kernel_context_switch_unlock,
|
|
.get_map_ofs = ffb_driver_get_map_ofs,
|
|
.get_reg_ofs = ffb_driver_get_reg_ofs,
|
|
.postinit = postinit,
|
|
.version = version,
|
|
.ioctls = ioctls,
|
|
.num_ioctls = DRM_ARRAY_SIZE(ioctls),
|
|
.fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = drm_open,
|
|
.release = drm_release,
|
|
.ioctl = drm_ioctl,
|
|
.mmap = drm_mmap,
|
|
.poll = drm_poll,
|
|
.fasync = drm_fasync,
|
|
},
|
|
};
|
|
|
|
static int __init ffb_init(void)
|
|
{
|
|
return -ENODEV;
|
|
}
|
|
|
|
static void __exit ffb_exit(void)
|
|
{
|
|
}
|
|
|
|
module_init(ffb_init);
|
|
module_exit(ffb_exit);
|
|
|
|
MODULE_AUTHOR( DRIVER_AUTHOR );
|
|
MODULE_DESCRIPTION( DRIVER_DESC );
|
|
MODULE_LICENSE("GPL and additional rights");
|