URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [media/] [video/] [vino.c] - Blame information for rev 1275

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * Driver for the VINO (Video In No Out) system found in SGI Indys.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
 */
 
#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/wrapper.h>
#include <linux/irq.h>
#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/videodev.h>
#include <linux/video_decoder.h>
#include <linux/i2c.h>
#include <linux/i2c-algo-sgi.h>
 
#include <asm/paccess.h>
#include <asm/io.h>
#include <asm/sgi/ip22.h>
#include <asm/sgi/hpc3.h>
#include <asm/sgi/mc.h>
 
#include "vino.h"
 
/* debugging? */
#if 1
#define DEBUG(x...)     printk(x);
#else
#define DEBUG(x...)
#endif
 
/* VINO video size */
#define VINO_PAL_WIDTH          768
#define VINO_PAL_HEIGHT         576
#define VINO_NTSC_WIDTH         646
#define VINO_NTSC_HEIGHT        486
 
/* set this to some sensible values. note: VINO_MIN_WIDTH has to be 8*x */
#define VINO_MIN_WIDTH          32
#define VINO_MIN_HEIGHT         32
 
/* channel selection */
#define VINO_INPUT_COMP         0
#define VINO_INPUT_SVIDEO       1
#define VINO_INPUT_CAMERA       2
#define VINO_INPUT_CHANNELS     3
 
#define PAGE_RATIO      (PAGE_SIZE / VINO_PAGE_SIZE)
 
/* VINO ASIC registers */
struct sgi_vino *vino;
 
static const char *vinostr = "VINO IndyCam/TV";
static int threshold_a = 512;
static int threshold_b = 512;
 
struct vino_device {
        struct video_device vdev;
#define VINO_CHAN_A     1
#define VINO_CHAN_B     2
        int chan;
        int alpha;
        /* clipping... */
        unsigned int left, right, top, bottom;
        /* decimation used */
        unsigned int decimation;
        /* palette used, picture hue, etc */
        struct video_picture picture;
        /* VINO_INPUT_COMP, VINO_INPUT_SVIDEO or VINO_INPUT_CAMERA */
        unsigned int input;
        /* bytes per line */
        unsigned int line_size;
        /* descriptor table (virtual addresses) */
        unsigned long *desc;
        /* # of allocated pages */
        int page_count;
        /* descriptor table (dma addresses) */
        struct {
                dma_addr_t *cpu;
                dma_addr_t dma;
        } dma_desc;
        /* add some more space to let VINO trigger End Of Field interrupt
         * before reaching end of buffer */
#define VINO_FBUFSIZE   (VINO_PAL_WIDTH * VINO_PAL_HEIGHT * 4 + 2 * PAGE_SIZE)
        unsigned int frame_size;
#define VINO_BUF_UNUSED         0
#define VINO_BUF_GRABBING       1
#define VINO_BUF_DONE           2
        int buffer_state;
 
        wait_queue_head_t dma_wait;
        spinlock_t state_lock;
        struct semaphore sem;
 
        /* Make sure we only have one user at the time */
        int users;
};
 
struct vino_client {
        struct i2c_client *driver;
        int owner;
};
 
struct vino_video {
        struct vino_device chA;
        struct vino_device chB;
 
        struct vino_client decoder;
        struct vino_client camera;
        spinlock_t vino_lock;
        spinlock_t input_lock;
 
        /* Loaded into VINO descriptors to clear End Of Descriptors table
         * interupt condition */
        unsigned long dummy_desc;
        struct {
                dma_addr_t *cpu;
                dma_addr_t dma;
        } dummy_dma;
};
 
static struct vino_video *Vino;
 
/* --- */
 
unsigned i2c_vino_getctrl(void *data)
{
        return vino->i2c_control;
}
 
void i2c_vino_setctrl(void *data, unsigned val)
{
        vino->i2c_control = val;
}
 
unsigned i2c_vino_rdata(void *data)
{
        return vino->i2c_data;
}
 
void i2c_vino_wdata(void *data, unsigned val)
{
        vino->i2c_data = val;
}
 
static struct i2c_algo_sgi_data i2c_sgi_vino_data =
{
        .getctrl = &i2c_vino_getctrl,
        .setctrl = &i2c_vino_setctrl,
        .rdata   = &i2c_vino_rdata,
        .wdata   = &i2c_vino_wdata,
        .xfer_timeout = 200,
        .ack_timeout  = 1000,
};
 
/*
 * There are two possible clients on VINO I2C bus, so we limit usage only
 * to them.
 */
static int i2c_vino_client_reg(struct i2c_client *client)
{
        int res = 0;
 
        spin_lock(&Vino->input_lock);
        switch (client->driver->id) {
        case I2C_DRIVERID_SAA7191:
                if (Vino->decoder.driver)
                        res = -EBUSY;
                else
                        Vino->decoder.driver = client;
                break;
        case I2C_DRIVERID_INDYCAM:
                if (Vino->camera.driver)
                        res = -EBUSY;
                else
                        Vino->camera.driver = client;
                break;
        default:
                res = -ENODEV;
        }
        spin_unlock(&Vino->input_lock);
 
        return res;
}
 
