drivers/char/drm/ffb_drv.c

   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.
   3  *
   4  * Copyright (C) 2000 David S. Miller (davem@redhat.com)
   5  */
   6
   7 #include <linux/config.h>
   8 #include "ffb.h"
   9 #include "drmP.h"
  10
  11 #include "ffb_drv.h"
  12
  13 #include <linux/sched.h>
  14 #include <linux/smp_lock.h>
  15 #include <asm/shmparam.h>
  16 #include <asm/oplib.h>
  17 #include <asm/upa.h>
  18
  19 #define DRIVER_AUTHOR           "David S. Miller"
  20
  21 #define DRIVER_NAME             "ffb"
  22 #define DRIVER_DESC             "Creator/Creator3D"
  23 #define DRIVER_DATE             "20000517"
  24
  25 #define DRIVER_MAJOR            0
  26 #define DRIVER_MINOR            0
  27 #define DRIVER_PATCHLEVEL       1
  28
  29 typedef struct _ffb_position_t {
  30         int node;
  31         int root;
  32 } ffb_position_t;
  33
  34 static ffb_position_t *ffb_position;
  35
  36 static void get_ffb_type(ffb_dev_priv_t *ffb_priv, int instance)
  37 {
  38         volatile unsigned char *strap_bits;
  39         unsigned char val;
  40
  41         strap_bits = (volatile unsigned char *)
  42                 (ffb_priv->card_phys_base + 0x00200000UL);
  43
  44         /* Don't ask, you have to read the value twice for whatever
  45          * reason to get correct contents.
  46          */
  47         val = upa_readb(strap_bits);
  48         val = upa_readb(strap_bits);
  49         switch (val & 0x78) {
  50         case (0x0 << 5) | (0x0 << 3):
  51                 ffb_priv->ffb_type = ffb1_prototype;
  52                 printk("ffb%d: Detected FFB1 pre-FCS prototype\n", instance);
  53                 break;
  54         case (0x0 << 5) | (0x1 << 3):
  55                 ffb_priv->ffb_type = ffb1_standard;
  56                 printk("ffb%d: Detected FFB1\n", instance);
  57                 break;
  58         case (0x0 << 5) | (0x3 << 3):
  59                 ffb_priv->ffb_type = ffb1_speedsort;
  60                 printk("ffb%d: Detected FFB1-SpeedSort\n", instance);
  61                 break;
  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);
  65                 break;
  66         case (0x1 << 5) | (0x1 << 3):
  67                 ffb_priv->ffb_type = ffb2_vertical;
  68                 printk("ffb%d: Detected FFB2/vertical\n", instance);
  69                 break;
  70         case (0x1 << 5) | (0x2 << 3):
  71                 ffb_priv->ffb_type = ffb2_vertical_plus;
  72                 printk("ffb%d: Detected FFB2+/vertical\n", instance);
  73                 break;
  74         case (0x2 << 5) | (0x0 << 3):
  75                 ffb_priv->ffb_type = ffb2_horizontal;
  76                 printk("ffb%d: Detected FFB2/horizontal\n", instance);
  77                 break;
  78         case (0x2 << 5) | (0x2 << 3):
  79                 ffb_priv->ffb_type = ffb2_horizontal;
  80                 printk("ffb%d: Detected FFB2+/horizontal\n", instance);
  81                 break;
  82         default:
  83                 ffb_priv->ffb_type = ffb2_vertical;
  84                 printk("ffb%d: Unknown boardID[%08x], assuming FFB2\n", instance, val);
  85                 break;
  86         };
  87 }
  88
  89 static void ffb_apply_upa_parent_ranges(int parent,
  90                                         struct linux_prom64_registers *regs)
  91 {
  92         struct linux_prom64_ranges ranges[PROMREG_MAX];
  93         char name[128];
  94         int len, i;
  95
  96         prom_getproperty(parent, "name", name, sizeof(name));
  97         if (strcmp(name, "upa") != 0)
  98                 return;
  99
 100         len = prom_getproperty(parent, "ranges", (void *) ranges, sizeof(ranges));
 101         if (len <= 0)
 102                 return;
 103
 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;
 108
 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;
 113                         return;
 114                 }
 115         }
 116
 117         return;
 118 }
 119
 120 static int ffb_init_one(drm_device_t *dev, int prom_node, int parent_node,
 121                         int instance)
 122 {
 123         struct linux_prom64_registers regs[2*PROMREG_MAX];
 124         ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
 125         int i;
 126
 127         ffb_priv->prom_node = prom_node;
 128         if (prom_getproperty(ffb_priv->prom_node, "reg",
 129                              (void *)regs, sizeof(regs)) <= 0) {
 130                 return -EINVAL;
 131         }
 132         ffb_apply_upa_parent_ranges(parent_node, &regs[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;
 139
 140         return 0;
 141 }
 142
 143 static drm_map_t *ffb_find_map(struct file *filp, unsigned long off)
 144 {
 145         drm_file_t      *priv   = filp->private_data;
 146         drm_device_t    *dev;
 147         drm_map_list_t  *r_list;
 148         struct list_head *list;
 149         drm_map_t       *map;
 150
 151         if (!priv || (dev = priv->dev) == NULL)
 152                 return NULL;
 153
 154         list_for_each(list, &dev->maplist->head) {
 155                 unsigned long uoff;
 156
 157                 r_list = (drm_map_list_t *)list;
 158                 map = r_list->map;
 159                 if (!map)
 160                         continue;
 161                 uoff = (map->offset & 0xffffffff);
 162                 if (uoff == off)
 163                         return map;
 164         }
 165
 166         return NULL;
 167 }
 168
 169 unsigned long ffb_get_unmapped_area(struct file *filp,
 170                                     unsigned long hint,
 171                                     unsigned long len,
 172                                     unsigned long pgoff,
 173                                     unsigned long flags)
 174 {
 175         drm_map_t *map = ffb_find_map(filp, pgoff << PAGE_SHIFT);
 176         unsigned long addr = -ENOMEM;
 177
 178         if (!map)
 179                 return get_unmapped_area(NULL, hint, len, pgoff, flags);
 180
 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);
 185 #else
 186                 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
 187 #endif
 188         } else if (map->type == _DRM_SHM && SHMLBA > PAGE_SIZE) {
 189                 unsigned long slack = SHMLBA - PAGE_SIZE;
 190
 191                 addr = get_unmapped_area(NULL, hint, len + slack, pgoff, flags);
 192                 if (!(addr & ~PAGE_MASK)) {
 193                         unsigned long kvirt = (unsigned long) map->handle;
 194
 195                         if ((kvirt & (SHMLBA - 1)) != (addr & (SHMLBA - 1))) {
 196                                 unsigned long koff, aoff;
 197
 198                                 koff = kvirt & (SHMLBA - 1);
 199                                 aoff = addr & (SHMLBA - 1);
 200                                 if (koff < aoff)
 201                                         koff += SHMLBA;
 202
 203                                 addr += (koff - aoff);
 204                         }
 205                 }
 206         } else {
 207                 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
 208         }
 209
 210         return addr;
 211 }
 212
 213 #include "drm_core.h"
 214
 215 /* This functions must be here since it references DRM(numdevs)
 216  * which drm_drv.h declares.
 217  */
 218 static int ffb_presetup(drm_device_t *dev)
 219 {
 220         ffb_dev_priv_t  *ffb_priv;
 221         drm_device_t *temp_dev;
 222         int ret = 0;
 223         int i;
 224
 225         /* Check for the case where no device was found. */
 226         if (ffb_position == NULL)
 227                 return -ENODEV;
 228
 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]);
 232                 if(temp_dev == dev)
 233                         break;
 234         }
 235
 236         if (i == DRM(numdevs))
 237                 return -ENODEV;
 238
 239         ffb_priv = kmalloc(sizeof(ffb_dev_priv_t), GFP_KERNEL);
 240         if (!ffb_priv)
 241                 return -ENOMEM;
 242         memset(ffb_priv, 0, sizeof(*ffb_priv));
 243         dev->dev_private = ffb_priv;
 244
 245         ret = ffb_init_one(dev,
 246                            ffb_position[i].node,
 247                            ffb_position[i].root,
 248                            i);
 249         return ret;
 250 }
 251
 252 static void ffb_driver_release(drm_device_t *dev, struct file *filp)
 253 {
 254         ffb_dev_priv_t *fpriv = (ffb_dev_priv_t *) dev->dev_private;
 255         int context = _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock);
 256         int idx;
 257
 258         idx = context - 1;
 259         if (fpriv &&
 260             context != DRM_KERNEL_CONTEXT &&
 261             fpriv->hw_state[idx] != NULL) {
 262                 kfree(fpriv->hw_state[idx]);
 263                 fpriv->hw_state[idx] = NULL;
 264         }
 265 }
 266
 267 static void ffb_driver_pretakedown(drm_device_t *dev)
 268 {
 269         if (dev->dev_private) kfree(dev->dev_private);
 270 }
 271
 272 static int ffb_driver_postcleanup(drm_device_t *dev)
 273 {
 274         if (ffb_position != NULL) kfree(ffb_position);
 275         return 0;
 276 }
 277
 278 static void ffb_driver_kernel_context_switch_unlock(struct drm_device *dev, drm_lock_t *lock)
 279 {
 280         dev->lock.filp = 0;
 281         {
 282                 __volatile__ unsigned int *plock = &dev->lock.hw_lock->lock;
 283                 unsigned int old, new, prev, ctx;
 284
 285                 ctx = lock->context;
 286                 do {
 287                         old  = *plock;
 288                         new  = ctx;
 289                         prev = cmpxchg(plock, old, new);
 290                 } while (prev != old);
 291         }
 292         wake_up_interruptible(&dev->lock.lock_queue);
 293 }
 294
 295 static unsigned long ffb_driver_get_map_ofs(drm_map_t *map)
 296 {
 297         return (map->offset & 0xffffffff);
 298 }
 299
 300 static unsigned long ffb_driver_get_reg_ofs(drm_device_t *dev)
 301 {
 302        ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
 303
 304        if (ffb_priv)
 305                return ffb_priv->card_phys_base;
 306
 307        return 0;
 308 }
 309
 310 void ffb_driver_register_fns(drm_device_t *dev)
 311 {
 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;
 322 }