drivers/char/vino.c

   1 /* $Id: vino.c,v 1.4 1999/02/09 23:59:36 ulfc Exp $
   2  * drivers/char/vino.c
   3  *
   4  * (incomplete) Driver for the Vino Video input system found in SGI Indys.
   5  *
   6  * Copyright (C) 1999 Ulf Carlsson (ulfc@bun.falkenberg.se)
   7  *
   8  * This isn't complete yet, please don't expect any video until I've written
   9  * some more code.
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/types.h>
  16 #include <linux/mm.h>
  17 #include <linux/errno.h>
  18 #include <linux/videodev.h>
  19
  20 #include <asm/addrspace.h>
  21 #include <asm/system.h>
  22
  23 #include "vino.h"
  24
  25 struct vino_device {
  26         struct video_device vdev;
  27
  28         unsigned long chan;
  29 #define VINO_CHAN_A             0
  30 #define VINO_CHAN_B             1
  31
  32         unsigned long flags;
  33 #define VINO_DMA_ACTIVE         (1<<0)
  34 };
  35
  36 /* We can actually receive TV and IndyCam input at the same time. Believe it or
  37  * not..
  38  */
  39 static struct vino_device vino[2];
  40
  41 /* Those registers have to be accessed by either *one* 64 bit write or *one* 64
  42  * bit read. We need some asm to fix this. We can't use mips3 as standard
  43  * because we just save 32 bits at context switch.
  44  */
  45
  46 static __inline__ unsigned long long vino_reg_read(unsigned long addr)
  47 {
  48         unsigned long long ret __attribute__ ((aligned (64)));
  49         unsigned long virt_addr = KSEG1ADDR(addr + VINO_BASE);
  50         unsigned long flags;
  51
  52         save_and_cli(flags);
  53         __asm__ __volatile__(
  54                 ".set\tmips3\n\t"
  55                 ".set\tnoat\n\t"
  56                 "ld\t$1,(%0)\n\t"
  57                 "sd\t$1,(%1)\n\t"
  58                 ".set\tat\n\t"
  59                 ".set\tmips0"
  60                 :
  61                 :"r" (virt_addr),
  62                  "r" (&ret)
  63                 :"$1");
  64         restore_flags(flags);
  65
  66         return ret;
  67 }
  68
  69 static __inline__ void vino_reg_write(unsigned long long value,
  70                                       unsigned long addr)
  71 {
  72         unsigned long virt_addr = KSEG1ADDR(addr + VINO_BASE);
  73         unsigned long flags;
  74
  75         /* we might lose the upper parts of the registers which are not saved
  76          * if there comes an interrupt in our way, play safe */
  77
  78         save_and_cli(flags);
  79         __asm__ __volatile__(
  80                 ".set\tmips3\n\t"
  81                 ".set\tnoat\n\t"
  82                 "ld\t$1,(%0)\n\t"
  83                 "sd\t$1,(%1)\n\t"
  84                 ".set\tat\n\t"
  85                 ".set\tmips0"
  86                 :
  87                 :"r" (&value),
  88                  "r" (virt_addr)
  89                 :"$1");
  90         restore_flags(flags);
  91 }
  92
  93 static __inline__ void vino_reg_and(unsigned long long value,
  94                                     unsigned long addr)
  95 {
  96         unsigned long virt_addr = KSEG1ADDR(addr + VINO_BASE);
  97         unsigned long flags;
  98
  99         save_and_cli(flags);
 100         __asm__ __volatile__(
 101                 ".set\tmips3\n\t"
 102                 ".set\tnoat\n\t"
 103                 "ld\t$1,(%0)\n\t"
 104                 "ld\t$2,(%1)\n\t"
 105                 "and\t$1,$1,$2\n\t"
 106                 "sd\t$1,(%0)\n\t"
 107                 ".set\tat\n\t"
 108                 ".set\tmips0"
 109                 :
 110                 :"r" (virt_addr),
 111                  "r" (&value)
 112                 :"$1","$2");
 113         restore_flags(flags);
 114 }
 115
 116 static __inline__ void vino_reg_or(unsigned long long value,
 117                                    unsigned long addr)
 118 {
 119         unsigned long virt_addr = KSEG1ADDR(addr + VINO_BASE);
 120         unsigned long flags;
 121
 122         save_and_cli(flags);
 123         __asm__ __volatile__(
 124                 ".set\tmips3\n\t"
 125                 ".set\tnoat\n\t"
 126                 "ld\t$1,(%0)\n\t"
 127                 "ld\t$2,(%1)\n\t"
 128                 "or\t$1,$1,$2\n\t"
 129                 "sd\t$1,(%0)\n\t"
 130                 ".set\tat\n\t"
 131                 ".set\tmips0"
 132                 :
 133                 :"r" (virt_addr),
 134                  "r" (&value)
 135                 :"$1","$2");
 136         restore_flags(flags);
 137 }
 138
 139 static int vino_dma_setup(void)
 140 {
 141         return 0;
 142 }
 143
 144 static void vino_dma_stop(void)
 145 {
 146
 147 }
 148
 149 static int vino_init(void)
 150 {
 151         unsigned long ret;
 152         unsigned short rev, id;
 153         unsigned long long foo;
 154         unsigned long *bar;
 155
 156         bar = (unsigned long *) &foo;
 157
 158         ret = vino_reg_read(VINO_REVID);
 159
 160         rev = (ret & VINO_REVID_REV_MASK);
 161         id = (ret & VINO_REVID_ID_MASK) >> 4;
 162
 163         printk("Vino: ID:%02hx Rev:%02hx\n", id, rev);
 164
 165         foo = vino_reg_read(VINO_A_DESC_DATA0);
 166         printk("0x%lx", bar[0]);
 167         printk("%lx ", bar[1]);
 168         foo = vino_reg_read(VINO_A_DESC_DATA1);
 169         printk("0x%lx", bar[0]);
 170         printk("%lx ", bar[1]);
 171         foo = vino_reg_read(VINO_A_DESC_DATA2);
 172         printk("0x%lx", bar[0]);
 173         printk("%lx ", bar[1]);
 174         foo = vino_reg_read(VINO_A_DESC_DATA3);
 175         printk("0x%lx", bar[0]);
 176         printk("%lx\n", bar[1]);
 177         foo = vino_reg_read(VINO_B_DESC_DATA0);
 178         printk("0x%lx", bar[0]);
 179         printk("%lx ", bar[1]);
 180         foo = vino_reg_read(VINO_B_DESC_DATA1);
 181         printk("0x%lx", bar[0]);
 182         printk("%lx ", bar[1]);
 183         foo = vino_reg_read(VINO_B_DESC_DATA2);
 184         printk("0x%lx", bar[0]);
 185         printk("%lx ", bar[1]);
 186         foo = vino_reg_read(VINO_B_DESC_DATA3);
 187         printk("0x%lx", bar[0]);
 188         printk("%lx\n", bar[1]);
 189
 190         return 0;
 191 }
 192
 193 static void vino_dma_go(struct vino_device *v)
 194 {
 195
 196 }
 197
 198 /* Reset the vino back to default state */
 199
 200 static void vino_setup(struct vino_device *v)
 201 {
 202
 203 }
 204
 205 static int vino_open(struct video_device *dev, int flags)
 206 {
 207         MOD_INC_USE_COUNT;
 208         return 0;
 209 }
 210
 211 static void vino_close(struct video_device *dev)
 212 {
 213         MOD_DEC_USE_COUNT;
 214 }
 215
 216 static int vino_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
 217 {
 218         return 0;
 219 }
 220
 221 static int vino_mmap(struct video_device *dev, const char *adr,
 222                      unsigned long size)
 223 {
 224         return 0;
 225 }
 226
 227 static struct video_device vino_dev = {
 228         "Vino IndyCam/TV",
 229         VID_TYPE_CAPTURE,
 230         VID_HARDWARE_VINO,
 231         vino_open,
 232         vino_close,
 233         NULL,           /* vino_read */
 234         NULL,           /* vino_write */
 235         NULL,           /* vino_poll */
 236         vino_ioctl,
 237         vino_mmap,
 238         NULL,           /* vino_init */
 239         NULL,
 240         0,
 241         0
 242 };
 243
 244 __initfunc(int init_vino(struct video_device *dev))
 245 {
 246         int err;
 247
 248         err = vino_init();
 249         if (err)
 250                 return err;
 251
 252 #if 0
 253         if (video_register_device(&vinodev, VFL_TYPE_GRABBER) == -1) {
 254                 return -ENODEV;
 255         }
 256 #endif
 257
 258         return 0;
 259 }
 260
 261 #ifdef MODULE
 262 int init_module(void)
 263 {
 264         int err;
 265
 266         err = vino_init();
 267         if (err)
 268                 return err;
 269
 270         return 0;
 271 }
 272
 273 void cleanup_module(void)
 274 {
 275 }
 276 #endif