static int i2c_vino_client_unreg(struct i2c_client *client)
{
        int res = 0;
 
        spin_lock(&Vino->input_lock);
        if (client == Vino->decoder.driver) {
                if (Vino->decoder.owner)
                        res = -EBUSY;
                else
                        Vino->decoder.driver = NULL;
        } else if (client == Vino->camera.driver) {
                if (Vino->camera.owner)
                        res = -EBUSY;
                else
                        Vino->camera.driver = NULL;
        }
        spin_unlock(&Vino->input_lock);
 
        return res;
}
 
static struct i2c_adapter vino_i2c_adapter =
{
        .name                   = "VINO I2C bus",
        .id                     = I2C_HW_SGI_VINO,
        .algo_data              = &i2c_sgi_vino_data,
        .client_register        = &i2c_vino_client_reg,
        .client_unregister      = &i2c_vino_client_unreg,
};
 
static int vino_i2c_add_bus(void)
{
        return i2c_sgi_add_bus(&vino_i2c_adapter);
}
 
static int vino_i2c_del_bus(void)
{
        return i2c_sgi_del_bus(&vino_i2c_adapter);
}
 
static int i2c_camera_command(unsigned int cmd, void *arg)
{
        return Vino->camera.driver->driver->command(Vino->camera.driver,
                                                    cmd, arg);
}
 
static int i2c_decoder_command(unsigned int cmd, void *arg)
{
        return Vino->decoder.driver->driver->command(Vino->decoder.driver,
                                                     cmd, arg);
}
 
/* --- */
 
static int bytes_per_pixel(struct vino_device *v)
{
        switch (v->picture.palette) {
        case VIDEO_PALETTE_GREY:
                return 1;
        case VIDEO_PALETTE_YUV422:
                return 2;
        default: /* VIDEO_PALETTE_RGB32 */
                return 4;
        }
}
 
static int get_capture_norm(struct vino_device *v)
{
        if (v->input == VINO_INPUT_CAMERA)
                return VIDEO_MODE_NTSC;
        else {
                /* TODO */
                return VIDEO_MODE_NTSC;
        }
}
 
/*
 * Set clipping. Try new values to fit, if they don't return -EINVAL
 */
static int set_clipping(struct vino_device *v, int x, int y, int w, int h,
                        int d)
{
        int maxwidth, maxheight, lsize;
 
        if (d < 1)
                d = 1;
        if (d > 8)
                d = 8;
        if (w / d < VINO_MIN_WIDTH || h / d < VINO_MIN_HEIGHT)
                return -EINVAL;
        if (get_capture_norm(v) == VIDEO_MODE_NTSC) {
                maxwidth = VINO_NTSC_WIDTH;
                maxheight = VINO_NTSC_HEIGHT;
        } else {
                maxwidth = VINO_PAL_WIDTH;
                maxheight = VINO_PAL_HEIGHT;
        }
        if (x < 0)
                x = 0;
        if (y < 0)
                y = 0;
        y &= ~1;        /* odd/even fields */
        if (x + w > maxwidth) {
                w = maxwidth - x;
                if (w / d < VINO_MIN_WIDTH)
                        x = maxwidth - VINO_MIN_WIDTH * d;
        }
        if (y + h > maxheight) {
                h = maxheight - y;
                if (h / d < VINO_MIN_HEIGHT)
                        y = maxheight - VINO_MIN_HEIGHT * d;
        }
        /* line size must be multiple of 8 bytes */
        lsize = (bytes_per_pixel(v) * w / d) & ~7;
        w = lsize * d / bytes_per_pixel(v);
        v->left = x;
        v->top = y;
        v->right = x + w;
        v->bottom = y + h;
        v->decimation = d;
        v->line_size = lsize;
        DEBUG("VINO: clipping %d, %d, %d, %d / %d - %d\n", v->left, v->top,
              v->right, v->bottom, v->decimation, v->line_size);
        return 0;
}
 
static int set_scaling(struct vino_device *v, int w, int h)
{
        int maxwidth, maxheight, lsize, d;
 
        if (w < VINO_MIN_WIDTH || h < VINO_MIN_HEIGHT)
                return -EINVAL;
        if (get_capture_norm(v) == VIDEO_MODE_NTSC) {
                maxwidth = VINO_NTSC_WIDTH;
                maxheight = VINO_NTSC_HEIGHT;
        } else {
                maxwidth = VINO_PAL_WIDTH;
                maxheight = VINO_PAL_HEIGHT;
        }
        if (w > maxwidth)
                w = maxwidth;
        if (h > maxheight)
                h = maxheight;
        d = max(maxwidth / w, maxheight / h);
        if (d > 8)
                d = 8;
        /* line size must be multiple of 8 bytes */
        lsize = (bytes_per_pixel(v) * w) & ~7;
        w = lsize * d / bytes_per_pixel(v);
        h *= d;
        if (v->left + w > maxwidth)
                v->left = maxwidth - w;
        if (v->top + h > maxheight)
                v->top = (maxheight - h) & ~1;  /* odd/even fields */
        /* FIXME: -1 bug... Verify clipping with video signal generator */
        v->right = v->left + w;
        v->bottom = v->top + h;
        v->decimation = d;
        v->line_size = lsize;
        DEBUG("VINO: scaling %d, %d, %d, %d / %d - %d\n", v->left, v->top,
              v->right, v->bottom, v->decimation, v->line_size);
 
        return 0;
}
 
/*
 * Prepare vino for DMA transfer... (execute only with vino_lock locked)
 */
