linux-core/ffb_drv.c

   1 /* $Id$
   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/sched.h>
   8 #include <linux/smp_lock.h>
   9 #include <asm/shmparam.h>
  10 #include <asm/oplib.h>
  11 #include <asm/upa.h>
  12
  13 #include "drmP.h"
  14 #include "ffb_drv.h"
  15
  16 #define DRIVER_AUTHOR           "David S. Miller"
  17
  18 #define DRIVER_NAME             "ffb"
  19 #define DRIVER_DESC             "Creator/Creator3D"
  20 #define DRIVER_DATE             "20000517"
  21
  22 #define DRIVER_MAJOR            0
  23 #define DRIVER_MINOR            0
  24 #define DRIVER_PATCHLEVEL       1
  25
  26 typedef struct _ffb_position_t {
  27         int node;
  28         int root;
  29 } ffb_position_t;
  30
  31 static ffb_position_t *ffb_position;
  32
  33 static void get_ffb_type(ffb_dev_priv_t *ffb_priv, int instance)
  34 {
  35         volatile unsigned char *strap_bits;
  36         unsigned char val;
  37
  38         strap_bits = (volatile unsigned char *)
  39                 (ffb_priv->card_phys_base + 0x00200000UL);
  40
  41         /* Don't ask, you have to read the value twice for whatever
  42          * reason to get correct contents.
  43          */
  44         val = upa_readb(strap_bits);
  45         val = upa_readb(strap_bits);
  46         switch (val & 0x78) {
  47         case (0x0 << 5) | (0x0 << 3):
  48                 ffb_priv->ffb_type = ffb1_prototype;
  49                 printk("ffb%d: Detected FFB1 pre-FCS prototype\n", instance);
  50                 break;
  51         case (0x0 << 5) | (0x1 << 3):
  52                 ffb_priv->ffb_type = ffb1_standard;
  53                 printk("ffb%d: Detected FFB1\n", instance);
  54                 break;
  55         case (0x0 << 5) | (0x3 << 3):
  56                 ffb_priv->ffb_type = ffb1_speedsort;
  57                 printk("ffb%d: Detected FFB1-SpeedSort\n", instance);
  58                 break;
  59         case (0x1 << 5) | (0x0 << 3):
  60                 ffb_priv->ffb_type = ffb2_prototype;
  61                 printk("ffb%d: Detected FFB2/vertical pre-FCS prototype\n", instance);
  62                 break;
  63         case (0x1 << 5) | (0x1 << 3):
  64                 ffb_priv->ffb_type = ffb2_vertical;
  65                 printk("ffb%d: Detected FFB2/vertical\n", instance);
  66                 break;
  67         case (0x1 << 5) | (0x2 << 3):
  68                 ffb_priv->ffb_type = ffb2_vertical_plus;
  69                 printk("ffb%d: Detected FFB2+/vertical\n", instance);
  70                 break;
  71         case (0x2 << 5) | (0x0 << 3):
  72                 ffb_priv->ffb_type = ffb2_horizontal;
  73                 printk("ffb%d: Detected FFB2/horizontal\n", instance);
  74                 break;
  75         case (0x2 << 5) | (0x2 << 3):
  76                 ffb_priv->ffb_type = ffb2_horizontal;
  77                 printk("ffb%d: Detected FFB2+/horizontal\n", instance);
  78                 break;
  79         default:
  80                 ffb_priv->ffb_type = ffb2_vertical;
  81                 printk("ffb%d: Unknown boardID[%08x], assuming FFB2\n", instance, val);
  82                 break;
  83         };
  84 }
  85
  86 static void ffb_apply_upa_parent_ranges(int parent,
  87                                         struct linux_prom64_registers *regs)
  88 {
  89         struct linux_prom64_ranges ranges[PROMREG_MAX];
  90         char name[128];
  91         int len, i;
  92
  93         prom_getproperty(parent, "name", name, sizeof(name));
  94         if (strcmp(name, "upa") != 0)
  95                 return;
  96
  97         len = prom_getproperty(parent, "ranges", (void *) ranges, sizeof(ranges));
  98         if (len <= 0)
  99                 return;
 100
 101         len /= sizeof(struct linux_prom64_ranges);
 102         for (i = 0; i < len; i++) {
 103                 struct linux_prom64_ranges *rng = &ranges[i];
 104                 u64 phys_addr = regs->phys_addr;
 105
 106                 if (phys_addr >= rng->ot_child_base &&
 107                     phys_addr < (rng->ot_child_base + rng->or_size)) {
 108                         regs->phys_addr -= rng->ot_child_base;
 109                         regs->phys_addr += rng->ot_parent_base;
 110                         return;
 111                 }
 112         }
 113
 114         return;
 115 }
 116
 117 static int ffb_init_one(struct drm_device *dev, int prom_node, int parent_node,
 118                         int instance)
 119 {
 120         struct linux_prom64_registers regs[2*PROMREG_MAX];
 121         ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
 122         int i;
 123
 124         ffb_priv->prom_node = prom_node;
 125         if (prom_getproperty(ffb_priv->prom_node, "reg",
 126                              (void *)regs, sizeof(regs)) <= 0) {
 127                 return -EINVAL;
 128         }
 129         ffb_apply_upa_parent_ranges(parent_node, &regs[0]);
 130         ffb_priv->card_phys_base = regs[0].phys_addr;
 131         ffb_priv->regs = (ffb_fbcPtr)
 132                 (regs[0].phys_addr + 0x00600000UL);
 133         get_ffb_type(ffb_priv, instance);
 134         for (i = 0; i < FFB_MAX_CTXS; i++)
 135                 ffb_priv->hw_state[i] = NULL;
 136
 137         return 0;
 138 }
 139
 140 static int __init ffb_count_siblings(int root)
 141 {
 142         int node, child, count = 0;
 143
 144         child = prom_getchild(root);
 145         for (node = prom_searchsiblings(child, "SUNW,ffb"); node;
 146              node = prom_searchsiblings(prom_getsibling(node), "SUNW,ffb"))
 147                 count++;
 148
 149         return count;
 150 }
 151
 152 static int __init ffb_scan_siblings(int root, int instance)
 153 {
 154         int node, child;
 155
 156         child = prom_getchild(root);
 157         for (node = prom_searchsiblings(child, "SUNW,ffb"); node;
 158              node = prom_searchsiblings(prom_getsibling(node), "SUNW,ffb")) {
 159                 ffb_position[instance].node = node;
 160                 ffb_position[instance].root = root;
 161                 instance++;
 162         }
 163
 164         return instance;
 165 }
 166
 167 static drm_map_t *ffb_find_map(struct file *filp, unsigned long off)
 168 {
 169         drm_file_t      *priv   = filp->private_data;
 170         struct drm_device       *dev;
 171         drm_map_list_t  *r_list;
 172         struct list_head *list;
 173         drm_map_t       *map;
 174
 175         if (!priv || (dev = priv->dev) == NULL)
 176                 return NULL;
 177
 178         list_for_each(list, &dev->maplist->head) {
 179                 unsigned long uoff;
 180
 181                 r_list = (drm_map_list_t *)list;
 182                 map = r_list->map;
 183                 if (!map)
 184                         continue;
 185                 uoff = (map->offset & 0xffffffff);
 186                 if (uoff == off)
 187                         return map;
 188         }
 189
 190         return NULL;
 191 }
 192
 193 unsigned long ffb_get_unmapped_area(struct file *filp,
 194                                     unsigned long hint,
 195                                     unsigned long len,
 196                                     unsigned long pgoff,
 197                                     unsigned long flags)
 198 {
 199         drm_map_t *map = ffb_find_map(filp, pgoff << PAGE_SHIFT);
 200         unsigned long addr = -ENOMEM;
 201
 202         if (!map)
 203                 return get_unmapped_area(NULL, hint, len, pgoff, flags);
 204
 205         if (map->type == _DRM_FRAME_BUFFER ||
 206             map->type == _DRM_REGISTERS) {
 207 #ifdef HAVE_ARCH_FB_UNMAPPED_AREA
 208                 addr = get_fb_unmapped_area(filp, hint, len, pgoff, flags);
 209 #else
 210                 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
 211 #endif
 212         } else if (map->type == _DRM_SHM && SHMLBA > PAGE_SIZE) {
 213                 unsigned long slack = SHMLBA - PAGE_SIZE;
 214
 215                 addr = get_unmapped_area(NULL, hint, len + slack, pgoff, flags);
 216                 if (!(addr & ~PAGE_MASK)) {
 217                         unsigned long kvirt = (unsigned long) map->handle;
 218
 219                         if ((kvirt & (SHMLBA - 1)) != (addr & (SHMLBA - 1))) {
 220                                 unsigned long koff, aoff;
 221
 222                                 koff = kvirt & (SHMLBA - 1);
 223                                 aoff = addr & (SHMLBA - 1);
 224                                 if (koff < aoff)
 225                                         koff += SHMLBA;
 226
 227                                 addr += (koff - aoff);
 228                         }
 229                 }
 230         } else {
 231                 addr = get_unmapped_area(NULL, hint, len, pgoff, flags);
 232         }
 233
 234         return addr;
 235 }
 236
 237 /* This functions must be here since it references drm_numdevs)
 238  * which drm_drv.h declares.
 239  */
 240 static int ffb_driver_firstopen(struct drm_device *dev)
 241 {
 242         ffb_dev_priv_t  *ffb_priv;
 243         struct drm_device *temp_dev;
 244         int ret = 0;
 245         int i;
 246
 247         /* Check for the case where no device was found. */
 248         if (ffb_position == NULL)
 249                 return -ENODEV;
 250
 251         /* Find our instance number by finding our device in dev structure */
 252         for (i = 0; i < drm_numdevs; i++) {
 253                 temp_dev = &(drm_device[i]);
 254                 if(temp_dev == dev)
 255                         break;
 256         }
 257
 258         if (i == drm_numdevs)
 259                 return -ENODEV;
 260
 261         ffb_priv = kmalloc(sizeof(ffb_dev_priv_t), GFP_KERNEL);
 262         if (!ffb_priv)
 263                 return -ENOMEM;
 264         memset(ffb_priv, 0, sizeof(*ffb_priv));
 265         dev->dev_private = ffb_priv;
 266
 267         ret = ffb_init_one(dev,
 268                            ffb_position[i].node,
 269                            ffb_position[i].root,
 270                            i);
 271         return ret;
 272 }
 273
 274 #include "drm_pciids.h"
 275
 276 static struct pci_device_id pciidlist[] = {
 277         ffb_PCI_IDS
 278 };
 279
 280 static struct drm_driver ffb_driver = {
 281         .release = ffb_driver_reclaim_buffers_locked,
 282         .firstopen = ffb_driver_firstopen,
 283         .lastclose = ffb_driver_lastclose,
 284         .unload = ffb_driver_unload,
 285         .kernel_context_switch = ffb_context_switch,
 286         .kernel_context_switch_unlock = ffb_driver_kernel_context_switch_unlock,
 287         .get_map_ofs = ffb_driver_get_map_ofs,
 288         .get_reg_ofs = ffb_driver_get_reg_ofs,
 289         .reclaim_buffers = drm_core_reclaim_buffers,
 290         fops = {
 291                 .owner   = THIS_MODULE,
 292                 .open    = drm_open,
 293                 .release = drm_release,
 294                 .ioctl   = drm_ioctl,
 295                 .mmap    = drm_mmap,
 296                 .fasync  = drm_fasync,
 297                 .poll    = drm_poll,
 298                 .get_unmapped_area = ffb_get_unmapped_area,
 299         },
 300 };
 301
 302 static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 303 {
 304         return drm_probe(pdev, ent, &driver);
 305 }
 306
 307 static struct pci_driver pci_driver = {
 308         .name          = DRIVER_NAME,
 309         .id_table      = pciidlist,
 310         .probe         = probe,
 311         .remove        = __devexit_p(drm_cleanup_pci),
 312 };
 313
 314 static int __init ffb_init(void)
 315 {
 316         return drm_init(&pci_driver, pciidlist, &driver);
 317 }
 318
 319 static void __exit ffb_exit(void)
 320 {
 321         drm_exit(&pci_driver);
 322 }
 323
 324 module_init(ffb_init);
 325 module_exit(ffb_exit));
 326
 327 MODULE_AUTHOR( DRIVER_AUTHOR );
 328 MODULE_DESCRIPTION( DRIVER_DESC );
 329 MODULE_LICENSE("GPL and additional rights");