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

static void cx18_process_eeprom(struct cx18 *cx){	struct tveeprom tv;	cx18_read_eeprom(cx, &tv);	/* Many thanks to Steven Toth from Hauppauge for providing the	   model numbers */	/* Note: the Samsung memory models cannot be reliably determined	   from the model number. Use the cardtype module option if you	   have one of these preproduction models. */	switch (tv.model) {	case 74000 ... 74999:		cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);		break;	case 0:		CX18_ERR("Invalid EEPROM/n");		return;	default:		CX18_ERR("Unknown model %d, defaulting to HVR-1600/n", tv.model);		cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);		break;	}	cx->v4l2_cap = cx->card->v4l2_capabilities;	cx->card_name = cx->card->name;	cx->card_i2c = cx->card->i2c;	CX18_INFO("Autodetected %s/n", cx->card_name);	if (tv.tuner_type == TUNER_ABSENT)		CX18_ERR("tveeprom cannot autodetect tuner!");	if (cx->options.tuner == -1)		cx->options.tuner = tv.tuner_type;	if (cx->options.radio == -1)		cx->options.radio = (tv.has_radio != 0);	if (cx->std != 0)		/* user specified tuner standard */		return;	/* autodetect tuner standard */	if (tv.tuner_formats & V4L2_STD_PAL) {		CX18_DEBUG_INFO("PAL tuner detected/n");		cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;	} else if (tv.tuner_formats & V4L2_STD_NTSC) {		CX18_DEBUG_INFO("NTSC tuner detected/n");		cx->std |= V4L2_STD_NTSC_M;	} else if (tv.tuner_formats & V4L2_STD_SECAM) {		CX18_DEBUG_INFO("SECAM tuner detected/n");		cx->std |= V4L2_STD_SECAM_L;	} else {		CX18_INFO("No tuner detected, default to NTSC-M/n");		cx->std |= V4L2_STD_NTSC_M;	}}

static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len){	int i;	CX18_INFO("eeprom dump:/n");	for (i = 0; i < len; i++) {		if (0 == (i % 16))			CX18_INFO("eeprom %02x:", i);		printk(KERN_CONT " %02x", eedata[i]);		if (15 == (i % 16))			printk(KERN_CONT "/n");	}}

static int load_cpu_fw_direct(const char *fn, u8 __iomem *mem, struct cx18 *cx, long size){    const struct firmware *fw = NULL;    int retries = 3;    int i, j;    u32 __iomem *dst = (u32 __iomem *)mem;    const u32 *src;retry:    if (!retries || request_firmware(&fw, fn, &cx->dev->dev)) {        CX18_ERR("Unable to open firmware %s (must be %ld bytes)/n",                fn, size);        CX18_ERR("Did you put the firmware in the hotplug firmware directory?/n");        return -ENOMEM;    }    src = (const u32 *)fw->data;    if (fw->size != size) {        /* Due to race conditions in firmware loading (esp. with           udev <0.95) the wrong file was sometimes loaded. So we check           filesizes to see if at least the right-sized file was           loaded. If not, then we retry. */        CX18_INFO("retry: file loaded was not %s (expected size %ld, got %zd)/n",                fn, size, fw->size);        release_firmware(fw);        retries--;        goto retry;    }    for (i = 0; i < fw->size; i += 4096) {        setup_page(i);        for (j = i; j < fw->size && j < i + 4096; j += 4) {            /* no need for endianness conversion on the ppc */            __raw_writel(*src, dst);            if (__raw_readl(dst) != *src) {                CX18_ERR("Mismatch at offset %x/n", i);                release_firmware(fw);                return -EIO;            }            dst++;            src++;        }    }    if (!test_bit(CX18_F_I_LOADED_FW, &cx->i_flags))        CX18_INFO("loaded %s firmware (%zd bytes)/n", fn, fw->size);    release_firmware(fw);    return size;}

/* Hauppauge card? get values from tveeprom */void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv){	struct i2c_client c;	u8 eedata[256];	memset(&c, 0, sizeof(c));	strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));	c.adapter = &cx->i2c_adap[0];	c.addr = 0xA0 >> 1;	memset(tv, 0, sizeof(*tv));	if (tveeprom_read(&c, eedata, sizeof(eedata)))		return;	switch (cx->card->type) {	case CX18_CARD_HVR_1600_ESMT:	case CX18_CARD_HVR_1600_SAMSUNG:	case CX18_CARD_HVR_1600_S5H1411:		tveeprom_hauppauge_analog(&c, tv, eedata);		break;	case CX18_CARD_YUAN_MPC718:	case CX18_CARD_GOTVIEW_PCI_DVD3:		tv->model = 0x718;		cx18_eeprom_dump(cx, eedata, sizeof(eedata));		CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x/n",			  eedata[2], eedata[1], eedata[4], eedata[3]);		break;	default:		tv->model = 0xffffffff;		cx18_eeprom_dump(cx, eedata, sizeof(eedata));		break;	}}

void cx18_dvb_unregister(struct cx18_stream *stream){	struct cx18 *cx = stream->cx;	struct cx18_dvb *dvb = stream->dvb;	struct dvb_adapter *dvb_adapter;	struct dvb_demux *dvbdemux;	struct dmx_demux *dmx;	CX18_INFO("unregister DVB/n");	if (dvb == NULL || !dvb->enabled)		return;	dvb_adapter = &dvb->dvb_adapter;	dvbdemux = &dvb->demux;	dmx = &dvbdemux->dmx;	dmx->close(dmx);	dvb_net_release(&dvb->dvbnet);	dmx->remove_frontend(dmx, &dvb->mem_frontend);	dmx->remove_frontend(dmx, &dvb->hw_frontend);	dvb_dmxdev_release(&dvb->dmxdev);	dvb_dmx_release(dvbdemux);	dvb_unregister_frontend(dvb->fe);	dvb_frontend_detach(dvb->fe);	dvb_unregister_adapter(dvb_adapter);}

static int cx18_prep_dev(struct cx18 *cx, int type){	struct cx18_stream *s = &cx->streams[type];	u32 cap = cx->v4l2_cap;	int num_offset = cx18_stream_info[type].num_offset;	int num = cx->instance + cx18_first_minor + num_offset;	/* These four fields are always initialized. If video_dev == NULL, then	   this stream is not in use. In that case no other fields but these	   four can be used. */	s->video_dev = NULL;	s->cx = cx;	s->type = type;	s->name = cx18_stream_info[type].name;	/* Check whether the radio is supported */	if (type == CX18_ENC_STREAM_TYPE_RAD && !(cap & V4L2_CAP_RADIO))		return 0;	/* Check whether VBI is supported */	if (type == CX18_ENC_STREAM_TYPE_VBI &&	    !(cap & (V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE)))		return 0;	/* User explicitly selected 0 buffers for these streams, so don't	   create them. */	if (cx18_stream_info[type].dma != PCI_DMA_NONE &&	    cx->stream_buffers[type] == 0) {		CX18_INFO("Disabled %s device/n", cx18_stream_info[type].name);		return 0;	}	cx18_stream_init(cx, type);	if (num_offset == -1)		return 0;	/* allocate and initialize the v4l2 video device structure */	s->video_dev = video_device_alloc();	if (s->video_dev == NULL) {		CX18_ERR("Couldn't allocate v4l2 video_device for %s/n",				s->name);		return -ENOMEM;	}	snprintf(s->video_dev->name, sizeof(s->video_dev->name), "%s %s",		 cx->v4l2_dev.name, s->name);	s->video_dev->num = num;	s->video_dev->v4l2_dev = &cx->v4l2_dev;	s->video_dev->fops = &cx18_v4l2_enc_fops;	s->video_dev->release = video_device_release;	s->video_dev->tvnorms = V4L2_STD_ALL;	cx18_set_funcs(s->video_dev);	return 0;}

static void epu_debug(struct cx18 *cx, struct cx18_epu_work_order *order){	char *p;	char *str = order->str;	CX18_DEBUG_INFO("%x %s/n", order->mb.args[0], str);	p = strchr(str, '.');	if (!test_bit(CX18_F_I_LOADED_FW, &cx->i_flags) && p && p > str)		CX18_INFO("FW version: %s/n", p - 1);}

static void cx18_remove(struct pci_dev *pci_dev){	struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);	struct cx18 *cx = to_cx18(v4l2_dev);	int i;	CX18_DEBUG_INFO("Removing Card/n");	/* Stop all captures */	CX18_DEBUG_INFO("Stopping all streams/n");	if (atomic_read(&cx->tot_capturing) > 0)		cx18_stop_all_captures(cx);	/* Stop interrupts that cause incoming work to be queued */	cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);	/* Incoming work can cause outgoing work, so clean up incoming first */#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)	cx18_cancel_in_work_orders(cx);	cx18_cancel_out_work_orders(cx);#else	flush_workqueue(cx->in_work_queue);	flush_workqueue(cx->out_work_queue);#endif	/* Stop ack interrupts that may have been needed for work to finish */	cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);	cx18_halt_firmware(cx);	destroy_workqueue(cx->in_work_queue);	destroy_workqueue(cx->out_work_queue);	cx18_streams_cleanup(cx, 1);	exit_cx18_i2c(cx);	free_irq(cx->pci_dev->irq, (void *)cx);	cx18_iounmap(cx);	release_mem_region(cx->base_addr, CX18_MEM_SIZE);	pci_disable_device(cx->pci_dev);	if (cx->vbi.sliced_mpeg_data[0] != NULL)		for (i = 0; i < CX18_VBI_FRAMES; i++)			kfree(cx->vbi.sliced_mpeg_data[i]);	CX18_INFO("Removed %s/n", cx->card_name);	v4l2_device_unregister(v4l2_dev);	kfree(cx);}