static int dma_setup(struct vino_device *v)
{
        u32 ctrl, intr;
        struct sgi_vino_channel *ch;
 
        ch = (v->chan == VINO_CHAN_A) ? &vino->a : &vino->b;
        ch->page_index = 0;
        ch->line_count = 0;
        /* let VINO know where to transfer data */
        ch->start_desc_tbl = v->dma_desc.dma;
        ch->next_4_desc = v->dma_desc.dma;
        /* give vino time to fetch the first four descriptors, 5 usec
         * should be more than enough time */
        udelay(5);
        /* VINO line size register is set 8 bytes less than actual */
        ch->line_size = v->line_size - 8;
        /* set the alpha register */
        ch->alpha = v->alpha;
        /* set cliping registers */
        ch->clip_start = VINO_CLIP_ODD(v->top) | VINO_CLIP_EVEN(v->top+1) |
                         VINO_CLIP_X(v->left);
        ch->clip_end = VINO_CLIP_ODD(v->bottom) | VINO_CLIP_EVEN(v->bottom+1) |
                       VINO_CLIP_X(v->right);
        /* FIXME: end-of-field bug workaround
                       VINO_CLIP_X(VINO_PAL_WIDTH);
         */
        /* init the frame rate and norm (full frame rate only for now...) */
        ch->frame_rate = VINO_FRAMERT_RT(0x1fff) |
                         (get_capture_norm(v) == VIDEO_MODE_PAL ?
                          VINO_FRAMERT_PAL : 0);
        ctrl = vino->control;
        intr = vino->intr_status;
        if (v->chan == VINO_CHAN_A) {
                /* All interrupt conditions for this channel was cleared
                 * so clear the interrupt status register and enable
                 * interrupts */
                intr &= ~VINO_INTSTAT_A;
                ctrl |= VINO_CTRL_A_INT;
                /* enable synchronization */
                ctrl |= VINO_CTRL_A_SYNC_ENBL;
                /* enable frame assembly */
                ctrl |= VINO_CTRL_A_INTERLEAVE_ENBL;
                /* set decimation used */
                if (v->decimation < 2)
                        ctrl &= ~VINO_CTRL_A_DEC_ENBL;
                else {
                        ctrl |= VINO_CTRL_A_DEC_ENBL;
                        ctrl &= ~VINO_CTRL_A_DEC_SCALE_MASK;
                        ctrl |= (v->decimation - 1) <<
                                VINO_CTRL_A_DEC_SCALE_SHIFT;
                }
                /* select input interface */
                if (v->input == VINO_INPUT_CAMERA)
                        ctrl |= VINO_CTRL_A_SELECT;
                else
                        ctrl &= ~VINO_CTRL_A_SELECT;
                /* palette */
                ctrl &= ~(VINO_CTRL_A_LUMA_ONLY | VINO_CTRL_A_RGB |
                          VINO_CTRL_A_DITHER);
        } else {
                intr &= ~VINO_INTSTAT_B;
                ctrl |= VINO_CTRL_B_INT;
                ctrl |= VINO_CTRL_B_SYNC_ENBL;
                ctrl |= VINO_CTRL_B_INTERLEAVE_ENBL;
                if (v->decimation < 2)
                        ctrl &= ~VINO_CTRL_B_DEC_ENBL;
                else {
                        ctrl |= VINO_CTRL_B_DEC_ENBL;
                        ctrl &= ~VINO_CTRL_B_DEC_SCALE_MASK;
                        ctrl |= (v->decimation - 1) <<
                                VINO_CTRL_B_DEC_SCALE_SHIFT;
                }
                if (v->input == VINO_INPUT_CAMERA)
                        ctrl |= VINO_CTRL_B_SELECT;
                else
                        ctrl &= ~VINO_CTRL_B_SELECT;
                ctrl &= ~(VINO_CTRL_B_LUMA_ONLY | VINO_CTRL_B_RGB |
                          VINO_CTRL_B_DITHER);
        }
        /* set palette */
        switch (v->picture.palette) {
                case VIDEO_PALETTE_GREY:
                        ctrl |= (v->chan == VINO_CHAN_A) ?
                                VINO_CTRL_A_LUMA_ONLY : VINO_CTRL_B_LUMA_ONLY;
                        break;
                case VIDEO_PALETTE_RGB32:
                        ctrl |= (v->chan == VINO_CHAN_A) ?
                                VINO_CTRL_A_RGB : VINO_CTRL_B_RGB;
                        break;
#if 0
                /* FIXME: this is NOT in v4l API :-( */
                case VIDEO_PALETTE_RGB332:
                        ctrl |= (v->chan == VINO_CHAN_A) ?
                                VINO_CTRL_A_RGB | VINO_CTRL_A_DITHER :
                                VINO_CTRL_B_RGB | VINO_CTRL_B_DITHER;
                        break;
#endif
        }
        vino->control = ctrl;
        vino->intr_status = intr;
 
        return 0;
}
 
/* (execute only with vino_lock locked) */
static void dma_stop(struct vino_device *v)
{
        u32 ctrl = vino->control;
        ctrl &= (v->chan == VINO_CHAN_A) ?
                ~VINO_CTRL_A_DMA_ENBL : ~VINO_CTRL_B_DMA_ENBL;
        vino->control = ctrl;
}
 
/* (execute only with vino_lock locked) */
static void dma_go(struct vino_device *v)
{
        u32 ctrl = vino->control;
        ctrl |= (v->chan == VINO_CHAN_A) ?
                VINO_CTRL_A_DMA_ENBL : VINO_CTRL_B_DMA_ENBL;
        vino->control = ctrl;
}
 
