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",
67 case (0x1 << 5) | (0x1 << 3):
68 ffb_priv
->ffb_type
= ffb2_vertical
;
69 printk("ffb%d: Detected FFB2/vertical\n", instance
);
71 case (0x1 << 5) | (0x2 << 3):
72 ffb_priv
->ffb_type
= ffb2_vertical_plus
;
73 printk("ffb%d: Detected FFB2+/vertical\n", instance
);
75 case (0x2 << 5) | (0x0 << 3):
76 ffb_priv
->ffb_type
= ffb2_horizontal
;
77 printk("ffb%d: Detected FFB2/horizontal\n", instance
);
79 case (0x2 << 5) | (0x2 << 3):
80 ffb_priv
->ffb_type
= ffb2_horizontal
;
81 printk("ffb%d: Detected FFB2+/horizontal\n", instance
);
84 ffb_priv
->ffb_type
= ffb2_vertical
;
85 printk("ffb%d: Unknown boardID[%08x], assuming FFB2\n",
91 static void ffb_apply_upa_parent_ranges(int parent
,
92 struct linux_prom64_registers
*regs
)
94 struct linux_prom64_ranges ranges
[PROMREG_MAX
];
98 prom_getproperty(parent
, "name", name
, sizeof(name
));
99 if (strcmp(name
, "upa") != 0)
103 prom_getproperty(parent
, "ranges", (void *)ranges
, sizeof(ranges
));
107 len
/= sizeof(struct linux_prom64_ranges
);
108 for (i
= 0; i
< len
; i
++) {
109 struct linux_prom64_ranges
*rng
= &ranges
[i
];
110 u64 phys_addr
= regs
->phys_addr
;
112 if (phys_addr
>= rng
->ot_child_base
&&
113 phys_addr
< (rng
->ot_child_base
+ rng
->or_size
)) {
114 regs
->phys_addr
-= rng
->ot_child_base
;
115 regs
->phys_addr
+= rng
->ot_parent_base
;
123 static int ffb_init_one(drm_device_t
* dev
, int prom_node
, int parent_node
,
126 struct linux_prom64_registers regs
[2 * PROMREG_MAX
];
127 ffb_dev_priv_t
*ffb_priv
= (ffb_dev_priv_t
*) dev
->dev_private
;
130 ffb_priv
->prom_node
= prom_node
;
131 if (prom_getproperty(ffb_priv
->prom_node
, "reg",
132 (void *)regs
, sizeof(regs
)) <= 0) {
135 ffb_apply_upa_parent_ranges(parent_node
, ®s
[0]);
136 ffb_priv
->card_phys_base
= regs
[0].phys_addr
;
137 ffb_priv
->regs
= (ffb_fbcPtr
)
138 (regs
[0].phys_addr
+ 0x00600000UL
);
139 get_ffb_type(ffb_priv
, instance
);
140 for (i
= 0; i
< FFB_MAX_CTXS
; i
++)
141 ffb_priv
->hw_state
[i
] = NULL
;
146 static drm_map_t
*ffb_find_map(struct file
*filp
, unsigned long off
)
148 drm_file_t
*priv
= filp
->private_data
;
150 drm_map_list_t
*r_list
;
151 struct list_head
*list
;
154 if (!priv
|| (dev
= priv
->dev
) == NULL
)
157 list_for_each(list
, &dev
->maplist
->head
) {
158 r_list
= (drm_map_list_t
*) list
;
162 if (r_list
->user_token
== off
)
169 unsigned long ffb_get_unmapped_area(struct file
*filp
,
172 unsigned long pgoff
, unsigned long flags
)
174 drm_map_t
*map
= ffb_find_map(filp
, pgoff
<< PAGE_SHIFT
);
175 unsigned long addr
= -ENOMEM
;
178 return get_unmapped_area(NULL
, hint
, len
, pgoff
, flags
);
180 if (map
->type
== _DRM_FRAME_BUFFER
|| map
->type
== _DRM_REGISTERS
) {
181 #ifdef HAVE_ARCH_FB_UNMAPPED_AREA
182 addr
= get_fb_unmapped_area(filp
, hint
, len
, pgoff
, flags
);
184 addr
= get_unmapped_area(NULL
, hint
, len
, pgoff
, flags
);
186 } else if (map
->type
== _DRM_SHM
&& SHMLBA
> PAGE_SIZE
) {
187 unsigned long slack
= SHMLBA
- PAGE_SIZE
;
189 addr
= get_unmapped_area(NULL
, hint
, len
+ slack
, pgoff
, flags
);
190 if (!(addr
& ~PAGE_MASK
)) {
191 unsigned long kvirt
= (unsigned long)map
->handle
;
193 if ((kvirt
& (SHMLBA
- 1)) != (addr
& (SHMLBA
- 1))) {
194 unsigned long koff
, aoff
;
196 koff
= kvirt
& (SHMLBA
- 1);
197 aoff
= addr
& (SHMLBA
- 1);
201 addr
+= (koff
- aoff
);
205 addr
= get_unmapped_area(NULL
, hint
, len
, pgoff
, flags
);
211 static int ffb_presetup(drm_device_t
* dev
)
213 ffb_dev_priv_t
*ffb_priv
;
217 /* Check for the case where no device was found. */
218 if (ffb_position
== NULL
)
221 /* code used to use numdevs no numdevs anymore */
222 ffb_priv
= kmalloc(sizeof(ffb_dev_priv_t
), GFP_KERNEL
);
225 memset(ffb_priv
, 0, sizeof(*ffb_priv
));
226 dev
->dev_private
= ffb_priv
;
228 ret
= ffb_init_one(dev
, ffb_position
[i
].node
, ffb_position
[i
].root
, i
);
232 static void ffb_driver_release(drm_device_t
* dev
, struct file
*filp
)
234 ffb_dev_priv_t
*fpriv
= (ffb_dev_priv_t
*) dev
->dev_private
;
235 int context
= _DRM_LOCKING_CONTEXT(dev
->lock
.hw_lock
->lock
);
240 context
!= DRM_KERNEL_CONTEXT
&& fpriv
->hw_state
[idx
] != NULL
) {
241 kfree(fpriv
->hw_state
[idx
]);
242 fpriv
->hw_state
[idx
] = NULL
;
246 static void ffb_driver_pretakedown(drm_device_t
* dev
)
248 if (dev
->dev_private
)
249 kfree(dev
->dev_private
);
252 static int ffb_driver_postcleanup(drm_device_t
* dev
)
254 if (ffb_position
!= NULL
)
259 static void ffb_driver_kernel_context_switch_unlock(struct drm_device
*dev
,
264 __volatile__
unsigned int *plock
= &dev
->lock
.hw_lock
->lock
;
265 unsigned int old
, new, prev
, ctx
;
271 prev
= cmpxchg(plock
, old
, new);
272 } while (prev
!= old
);
274 wake_up_interruptible(&dev
->lock
.lock_queue
);
277 static unsigned long ffb_driver_get_map_ofs(drm_map_t
* map
)
279 return (map
->offset
& 0xffffffff);
282 static unsigned long ffb_driver_get_reg_ofs(drm_device_t
* dev
)
284 ffb_dev_priv_t
*ffb_priv
= (ffb_dev_priv_t
*) dev
->dev_private
;
287 return ffb_priv
->card_phys_base
;
292 static int postinit(struct drm_device
*dev
, unsigned long flags
)
294 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
297 DRIVER_MINOR
, DRIVER_PATCHLEVEL
, DRIVER_DATE
, dev
->minor
);
301 static int version(drm_version_t
* version
)
305 version
->version_major
= DRIVER_MAJOR
;
306 version
->version_minor
= DRIVER_MINOR
;
307 version
->version_patchlevel
= DRIVER_PATCHLEVEL
;
308 DRM_COPY(version
->name
, DRIVER_NAME
);
309 DRM_COPY(version
->date
, DRIVER_DATE
);
310 DRM_COPY(version
->desc
, DRIVER_DESC
);
314 static drm_ioctl_desc_t ioctls
[] = {
318 static struct drm_driver driver
= {
319 .driver_features
= 0,
320 .dev_priv_size
= sizeof(u32
),
321 .release
= ffb_driver_release
,
322 .presetup
= ffb_presetup
,
323 .pretakedown
= ffb_driver_pretakedown
,
324 .postcleanup
= ffb_driver_postcleanup
,
325 .kernel_context_switch
= ffb_driver_context_switch
,
326 .kernel_context_switch_unlock
= ffb_driver_kernel_context_switch_unlock
,
327 .get_map_ofs
= ffb_driver_get_map_ofs
,
328 .get_reg_ofs
= ffb_driver_get_reg_ofs
,
329 .postinit
= postinit
,
332 .num_ioctls
= DRM_ARRAY_SIZE(ioctls
),
334 .owner
= THIS_MODULE
,
336 .release
= drm_release
,
340 .fasync
= drm_fasync
,
345 static int __init
ffb_init(void)
350 static void __exit
ffb_exit(void)
354 module_init(ffb_init
);
355 module_exit(ffb_exit
);
357 MODULE_AUTHOR(DRIVER_AUTHOR
);
358 MODULE_DESCRIPTION(DRIVER_DESC
);
359 MODULE_LICENSE("GPL and additional rights");