自学教程：C++ DEB_S函数代码示例

static int video_begin(struct saa7146_fh *fh){	struct saa7146_dev *dev = fh->dev;	struct saa7146_vv *vv = dev->vv_data;	struct saa7146_format *fmt = NULL;	unsigned int resource;	int ret = 0, err = 0;	DEB_EE(("dev:%p, fh:%p/n",dev,fh));	if ((vv->video_status & STATUS_CAPTURE) != 0) {		if (vv->video_fh == fh) {			DEB_S(("already capturing./n"));			return 0;		}		DEB_S(("already capturing in another open./n"));		return -EBUSY;	}	if ((vv->video_status & STATUS_OVERLAY) != 0) {		DEB_S(("warning: suspending overlay video for streaming capture./n"));		vv->ov_suspend = vv->video_fh;		err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */		if (0 != err) {			DEB_D(("suspending video failed. aborting/n"));			return err;		}	}	fmt = format_by_fourcc(dev,fh->video_fmt.pixelformat);	/* we need to have a valid format set here */	BUG_ON(NULL == fmt);	if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {		resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS;	} else {		resource = RESOURCE_DMA1_HPS;	}	ret = saa7146_res_get(fh, resource);	if (0 == ret) {		DEB_S(("cannot get capture resource %d/n",resource));		if (vv->ov_suspend != NULL) {			saa7146_start_preview(vv->ov_suspend);			vv->ov_suspend = NULL;		}		return -EBUSY;	}	/* clear out beginning of streaming bit (rps register 0)*/	saa7146_write(dev, MC2, MASK_27 );	/* enable rps0 irqs */	SAA7146_IER_ENABLE(dev, MASK_27);	vv->video_fh = fh;	vv->video_status = STATUS_CAPTURE;	return 0;}

static int vidioc_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type){	struct saa7146_fh *fh = __fh;	struct saa7146_dev *dev = fh->dev;	struct saa7146_vv *vv = dev->vv_data;	int err;	DEB_D("VIDIOC_STREAMOFF, type:%d/n", type);	/* ugly: we need to copy some checks from video_end(),	   because videobuf_streamoff() relies on the capture running.	   check and fix this */	if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) {		DEB_S("not capturing/n");		return 0;	}	if (vv->video_fh != fh) {		DEB_S("capturing, but in another open/n");		return -EBUSY;	}	err = -EINVAL;	if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)		err = videobuf_streamoff(&fh->video_q);	else if (type == V4L2_BUF_TYPE_VBI_CAPTURE)		err = videobuf_streamoff(&fh->vbi_q);	if (0 != err) {		DEB_D("warning: videobuf_streamoff() failed/n");		video_end(fh, file);	} else {		err = video_end(fh, file);	}	return err;}

static int video_end(struct saa7146_fh *fh, struct file *file){	struct saa7146_dev *dev = fh->dev;	struct saa7146_vv *vv = dev->vv_data;	struct saa7146_format *fmt = NULL;	unsigned long flags;	unsigned int resource;	u32 dmas = 0;	DEB_EE(("dev:%p, fh:%p/n",dev,fh));	if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) {		DEB_S(("not capturing./n"));		return 0;	}	if (vv->video_fh != fh) {		DEB_S(("capturing, but in another open./n"));		return -EBUSY;	}	fmt = format_by_fourcc(dev,fh->video_fmt.pixelformat);	/* we need to have a valid format set here */	BUG_ON(NULL == fmt);	if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {		resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS;		dmas = MASK_22 | MASK_21 | MASK_20;	} else {		resource = RESOURCE_DMA1_HPS;		dmas = MASK_22;	}	spin_lock_irqsave(&dev->slock,flags);	/* disable rps0  */	saa7146_write(dev, MC1, MASK_28);	/* disable rps0 irqs */	SAA7146_IER_DISABLE(dev, MASK_27);	/* shut down all used video dma transfers */	saa7146_write(dev, MC1, dmas);	spin_unlock_irqrestore(&dev->slock, flags);	vv->video_fh = NULL;	vv->video_status = 0;	saa7146_res_free(fh, resource);	if (vv->ov_suspend != NULL) {		saa7146_start_preview(vv->ov_suspend);		vv->ov_suspend = NULL;	}	return 0;}