static int cx18_log_status(struct file *file, void *fh){	struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;	struct v4l2_input vidin;	struct v4l2_audio audin;	int i;	CX18_INFO("=================  START STATUS CARD #%d  =================/n", cx->num);	if (cx->hw_flags & CX18_HW_TVEEPROM) {		struct tveeprom tv;		cx18_read_eeprom(cx, &tv);	}	cx18_call_i2c_clients(cx, VIDIOC_LOG_STATUS, NULL);	cx18_get_input(cx, cx->active_input, &vidin);	cx18_get_audio_input(cx, cx->audio_input, &audin);	CX18_INFO("Video Input: %s/n", vidin.name);	CX18_INFO("Audio Input: %s/n", audin.name);	mutex_lock(&cx->gpio_lock);	CX18_INFO("GPIO:  direction 0x%08x, value 0x%08x/n",		cx->gpio_dir, cx->gpio_val);	mutex_unlock(&cx->gpio_lock);	CX18_INFO("Tuner: %s/n",		test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ?  "Radio" : "TV");	cx2341x_log_status(&cx->params, cx->name);	CX18_INFO("Status flags: 0x%08lx/n", cx->i_flags);	for (i = 0; i < CX18_MAX_STREAMS; i++) {		struct cx18_stream *s = &cx->streams[i];		if (s->v4l2dev == NULL || s->buffers == 0)			continue;		CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use/n",			  s->name, s->s_flags,			  (s->buffers - atomic_read(&s->q_free.buffers))				* 100 / s->buffers,			  (s->buffers * s->buf_size) / 1024, s->buffers);	}	CX18_INFO("Read MPEG/VBI: %lld/%lld bytes/n",			(long long)cx->mpg_data_received,			(long long)cx->vbi_data_inserted);	cx18_log_statistics(cx);	CX18_INFO("==================  END STATUS CARD #%d  ==================/n", cx->num);	return 0;}

int cx18_stop_v4l2_encode_stream(struct cx18_stream *s, int gop_end){	struct cx18 *cx = s->cx;	unsigned long then;	if (!cx18_stream_enabled(s))		return -EINVAL;	/* This function assumes that you are allowed to stop the capture	   and that we are actually capturing */	CX18_DEBUG_INFO("Stop Capture/n");	if (atomic_read(&cx->tot_capturing) == 0)		return 0;	set_bit(CX18_F_S_STOPPING, &s->s_flags);	if (s->type == CX18_ENC_STREAM_TYPE_MPG)		cx18_vapi(cx, CX18_CPU_CAPTURE_STOP, 2, s->handle, !gop_end);	else		cx18_vapi(cx, CX18_CPU_CAPTURE_STOP, 1, s->handle);	then = jiffies;	if (s->type == CX18_ENC_STREAM_TYPE_MPG && gop_end) {		CX18_INFO("ignoring gop_end: not (yet?) supported by the firmware/n");	}	if (s->type != CX18_ENC_STREAM_TYPE_TS)		atomic_dec(&cx->ana_capturing);	atomic_dec(&cx->tot_capturing);	/* Clear capture and no-read bits */	clear_bit(CX18_F_S_STREAMING, &s->s_flags);	/* Tell the CX23418 it can't use our buffers anymore */	cx18_vapi(cx, CX18_CPU_DE_RELEASE_MDL, 1, s->handle);	cx18_vapi(cx, CX18_DESTROY_TASK, 1, s->handle);	s->handle = CX18_INVALID_TASK_HANDLE;	clear_bit(CX18_F_S_STOPPING, &s->s_flags);	if (atomic_read(&cx->tot_capturing) > 0)		return 0;	cx2341x_handler_set_busy(&cx->cxhdl, 0);	cx18_write_reg(cx, 5, CX18_DSP0_INTERRUPT_MASK);	wake_up(&s->waitq);	return 0;}

static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,			  const struct pci_device_id *pci_id){	u16 cmd;	unsigned char pci_latency;	CX18_DEBUG_INFO("Enabling pci device/n");	if (pci_enable_device(dev)) {		CX18_ERR("Can't enable device %d!/n", cx->num);		return -EIO;	}	if (pci_set_dma_mask(dev, 0xffffffff)) {		CX18_ERR("No suitable DMA available on card %d./n", cx->num);		return -EIO;	}	if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {		CX18_ERR("Cannot request encoder memory region on card %d./n", cx->num);		return -EIO;	}	/* Check for bus mastering */	pci_read_config_word(dev, PCI_COMMAND, &cmd);	cmd |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;	pci_write_config_word(dev, PCI_COMMAND, cmd);	pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);	pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);	if (pci_latency < 64 && cx18_pci_latency) {		CX18_INFO("Unreasonably low latency timer, "			       "setting to 64 (was %d)/n", pci_latency);		pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);		pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);	}	/* This config space value relates to DMA latencies. The	   default value 0x8080 is too low however and will lead	   to DMA errors. 0xffff is the max value which solves	   these problems. */	pci_write_config_dword(dev, 0x40, 0xffff);	CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "		   "irq: %d, latency: %d, memory: 0x%lx/n",		   cx->dev->device, cx->card_rev, dev->bus->number,		   PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),		   cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);	return 0;}