/*
 * Load dummy page to descriptor registers. This prevents generating of
 * spurious interrupts. (execute only with vino_lock locked)
 */
static void clear_eod(struct vino_device *v)
{
        struct sgi_vino_channel *ch;
 
        DEBUG("VINO: chnl %c clear EOD\n", (v->chan == VINO_CHAN_A) ? 'A':'B');
        ch = (v->chan == VINO_CHAN_A) ? &vino->a : &vino->b;
        ch->page_index = 0;
        ch->line_count = 0;
        ch->start_desc_tbl = Vino->dummy_dma.dma;
        ch->next_4_desc = Vino->dummy_dma.dma;
        udelay(5);
}
 
static void field_done(struct vino_device *v)
{
        spin_lock(&v->state_lock);
        if (v->buffer_state == VINO_BUF_GRABBING)
                v->buffer_state = VINO_BUF_DONE;
        spin_unlock(&v->state_lock);
        wake_up(&v->dma_wait);
}
 
static void vino_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
        u32 intr, ctrl;
 
        spin_lock(&Vino->vino_lock);
        ctrl = vino->control;
        intr = vino->intr_status;
        DEBUG("VINO: intr status %04x\n", intr);
        if (intr & (VINO_INTSTAT_A_FIFO | VINO_INTSTAT_A_EOD)) {
                ctrl &= ~VINO_CTRL_A_DMA_ENBL;
                vino->control = ctrl;
                clear_eod(&Vino->chA);
        }
        if (intr & (VINO_INTSTAT_B_FIFO | VINO_INTSTAT_B_EOD)) {
                ctrl &= ~VINO_CTRL_B_DMA_ENBL;
                vino->control = ctrl;
                clear_eod(&Vino->chB);
        }
        vino->intr_status = ~intr;
        spin_unlock(&Vino->vino_lock);
        /* FIXME: For now we are assuming that interrupt means that frame is
         * done. That's not true, but we can live with such brokeness for
         * a while ;-) */
        field_done(&Vino->chA);
}
 
static int vino_grab(struct vino_device *v, int frame)
{
        int err = 0;
 
        spin_lock_irq(&v->state_lock);
        if (v->buffer_state == VINO_BUF_GRABBING)
                err = -EBUSY;
        v->buffer_state = VINO_BUF_GRABBING;
        spin_unlock_irq(&v->state_lock);
 
        if (err)
                return err;
 
        spin_lock_irq(&Vino->vino_lock);
        dma_setup(v);
        dma_go(v);
        spin_unlock_irq(&Vino->vino_lock);
 
        return 0;
}
 
static int vino_waitfor(struct vino_device *v, int frame)
{
        wait_queue_t wait;
        int i, err = 0;
 
        if (frame != 0)
                return -EINVAL;
 
        spin_lock_irq(&v->state_lock);
        switch (v->buffer_state) {
        case VINO_BUF_GRABBING:
                init_waitqueue_entry(&wait, current);
                /* add ourselves into wait queue */
                add_wait_queue(&v->dma_wait, &wait);
                /* and set current state */
                set_current_state(TASK_INTERRUPTIBLE);
                /* before releasing spinlock */
                spin_unlock_irq(&v->state_lock);
                /* to ensure that schedule_timeout will return imediately
                 * if VINO interrupt was triggred meanwhile */
                schedule_timeout(HZ / 10);
                if (signal_pending(current))
                        err = -EINTR;
                spin_lock_irq(&v->state_lock);
                remove_wait_queue(&v->dma_wait, &wait);
                /* don't rely on schedule_timeout return value and check what
                 * really happened */
                if (!err && v->buffer_state == VINO_BUF_GRABBING)
                        err = -EIO;
                /* fall through */
        case VINO_BUF_DONE:
                for (i = 0; i < v->page_count; i++)
                        pci_dma_sync_single(NULL, v->dma_desc.cpu[PAGE_RATIO*i],
                                            PAGE_SIZE, PCI_DMA_FROMDEVICE);
                v->buffer_state = VINO_BUF_UNUSED;
                break;
        default:
                err = -EINVAL;
        }
        spin_unlock_irq(&v->state_lock);
 
        if (err && err != -EINVAL) {
                DEBUG("VINO: waiting for frame failed\n");
                spin_lock_irq(&Vino->vino_lock);
                dma_stop(v);
                clear_eod(v);
                spin_unlock_irq(&Vino->vino_lock);
        }
 
        return err;
}
 
