1 /* $Id: ffb_drv.c,v 1.16 2001/10/18 16:00:24 davem Exp $
2 * ffb_drv.c: Creator/Creator3D direct rendering driver.
4 * Copyright (C) 2000 David S. Miller (davem@redhat.com)
7 #include <linux/config.h>
13 #include <linux/sched.h>
14 #include <linux/smp_lock.h>
15 #include <asm/shmparam.h>
16 #include <asm/oplib.h>
19 #define DRIVER_AUTHOR "David S. Miller"
21 #define DRIVER_NAME "ffb"
22 #define DRIVER_DESC "Creator/Creator3D"
23 #define DRIVER_DATE "20000517"
25 #define DRIVER_MAJOR 0
26 #define DRIVER_MINOR 0
27 #define DRIVER_PATCHLEVEL 1
29 typedef struct _ffb_position_t {
34 static ffb_position_t *ffb_position;
36 static void get_ffb_type(ffb_dev_priv_t *ffb_priv, int instance)
38 volatile unsigned char *strap_bits;
41 strap_bits = (volatile unsigned char *)
42 (ffb_priv->card_phys_base + 0x00200000UL);
44 /* Don't ask, you have to read the value twice for whatever
45 * reason to get correct contents.
47 val = upa_readb(strap_bits);
48 val = upa_readb(strap_bits);
50 case (0x0 << 5) | (0x0 << 3):
51 ffb_priv->ffb_type = ffb1_prototype;
52 printk("ffb%d: Detected FFB1 pre-FCS prototype\n", instance);
54 case (0x0 << 5) | (0x1 << 3):
55 ffb_priv->ffb_type = ffb1_standard;
56 printk("ffb%d: Detected FFB1\n", instance);
58 case (0x0 << 5) | (0x3 << 3):
59 ffb_priv->ffb_type = ffb1_speedsort;
60 printk("ffb%d: Detected FFB1-SpeedSort\n", instance);
62 case (0x1 << 5) | (0x0 << 3):
63 ffb_priv->ffb_type = ffb2_prototype;
64 printk("ffb%d: Detected FFB2/vertical pre-FCS prototype\n", instance);
66 case (0x1 << 5) | (0x1 << 3):
67 ffb_priv->ffb_type = ffb2_vertical;
68 printk("ffb%d: Detected FFB2/vertical\n", instance);
70 case (0x1 << 5) | (0x2 << 3):
71 ffb_priv->ffb_type = ffb2_vertical_plus;
72 printk("ffb%d: Detected FFB2+/vertical\n", instance);
74 case (0x2 << 5) | (0x0 << 3):
75 ffb_priv->ffb_type = ffb2_horizontal;
76 printk("ffb%d: Detected FFB2/horizontal\n", instance);
78 case (0x2 << 5) | (0x2 << 3):
79 ffb_priv->ffb_type = ffb2_horizontal;
80 printk("ffb%d: Detected FFB2+/horizontal\n", instance);
83 ffb_priv->ffb_type = ffb2_vertical;
84 printk("ffb%d: Unknown boardID[%08x], assuming FFB2\n", instance, val);
89 static void ffb_apply_upa_parent_ranges(int parent,
90 struct linux_prom64_registers *regs)
92 struct linux_prom64_ranges ranges[PROMREG_MAX];
96 prom_getproperty(parent, "name", name, sizeof(name));
97 if (strcmp(name, "upa") != 0)
100 len = prom_getproperty(parent, "ranges", (void *) ranges, sizeof(ranges));
104 len /= sizeof(struct linux_prom64_ranges);
105 for (i = 0; i < len; i++) {
106 struct linux_prom64_ranges *rng = &ranges[i];
107 u64 phys_addr = regs->phys_addr;
109 if (phys_addr >= rng->ot_child_base &&
110 phys_addr < (rng->ot_child_base + rng->or_size)) {
111 regs->phys_addr -= rng->ot_child_base;
112 regs->phys_addr += rng->ot_parent_base;
120 static int ffb_init_one(drm_device_t *dev, int prom_node, int parent_node,
123 struct linux_prom64_registers regs[2*PROMREG_MAX];
124 ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
127 ffb_priv->prom_node = prom_node;
128 if (prom_getproperty(ffb_priv->prom_node, "reg",
129 (void *)regs, sizeof(regs)) <= 0) {
132 ffb_apply_upa_parent_ranges(parent_node, ®s[0]);
133 ffb_priv->card_phys_base = regs[0].phys_addr;
134 ffb_priv->regs = (ffb_fbcPtr)
135 (regs[0].phys_addr + 0x00600000UL);
136 get_ffb_type(ffb_priv, instance);
137 for (i = 0; i < FFB_MAX_CTXS; i++)
138 ffb_priv->hw_state[i] = NULL;
143 static drm_map_t *ffb_find_map(struct file *filp, unsigned long off)
145 drm_file_t *priv = filp->private_data;
147 drm_map_list_t *r_list;
148 struct list_head *list;
151 if (!priv || (dev = priv->dev) == NULL)
154 list_for_each(list, &dev->maplist->head) {
157 r_list = (drm_map_list_t *)list;
161 uoff = (map->offset & 0xffffffff);
169 unsigned long ffb_get_unmapped_area(struct file *filp,
175 drm_map_t *map = ffb_find_map(filp, pgoff << PAGE_SHIFT);
176 unsigned long addr = -ENOMEM;
179 return get_unmapped_area(NULL, hint, len, pgoff, flags);
181 if (map->type == _DRM_FRAME_BUFFER ||
182 map->type == _DRM_REGISTERS) {
183 #ifdef HAVE_ARCH_FB_UNMAPPED_AREA
184 addr = get_fb_unmapped_area(filp, hint, len, pgoff, flags);
186 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
188 } else if (map->type == _DRM_SHM && SHMLBA > PAGE_SIZE) {
189 unsigned long slack = SHMLBA - PAGE_SIZE;
191 addr = get_unmapped_area(NULL, hint, len + slack, pgoff, flags);
192 if (!(addr & ~PAGE_MASK)) {
193 unsigned long kvirt = (unsigned long) map->handle;
195 if ((kvirt & (SHMLBA - 1)) != (addr & (SHMLBA - 1))) {
196 unsigned long koff, aoff;
198 koff = kvirt & (SHMLBA - 1);
199 aoff = addr & (SHMLBA - 1);
203 addr += (koff - aoff);
207 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
213 #include "drm_core.h"
215 /* This functions must be here since it references DRM(numdevs)
216 * which drm_drv.h declares.
218 static int ffb_presetup(drm_device_t *dev)
220 ffb_dev_priv_t *ffb_priv;
221 drm_device_t *temp_dev;
225 /* Check for the case where no device was found. */
226 if (ffb_position == NULL)
229 /* Find our instance number by finding our device in dev structure */
230 for (i = 0; i < DRM(numdevs); i++) {
231 temp_dev = &(DRM(device)[i]);
236 if (i == DRM(numdevs))
239 ffb_priv = kmalloc(sizeof(ffb_dev_priv_t), GFP_KERNEL);
242 memset(ffb_priv, 0, sizeof(*ffb_priv));
243 dev->dev_private = ffb_priv;
245 ret = ffb_init_one(dev,
246 ffb_position[i].node,
247 ffb_position[i].root,
252 static void ffb_driver_release(drm_device_t *dev, struct file *filp)
254 ffb_dev_priv_t *fpriv = (ffb_dev_priv_t *) dev->dev_private;
255 int context = _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock);
260 context != DRM_KERNEL_CONTEXT &&
261 fpriv->hw_state[idx] != NULL) {
262 kfree(fpriv->hw_state[idx]);
263 fpriv->hw_state[idx] = NULL;
267 static void ffb_driver_pretakedown(drm_device_t *dev)
269 if (dev->dev_private) kfree(dev->dev_private);
272 static int ffb_driver_postcleanup(drm_device_t *dev)
274 if (ffb_position != NULL) kfree(ffb_position);
278 static void ffb_driver_kernel_context_switch_unlock(struct drm_device *dev, drm_lock_t *lock)
282 __volatile__ unsigned int *plock = &dev->lock.hw_lock->lock;
283 unsigned int old, new, prev, ctx;
289 prev = cmpxchg(plock, old, new);
290 } while (prev != old);
292 wake_up_interruptible(&dev->lock.lock_queue);
295 static unsigned long ffb_driver_get_map_ofs(drm_map_t *map)
297 return (map->offset & 0xffffffff);
300 static unsigned long ffb_driver_get_reg_ofs(drm_device_t *dev)
302 ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
305 return ffb_priv->card_phys_base;
310 void ffb_driver_register_fns(drm_device_t *dev)
312 ffb_set_context_ioctls();
313 DRM(fops).get_unmapped_area = ffb_get_unmapped_area;
314 dev->fn_tbl.release = ffb_driver_release;
315 dev->fn_tbl.presetup = ffb_presetup;
316 dev->fn_tbl.pretakedown = ffb_driver_pretakedown;
317 dev->fn_tbl.postcleanup = ffb_driver_postcleanup;
318 dev->fn_tbl.kernel_context_switch = ffb_context_switch;
319 dev->fn_tbl.kernel_context_switch_unlock = ffb_driver_kernel_context_switch_unlock;
320 dev->fn_tbl.get_map_ofs = ffb_driver_get_map_ofs;
321 dev->fn_tbl.get_reg_ofs = ffb_driver_get_reg_ofs;