static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,			  const struct pci_device_id *pci_id){	u16 cmd;	unsigned char pci_latency;	CX18_DEBUG_INFO("Enabling pci device/n");	if (pci_enable_device(pci_dev)) {		CX18_ERR("Can't enable device %d!/n", cx->instance);		return -EIO;	}	if (pci_set_dma_mask(pci_dev, 0xffffffff)) {		CX18_ERR("No suitable DMA available, card %d/n", cx->instance);		return -EIO;	}	if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {		CX18_ERR("Cannot request encoder memory region, card %d/n",			 cx->instance);		return -EIO;	}	/* Enable bus mastering and memory mapped IO for the CX23418 */	pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);	cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;	pci_write_config_word(pci_dev, PCI_COMMAND, cmd);	cx->card_rev = pci_dev->revision;	pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);	if (pci_latency < 64 && cx18_pci_latency) {		CX18_INFO("Unreasonably low latency timer, "			       "setting to 64 (was %d)/n", pci_latency);		pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);		pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);	}	CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "		   "irq: %d, latency: %d, memory: 0x%lx/n",		   cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,		   PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),		   cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);	return 0;}

static int load_cpu_fw_direct(const char *fn, u8 __iomem *mem, struct cx18 *cx){	const struct firmware *fw = NULL;	int i, j;	unsigned size;	u32 __iomem *dst = (u32 __iomem *)mem;	const u32 *src;	if (request_firmware(&fw, fn, &cx->pci_dev->dev)) {		CX18_ERR("Unable to open firmware %s/n", fn);		CX18_ERR("Did you put the firmware in the hotplug firmware directory?/n");		return -ENOMEM;	}	src = (const u32 *)fw->data;	for (i = 0; i < fw->size; i += 4096) {		cx18_setup_page(cx, i);		for (j = i; j < fw->size && j < i + 4096; j += 4) {			/* no need for endianness conversion on the ppc */			cx18_raw_writel(cx, *src, dst);			if (cx18_raw_readl(cx, dst) != *src) {				CX18_ERR("Mismatch at offset %x/n", i);				release_firmware(fw);				cx18_setup_page(cx, 0);				return -EIO;			}			dst++;			src++;		}	}	if (!test_bit(CX18_F_I_LOADED_FW, &cx->i_flags))		CX18_INFO("loaded %s firmware (%zd bytes)/n", fn, fw->size);	size = fw->size;	release_firmware(fw);	cx18_setup_page(cx, SCB_OFFSET);	return size;}

static int __devinit cx18_probe(struct pci_dev *pci_dev,				const struct pci_device_id *pci_id){	int retval = 0;	int i;	u32 devtype;	struct cx18 *cx;	/* FIXME - module parameter arrays constrain max instances */	i = atomic_inc_return(&cx18_instance) - 1;	if (i >= CX18_MAX_CARDS) {		printk(KERN_ERR "cx18: cannot manage card %d, driver has a "		       "limit of 0 - %d/n", i, CX18_MAX_CARDS - 1);		return -ENOMEM;	}	cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);	if (cx == NULL) {		printk(KERN_ERR "cx18: cannot manage card %d, out of memory/n",		       i);		return -ENOMEM;	}	cx->pci_dev = pci_dev;	cx->instance = i;	retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);	if (retval) {		printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"		       "/n", cx->instance);		kfree(cx);		return retval;	}	snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",		 cx->instance);	CX18_INFO("Initializing card %d/n", cx->instance);	cx18_process_options(cx);	if (cx->options.cardtype == -1) {		retval = -ENODEV;		goto err;	}	retval = cx18_init_struct1(cx);	if (retval)		goto err;	CX18_DEBUG_INFO("base addr: 0x%08x/n", cx->base_addr);	/* PCI Device Setup */	retval = cx18_setup_pci(cx, pci_dev, pci_id);	if (retval != 0)		goto free_workqueues;	/* map io memory */	CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x/n",		   cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);	cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,				       CX18_MEM_SIZE);	if (!cx->enc_mem) {		CX18_ERR("ioremap failed. Can't get a window into CX23418 "			 "memory and register space/n");		CX18_ERR("Each capture card with a CX23418 needs 64 MB of "			 "vmalloc address space for the window/n");		CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'/n");		CX18_ERR("Use the vmalloc= kernel command line option to set "			 "VmallocTotal to a larger value/n");		retval = -ENOMEM;		goto free_mem;	}	cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;	devtype = cx18_read_reg(cx, 0xC72028);	switch (devtype & 0xff000000) {	case 0xff000000:		CX18_INFO("cx23418 revision %08x (A)/n", devtype);		break;	case 0x01000000:		CX18_INFO("cx23418 revision %08x (B)/n", devtype);		break;	default:		CX18_INFO("cx23418 revision %08x (Unknown)/n", devtype);		break;	}	cx18_init_power(cx, 1);	cx18_init_memory(cx);	cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);	cx18_init_scb(cx);	cx18_gpio_init(cx);	/* Initialize integrated A/V decoder early to set PLLs, just in case */	retval = cx18_av_probe(cx);	if (retval) {		CX18_ERR("Could not register A/V decoder subdevice/n");		goto free_map;	}	/* Initialize GPIO Reset Controller to do chip resets during i2c init */	if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {//.........这里部分代码省略.........