static int alloc_buffer(struct vino_device *v, int size)
{
        int count, i, j, err;
 
        err = i = 0;
        count = (size / PAGE_SIZE + 4) & ~3;
        v->desc = (unsigned long *) kmalloc(count * sizeof(unsigned long),
                                            GFP_KERNEL);
        if (!v->desc)
                return -ENOMEM;
 
        v->dma_desc.cpu = pci_alloc_consistent(NULL, PAGE_RATIO * (count+4) *
                                               sizeof(dma_addr_t),
                                               &v->dma_desc.dma);
        if (!v->dma_desc.cpu) {
                err = -ENOMEM;
                goto out_free_desc;
        }
        while (i < count) {
                dma_addr_t dma;
 
                v->desc[i] = get_zeroed_page(GFP_KERNEL | GFP_DMA);
                if (!v->desc[i])
                        break;
                dma = pci_map_single(NULL, (void *)v->desc[i], PAGE_SIZE,
                                     PCI_DMA_FROMDEVICE);
                for (j = 0; j < PAGE_RATIO; j++)
                        v->dma_desc.cpu[PAGE_RATIO * i + j ] =
                                dma + VINO_PAGE_SIZE * j;
                mem_map_reserve(virt_to_page(v->desc[i]));
                i++;
        }
        v->dma_desc.cpu[PAGE_RATIO * count] = VINO_DESC_STOP;
        if (i-- < count) {
                while (i >= 0) {
                        mem_map_unreserve(virt_to_page(v->desc[i]));
                        pci_unmap_single(NULL, v->dma_desc.cpu[PAGE_RATIO * i],
                                         PAGE_SIZE, PCI_DMA_FROMDEVICE);
                        free_page(v->desc[i]);
                        i--;
                }
                pci_free_consistent(NULL,
                                    PAGE_RATIO * (count+4) * sizeof(dma_addr_t),
                                    (void *)v->dma_desc.cpu, v->dma_desc.dma);
                err = -ENOBUFS;
                goto out_free_desc;
        }
        v->page_count = count;
        return 0;
 
out_free_desc:
        kfree(v->desc);
        return err;
}
 
static void free_buffer(struct vino_device *v)
{
        int i;
 
        for (i = 0; i < v->page_count; i++) {
                mem_map_unreserve(virt_to_page(v->desc[i]));
                pci_unmap_single(NULL, v->dma_desc.cpu[PAGE_RATIO * i],
                                 PAGE_SIZE, PCI_DMA_FROMDEVICE);
                free_page(v->desc[i]);
        }
        pci_free_consistent(NULL,
                            PAGE_RATIO * (v->page_count+4) * sizeof(dma_addr_t),
                            (void *)v->dma_desc.cpu, v->dma_desc.dma);
        kfree(v->desc);
}
 
static int vino_open(struct inode *inode, struct file *file)
{
        struct video_device *dev = video_devdata(file);
        struct vino_device *v = dev->priv;
        int err = 0;
 
        down(&v->sem);
        if (v->users) {
                err =  -EBUSY;
                goto out;
        }
        /* Check for input device (IndyCam, saa7191) availability.
         * Both DMA channels can run from the same source, but only
         * source owner is allowed to change its parameters */
        spin_lock(&Vino->input_lock);
        if (Vino->camera.driver) {
                v->input = VINO_INPUT_CAMERA;
                if (!Vino->camera.owner)
                        Vino->camera.owner = v->chan;
        }
        if (Vino->decoder.driver && Vino->camera.owner != v->chan) {
                /* There are two inputs (Composite and SVideo) but only
                 * one output available to VINO DMA engine */
                if (!Vino->decoder.owner) {
                        Vino->decoder.owner = v->chan;
                        v->input = VINO_INPUT_COMP;
                        i2c_decoder_command(DECODER_SET_INPUT, &v->input);
                } else
                        v->input = (v->chan == VINO_CHAN_A) ?
                                   Vino->chB.input : Vino->chA.input;
        }
        if (v->input == -1)
                err = -ENODEV;
        spin_unlock(&Vino->input_lock);
 
        if (err)
                goto out;
        if (alloc_buffer(v, VINO_FBUFSIZE)) {
                err = -ENOBUFS;
                goto out;
        }
        v->users++;
out:
        up(&v->sem);
        return err;
}
 
static int vino_close(struct inode *inode, struct file *file)
{
        struct video_device *dev = video_devdata(file);
        struct vino_device *v = dev->priv;
 
        down(&v->sem);
        v->users--;
        if (!v->users) {
                struct vino_device *w = (v->chan == VINO_CHAN_A) ?
                                        &Vino->chB : &Vino->chA;
                /* Eventually make other channel owner of input device */
                spin_lock(&Vino->input_lock);
                if (Vino->camera.owner == v->chan)
                        Vino->camera.owner = (w->input == VINO_INPUT_CAMERA) ?
                                             w->chan : 0;
                else if (Vino->decoder.owner == v->chan)
                        Vino->decoder.owner = (w->input == VINO_INPUT_COMP ||
                                               w->input == VINO_INPUT_SVIDEO) ?
                                              w->chan : 0;
                v->input = -1;
                spin_unlock(&Vino->input_lock);
 
                vino_waitfor(v, 0);
                free_buffer(v);
        }
        up(&v->sem);
        return 0;
}
 
static int vino_mmap(struct file *file, struct vm_area_struct *vma)
{
        struct video_device *dev = video_devdata(file);
        struct vino_device *v = dev->priv;
        unsigned long start = vma->vm_start;
        unsigned long size  = vma->vm_end - vma->vm_start;
        int i, err = 0;
 
        if (down_interruptible(&v->sem))
                return -EINTR;
        if (size > v->page_count * PAGE_SIZE) {
                err = -EINVAL;
                goto out;
        }
        for (i = 0; i < v->page_count; i++) {
                unsigned long page = virt_to_phys((void *)v->desc[i]);
                if (remap_page_range(start, page, PAGE_SIZE, PAGE_READONLY)) {
                        err = -EAGAIN;
                        goto out;
                }
                start += PAGE_SIZE;
                if (size <= PAGE_SIZE) break;
                size -= PAGE_SIZE;
        }
out:
        up(&v->sem);
        return err;
 
}
 