static inline int saa7146_wait_for_debi_done_busyloop(struct saa7146_dev *dev,        unsigned long us1, unsigned long us2){    unsigned long loops;    /* wait for registers to be programmed */    loops = us1;    while (1) {        if (saa7146_read(dev, MC2) & 2)            break;        if (!loops--) {            printk(KERN_ERR "%s: %s timed out while waiting for "                   "registers getting programmed/n",                   dev->name, __func__);            return -ETIMEDOUT;        }        udelay(1);    }    /* wait for transfer to complete */    loops = us2 / 5;    while (1) {        if (!(saa7146_read(dev, PSR) & SPCI_DEBI_S))            break;        saa7146_read(dev, MC2);        if (!loops--) {            DEB_S(("%s: %s timed out while waiting for transfer "                   "completion/n", dev->name, __func__));            return -ETIMEDOUT;        }        udelay(5);    }    return 0;}

static int vbi_open(struct saa7146_dev *dev, struct file *file){    struct saa7146_fh *fh = file->private_data;    u32 arbtr_ctrl	= saa7146_read(dev, PCI_BT_V1);    int ret = 0;    DEB_VBI(("dev:%p, fh:%p/n",dev,fh));    ret = saa7146_res_get(fh, RESOURCE_DMA3_BRS);    if (0 == ret) {        DEB_S(("cannot get vbi RESOURCE_DMA3_BRS resource/n"));        return -EBUSY;    }    /* adjust arbitrition control for video dma 3 */    arbtr_ctrl &= ~0x1f0000;    arbtr_ctrl |=  0x1d0000;    saa7146_write(dev, PCI_BT_V1, arbtr_ctrl);    saa7146_write(dev, MC2, (MASK_04|MASK_20));    memset(&fh->vbi_fmt,0,sizeof(fh->vbi_fmt));    fh->vbi_fmt.sampling_rate	= 27000000;    fh->vbi_fmt.offset		= 248; /* todo */    fh->vbi_fmt.samples_per_line	= vbi_pixel_to_capture;    fh->vbi_fmt.sample_format	= V4L2_PIX_FMT_GREY;    fh->vbi_fmt.start[0] = 5;    fh->vbi_fmt.count[0] = 16;    fh->vbi_fmt.start[1] = 312;    fh->vbi_fmt.count[1] = 16;    videobuf_queue_sg_init(&fh->vbi_q, &vbi_qops,                           &dev->pci->dev, &dev->slock,                           V4L2_BUF_TYPE_VBI_CAPTURE,                           V4L2_FIELD_SEQ_TB,                           sizeof(struct saa7146_buf),                           file);    init_timer(&fh->vbi_read_timeout);    fh->vbi_read_timeout.function = vbi_read_timeout;    fh->vbi_read_timeout.data = (unsigned long)file;    /* initialize the brs */    if ( 0 != (SAA7146_USE_PORT_B_FOR_VBI & dev->ext_vv_data->flags)) {        saa7146_write(dev, BRS_CTRL, MASK_30|MASK_29 | (7 << 19));    } else {        saa7146_write(dev, BRS_CTRL, 0x00000001);        if (0 != (ret = vbi_workaround(dev))) {            DEB_VBI(("vbi workaround failed!/n"));            /* return ret;*/        }    }    /* upload brs register */    saa7146_write(dev, MC2, (MASK_08|MASK_24));    return 0;}

static int __init dpc_init_module(void){	if( 0 != saa7146_register_extension(&extension)) {		DEB_S(("failed to register extension./n"));		return -ENODEV;	}	return 0;}

static int __init mxb_init_module(void){	if (saa7146_register_extension(&extension)) {		DEB_S("failed to register extension/n");		return -ENODEV;	}	return 0;}