//.........这里部分代码省略.........			if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE)				cx->stream_buf_size[i] =						CX18_UNIT_ENC_IDX_BUFSIZE;		}		/*		 * YUV and IDX are special cases where the stream_buf_size is		 * now in bytes.		 * VBI is a special case where the stream_buf_size is fixed		 * and already in bytes		 */		if (i == CX18_ENC_STREAM_TYPE_VBI ||		    i == CX18_ENC_STREAM_TYPE_YUV ||		    i == CX18_ENC_STREAM_TYPE_IDX) {			if (cx->stream_buffers[i] < 0) {				cx->stream_buffers[i] =					cx->options.megabytes[i] * 1024 * 1024					/ cx->stream_buf_size[i];			} else {				/* N.B. This might round down to 0 */				cx->options.megabytes[i] =					cx->stream_buffers[i]					* cx->stream_buf_size[i]/(1024 * 1024);			}		} else {			/* All other streams have stream_buf_size in kB here */			if (cx->stream_buffers[i] < 0) {				cx->stream_buffers[i] =						cx->options.megabytes[i] * 1024						/ cx->stream_buf_size[i];			} else {				/* N.B. This might round down to 0 */				cx->options.megabytes[i] =						cx->stream_buffers[i]						* cx->stream_buf_size[i] / 1024;			}			/* convert from kB to bytes */			cx->stream_buf_size[i] *= 1024;		}		CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "				"%d bytes/n", i, cx->options.megabytes[i],				cx->stream_buffers[i], cx->stream_buf_size[i]);	}	cx->options.cardtype = cardtype[cx->instance];	cx->options.tuner = tuner[cx->instance];	cx->options.radio = radio[cx->instance];	cx->std = cx18_parse_std(cx);	if (cx->options.cardtype == -1) {		CX18_INFO("Ignore card/n");		return;	}	cx->card = cx18_get_card(cx->options.cardtype - 1);	if (cx->card)		CX18_INFO("User specified %s card/n", cx->card->name);	else if (cx->options.cardtype != 0)		CX18_ERR("Unknown user specified type, trying to autodetect card/n");	if (cx->card == NULL) {		if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {			cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);			CX18_INFO("Autodetected Hauppauge card/n");		}	}	if (cx->card == NULL) {		for (i = 0; (cx->card = cx18_get_card(i)); i++) {			if (cx->card->pci_list == NULL)				continue;			for (j = 0; cx->card->pci_list[j].device; j++) {				if (cx->pci_dev->device !=				    cx->card->pci_list[j].device)					continue;				if (cx->pci_dev->subsystem_vendor !=				    cx->card->pci_list[j].subsystem_vendor)					continue;				if (cx->pci_dev->subsystem_device !=				    cx->card->pci_list[j].subsystem_device)					continue;				CX18_INFO("Autodetected %s card/n", cx->card->name);				goto done;			}		}	}done:	if (cx->card == NULL) {		cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);		CX18_ERR("Unknown card: vendor/device: [%04x:%04x]/n",			 cx->pci_dev->vendor, cx->pci_dev->device);		CX18_ERR("              subsystem vendor/device: [%04x:%04x]/n",			 cx->pci_dev->subsystem_vendor,			 cx->pci_dev->subsystem_device);		CX18_ERR("Defaulting to %s card/n", cx->card->name);		CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of/n");		CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)/n");		CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD]./n");	}	cx->v4l2_cap = cx->card->v4l2_capabilities;	cx->card_name = cx->card->name;	cx->card_i2c = cx->card->i2c;}

static void cx18_process_eeprom(struct cx18 *cx){	struct tveeprom tv;	cx18_read_eeprom(cx, &tv);	/* Many thanks to Steven Toth from Hauppauge for providing the	   model numbers */	/* Note: the Samsung memory models cannot be reliably determined	   from the model number. Use the cardtype module option if you	   have one of these preproduction models. */	switch (tv.model) {	case 74301: /* Retail models */	case 74321:	case 74351: /* OEM models */	case 74361:		/* Digital side is s5h1411/tda18271 */		cx->card = cx18_get_card(CX18_CARD_HVR_1600_S5H1411);		break;	case 74021: /* Retail models */	case 74031:	case 74041:	case 74141:	case 74541: /* OEM models */	case 74551:	case 74591:	case 74651:	case 74691:	case 74751:	case 74891:		/* Digital side is s5h1409/mxl5005s */		cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);		break;	case 0x718:		return;	case 0xffffffff:		CX18_INFO("Unknown EEPROM encoding/n");		return;	case 0:		CX18_ERR("Invalid EEPROM/n");		return;	default:		CX18_ERR("Unknown model %d, defaulting to original HVR-1600 "			 "(cardtype=1)/n", tv.model);		cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);		break;	}	cx->v4l2_cap = cx->card->v4l2_capabilities;	cx->card_name = cx->card->name;	cx->card_i2c = cx->card->i2c;	CX18_INFO("Autodetected %s/n", cx->card_name);	if (tv.tuner_type == TUNER_ABSENT)		CX18_ERR("tveeprom cannot autodetect tuner!/n");	if (cx->options.tuner == -1)		cx->options.tuner = tv.tuner_type;	if (cx->options.radio == -1)		cx->options.radio = (tv.has_radio != 0);	if (cx->std != 0)		/* user specified tuner standard */		return;	/* autodetect tuner standard */#define TVEEPROM_TUNER_FORMAT_ALL (V4L2_STD_B  | V4L2_STD_GH | /				   V4L2_STD_MN | /				   V4L2_STD_PAL_I | /				   V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC | /				   V4L2_STD_DK)	if ((tv.tuner_formats & TVEEPROM_TUNER_FORMAT_ALL)					== TVEEPROM_TUNER_FORMAT_ALL) {		CX18_DEBUG_INFO("Worldwide tuner detected/n");		cx->std = V4L2_STD_ALL;	} else if (tv.tuner_formats & V4L2_STD_PAL) {		CX18_DEBUG_INFO("PAL tuner detected/n");		cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;	} else if (tv.tuner_formats & V4L2_STD_NTSC) {		CX18_DEBUG_INFO("NTSC tuner detected/n");		cx->std |= V4L2_STD_NTSC_M;	} else if (tv.tuner_formats & V4L2_STD_SECAM) {		CX18_DEBUG_INFO("SECAM tuner detected/n");		cx->std |= V4L2_STD_SECAM_L;	} else {		CX18_INFO("No tuner detected, default to NTSC-M/n");		cx->std |= V4L2_STD_NTSC_M;	}}

static int load_apu_fw_direct(const char *fn, u8 __iomem *dst, struct cx18 *cx,				u32 *entry_addr){	const struct firmware *fw = NULL;	int i, j;	unsigned size;	const u32 *src;	struct cx18_apu_rom_seghdr seghdr;	const u8 *vers;	u32 offset = 0;	u32 apu_version = 0;	int sz;	if (request_firmware(&fw, fn, &cx->pci_dev->dev)) {		CX18_ERR("unable to open firmware %s/n", fn);		CX18_ERR("did you put the firmware in the hotplug firmware directory?/n");		cx18_setup_page(cx, 0);		return -ENOMEM;	}	*entry_addr = 0;	src = (const u32 *)fw->data;	vers = fw->data + sizeof(seghdr);	sz = fw->size;	apu_version = (vers[0] << 24) | (vers[4] << 16) | vers[32];	while (offset + sizeof(seghdr) < fw->size) {		/* TODO: byteswapping */		memcpy(&seghdr, src + offset / 4, sizeof(seghdr));		offset += sizeof(seghdr);		if (seghdr.sync1 != APU_ROM_SYNC1 ||		    seghdr.sync2 != APU_ROM_SYNC2) {			offset += seghdr.size;			continue;		}		CX18_DEBUG_INFO("load segment %x-%x/n", seghdr.addr,				seghdr.addr + seghdr.size - 1);		if (*entry_addr == 0)			*entry_addr = seghdr.addr;		if (offset + seghdr.size > sz)			break;		for (i = 0; i < seghdr.size; i += 4096) {			cx18_setup_page(cx, seghdr.addr + i);			for (j = i; j < seghdr.size && j < i + 4096; j += 4) {				/* no need for endianness conversion on the ppc */				cx18_raw_writel(cx, src[(offset + j) / 4],						dst + seghdr.addr + j);				if (cx18_raw_readl(cx, dst + seghdr.addr + j)				    != src[(offset + j) / 4]) {					CX18_ERR("Mismatch at offset %x/n",						 offset + j);					release_firmware(fw);					cx18_setup_page(cx, 0);					return -EIO;				}			}		}		offset += seghdr.size;	}	if (!test_bit(CX18_F_I_LOADED_FW, &cx->i_flags))		CX18_INFO("loaded %s firmware V%08x (%zd bytes)/n",				fn, apu_version, fw->size);	size = fw->size;	release_firmware(fw);	cx18_setup_page(cx, 0);	return size;}