static int vino_do_ioctl(struct inode *inode, struct file *file,
                         unsigned int cmd, void *arg)
{
        struct video_device *dev = video_devdata(file);
        struct vino_device *v = dev->priv;
 
        switch (cmd) {
        case VIDIOCGCAP: {
                struct video_capability *cap = arg;
 
                strcpy(cap->name, vinostr);
                cap->type = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE;
                cap->channels = VINO_INPUT_CHANNELS;
                cap->audios = 0;
                cap->maxwidth = VINO_PAL_WIDTH;
                cap->maxheight = VINO_PAL_HEIGHT;
                cap->minwidth = VINO_MIN_WIDTH;
                cap->minheight = VINO_MIN_HEIGHT;
                break;
        }
        case VIDIOCGCHAN: {
                struct video_channel *ch = arg;
 
                ch->flags = 0;
                ch->tuners = 0;
                switch (ch->channel) {
                case VINO_INPUT_COMP:
                        ch->norm = VIDEO_MODE_PAL | VIDEO_MODE_NTSC;
                        ch->type = VIDEO_TYPE_TV;
                        strcpy(ch->name, "Composite");
                        break;
                case VINO_INPUT_SVIDEO:
                        ch->norm = VIDEO_MODE_PAL | VIDEO_MODE_NTSC;
                        ch->type = VIDEO_TYPE_TV;
                        strcpy(ch->name, "S-Video");
                        break;
                case VINO_INPUT_CAMERA:
                        ch->norm = VIDEO_MODE_NTSC;
                        ch->type = VIDEO_TYPE_CAMERA;
                        strcpy(ch->name, "IndyCam");
                        break;
                default:
                        return -EINVAL;
                }
                break;
        }
        case VIDIOCSCHAN: {
                struct video_channel *ch = arg;
                int err = 0;
                struct vino_device *w = (v->chan == VINO_CHAN_A) ?
                                        &Vino->chB : &Vino->chA;
 
                spin_lock(&Vino->input_lock);
                switch (ch->channel) {
                case VINO_INPUT_COMP:
                case VINO_INPUT_SVIDEO:
                        if (!Vino->decoder.driver) {
                                err = -ENODEV;
                                break;
                        }
                        if (!Vino->decoder.owner)
                                Vino->decoder.owner = v->chan;
                        if (Vino->decoder.owner == v->chan)
                                i2c_decoder_command(DECODER_SET_INPUT,
                                                    &ch->channel);
                        else
                                if (ch->channel != w->input) {
                                        err = -EBUSY;
                                        break;
                                }
                        if (Vino->camera.owner == v->chan)
                                Vino->camera.owner =
                                        (w->input == VINO_INPUT_CAMERA) ?
                                        w->chan : 0;
                        break;
                case VINO_INPUT_CAMERA:
                        if (!Vino->camera.driver) {
                                err = -ENODEV;
                                break;
                        }
                        if (!Vino->camera.owner)
                                Vino->camera.owner = v->chan;
                        if (Vino->decoder.owner == v->chan)
                                Vino->decoder.owner =
                                        (w->input == VINO_INPUT_COMP ||
                                         w->input == VINO_INPUT_SVIDEO) ?
                                        w->chan : 0;
                        break;
                default:
                        err = -EINVAL;
                }
                if (!err)
                        v->input = ch->channel;
                spin_unlock(&Vino->input_lock);
 
                return err;
        }
        case VIDIOCGPICT: {
                struct video_picture *pic = arg;
 
                memcpy(pic, &v->picture, sizeof(struct video_picture));
                break;
        }
        case VIDIOCSPICT: {
                struct video_picture *pic = arg;
 
                switch (pic->palette) {
                case VIDEO_PALETTE_GREY:
                        pic->depth = 8;
                        break;
                case VIDEO_PALETTE_YUV422:
                        pic->depth = 16;
                        break;
                case VIDEO_PALETTE_RGB32:
                        pic->depth = 24;
                        break;
                default:
                        return -EINVAL;
                }
                if (v->picture.palette != pic->palette) {
                        v->picture.palette = pic->palette;
                        v->picture.depth = pic->depth;
                        /* TODO: we need to change line size */
                }
                DEBUG("XXX %d, %d\n", v->input, Vino->camera.owner);
                spin_lock(&Vino->input_lock);
                if (v->input == VINO_INPUT_CAMERA) {
                        if (Vino->camera.owner == v->chan) {
                                spin_unlock(&Vino->input_lock);
                                memcpy(&v->picture, pic,
                                        sizeof(struct video_picture));
                                i2c_camera_command(DECODER_SET_PICTURE, pic);
                                goto out_unlocked;
                        }
                } else {
                        if (Vino->decoder.owner == v->chan) {
                                spin_unlock(&Vino->input_lock);
                                memcpy(&v->picture, pic,
                                        sizeof(struct video_picture));
                                i2c_decoder_command(DECODER_SET_PICTURE, pic);
                                goto out_unlocked;
                        }
                }
                spin_unlock(&Vino->input_lock);
out_unlocked:
                break;
        }
        /* get cropping */
        case VIDIOCGCAPTURE: {
                struct video_capture *capture = arg;
 
                capture->x = v->left;
                capture->y = v->top;
                capture->width = v->right - v->left;
                capture->height = v->bottom - v->top;
                capture->decimation = v->decimation;
                capture->flags = 0;
                break;
        }
        /* set cropping */
        case VIDIOCSCAPTURE: {
                struct video_capture *capture = arg;
 
                return set_clipping(v, capture->x, capture->y, capture->width,
                                    capture->height, capture->decimation);
        }
        /* get scaling */
        case VIDIOCGWIN: {
                struct video_window *win = arg;
 
                memset(win, 0, sizeof(*win));
                win->width = (v->right - v->left) / v->decimation;
                win->height = (v->bottom - v->top) / v->decimation;
                break;
        }
        /* set scaling */
        case VIDIOCSWIN: {
                struct video_window *win = arg;
 
                if (win->x || win->y || win->clipcount || win->clips)
                        return -EINVAL;
                return set_scaling(v, win->width, win->height);
        }
        case VIDIOCGMBUF: {
                struct video_mbuf *buf = arg;
 
                buf->frames = 1;
                buf->offsets[0] = 0;
                buf->size = v->page_count * PAGE_SIZE;
                break;
        }
        case VIDIOCMCAPTURE: {
                struct video_mmap *mmap = arg;
 
                if (mmap->width != v->right - v->left ||
                    mmap->height != v->bottom - v->top ||
                    mmap->format != v->picture.palette ||
                    mmap->frame != 0)
                        return -EINVAL;
 
                return vino_grab(v, mmap->frame);
        }
        case VIDIOCSYNC:
                return vino_waitfor(v, *((int*)arg));
        default:
                return -ENOIOCTLCMD;
        }
        return 0;
}
 