static ssize_t video_read(struct file *file, char __user *data, size_t count, loff_t *ppos){	struct saa7146_fh *fh = file->private_data;	struct saa7146_dev *dev = fh->dev;	struct saa7146_vv *vv = dev->vv_data;	ssize_t ret = 0;	DEB_EE(("called./n"));	if ((vv->video_status & STATUS_CAPTURE) != 0) {		/* fixme: should we allow read() captures while streaming capture? */		if (vv->video_fh == fh) {			DEB_S(("already capturing./n"));			return -EBUSY;		}		DEB_S(("already capturing in another open./n"));		return -EBUSY;	}	ret = video_begin(fh);	if( 0 != ret) {		goto out;	}	ret = videobuf_read_one(&fh->video_q , data, count, ppos,				file->f_flags & O_NONBLOCK);	if (ret != 0) {		video_end(fh, file);	} else {		ret = video_end(fh, file);	}out:	/* restart overlay if it was active before */	if (vv->ov_suspend != NULL) {		saa7146_start_preview(vv->ov_suspend);		vv->ov_suspend = NULL;	}	return ret;}

static int mxb_probe(struct saa7146_dev *dev){	struct mxb *mxb = NULL;	mxb = kzalloc(sizeof(struct mxb), GFP_KERNEL);	if (mxb == NULL) {		DEB_D(("not enough kernel memory./n"));		return -ENOMEM;	}	snprintf(mxb->i2c_adapter.name, sizeof(mxb->i2c_adapter.name), "mxb%d", mxb_num);	saa7146_i2c_adapter_prepare(dev, &mxb->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);	if (i2c_add_adapter(&mxb->i2c_adapter) < 0) {		DEB_S(("cannot register i2c-device. skipping./n"));		kfree(mxb);		return -EFAULT;	}	mxb->saa7111a = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,			"saa7115", "saa7111", I2C_SAA7111A);	mxb->tea6420_1 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,			"tea6420", "tea6420", I2C_TEA6420_1);	mxb->tea6420_2 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,			"tea6420", "tea6420", I2C_TEA6420_2);	mxb->tea6415c = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,			"tea6415c", "tea6415c", I2C_TEA6415C);	mxb->tda9840 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,			"tda9840", "tda9840", I2C_TDA9840);	mxb->tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,			"tuner", "tuner", I2C_TUNER);	if (v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,			"saa5246a", "saa5246a", I2C_SAA5246A)) {		printk(KERN_INFO "mxb: found teletext decoder/n");	}	/* check if all devices are present */	if (!mxb->tea6420_1 || !mxb->tea6420_2 || !mxb->tea6415c ||	    !mxb->tda9840 || !mxb->saa7111a || !mxb->tuner) {		printk("mxb: did not find all i2c devices. aborting/n");		i2c_del_adapter(&mxb->i2c_adapter);		kfree(mxb);		return -ENODEV;	}	/* all devices are present, probe was successful */	/* we store the pointer in our private data field */	dev->ext_priv = mxb;	return 0;}

static int mxb_probe(struct saa7146_dev *dev){    struct mxb *mxb = NULL;    mxb = kzalloc(sizeof(struct mxb), GFP_KERNEL);    if (mxb == NULL) {        DEB_D("not enough kernel memory/n");        return -ENOMEM;    }    snprintf(mxb->i2c_adapter.name, sizeof(mxb->i2c_adapter.name), "mxb%d", mxb_num);    saa7146_i2c_adapter_prepare(dev, &mxb->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);    if (i2c_add_adapter(&mxb->i2c_adapter) < 0) {        DEB_S("cannot register i2c-device. skipping./n");        kfree(mxb);        return -EFAULT;    }    mxb->saa7111a = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,                                        "saa7111", I2C_SAA7111A, NULL);    mxb->tea6420_1 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,                                         "tea6420", I2C_TEA6420_1, NULL);    mxb->tea6420_2 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,                                         "tea6420", I2C_TEA6420_2, NULL);    mxb->tea6415c = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,                                        "tea6415c", I2C_TEA6415C, NULL);    mxb->tda9840 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,                                       "tda9840", I2C_TDA9840, NULL);    mxb->tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,                                     "tuner", I2C_TUNER, NULL);    if (!mxb->tea6420_1 || !mxb->tea6420_2 || !mxb->tea6415c ||            !mxb->tda9840 || !mxb->saa7111a || !mxb->tuner) {        pr_err("did not find all i2c devices. aborting/n");        i2c_del_adapter(&mxb->i2c_adapter);        kfree(mxb);        return -ENODEV;    }    dev->ext_priv = mxb;    return 0;}