int cx18_av_loadfw(struct cx18 *cx){	const struct firmware *fw = NULL;	u32 size;	u32 v;	u8 *ptr;	int i;	if (request_firmware(&fw, FWFILE, &cx->dev->dev) != 0) {		CX18_ERR("unable to open firmware %s/n", FWFILE);		return -EINVAL;	}	cx18_av_write4(cx, CXADEC_CHIP_CTRL, 0x00010000);	cx18_av_write(cx, CXADEC_STD_DET_CTL, 0xf6); /* Byte 0 */	/* Reset the Mako core (Register is undocumented.) */	cx18_av_write4(cx, 0x8100, 0x00010000);	/* Put the 8051 in reset and enable firmware upload */	cx18_av_write4(cx, CXADEC_DL_CTL, 0x0F000000);	ptr = fw->data;	size = fw->size;	for (i = 0; i < size; i++) {		u32 dl_control = 0x0F000000 | ((u32)ptr[i] << 16);		u32 value = 0;		int retries;		for (retries = 0; retries < 5; retries++) {			cx18_av_write4(cx, CXADEC_DL_CTL, dl_control);			value = cx18_av_read4(cx, CXADEC_DL_CTL);			if ((value & 0x3F00) == (dl_control & 0x3F00))				break;		}		if (retries >= 5) {			CX18_ERR("unable to load firmware %s/n", FWFILE);			release_firmware(fw);			return -EIO;		}	}	cx18_av_write4(cx, CXADEC_DL_CTL, 0x13000000 | fw->size);	/* Output to the 416 */	cx18_av_and_or4(cx, CXADEC_PIN_CTRL1, ~0, 0x78000);	/* Audio input control 1 set to Sony mode */	/* Audio output input 2 is 0 for slave operation input */	/* 0xC4000914[5]: 0 = left sample on WS=0, 1 = left sample on WS=1 */	/* 0xC4000914[7]: 0 = Philips mode, 1 = Sony mode (1st SCK rising edge	   after WS transition for first bit of audio word. */	cx18_av_write4(cx, CXADEC_I2S_IN_CTL, 0x000000A0);	/* Audio output control 1 is set to Sony mode */	/* Audio output control 2 is set to 1 for master mode */	/* 0xC4000918[5]: 0 = left sample on WS=0, 1 = left sample on WS=1 */	/* 0xC4000918[7]: 0 = Philips mode, 1 = Sony mode (1st SCK rising edge	   after WS transition for first bit of audio word. */	/* 0xC4000918[8]: 0 = slave operation, 1 = master (SCK_OUT and WS_OUT	   are generated) */	cx18_av_write4(cx, CXADEC_I2S_OUT_CTL, 0x000001A0);	/* set alt I2s master clock to /16 and enable alt divider i2s	   passthrough */	cx18_av_write4(cx, CXADEC_PIN_CFG3, 0x5000B687);	cx18_av_write4(cx, CXADEC_STD_DET_CTL, 0x000000F6);	/* CxDevWrReg(CXADEC_STD_DET_CTL, 0x000000FF); */	/* Set bit 0 in register 0x9CC to signify that this is MiniMe. */	/* Register 0x09CC is defined by the Merlin firmware, and doesn't	   have a name in the spec. */	cx18_av_write4(cx, 0x09CC, 1);#define CX18_AUDIO_ENABLE            	0xc72014	v = read_reg(CX18_AUDIO_ENABLE);	/* If bit 11 is 1 */	if (v & 0x800)		write_reg(v & 0xFFFFFBFF, CX18_AUDIO_ENABLE); /* Clear bit 10 */	/* Enable WW auto audio standard detection */	v = cx18_av_read4(cx, CXADEC_STD_DET_CTL);	v |= 0xFF;   /* Auto by default */	v |= 0x400;  /* Stereo by default */	v |= 0x14000000;	cx18_av_write4(cx, CXADEC_STD_DET_CTL, v);	release_firmware(fw);	CX18_INFO("loaded %s firmware (%d bytes)/n", FWFILE, size);	return 0;}

int cx18_stop_v4l2_encode_stream(struct cx18_stream *s, int gop_end){	struct cx18 *cx = s->cx;	unsigned long then;	if (!cx18_stream_enabled(s))		return -EINVAL;	/* This function assumes that you are allowed to stop the capture	   and that we are actually capturing */	CX18_DEBUG_INFO("Stop Capture/n");	if (atomic_read(&cx->tot_capturing) == 0)		return 0;	set_bit(CX18_F_S_STOPPING, &s->s_flags);	if (s->type == CX18_ENC_STREAM_TYPE_MPG)		cx18_vapi(cx, CX18_CPU_CAPTURE_STOP, 2, s->handle, !gop_end);	else		cx18_vapi(cx, CX18_CPU_CAPTURE_STOP, 1, s->handle);	then = jiffies;	if (s->type == CX18_ENC_STREAM_TYPE_MPG && gop_end) {#if 0		/* only run these if we're shutting down the last cap */		DECLARE_WAITQUEUE(wait, current);		unsigned long duration;		then = jiffies;		add_wait_queue(&cx->cap_w, &wait);		set_current_state(TASK_INTERRUPTIBLE);		/* TODO: wait 2s for EOS interrupt */		while (!test_bit(CX18_F_I_EOS, &cx->i_flags) &&		       time_before(jiffies, then + msecs_to_jiffies(2000)))			schedule_timeout(msecs_to_jiffies(10));		duration = jiffies_to_msecs(jiffies - then);		if (!test_bit(CX18_F_I_EOS, &cx->i_flags)) {			CX18_DEBUG_WARN("%s: EOS interrupt not received! stopping anyway./n", s->name);			CX18_DEBUG_WARN("%s: waited %lu ms./n", s->name, duration);		} else {			CX18_DEBUG_INFO("%s: EOS took %lu ms to occur./n", s->name, duration);		}		set_current_state(TASK_RUNNING);		remove_wait_queue(&cx->cap_w, &wait);#else		CX18_INFO("ignoring gop_end: not (yet?) supported by the firmware/n");#endif	}	if (s->type != CX18_ENC_STREAM_TYPE_TS)		atomic_dec(&cx->ana_capturing);	atomic_dec(&cx->tot_capturing);	/* Clear capture and no-read bits */	clear_bit(CX18_F_S_STREAMING, &s->s_flags);	/* Tell the CX23418 it can't use our buffers anymore */	cx18_vapi(cx, CX18_CPU_DE_RELEASE_MDL, 1, s->handle);	cx18_vapi(cx, CX18_DESTROY_TASK, 1, s->handle);	s->handle = CX18_INVALID_TASK_HANDLE;	clear_bit(CX18_F_S_STOPPING, &s->s_flags);	if (atomic_read(&cx->tot_capturing) > 0)		return 0;	cx18_write_reg(cx, 5, CX18_DSP0_INTERRUPT_MASK);	wake_up(&s->waitq);	return 0;}

static int cx18_prep_dev(struct cx18 *cx, int type){	struct cx18_stream *s = &cx->streams[type];	u32 cap = cx->v4l2_cap;	int num_offset = cx18_stream_info[type].num_offset;	int num = cx->instance + cx18_first_minor + num_offset;	/*	 * These five fields are always initialized.	 * For analog capture related streams, if video_dev == NULL then the	 * stream is not in use.	 * For the TS stream, if dvb == NULL then the stream is not in use.	 * In those cases no other fields but these four can be used.	 */	s->video_dev = NULL;	s->dvb = NULL;	s->cx = cx;	s->type = type;	s->name = cx18_stream_info[type].name;	/* Check whether the radio is supported */	if (type == CX18_ENC_STREAM_TYPE_RAD && !(cap & V4L2_CAP_RADIO))		return 0;	/* Check whether VBI is supported */	if (type == CX18_ENC_STREAM_TYPE_VBI &&	    !(cap & (V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE)))		return 0;	/* User explicitly selected 0 buffers for these streams, so don't	   create them. */	if (cx18_stream_info[type].dma != PCI_DMA_NONE &&	    cx->stream_buffers[type] == 0) {		CX18_INFO("Disabled %s device/n", cx18_stream_info[type].name);		return 0;	}	cx18_stream_init(cx, type);	/* Allocate the cx18_dvb struct only for the TS on cards with DTV */	if (type == CX18_ENC_STREAM_TYPE_TS) {		if (cx->card->hw_all & CX18_HW_DVB) {			s->dvb = kzalloc(sizeof(struct cx18_dvb), GFP_KERNEL);			if (s->dvb == NULL) {				CX18_ERR("Couldn't allocate cx18_dvb structure"					 " for %s/n", s->name);				return -ENOMEM;			}		} else {			/* Don't need buffers for the TS, if there is no DVB */			s->buffers = 0;		}	}	if (num_offset == -1)		return 0;	/* allocate and initialize the v4l2 video device structure */	s->video_dev = video_device_alloc();	if (s->video_dev == NULL) {		CX18_ERR("Couldn't allocate v4l2 video_device for %s/n",				s->name);		return -ENOMEM;	}	snprintf(s->video_dev->name, sizeof(s->video_dev->name), "%s %s",		 cx->v4l2_dev.name, s->name);	s->video_dev->num = num;	s->video_dev->v4l2_dev = &cx->v4l2_dev;	s->video_dev->fops = &cx18_v4l2_enc_fops;	s->video_dev->release = video_device_release;	s->video_dev->tvnorms = V4L2_STD_ALL;	s->video_dev->lock = &cx->serialize_lock;	set_bit(V4L2_FL_USE_FH_PRIO, &s->video_dev->flags);	cx18_set_funcs(s->video_dev);	return 0;}

static int cx18_prep_dev(struct cx18 *cx, int type){	struct cx18_stream *s = &cx->streams[type];	u32 cap = cx->v4l2_cap;	int num_offset = cx18_stream_info[type].num_offset;	int num = cx->instance + cx18_first_minor + num_offset;	s->video_dev = NULL;	s->dvb = NULL;	s->cx = cx;	s->type = type;	s->name = cx18_stream_info[type].name;		if (type == CX18_ENC_STREAM_TYPE_RAD && !(cap & V4L2_CAP_RADIO))		return 0;		if (type == CX18_ENC_STREAM_TYPE_VBI &&	    !(cap & (V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE)))		return 0;	if (cx18_stream_info[type].dma != PCI_DMA_NONE &&	    cx->stream_buffers[type] == 0) {		CX18_INFO("Disabled %s device/n", cx18_stream_info[type].name);		return 0;	}	cx18_stream_init(cx, type);		if (type == CX18_ENC_STREAM_TYPE_TS) {		if (cx->card->hw_all & CX18_HW_DVB) {			s->dvb = kzalloc(sizeof(struct cx18_dvb), GFP_KERNEL);			if (s->dvb == NULL) {				CX18_ERR("Couldn't allocate cx18_dvb structure"					 " for %s/n", s->name);				return -ENOMEM;			}		} else {						s->buffers = 0;		}	}	if (num_offset == -1)		return 0;		s->video_dev = video_device_alloc();	if (s->video_dev == NULL) {		CX18_ERR("Couldn't allocate v4l2 video_device for %s/n",				s->name);		return -ENOMEM;	}	snprintf(s->video_dev->name, sizeof(s->video_dev->name), "%s %s",		 cx->v4l2_dev.name, s->name);	s->video_dev->num = num;	s->video_dev->v4l2_dev = &cx->v4l2_dev;	s->video_dev->fops = &cx18_v4l2_enc_fops;	s->video_dev->release = video_device_release;	s->video_dev->tvnorms = V4L2_STD_ALL;	set_bit(V4L2_FL_USE_FH_PRIO, &s->video_dev->flags);	cx18_set_funcs(s->video_dev);	return 0;}

static void cx18_process_options(struct cx18 *cx){	int i, j;	cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;	cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;	cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;	cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;	cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;	cx->options.cardtype = cardtype[cx->num];	cx->options.tuner = tuner[cx->num];	cx->options.radio = radio[cx->num];	cx->std = cx18_parse_std(cx);	if (cx->options.cardtype == -1) {		CX18_INFO("Ignore card/n");		return;	}	cx->card = cx18_get_card(cx->options.cardtype - 1);	if (cx->card)		CX18_INFO("User specified %s card/n", cx->card->name);	else if (cx->options.cardtype != 0)		CX18_ERR("Unknown user specified type, trying to autodetect card/n");	if (cx->card == NULL) {		if (cx->dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {			cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);			CX18_INFO("Autodetected Hauppauge card/n");		}	}	if (cx->card == NULL) {		for (i = 0; (cx->card = cx18_get_card(i)); i++) {			if (cx->card->pci_list == NULL)				continue;			for (j = 0; cx->card->pci_list[j].device; j++) {				if (cx->dev->device !=				    cx->card->pci_list[j].device)					continue;				if (cx->dev->subsystem_vendor !=				    cx->card->pci_list[j].subsystem_vendor)					continue;				if (cx->dev->subsystem_device !=				    cx->card->pci_list[j].subsystem_device)					continue;				CX18_INFO("Autodetected %s card/n", cx->card->name);				goto done;			}		}	}done:	if (cx->card == NULL) {		cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);		CX18_ERR("Unknown card: vendor/device: %04x/%04x/n",		     cx->dev->vendor, cx->dev->device);		CX18_ERR("              subsystem vendor/device: %04x/%04x/n",		     cx->dev->subsystem_vendor, cx->dev->subsystem_device);		CX18_ERR("Defaulting to %s card/n", cx->card->name);		CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of/n");		CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)/n");		CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD]./n");	}	cx->v4l2_cap = cx->card->v4l2_capabilities;	cx->card_name = cx->card->name;	cx->card_i2c = cx->card->i2c;}

static int load_apu_fw_direct(const char *fn, u8 __iomem *dst, struct cx18 *cx, long size){    const struct firmware *fw = NULL;    int retries = 3;    int i, j;    const u32 *src;    struct cx18_apu_rom_seghdr seghdr;    const u8 *vers;    u32 offset = 0;    u32 apu_version = 0;    int sz;retry:    if (!retries || request_firmware(&fw, fn, &cx->dev->dev)) {        CX18_ERR("unable to open firmware %s (must be %ld bytes)/n",                fn, size);        CX18_ERR("did you put the firmware in the hotplug firmware directory?/n");        return -ENOMEM;    }    src = (const u32 *)fw->data;    vers = fw->data + sizeof(seghdr);    sz = fw->size;    if (fw->size != size) {        /* Due to race conditions in firmware loading (esp. with           udev <0.95) the wrong file was sometimes loaded. So we check           filesizes to see if at least the right-sized file was           loaded. If not, then we retry. */        CX18_INFO("retry: file loaded was not %s (expected size %ld, got %zd)/n",                   fn, size, fw->size);        release_firmware(fw);        retries--;        goto retry;    }    apu_version = (vers[0] << 24) | (vers[4] << 16) | vers[32];    while (offset + sizeof(seghdr) < size) {        /* TODO: byteswapping */        memcpy(&seghdr, src + offset / 4, sizeof(seghdr));        offset += sizeof(seghdr);        if (seghdr.sync1 != APU_ROM_SYNC1 ||            seghdr.sync2 != APU_ROM_SYNC2) {            offset += seghdr.size;            continue;        }        CX18_DEBUG_INFO("load segment %x-%x/n", seghdr.addr,                seghdr.addr + seghdr.size - 1);        if (offset + seghdr.size > sz)            break;        for (i = 0; i < seghdr.size; i += 4096) {            setup_page(offset + i);            for (j = i; j < seghdr.size && j < i + 4096; j += 4) {                /* no need for endianness conversion on the ppc */                __raw_writel(src[(offset + j) / 4], dst + seghdr.addr + j);                if (__raw_readl(dst + seghdr.addr + j) != src[(offset + j) / 4]) {                    CX18_ERR("Mismatch at offset %x/n", offset + j);                    release_firmware(fw);                    return -EIO;                }            }        }        offset += seghdr.size;    }    if (!test_bit(CX18_F_I_LOADED_FW, &cx->i_flags))        CX18_INFO("loaded %s firmware V%08x (%zd bytes)/n",                fn, apu_version, fw->size);    release_firmware(fw);    /* Clear bit0 for APU to start from 0 */    write_reg(read_reg(0xc72030) & ~1, 0xc72030);    return size;}

static int __devinit cx18_probe(struct pci_dev *dev,				const struct pci_device_id *pci_id){	int retval = 0;	int vbi_buf_size;	u32 devtype;	struct cx18 *cx;	spin_lock(&cx18_cards_lock);	/* Make sure we've got a place for this card */	if (cx18_cards_active == CX18_MAX_CARDS) {		printk(KERN_ERR "cx18:  Maximum number of cards detected (%d)./n",			      cx18_cards_active);		spin_unlock(&cx18_cards_lock);		return -ENOMEM;	}	cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);	if (!cx) {		spin_unlock(&cx18_cards_lock);		return -ENOMEM;	}	cx18_cards[cx18_cards_active] = cx;	cx->dev = dev;	cx->num = cx18_cards_active++;	snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);	CX18_INFO("Initializing card #%d/n", cx->num);	spin_unlock(&cx18_cards_lock);	cx18_process_options(cx);	if (cx->options.cardtype == -1) {		retval = -ENODEV;		goto err;	}	if (cx18_init_struct1(cx)) {		retval = -ENOMEM;		goto err;	}	CX18_DEBUG_INFO("base addr: 0x%08x/n", cx->base_addr);	/* PCI Device Setup */	retval = cx18_setup_pci(cx, dev, pci_id);	if (retval != 0) {		if (retval == -EIO)			goto free_workqueue;		else if (retval == -ENXIO)			goto free_mem;	}	/* save cx in the pci struct for later use */	pci_set_drvdata(dev, cx);	/* map io memory */	CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x/n",		   cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);	cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,				       CX18_MEM_SIZE);	if (!cx->enc_mem) {		CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h/n");		CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help/n");		retval = -ENOMEM;		goto free_mem;	}	cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;	devtype = read_reg(0xC72028);	switch (devtype & 0xff000000) {	case 0xff000000:		CX18_INFO("cx23418 revision %08x (A)/n", devtype);		break;	case 0x01000000:		CX18_INFO("cx23418 revision %08x (B)/n", devtype);		break;	default:		CX18_INFO("cx23418 revision %08x (Unknown)/n", devtype);		break;	}	cx18_init_power(cx, 1);	cx18_init_memory(cx);	cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);	cx18_init_scb(cx);	cx18_gpio_init(cx);	/* active i2c  */	CX18_DEBUG_INFO("activating i2c.../n");	if (init_cx18_i2c(cx)) {		CX18_ERR("Could not initialize i2c/n");		goto free_map;	}	CX18_DEBUG_INFO("Active card count: %d./n", cx18_cards_active);	if (cx->card->hw_all & CX18_HW_TVEEPROM) {		/* Based on the model number the cardtype may be changed.		   The PCI IDs are not always reliable. */		cx18_process_eeprom(cx);//.........这里部分代码省略.........