static int vino_ioctl(struct inode *inode, struct file *file,
                      unsigned int cmd, unsigned long arg)
{
        struct video_device *dev = video_devdata(file);
        struct vino_device *v = dev->priv;
        int err;
 
        if (down_interruptible(&v->sem))
                return -EINTR;
        err = video_usercopy(inode, file, cmd, arg, vino_do_ioctl);
        up(&v->sem);
        return err;
}
 
static struct file_operations vino_fops = {
        .owner          = THIS_MODULE,
        .open           = vino_open,
        .release        = vino_close,
        .ioctl          = vino_ioctl,
        .mmap           = vino_mmap,
        .llseek         = no_llseek,
};
 
static const struct video_device vino_template = {
        .owner          = THIS_MODULE,
        .type           = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE,
        .hardware       = VID_HARDWARE_VINO,
        .name           = "VINO",
        .fops           = &vino_fops,
        .minor          = -1,
};
 
static void init_channel_data(struct vino_device *v, int channel)
{
        init_waitqueue_head(&v->dma_wait);
        init_MUTEX(&v->sem);
        spin_lock_init(&v->state_lock);
        memcpy(&v->vdev, &vino_template, sizeof(vino_template));
        v->vdev.priv = v;
        v->chan = channel;
        v->input = -1;
        v->picture.palette = VIDEO_PALETTE_GREY;
        v->picture.depth = 8;
        v->buffer_state = VINO_BUF_UNUSED;
        v->users = 0;
        set_clipping(v, 0, 0, VINO_NTSC_WIDTH, VINO_NTSC_HEIGHT, 1);
}
 