static int vbi_open(struct saa7146_dev *dev, struct file *file){	struct saa7146_fh *fh = file->private_data;	struct saa7146_vv *vv = fh->dev->vv_data;	u32 arbtr_ctrl	= saa7146_read(dev, PCI_BT_V1);	int ret = 0;	DEB_VBI("dev:%p, fh:%p/n", dev, fh);	ret = saa7146_res_get(fh, RESOURCE_DMA3_BRS);	if (0 == ret) {		DEB_S("cannot get vbi RESOURCE_DMA3_BRS resource/n");		return -EBUSY;	}	/* adjust arbitrition control for video dma 3 */	arbtr_ctrl &= ~0x1f0000;	arbtr_ctrl |=  0x1d0000;	saa7146_write(dev, PCI_BT_V1, arbtr_ctrl);	saa7146_write(dev, MC2, (MASK_04|MASK_20));	videobuf_queue_sg_init(&fh->vbi_q, &vbi_qops,			    &dev->pci->dev, &dev->slock,			    V4L2_BUF_TYPE_VBI_CAPTURE,			    V4L2_FIELD_SEQ_TB, // FIXME: does this really work?			    sizeof(struct saa7146_buf),			    file, &dev->v4l2_lock);	vv->vbi_read_timeout.function = vbi_read_timeout;	vv->vbi_read_timeout.data = (unsigned long)file;	/* initialize the brs */	if ( 0 != (SAA7146_USE_PORT_B_FOR_VBI & dev->ext_vv_data->flags)) {		saa7146_write(dev, BRS_CTRL, MASK_30|MASK_29 | (7 << 19));	} else {		saa7146_write(dev, BRS_CTRL, 0x00000001);		if (0 != (ret = vbi_workaround(dev))) {			DEB_VBI("vbi workaround failed!/n");			/* return ret;*/		}	}	/* upload brs register */	saa7146_write(dev, MC2, (MASK_08|MASK_24));	return 0;}

static int vidioc_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb){	struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;	struct saa7146_vv *vv = dev->vv_data;	struct saa7146_format *fmt;	DEB_EE(("VIDIOC_S_FBUF/n"));	if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))		return -EPERM;	/* check args */	fmt = saa7146_format_by_fourcc(dev, fb->fmt.pixelformat);	if (NULL == fmt)		return -EINVAL;	/* planar formats are not allowed for overlay video, clipping and video dma would clash */	if (fmt->flags & FORMAT_IS_PLANAR)		DEB_S(("planar pixelformat '%4.4s' not allowed for overlay/n",					(char *)&fmt->pixelformat));	/* check if overlay is running */	if (IS_OVERLAY_ACTIVE(fh) != 0) {		if (vv->video_fh != fh) {			DEB_D(("refusing to change framebuffer informations while overlay is active in another open./n"));			return -EBUSY;		}	}	mutex_lock(&dev->lock);	/* ok, accept it */	vv->ov_fb = *fb;	vv->ov_fmt = fmt;	if (vv->ov_fb.fmt.bytesperline < vv->ov_fb.fmt.width) {		vv->ov_fb.fmt.bytesperline = vv->ov_fb.fmt.width * fmt->depth / 8;		DEB_D(("setting bytesperline to %d/n", vv->ov_fb.fmt.bytesperline));	}	mutex_unlock(&dev->lock);	return 0;}

/* This DEBI code is based on the saa7146 Stradis driver by Nathan Laredo */static inline int saa7146_wait_for_debi_done_sleep(struct saa7146_dev *dev,        unsigned long us1, unsigned long us2){    unsigned long timeout;    int err;    /* wait for registers to be programmed */    timeout = jiffies + usecs_to_jiffies(us1);    while (1) {        err = time_after(jiffies, timeout);        if (saa7146_read(dev, MC2) & 2)            break;        if (err) {            printk(KERN_ERR "%s: %s timed out while waiting for "                   "registers getting programmed/n",                   dev->name, __func__);            return -ETIMEDOUT;        }        msleep(1);    }    /* wait for transfer to complete */    timeout = jiffies + usecs_to_jiffies(us2);    while (1) {        err = time_after(jiffies, timeout);        if (!(saa7146_read(dev, PSR) & SPCI_DEBI_S))            break;        saa7146_read(dev, MC2);        if (err) {            DEB_S(("%s: %s timed out while waiting for transfer "                   "completion/n",	dev->name, __func__));            return -ETIMEDOUT;        }        msleep(1);    }    return 0;}