static int cx18_reg_dev(struct cx18 *cx, int type){	struct cx18_stream *s = &cx->streams[type];	int vfl_type = cx18_stream_info[type].vfl_type;	int num, ret;	/* TODO: Shouldn't this be a VFL_TYPE_TRANSPORT or something?	 * We need a VFL_TYPE_TS defined.	 */	if (strcmp("TS", s->name) == 0) {		/* just return if no DVB is supported */		if ((cx->card->hw_all & CX18_HW_DVB) == 0)			return 0;		ret = cx18_dvb_register(s);		if (ret < 0) {			CX18_ERR("DVB failed to register/n");			return ret;		}	}	if (s->video_dev == NULL)		return 0;	num = s->video_dev->num;	/* card number + user defined offset + device offset */	if (type != CX18_ENC_STREAM_TYPE_MPG) {		struct cx18_stream *s_mpg = &cx->streams[CX18_ENC_STREAM_TYPE_MPG];		if (s_mpg->video_dev)			num = s_mpg->video_dev->num			    + cx18_stream_info[type].num_offset;	}	video_set_drvdata(s->video_dev, s);	/* Register device. First try the desired minor, then any free one. */	ret = video_register_device_no_warn(s->video_dev, vfl_type, num);	if (ret < 0) {		CX18_ERR("Couldn't register v4l2 device for %s (device node number %d)/n",			s->name, num);		video_device_release(s->video_dev);		s->video_dev = NULL;		return ret;	}	num = s->video_dev->num;	switch (vfl_type) {	case VFL_TYPE_GRABBER:		CX18_INFO("Registered device video%d for %s "			  "(%d x %d.%02d kB)/n",			  num, s->name, cx->stream_buffers[type],			  cx->stream_buf_size[type] / 1024,			  (cx->stream_buf_size[type] * 100 / 1024) % 100);		break;	case VFL_TYPE_RADIO:		CX18_INFO("Registered device radio%d for %s/n",			num, s->name);		break;	case VFL_TYPE_VBI:		if (cx->stream_buffers[type])			CX18_INFO("Registered device vbi%d for %s "				  "(%d x %d bytes)/n",				  num, s->name, cx->stream_buffers[type],				  cx->stream_buf_size[type]);		else			CX18_INFO("Registered device vbi%d for %s/n",				num, s->name);		break;	}	return 0;}

