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)
12 #include <linux/smp_lock.h>
13 #include <asm/shmparam.h>
14 #include <asm/oplib.h>
17 #define DRIVER_AUTHOR "David S. Miller"
19 #define DRIVER_NAME "ffb"
20 #define DRIVER_DESC "Creator/Creator3D"
21 #define DRIVER_DATE "20000517"
23 #define DRIVER_MAJOR 0
24 #define DRIVER_MINOR 0
25 #define DRIVER_PATCHLEVEL 1
27 typedef struct _ffb_position_t
{
32 static ffb_position_t
*ffb_position
;
34 static void get_ffb_type(ffb_dev_priv_t
* ffb_priv
, int instance
)
36 volatile unsigned char *strap_bits
;
39 strap_bits
= (volatile unsigned char *)
40 (ffb_priv
->card_phys_base
+ 0x00200000UL
);
42 /* Don't ask, you have to read the value twice for whatever
43 * reason to get correct contents.
45 val
= upa_readb(strap_bits
);
46 val
= upa_readb(strap_bits
);
48 case (0x0 << 5) | (0x0 << 3):
49 ffb_priv
->ffb_type
= ffb1_prototype
;
50 printk("ffb%d: Detected FFB1 pre-FCS prototype\n", instance
);
52 case (0x0 << 5) | (0x1 << 3):
53 ffb_priv
->ffb_type
= ffb1_standard
;
54 printk("ffb%d: Detected FFB1\n", instance
);
56 case (0x0 << 5) | (0x3 << 3):
57 ffb_priv
->ffb_type
= ffb1_speedsort
;
58 printk("ffb%d: Detected FFB1-SpeedSort\n", instance
);
60 case (0x1 << 5) | (0x0 << 3):
61 ffb_priv
->ffb_type
= ffb2_prototype
;
62 printk("ffb%d: Detected FFB2/vertical pre-FCS prototype\n",
65 case (0x1 << 5) | (0x1 << 3):
66 ffb_priv
->ffb_type
= ffb2_vertical
;
67 printk("ffb%d: Detected FFB2/vertical\n", instance
);
69 case (0x1 << 5) | (0x2 << 3):
70 ffb_priv
->ffb_type
= ffb2_vertical_plus
;
71 printk("ffb%d: Detected FFB2+/vertical\n", instance
);
73 case (0x2 << 5) | (0x0 << 3):
74 ffb_priv
->ffb_type
= ffb2_horizontal
;
75 printk("ffb%d: Detected FFB2/horizontal\n", instance
);
77 case (0x2 << 5) | (0x2 << 3):
78 ffb_priv
->ffb_type
= ffb2_horizontal
;
79 printk("ffb%d: Detected FFB2+/horizontal\n", instance
);
82 ffb_priv
->ffb_type
= ffb2_vertical
;
83 printk("ffb%d: Unknown boardID[%08x], assuming FFB2\n",
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)
101 prom_getproperty(parent
, "ranges", (void *)ranges
, sizeof(ranges
));
105 len
/= sizeof(struct linux_prom64_ranges
);
106 for (i
= 0; i
< len
; i
++) {
107 struct linux_prom64_ranges
*rng
= &ranges
[i
];
108 u64 phys_addr
= regs
->phys_addr
;
110 if (phys_addr
>= rng
->ot_child_base
&&
111 phys_addr
< (rng
->ot_child_base
+ rng
->or_size
)) {
112 regs
->phys_addr
-= rng
->ot_child_base
;
113 regs
->phys_addr
+= rng
->ot_parent_base
;
121 static int ffb_init_one(drm_device_t
* dev
, int prom_node
, int parent_node
,
124 struct linux_prom64_registers regs
[2 * PROMREG_MAX
];
125 ffb_dev_priv_t
*ffb_priv
= (ffb_dev_priv_t
*) dev
->dev_private
;
128 ffb_priv
->prom_node
= prom_node
;
129 if (prom_getproperty(ffb_priv
->prom_node
, "reg",
130 (void *)regs
, sizeof(regs
)) <= 0) {
133 ffb_apply_upa_parent_ranges(parent_node
, ®s
[0]);
134 ffb_priv
->card_phys_base
= regs
[0].phys_addr
;
135 ffb_priv
->regs
= (ffb_fbcPtr
)
136 (regs
[0].phys_addr
+ 0x00600000UL
);
137 get_ffb_type(ffb_priv
, instance
);
138 for (i
= 0; i
< FFB_MAX_CTXS
; i
++)
139 ffb_priv
->hw_state
[i
] = NULL
;
144 static drm_map_t
*ffb_find_map(struct file
*filp
, unsigned long off
)
146 drm_file_t
*priv
= filp
->private_data
;
148 drm_map_list_t
*r_list
;
149 struct list_head
*list
;
152 if (!priv
|| (dev
= priv
->dev
) == NULL
)
155 list_for_each(list
, &dev
->maplist
->head
) {
156 r_list
= (drm_map_list_t
*) list
;
160 if (r_list
->user_token
== off
)
167 unsigned long ffb_get_unmapped_area(struct file
*filp
,
170 unsigned long pgoff
, unsigned long flags
)
172 drm_map_t
*map
= ffb_find_map(filp
, pgoff
<< PAGE_SHIFT
);
173 unsigned long addr
= -ENOMEM
;
176 return get_unmapped_area(NULL
, hint
, len
, pgoff
, flags
);
178 if (map
->type
== _DRM_FRAME_BUFFER
|| map
->type
== _DRM_REGISTERS
) {
179 #ifdef HAVE_ARCH_FB_UNMAPPED_AREA
180 addr
= get_fb_unmapped_area(filp
, hint
, len
, pgoff
, flags
);
182 addr
= get_unmapped_area(NULL
, hint
, len
, pgoff
, flags
);
184 } else if (map
->type
== _DRM_SHM
&& SHMLBA
> PAGE_SIZE
) {
185 unsigned long slack
= SHMLBA
- PAGE_SIZE
;
187 addr
= get_unmapped_area(NULL
, hint
, len
+ slack
, pgoff
, flags
);
188 if (!(addr
& ~PAGE_MASK
)) {
189 unsigned long kvirt
= (unsigned long)map
->handle
;
191 if ((kvirt
& (SHMLBA
- 1)) != (addr
& (SHMLBA
- 1))) {
192 unsigned long koff
, aoff
;
194 koff
= kvirt
& (SHMLBA
- 1);
195 aoff
= addr
& (SHMLBA
- 1);
199 addr
+= (koff
- aoff
);
203 addr
= get_unmapped_area(NULL
, hint
, len
, pgoff
, flags
);
209 static int ffb_presetup(drm_device_t
* dev
)
211 ffb_dev_priv_t
*ffb_priv
;
215 /* Check for the case where no device was found. */
216 if (ffb_position
== NULL
)
219 /* code used to use numdevs no numdevs anymore */
220 ffb_priv
= kmalloc(sizeof(ffb_dev_priv_t
), GFP_KERNEL
);
223 memset(ffb_priv
, 0, sizeof(*ffb_priv
));
224 dev
->dev_private
= ffb_priv
;
226 ret
= ffb_init_one(dev
, ffb_position
[i
].node
, ffb_position
[i
].root
, i
);
230 static void ffb_driver_release(drm_device_t
* dev
, struct file
*filp
)
232 ffb_dev_priv_t
*fpriv
= (ffb_dev_priv_t
*) dev
->dev_private
;
233 int context
= _DRM_LOCKING_CONTEXT(dev
->lock
.hw_lock
->lock
);
238 context
!= DRM_KERNEL_CONTEXT
&& fpriv
->hw_state
[idx
] != NULL
) {
239 kfree(fpriv
->hw_state
[idx
]);
240 fpriv
->hw_state
[idx
] = NULL
;
244 static void ffb_driver_pretakedown(drm_device_t
* dev
)
246 kfree(dev
->dev_private
);
249 static int ffb_driver_postcleanup(drm_device_t
* dev
)
255 static void ffb_driver_kernel_context_switch_unlock(struct drm_device
*dev
,
260 __volatile__
unsigned int *plock
= &dev
->lock
.hw_lock
->lock
;
261 unsigned int old
, new, prev
, ctx
;
267 prev
= cmpxchg(plock
, old
, new);
268 } while (prev
!= old
);
270 wake_up_interruptible(&dev
->lock
.lock_queue
);
273 static unsigned long ffb_driver_get_map_ofs(drm_map_t
* map
)
275 return (map
->offset
& 0xffffffff);
278 static unsigned long ffb_driver_get_reg_ofs(drm_device_t
* dev
)
280 ffb_dev_priv_t
*ffb_priv
= (ffb_dev_priv_t
*) dev
->dev_private
;
283 return ffb_priv
->card_phys_base
;
288 static int postinit(struct drm_device
*dev
, unsigned long flags
)
290 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
293 DRIVER_MINOR
, DRIVER_PATCHLEVEL
, DRIVER_DATE
, dev
->minor
);
297 static int version(drm_version_t
* version
)
301 version
->version_major
= DRIVER_MAJOR
;
302 version
->version_minor
= DRIVER_MINOR
;
303 version
->version_patchlevel
= DRIVER_PATCHLEVEL
;
304 DRM_COPY(version
->name
, DRIVER_NAME
);
305 DRM_COPY(version
->date
, DRIVER_DATE
);
306 DRM_COPY(version
->desc
, DRIVER_DESC
);
310 static drm_ioctl_desc_t ioctls
[] = {
314 static struct drm_driver driver
= {
315 .driver_features
= 0,
316 .dev_priv_size
= sizeof(u32
),
317 .release
= ffb_driver_release
,
318 .presetup
= ffb_presetup
,
319 .pretakedown
= ffb_driver_pretakedown
,
320 .postcleanup
= ffb_driver_postcleanup
,
321 .kernel_context_switch
= ffb_driver_context_switch
,
322 .kernel_context_switch_unlock
= ffb_driver_kernel_context_switch_unlock
,
323 .get_map_ofs
= ffb_driver_get_map_ofs
,
324 .get_reg_ofs
= ffb_driver_get_reg_ofs
,
325 .postinit
= postinit
,
328 .num_ioctls
= DRM_ARRAY_SIZE(ioctls
),
330 .owner
= THIS_MODULE
,
332 .release
= drm_release
,
336 .fasync
= drm_fasync
,
341 static int __init
ffb_init(void)
346 static void __exit
ffb_exit(void)
350 module_init(ffb_init
);
351 module_exit(ffb_exit
);
353 MODULE_AUTHOR(DRIVER_AUTHOR
);
354 MODULE_DESCRIPTION(DRIVER_DESC
);
355 MODULE_LICENSE("GPL and additional rights");