#include <linux/mm.h>
#include <linux/pci.h>
#include <linux/signal.h>
+#include <linux/wait.h>
#include <asm/io.h>
#include <asm/pgtable.h>
#include <asm/page.h>
MODULE_DESCRIPTION("Zoran ZR36120 based framegrabber");
MODULE_LICENSE("GPL");
-MODULE_PARM(triton1,"i");
-MODULE_PARM(cardtype,"1-" __MODULE_STRING(ZORAN_MAX) "i");
-MODULE_PARM(video_nr,"i");
-MODULE_PARM(vbi_nr,"i");
+module_param(triton1, uint, 0);
+module_param_array(cardtype, uint, NULL, 0);
+module_param(video_nr, int, 0);
+module_param(vbi_nr, int, 0);
static int zoran_cards;
static struct zoran zorans[ZORAN_MAX];
static
void __init handle_chipset(void)
{
- struct pci_dev *dev = NULL;
-
/* Just in case some nut set this to something dangerous */
if (triton1)
triton1 = ZORAN_VDC_TRICOM;
- while ((dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82437, dev)))
- {
+ if (pci_pci_problems & PCIPCI_TRITON) {
printk(KERN_INFO "zoran: Host bridge 82437FX Triton PIIX\n");
triton1 = ZORAN_VDC_TRICOM;
}
item->status = FBUFFER_BUSY;
if (!lastitem)
ztv->workqueue = item;
- else
+ else
lastitem->next = item;
lastitem = item;
}
{
u32 stat,estat;
int count = 0;
- struct zoran *ztv = (struct zoran *)dev_id;
+ struct zoran *ztv = dev_id;
UNUSED(irq); UNUSED(regs);
for (;;) {
zraor((ztv->vidInterlace*ystep)<<0,~ZORAN_OCR_MASKSTRIDE,ZORAN_OCR);
}
-struct tvnorm
+struct tvnorm
{
u16 Wt, Wa, Ht, Ha, HStart, VStart;
};
int HorDcm = 64-X;
int hcrop1 = 2*(Wa-We)/4;
/*
- * BUGFIX: Juha Nurmela <junki@qn-lpr2-165.quicknet.inet.fi>
+ * BUGFIX: Juha Nurmela <junki@qn-lpr2-165.quicknet.inet.fi>
* found the solution to the color phase shift.
* See ChangeLog for the full explanation)
*/
memset(ztv->fbuffer,0,ZORAN_MAX_FBUFSIZE);
if (!ztv->overinfo.overlay)
- ztv->overinfo.overlay = (void*)kmalloc(1024*1024/8, GFP_KERNEL);
+ ztv->overinfo.overlay = kmalloc(1024*1024/8, GFP_KERNEL);
if (!ztv->overinfo.overlay) {
/* could not get an overlay buffer, bail out */
bfree(ztv->fbuffer, ZORAN_MAX_FBUFSIZE);
zoran_common_close(ztv);
- /*
- * This is sucky but right now I can't find a good way to
- * be sure its safe to free the buffer. We wait 5-6 fields
- * which is more than sufficient to be sure.
- */
- current->state = TASK_UNINTERRUPTIBLE;
- schedule_timeout(HZ/10); /* Wait 1/10th of a second */
+ /*
+ * This is sucky but right now I can't find a good way to
+ * be sure its safe to free the buffer. We wait 5-6 fields
+ * which is more than sufficient to be sure.
+ */
+ msleep(100); /* Wait 1/10th of a second */
/* free the allocated framebuffer */
- if (ztv->fbuffer)
- bfree( ztv->fbuffer, ZORAN_MAX_FBUFSIZE );
+ bfree(ztv->fbuffer, ZORAN_MAX_FBUFSIZE);
ztv->fbuffer = 0;
- if (ztv->overinfo.overlay)
- kfree( ztv->overinfo.overlay );
+ kfree(ztv->overinfo.overlay);
ztv->overinfo.overlay = 0;
}
zoran_cap(ztv, 1);
/* wait till this buffer gets grabbed */
- while (unused->status == FBUFFER_BUSY) {
- interruptible_sleep_on(&ztv->grabq);
- /* see if a signal did it */
- if (signal_pending(current))
- return -EINTR;
- }
+ wait_event_interruptible(ztv->grabq,
+ (unused->status != FBUFFER_BUSY));
+ /* see if a signal did it */
+ if (signal_pending(current))
+ return -EINTR;
done = unused;
}
else
return -EINVAL;
case FBUFFER_BUSY:
/* wait till this buffer gets grabbed */
- while (ztv->grabinfo[i].status == FBUFFER_BUSY) {
- interruptible_sleep_on(&ztv->grabq);
- /* see if a signal did it */
- if (signal_pending(current))
- return -EINTR;
- }
+ wait_event_interruptible(ztv->grabq,
+ (ztv->grabinfo[i].status != FBUFFER_BUSY));
+ /* see if a signal did it */
+ if (signal_pending(current))
+ return -EINTR;
/* don't fall through; a DONE buffer is not UNUSED */
break;
case FBUFFER_DONE:
/* Why isn't this in the API?
* And why doesn't it take a buffer number?
- case BTTV_FIELDNR:
+ case BTTV_FIELDNR:
{
unsigned long v = ztv->lastfieldnr;
if (copy_to_user(arg,&v,sizeof(v)))
/* start mapping the whole shabang to user memory */
pos = (unsigned long)ztv->fbuffer;
while (size>0) {
- unsigned long page = virt_to_phys((void*)pos);
- if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
+ unsigned long pfn = virt_to_phys((void*)pos) >> PAGE_SHIFT;
+ if (remap_pfn_range(vma, start, pfn, PAGE_SIZE, PAGE_SHARED))
return -EAGAIN;
start += PAGE_SIZE;
pos += PAGE_SIZE;
.write = zoran_write,
.poll = zoran_poll,
.ioctl = zoran_ioctl,
+ .compat_ioctl = v4l_compat_ioctl32,
.mmap = zoran_mmap,
.minor = -1,
};
static
int vbi_open(struct video_device *dev, int flags)
{
- struct zoran *ztv = (struct zoran*)dev->priv;
+ struct zoran *ztv = dev->priv;
struct vidinfo* item;
DEBUG(printk(CARD_DEBUG "vbi_open(dev,%d)\n",CARD,flags));
static
void vbi_close(struct video_device *dev)
{
- struct zoran *ztv = (struct zoran*)dev->priv;
+ struct zoran *ztv = dev->priv;
struct vidinfo* item;
DEBUG(printk(CARD_DEBUG "vbi_close(dev)\n",CARD));
zoran_common_close(ztv);
- /*
- * This is sucky but right now I can't find a good way to
- * be sure its safe to free the buffer. We wait 5-6 fields
- * which is more than sufficient to be sure.
- */
- current->state = TASK_UNINTERRUPTIBLE;
- schedule_timeout(HZ/10); /* Wait 1/10th of a second */
+ /*
+ * This is sucky but right now I can't find a good way to
+ * be sure its safe to free the buffer. We wait 5-6 fields
+ * which is more than sufficient to be sure.
+ */
+ msleep(100); /* Wait 1/10th of a second */
for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
{
static
long vbi_read(struct video_device* dev, char* buf, unsigned long count, int nonblock)
{
- struct zoran *ztv = (struct zoran*)dev->priv;
+ struct zoran *ztv = dev->priv;
unsigned long max;
struct vidinfo* unused = 0;
struct vidinfo* done = 0;
write_unlock_irq(&ztv->lock);
return -EWOULDBLOCK;
}
-
+
/* mark the unused buffer as wanted */
unused->status = FBUFFER_BUSY;
unused->next = 0;
zoran_cap(ztv, 1);
/* wait till this buffer gets grabbed */
- while (unused->status == FBUFFER_BUSY) {
- interruptible_sleep_on(&ztv->vbiq);
- /* see if a signal did it */
- if (signal_pending(current))
- return -EINTR;
- }
+ wait_event_interruptible(ztv->vbiq,
+ (unused->status != FBUFFER_BUSY));
+ /* see if a signal did it */
+ if (signal_pending(current))
+ return -EINTR;
done = unused;
}
else
if (count == 2*19*2048) {
/*
* Extreme HACK, old VBI programs expect 2048 points
- * of data, and we only got 864 orso. Double each
+ * of data, and we only got 864 orso. Double each
* datapoint and clear the rest of the line.
* This way we have appear to have a
* sample_frequency of 29.5 Mc.
static
unsigned int vbi_poll(struct video_device *dev, struct file *file, poll_table *wait)
{
- struct zoran *ztv = (struct zoran*)dev->priv;
+ struct zoran *ztv = dev->priv;
struct vidinfo* item;
unsigned int mask = 0;
static
int vbi_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
{
- struct zoran* ztv = (struct zoran*)dev->priv;
+ struct zoran* ztv = dev->priv;
switch (cmd) {
case VIDIOCGVBIFMT:
DEBUG(printk(KERN_DEBUG "zoran: mapped-memory at 0x%p\n",ztv->zoran_mem));
result = request_irq(dev->irq, zoran_irq,
- SA_SHIRQ|SA_INTERRUPT,"zoran",(void *)ztv);
+ SA_SHIRQ|SA_INTERRUPT,"zoran", ztv);
if (result==-EINVAL)
{
iounmap(ztv->zoran_mem);
ztv->tuner_type = 0;
ztv->running = 0;
ztv->users = 0;
- ztv->lock = RW_LOCK_UNLOCKED;
+ rwlock_init(&ztv->lock);
ztv->workqueue = 0;
ztv->fieldnr = 0;
ztv->lastfieldnr = 0;
zrand(~ZORAN_VDC_TRICOM, ZORAN_VDC);
/* external FL determines TOP frame */
- zror(ZORAN_VFEC_EXTFL, ZORAN_VFEC);
+ zror(ZORAN_VFEC_EXTFL, ZORAN_VFEC);
/* set HSpol */
if (ztv->card->hsync_pos)
struct zoran *ztv;
int i;
- for (i=0;i<max; i++)
+ for (i=0;i<max; i++)
{
ztv = &zorans[i];
/* free it */
free_irq(ztv->dev->irq,ztv);
-
+
/* unregister i2c_bus */
i2c_unregister_bus((&ztv->i2c));
int __init zr36120_init(void)
{
int card;
-
+
handle_chipset();
zoran_cards = find_zoran();
if (zoran_cards<0)
/* only release the zorans we have registered */
release_zoran(card);
return -EIO;
- }
+ }
}
return 0;
}
git://git.onelab.eu / linux-2.6.git / blobdiff