static int cx18_reg_dev(struct cx18 *cx, int type){	struct cx18_stream *s = &cx->streams[type];	int vfl_type = cx18_stream_info[type].vfl_type;	const char *name;	int num, ret;	if (type == CX18_ENC_STREAM_TYPE_TS && s->dvb != NULL) {		ret = cx18_dvb_register(s);		if (ret < 0) {			CX18_ERR("DVB failed to register/n");			return ret;		}	}	if (s->video_dev == NULL)		return 0;	num = s->video_dev->num;	/* card number + user defined offset + device offset */	if (type != CX18_ENC_STREAM_TYPE_MPG) {		struct cx18_stream *s_mpg = &cx->streams[CX18_ENC_STREAM_TYPE_MPG];		if (s_mpg->video_dev)			num = s_mpg->video_dev->num			    + cx18_stream_info[type].num_offset;	}	video_set_drvdata(s->video_dev, s);	/* Register device. First try the desired minor, then any free one. */	ret = video_register_device_no_warn(s->video_dev, vfl_type, num);	if (ret < 0) {		CX18_ERR("Couldn't register v4l2 device for %s (device node number %d)/n",			s->name, num);		video_device_release(s->video_dev);		s->video_dev = NULL;		return ret;	}	name = video_device_node_name(s->video_dev);	switch (vfl_type) {	case VFL_TYPE_GRABBER:		CX18_INFO("Registered device %s for %s (%d x %d.%02d kB)/n",			  name, s->name, cx->stream_buffers[type],			  cx->stream_buf_size[type] / 1024,			  (cx->stream_buf_size[type] * 100 / 1024) % 100);		break;	case VFL_TYPE_RADIO:		CX18_INFO("Registered device %s for %s/n", name, s->name);		break;	case VFL_TYPE_VBI:		if (cx->stream_buffers[type])			CX18_INFO("Registered device %s for %s "				  "(%d x %d bytes)/n",				  name, s->name, cx->stream_buffers[type],				  cx->stream_buf_size[type]);		else			CX18_INFO("Registered device %s for %s/n",				name, s->name);		break;	}	return 0;}

