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 "ffb.h"
   8 #include "drmP.h"
   9
  10 #include "ffb_drv.h"
  11
  12 #include <linux/smp_lock.h>
  13 #include <asm/shmparam.h>
  14 #include <asm/oplib.h>
  15 #include <asm/upa.h>
  16
  17 #define DRIVER_AUTHOR           "David S. Miller"
  18
  19 #define DRIVER_NAME             "ffb"
  20 #define DRIVER_DESC             "Creator/Creator3D"
  21 #define DRIVER_DATE             "20000517"
  22
  23 #define DRIVER_MAJOR            0
  24 #define DRIVER_MINOR            0
  25 #define DRIVER_PATCHLEVEL       1
  26
  27 typedef struct _ffb_position_t {
  28         int node;
  29         int root;
  30 } ffb_position_t;
  31
  32 static ffb_position_t *ffb_position;
  33
  34 static void get_ffb_type(ffb_dev_priv_t * ffb_priv, int instance)
  35 {
  36         volatile unsigned char *strap_bits;
  37         unsigned char val;
  38
  39         strap_bits = (volatile unsigned char *)
  40             (ffb_priv->card_phys_base + 0x00200000UL);
  41
  42         /* Don't ask, you have to read the value twice for whatever
  43          * reason to get correct contents.
  44          */
  45         val = upa_readb(strap_bits);
  46         val = upa_readb(strap_bits);
  47         switch (val & 0x78) {
  48         case (0x0 << 5) | (0x0 << 3):
  49                 ffb_priv->ffb_type = ffb1_prototype;
  50                 printk("ffb%d: Detected FFB1 pre-FCS prototype\n", instance);
  51                 break;
  52         case (0x0 << 5) | (0x1 << 3):
  53                 ffb_priv->ffb_type = ffb1_standard;
  54                 printk("ffb%d: Detected FFB1\n", instance);
  55                 break;
  56         case (0x0 << 5) | (0x3 << 3):
  57                 ffb_priv->ffb_type = ffb1_speedsort;
  58                 printk("ffb%d: Detected FFB1-SpeedSort\n", instance);
  59                 break;
  60         case (0x1 << 5) | (0x0 << 3):
  61                 ffb_priv->ffb_type = ffb2_prototype;
  62                 printk("ffb%d: Detected FFB2/vertical pre-FCS prototype\n",
  63                        instance);
  64                 break;
  65         case (0x1 << 5) | (0x1 << 3):
  66                 ffb_priv->ffb_type = ffb2_vertical;
  67                 printk("ffb%d: Detected FFB2/vertical\n", instance);
  68                 break;
  69         case (0x1 << 5) | (0x2 << 3):
  70                 ffb_priv->ffb_type = ffb2_vertical_plus;
  71                 printk("ffb%d: Detected FFB2+/vertical\n", instance);
  72                 break;
  73         case (0x2 << 5) | (0x0 << 3):
  74                 ffb_priv->ffb_type = ffb2_horizontal;
  75                 printk("ffb%d: Detected FFB2/horizontal\n", instance);
  76                 break;
  77         case (0x2 << 5) | (0x2 << 3):
  78                 ffb_priv->ffb_type = ffb2_horizontal;
  79                 printk("ffb%d: Detected FFB2+/horizontal\n", instance);
  80                 break;
  81         default:
  82                 ffb_priv->ffb_type = ffb2_vertical;
  83                 printk("ffb%d: Unknown boardID[%08x], assuming FFB2\n",
  84                        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 =
 101             prom_getproperty(parent, "ranges", (void *)ranges, sizeof(ranges));
 102         if (len <= 0)
 103                 return;
 104
 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;
 109
 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;
 114                         return;
 115                 }
 116         }
 117
 118         return;
 119 }
 120
 121 static int ffb_init_one(drm_device_t * dev, int prom_node, int parent_node,
 122                         int instance)
 123 {
 124         struct linux_prom64_registers regs[2 * PROMREG_MAX];
 125         ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *) dev->dev_private;
 126         int i;
 127
 128         ffb_priv->prom_node = prom_node;
 129         if (prom_getproperty(ffb_priv->prom_node, "reg",
 130                              (void *)regs, sizeof(regs)) <= 0) {
 131                 return -EINVAL;
 132         }
 133         ffb_apply_upa_parent_ranges(parent_node, &regs[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;
 140
 141         return 0;
 142 }
 143
 144 static drm_map_t *ffb_find_map(struct file *filp, unsigned long off)
 145 {
 146         drm_file_t *priv = filp->private_data;
 147         drm_device_t *dev;
 148         drm_map_list_t *r_list;
 149         struct list_head *list;
 150         drm_map_t *map;
 151
 152         if (!priv || (dev = priv->dev) == NULL)
 153                 return NULL;
 154
 155         list_for_each(list, &dev->maplist->head) {
 156                 r_list = (drm_map_list_t *) list;
 157                 map = r_list->map;
 158                 if (!map)
 159                         continue;
 160                 if (r_list->user_token == off)
 161                         return map;
 162         }
 163
 164         return NULL;
 165 }
 166
 167 unsigned long ffb_get_unmapped_area(struct file *filp,
 168                                     unsigned long hint,
 169                                     unsigned long len,
 170                                     unsigned long pgoff, unsigned long flags)
 171 {
 172         drm_map_t *map = ffb_find_map(filp, pgoff << PAGE_SHIFT);
 173         unsigned long addr = -ENOMEM;
 174
 175         if (!map)
 176                 return get_unmapped_area(NULL, hint, len, pgoff, flags);
 177
 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);
 181 #else
 182                 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
 183 #endif
 184         } else if (map->type == _DRM_SHM && SHMLBA > PAGE_SIZE) {
 185                 unsigned long slack = SHMLBA - PAGE_SIZE;
 186
 187                 addr = get_unmapped_area(NULL, hint, len + slack, pgoff, flags);
 188                 if (!(addr & ~PAGE_MASK)) {
 189                         unsigned long kvirt = (unsigned long)map->handle;
 190
 191                         if ((kvirt & (SHMLBA - 1)) != (addr & (SHMLBA - 1))) {
 192                                 unsigned long koff, aoff;
 193
 194                                 koff = kvirt & (SHMLBA - 1);
 195                                 aoff = addr & (SHMLBA - 1);
 196                                 if (koff < aoff)
 197                                         koff += SHMLBA;
 198
 199                                 addr += (koff - aoff);
 200                         }
 201                 }
 202         } else {
 203                 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
 204         }
 205
 206         return addr;
 207 }
 208
 209 static int ffb_presetup(drm_device_t * dev)
 210 {
 211         ffb_dev_priv_t *ffb_priv;
 212         int ret = 0;
 213         int i = 0;
 214
 215         /* Check for the case where no device was found. */
 216         if (ffb_position == NULL)
 217                 return -ENODEV;
 218
 219         /* code used to use numdevs no numdevs anymore */
 220         ffb_priv = kmalloc(sizeof(ffb_dev_priv_t), GFP_KERNEL);
 221         if (!ffb_priv)
 222                 return -ENOMEM;
 223         memset(ffb_priv, 0, sizeof(*ffb_priv));
 224         dev->dev_private = ffb_priv;
 225
 226         ret = ffb_init_one(dev, ffb_position[i].node, ffb_position[i].root, i);
 227         return ret;
 228 }
 229
 230 static void ffb_driver_release(drm_device_t * dev, struct file *filp)
 231 {
 232         ffb_dev_priv_t *fpriv = (ffb_dev_priv_t *) dev->dev_private;
 233         int context = _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock);
 234         int idx;
 235
 236         idx = context - 1;
 237         if (fpriv &&
 238             context != DRM_KERNEL_CONTEXT && fpriv->hw_state[idx] != NULL) {
 239                 kfree(fpriv->hw_state[idx]);
 240                 fpriv->hw_state[idx] = NULL;
 241         }
 242 }
 243
 244 static void ffb_driver_pretakedown(drm_device_t * dev)
 245 {
 246         kfree(dev->dev_private);
 247 }
 248
 249 static int ffb_driver_postcleanup(drm_device_t * dev)
 250 {
 251         kfree(ffb_position);
 252         return 0;
 253 }
 254
 255 static void ffb_driver_kernel_context_switch_unlock(struct drm_device *dev,
 256                                                     drm_lock_t * lock)
 257 {
 258         dev->lock.filp = 0;
 259         {
 260                 __volatile__ unsigned int *plock = &dev->lock.hw_lock->lock;
 261                 unsigned int old, new, prev, ctx;
 262
 263                 ctx = lock->context;
 264                 do {
 265                         old = *plock;
 266                         new = ctx;
 267                         prev = cmpxchg(plock, old, new);
 268                 } while (prev != old);
 269         }
 270         wake_up_interruptible(&dev->lock.lock_queue);
 271 }
 272
 273 static unsigned long ffb_driver_get_map_ofs(drm_map_t * map)
 274 {
 275         return (map->offset & 0xffffffff);
 276 }
 277
 278 static unsigned long ffb_driver_get_reg_ofs(drm_device_t * dev)
 279 {
 280         ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *) dev->dev_private;
 281
 282         if (ffb_priv)
 283                 return ffb_priv->card_phys_base;
 284
 285         return 0;
 286 }
 287
 288 static int postinit(struct drm_device *dev, unsigned long flags)
 289 {
 290         DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
 291                  DRIVER_NAME,
 292                  DRIVER_MAJOR,
 293                  DRIVER_MINOR, DRIVER_PATCHLEVEL, DRIVER_DATE, dev->minor);
 294         return 0;
 295 }
 296
 297 static int version(drm_version_t * version)
 298 {
 299         int len;
 300
 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);
 307         return 0;
 308 }
 309
 310 static drm_ioctl_desc_t ioctls[] = {
 311
 312 };
 313
 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,
 326         .version = version,
 327         .ioctls = ioctls,
 328         .num_ioctls = DRM_ARRAY_SIZE(ioctls),
 329         .fops = {
 330                  .owner = THIS_MODULE,
 331                  .open = drm_open,
 332                  .release = drm_release,
 333                  .ioctl = drm_ioctl,
 334                  .mmap = drm_mmap,
 335                  .poll = drm_poll,
 336                  .fasync = drm_fasync,
 337                  }
 338         ,
 339 };
 340
 341 static int __init ffb_init(void)
 342 {
 343         return -ENODEV;
 344 }
 345
 346 static void __exit ffb_exit(void)
 347 {
 348 }
 349
 350 module_init(ffb_init);
 351 module_exit(ffb_exit);
 352
 353 MODULE_AUTHOR(DRIVER_AUTHOR);
 354 MODULE_DESCRIPTION(DRIVER_DESC);
 355 MODULE_LICENSE("GPL and additional rights");