int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd, void *arg){	struct saa7146_fh *fh  = file->private_data;	struct saa7146_dev *dev = fh->dev;	struct saa7146_vv *vv = dev->vv_data;	int err = 0, result = 0, ee = 0;	struct saa7146_use_ops *ops;	struct videobuf_queue *q;	/* check if extension handles the command */	for(ee = 0; dev->ext_vv_data->ioctls[ee].flags != 0; ee++) {		if( cmd == dev->ext_vv_data->ioctls[ee].cmd )			break;	}	if( 0 != (dev->ext_vv_data->ioctls[ee].flags & SAA7146_EXCLUSIVE) ) {		DEB_D(("extension handles ioctl exclusive./n"));		result = dev->ext_vv_data->ioctl(fh, cmd, arg);		return result;	}	if( 0 != (dev->ext_vv_data->ioctls[ee].flags & SAA7146_BEFORE) ) {		DEB_D(("extension handles ioctl before./n"));		result = dev->ext_vv_data->ioctl(fh, cmd, arg);		if( -EAGAIN != result ) {			return result;		}	}	/* fixme: add handle "after" case (is it still needed?) */	switch (fh->type) {	case V4L2_BUF_TYPE_VIDEO_CAPTURE: {		ops = &saa7146_video_uops;		q = &fh->video_q;		break;		}	case V4L2_BUF_TYPE_VBI_CAPTURE: {		ops = &saa7146_vbi_uops;		q = &fh->vbi_q;		break;		}	default:		BUG();		return 0;	}	switch (cmd) {	case VIDIOC_QUERYCAP:	{		struct v4l2_capability *cap = arg;		memset(cap,0,sizeof(*cap));		DEB_EE(("VIDIOC_QUERYCAP/n"));		strcpy(cap->driver, "saa7146 v4l2");		strlcpy(cap->card, dev->ext->name, sizeof(cap->card));		sprintf(cap->bus_info,"PCI:%s", pci_name(dev->pci));		cap->version = SAA7146_VERSION_CODE;		cap->capabilities =			V4L2_CAP_VIDEO_CAPTURE |			V4L2_CAP_VIDEO_OVERLAY |			V4L2_CAP_READWRITE |			V4L2_CAP_STREAMING;		cap->capabilities |= dev->ext_vv_data->capabilities;		return 0;	}	case VIDIOC_G_FBUF:	{		struct v4l2_framebuffer *fb = arg;		DEB_EE(("VIDIOC_G_FBUF/n"));		*fb = vv->ov_fb;		fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;		return 0;	}	case VIDIOC_S_FBUF:	{		struct v4l2_framebuffer *fb = arg;		struct saa7146_format *fmt;		DEB_EE(("VIDIOC_S_FBUF/n"));		if(!capable(CAP_SYS_ADMIN) &&		   !capable(CAP_SYS_RAWIO))			return -EPERM;		/* check args */		fmt = format_by_fourcc(dev,fb->fmt.pixelformat);		if (NULL == fmt) {			return -EINVAL;		}		/* planar formats are not allowed for overlay video, clipping and video dma would clash */		if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {			DEB_S(("planar pixelformat '%4.4s' not allowed for overlay/n",(char *)&fmt->pixelformat));		}//.........这里部分代码省略.........

static int mxb_probe(struct saa7146_dev* dev){	struct mxb* mxb = NULL;	int result;	if ((result = request_module("saa7111")) < 0) {		printk("mxb: saa7111 i2c module not available./n");		return -ENODEV;	}	if ((result = request_module("tea6420")) < 0) {		printk("mxb: tea6420 i2c module not available./n");		return -ENODEV;	}	if ((result = request_module("tea6415c")) < 0) {		printk("mxb: tea6415c i2c module not available./n");		return -ENODEV;	}	if ((result = request_module("tda9840")) < 0) {		printk("mxb: tda9840 i2c module not available./n");		return -ENODEV;	}	if ((result = request_module("tuner")) < 0) {		printk("mxb: tuner i2c module not available./n");		return -ENODEV;	}	mxb = kzalloc(sizeof(struct mxb), GFP_KERNEL);	if( NULL == mxb ) {		DEB_D(("not enough kernel memory./n"));		return -ENOMEM;	}	mxb->i2c_adapter = (struct i2c_adapter) {		.class = I2C_CLASS_TV_ANALOG,		.name = "mxb",	};	saa7146_i2c_adapter_prepare(dev, &mxb->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);	if(i2c_add_adapter(&mxb->i2c_adapter) < 0) {		DEB_S(("cannot register i2c-device. skipping./n"));		kfree(mxb);		return -EFAULT;	}	/* loop through all i2c-devices on the bus and look who is there */	device_for_each_child(&mxb->i2c_adapter.dev, mxb, mxb_check_clients);	/* check if all devices are present */	if (!mxb->tea6420_1 || !mxb->tea6420_2 || !mxb->tea6415c ||	    !mxb->tda9840 || !mxb->saa7111a || !mxb->tuner) {		printk("mxb: did not find all i2c devices. aborting/n");		i2c_del_adapter(&mxb->i2c_adapter);		kfree(mxb);		return -ENODEV;	}	/* all devices are present, probe was successful */	/* we store the pointer in our private data field */	dev->ext_priv = mxb;	return 0;}/* some init data for the saa7740, the so-called 'sound arena module'.   there are no specs available, so we simply use some init values */static struct {	int	length;	char	data[9];} mxb_saa7740_init[] = {	{ 3, { 0x80, 0x00, 0x00 } },{ 3, { 0x80, 0x89, 0x00 } },	{ 3, { 0x80, 0xb0, 0x0a } },{ 3, { 0x00, 0x00, 0x00 } },	{ 3, { 0x49, 0x00, 0x00 } },{ 3, { 0x4a, 0x00, 0x00 } },	{ 3, { 0x4b, 0x00, 0x00 } },{ 3, { 0x4c, 0x00, 0x00 } },	{ 3, { 0x4d, 0x00, 0x00 } },{ 3, { 0x4e, 0x00, 0x00 } },	{ 3, { 0x4f, 0x00, 0x00 } },{ 3, { 0x50, 0x00, 0x00 } },	{ 3, { 0x51, 0x00, 0x00 } },{ 3, { 0x52, 0x00, 0x00 } },	{ 3, { 0x53, 0x00, 0x00 } },{ 3, { 0x54, 0x00, 0x00 } },	{ 3, { 0x55, 0x00, 0x00 } },{ 3, { 0x56, 0x00, 0x00 } },	{ 3, { 0x57, 0x00, 0x00 } },{ 3, { 0x58, 0x00, 0x00 } },	{ 3, { 0x59, 0x00, 0x00 } },{ 3, { 0x5a, 0x00, 0x00 } },	{ 3, { 0x5b, 0x00, 0x00 } },{ 3, { 0x5c, 0x00, 0x00 } },	{ 3, { 0x5d, 0x00, 0x00 } },{ 3, { 0x5e, 0x00, 0x00 } },	{ 3, { 0x5f, 0x00, 0x00 } },{ 3, { 0x60, 0x00, 0x00 } },	{ 3, { 0x61, 0x00, 0x00 } },{ 3, { 0x62, 0x00, 0x00 } },	{ 3, { 0x63, 0x00, 0x00 } },{ 3, { 0x64, 0x00, 0x00 } },	{ 3, { 0x65, 0x00, 0x00 } },{ 3, { 0x66, 0x00, 0x00 } },	{ 3, { 0x67, 0x00, 0x00 } },{ 3, { 0x68, 0x00, 0x00 } },	{ 3, { 0x69, 0x00, 0x00 } },{ 3, { 0x6a, 0x00, 0x00 } },	{ 3, { 0x6b, 0x00, 0x00 } },{ 3, { 0x6c, 0x00, 0x00 } },	{ 3, { 0x6d, 0x00, 0x00 } },{ 3, { 0x6e, 0x00, 0x00 } },	{ 3, { 0x6f, 0x00, 0x00 } },{ 3, { 0x70, 0x00, 0x00 } },	{ 3, { 0x71, 0x00, 0x00 } },{ 3, { 0x72, 0x00, 0x00 } },	{ 3, { 0x73, 0x00, 0x00 } },{ 3, { 0x74, 0x00, 0x00 } },	{ 3, { 0x75, 0x00, 0x00 } },{ 3, { 0x76, 0x00, 0x00 } },	{ 3, { 0x77, 0x00, 0x00 } },{ 3, { 0x41, 0x00, 0x42 } },	{ 3, { 0x42, 0x10, 0x42 } },{ 3, { 0x43, 0x20, 0x42 } },	{ 3, { 0x44, 0x30, 0x42 } },{ 3, { 0x45, 0x00, 0x01 } },	{ 3, { 0x46, 0x00, 0x01 } },{ 3, { 0x47, 0x00, 0x01 } },	{ 3, { 0x48, 0x00, 0x01 } },//.........这里部分代码省略.........

/* fixme: add vbi stuff here */static int dpc_probe(struct saa7146_dev* dev){	struct dpc* dpc = NULL;	dpc = kzalloc(sizeof(struct dpc), GFP_KERNEL);	if( NULL == dpc ) {		printk("dpc_v4l2.o: dpc_probe: not enough kernel memory./n");		return -ENOMEM;	}	/* FIXME: enable i2c-port pins, video-port-pins	   video port pins should be enabled here ?! */	saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));	dpc->i2c_adapter = (struct i2c_adapter) {		.class = I2C_CLASS_TV_ANALOG,		.name = "dpc7146",	};	saa7146_i2c_adapter_prepare(dev, &dpc->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);	if(i2c_add_adapter(&dpc->i2c_adapter) < 0) {		DEB_S(("cannot register i2c-device. skipping./n"));		kfree(dpc);		return -EFAULT;	}	/* loop through all i2c-devices on the bus and look who is there */	device_for_each_child(&dpc->i2c_adapter.dev, dpc, dpc_check_clients);	/* check if all devices are present */	if (!dpc->saa7111a) {		DEB_D(("dpc_v4l2.o: dpc_attach failed for this device./n"));		i2c_del_adapter(&dpc->i2c_adapter);		kfree(dpc);		return -ENODEV;	}	/* all devices are present, probe was successful */	DEB_D(("dpc_v4l2.o: dpc_probe succeeded for this device./n"));	/* we store the pointer in our private data field */	dev->ext_priv = dpc;	return 0;}/* bring hardware to a sane state. this has to be done, just in case someone   wants to capture from this device before it has been properly initialized.   the capture engine would badly fail, because no valid signal arrives on the   saa7146, thus leading to timeouts and stuff. */static int dpc_init_done(struct saa7146_dev* dev){	struct dpc* dpc = (struct dpc*)dev->ext_priv;	DEB_D(("dpc_v4l2.o: dpc_init_done called./n"));	/* initialize the helper ics to useful values */	i2c_smbus_write_byte_data(dpc->saa7111a, 0x00, 0x11);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x02, 0xc0);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x03, 0x30);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x04, 0x00);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x05, 0x00);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x06, 0xde);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x07, 0xad);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x08, 0xa8);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x09, 0x00);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x0a, 0x80);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x0b, 0x47);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x0c, 0x40);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x0d, 0x00);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x0e, 0x03);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x10, 0xd0);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x11, 0x1c);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x12, 0xc1);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x13, 0x30);	i2c_smbus_write_byte_data(dpc->saa7111a, 0x1f, 0x81);	return 0;}static struct saa7146_ext_vv vv_data;/* this function only gets called when the probing was successful */static int dpc_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *info){	struct dpc* dpc = (struct dpc*)dev->ext_priv;	DEB_D(("dpc_v4l2.o: dpc_attach called./n"));	/* checking for i2c-devices can be omitted here, because we	   already did this in "dpc_vl42_probe" */	saa7146_vv_init(dev,&vv_data);	if( 0 != saa7146_register_device(&dpc->video_dev, dev, "dpc", VFL_TYPE_GRABBER)) {		ERR(("cannot register capture v4l2 device. skipping./n"));		return -1;	}//.........这里部分代码省略.........