static int __init vino_init(void)
{
        unsigned long rev;
        dma_addr_t dma;
        int i, ret = 0;
 
        /* VINO is Indy specific beast */
        if (ip22_is_fullhouse())
                return -ENODEV;
 
        /*
         * VINO is in the EISA address space, so the sysid register will tell
         * us if the EISA_PRESENT pin on MC has been pulled low.
         *
         * If EISA_PRESENT is not set we definitely don't have a VINO equiped
         * system.
         */
        if (!(sgimc->systemid & SGIMC_SYSID_EPRESENT)) {
                printk(KERN_ERR "VINO not found\n");
                return -ENODEV;
        }
 
        vino = (struct sgi_vino *)ioremap(VINO_BASE, sizeof(struct sgi_vino));
        if (!vino)
                return -EIO;
 
        /* Okay, once we know that VINO is present we'll read its revision
         * safe way. One never knows... */
        if (get_dbe(rev, &(vino->rev_id))) {
                printk(KERN_ERR "VINO: failed to read revision register\n");
                ret = -ENODEV;
                goto out_unmap;
        }
        if (VINO_ID_VALUE(rev) != VINO_CHIP_ID) {
                printk(KERN_ERR "VINO is not VINO (Rev/ID: 0x%04lx)\n", rev);
                ret = -ENODEV;
                goto out_unmap;
        }
        printk(KERN_INFO "VINO Rev: 0x%02lx\n", VINO_REV_NUM(rev));
 
        Vino = (struct vino_video *)
                kmalloc(sizeof(struct vino_video), GFP_KERNEL);
        if (!Vino) {
                ret = -ENOMEM;
                goto out_unmap;
        }
        memset(Vino, 0, sizeof(struct vino_video));
 
        Vino->dummy_desc = get_zeroed_page(GFP_KERNEL | GFP_DMA);
        if (!Vino->dummy_desc) {
                ret = -ENOMEM;
                goto out_free_vino;
        }
        Vino->dummy_dma.cpu = pci_alloc_consistent(NULL, 4 * sizeof(dma_addr_t),
                                                   &Vino->dummy_dma.dma);
        if (!Vino->dummy_dma.cpu) {
                ret = -ENOMEM;
                goto out_free_dummy_desc;
        }
        dma = pci_map_single(NULL, (void *)Vino->dummy_desc, PAGE_SIZE,
                             PCI_DMA_FROMDEVICE);
        for (i = 0; i < 4; i++)
                Vino->dummy_dma.cpu[i] = dma;
 
        vino->control = 0;
        /* prevent VINO from throwing spurious interrupts */
        vino->a.next_4_desc = Vino->dummy_dma.dma;
        vino->b.next_4_desc = Vino->dummy_dma.dma;
        udelay(5);
        vino->intr_status = 0;
        /* set threshold level */
        vino->a.fifo_thres = threshold_a;
        vino->b.fifo_thres = threshold_b;
 
        spin_lock_init(&Vino->vino_lock);
        spin_lock_init(&Vino->input_lock);
        init_channel_data(&Vino->chA, VINO_CHAN_A);
        init_channel_data(&Vino->chB, VINO_CHAN_B);
 
        if (request_irq(SGI_VINO_IRQ, vino_interrupt, 0, vinostr, NULL)) {
                printk(KERN_ERR "VINO: request irq%02d failed\n",
                       SGI_VINO_IRQ);
                ret = -EAGAIN;
                goto out_unmap_dummy_desc;
        }
 
        ret = vino_i2c_add_bus();
        if (ret) {
                printk(KERN_ERR "VINO: I2C bus registration failed\n");
                goto out_free_irq;
        }
 
        if (video_register_device(&Vino->chA.vdev, VFL_TYPE_GRABBER, -1) < 0) {
                printk("%s, chnl %d: device registration failed.\n",
                        Vino->chA.vdev.name, Vino->chA.chan);
                ret = -EINVAL;
                goto out_i2c_del_bus;
        }
        if (video_register_device(&Vino->chB.vdev, VFL_TYPE_GRABBER, -1) < 0) {
                printk("%s, chnl %d: device registration failed.\n",
                        Vino->chB.vdev.name, Vino->chB.chan);
                ret = -EINVAL;
                goto out_unregister_vdev;
        }
 
#if defined(CONFIG_KMOD) && defined (MODULE)
        request_module("saa7191");
        request_module("indycam");
#endif
        return 0;
 
out_unregister_vdev:
        video_unregister_device(&Vino->chA.vdev);
out_i2c_del_bus:
        vino_i2c_del_bus();
out_free_irq:
        free_irq(SGI_VINO_IRQ, NULL);
out_unmap_dummy_desc:
        pci_unmap_single(NULL, Vino->dummy_dma.dma, PAGE_SIZE,
                         PCI_DMA_FROMDEVICE);
        pci_free_consistent(NULL, 4 * sizeof(dma_addr_t),
                            (void *)Vino->dummy_dma.cpu, Vino->dummy_dma.dma);
out_free_dummy_desc:
        free_page(Vino->dummy_desc);
out_free_vino:
        kfree(Vino);
out_unmap:
        iounmap(vino);
 
        return ret;
}
 
static void __exit vino_exit(void)
{
        video_unregister_device(&Vino->chA.vdev);
        video_unregister_device(&Vino->chB.vdev);
        vino_i2c_del_bus();
        free_irq(SGI_VINO_IRQ, NULL);
        pci_unmap_single(NULL, Vino->dummy_dma.dma, PAGE_SIZE,
                         PCI_DMA_FROMDEVICE);
        pci_free_consistent(NULL, 4 * sizeof(dma_addr_t),
                            (void *)Vino->dummy_dma.cpu, Vino->dummy_dma.dma);
        free_page(Vino->dummy_desc);
        kfree(Vino);
        iounmap(vino);
}
 
module_init(vino_init);
module_exit(vino_exit);
 
MODULE_AUTHOR("Ladislav Michl <ladis@linux-mips.org>");
MODULE_DESCRIPTION("Video4Linux driver for SGI Indy VINO (IndyCam)");
MODULE_LICENSE("GPL");
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [media/] [video/] [vino.c] - Blame information for rev 1275

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* Driver for the VINO (Video In No Out) system found in SGI Indys.`
3			`*`
4			`* This file is subject to the terms and conditions of the GNU General Public`
5			`* License version 2 as published by the Free Software Foundation.`
6			`*`
7			`* Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>`
8			`*/`
9
10			`#include <linux/module.h>`
11			`#include <linux/kmod.h>`
12			`#include <linux/init.h>`
13			`#include <linux/types.h>`
14			`#include <linux/errno.h>`
15			`#include <linux/mm.h>`
16			`#include <linux/wrapper.h>`
17			`#include <linux/irq.h>`
18			`#include <linux/delay.h>`
19			`#include <linux/pci.h>`
20			`#include <linux/videodev.h>`
21			`#include <linux/video_decoder.h>`
22			`#include <linux/i2c.h>`
23			`#include <linux/i2c-algo-sgi.h>`
24
25			`#include <asm/paccess.h>`
26			`#include <asm/io.h>`
27			`#include <asm/sgi/ip22.h>`
28			`#include <asm/sgi/hpc3.h>`
29			`#include <asm/sgi/mc.h>`
30
31			`#include "vino.h"`
32
33			`/* debugging? */`
34			`#if 1`
35			`#define DEBUG(x...) printk(x);`
36			`#else`
37			`#define DEBUG(x...)`
38			`#endif`
39
40			`/* VINO video size */`