int cx18_dvb_register(struct cx18_stream *stream){	struct cx18 *cx = stream->cx;	struct cx18_dvb *dvb = stream->dvb;	struct dvb_adapter *dvb_adapter;	struct dvb_demux *dvbdemux;	struct dmx_demux *dmx;	int ret;	if (!dvb)		return -EINVAL;	dvb->enabled = 0;	dvb->stream = stream;	ret = dvb_register_adapter(&dvb->dvb_adapter,			CX18_DRIVER_NAME,			THIS_MODULE, &cx->pci_dev->dev, adapter_nr);	if (ret < 0)		goto err_out;	dvb_adapter = &dvb->dvb_adapter;	dvbdemux = &dvb->demux;	dvbdemux->priv = (void *)stream;	dvbdemux->filternum = 256;	dvbdemux->feednum = 256;	dvbdemux->start_feed = cx18_dvb_start_feed;	dvbdemux->stop_feed = cx18_dvb_stop_feed;	dvbdemux->dmx.capabilities = (DMX_TS_FILTERING |		DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING);	ret = dvb_dmx_init(dvbdemux);	if (ret < 0)		goto err_dvb_unregister_adapter;	dmx = &dvbdemux->dmx;	dvb->hw_frontend.source = DMX_FRONTEND_0;	dvb->mem_frontend.source = DMX_MEMORY_FE;	dvb->dmxdev.filternum = 256;	dvb->dmxdev.demux = dmx;	ret = dvb_dmxdev_init(&dvb->dmxdev, dvb_adapter);	if (ret < 0)		goto err_dvb_dmx_release;	ret = dmx->add_frontend(dmx, &dvb->hw_frontend);	if (ret < 0)		goto err_dvb_dmxdev_release;	ret = dmx->add_frontend(dmx, &dvb->mem_frontend);	if (ret < 0)		goto err_remove_hw_frontend;	ret = dmx->connect_frontend(dmx, &dvb->hw_frontend);	if (ret < 0)		goto err_remove_mem_frontend;	ret = dvb_register(stream);	if (ret < 0)		goto err_disconnect_frontend;	dvb_net_init(dvb_adapter, &dvb->dvbnet, dmx);	CX18_INFO("DVB Frontend registered/n");	CX18_INFO("Registered DVB adapter%d for %s (%d x %d.%02d kB)/n",		  stream->dvb->dvb_adapter.num, stream->name,		  stream->buffers, stream->buf_size/1024,		  (stream->buf_size * 100 / 1024) % 100);	mutex_init(&dvb->feedlock);	dvb->enabled = 1;	return ret;err_disconnect_frontend:	dmx->disconnect_frontend(dmx);err_remove_mem_frontend:	dmx->remove_frontend(dmx, &dvb->mem_frontend);err_remove_hw_frontend:	dmx->remove_frontend(dmx, &dvb->hw_frontend);err_dvb_dmxdev_release:	dvb_dmxdev_release(&dvb->dmxdev);err_dvb_dmx_release:	dvb_dmx_release(dvbdemux);err_dvb_unregister_adapter:	dvb_unregister_adapter(dvb_adapter);err_out:	return ret;}