- fix the not-checked-return value at start_feed() bug

 - code review + simplification
 - use const pointers in section and ts callbacks

1 files changed, 112 insertions, 127 deletions

diff --git a/linux/drivers/media/dvb/av7110/av7110.c b/linux/drivers/media/dvb/av7110/av7110.c
index 6fcc7fec7..8acea0af7 100644
--- a/linux/drivers/media/dvb/av7110/av7110.c
+++ b/linux/drivers/media/dvb/av7110/av7110.c
@@ -2979,46 +2979,43 @@ StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
 
 
 static int 
-dvb_write_to_decoder(struct dvb_demux_feed *dvbdmxfeed, u8 *buf, size_t count)
+av7110_write_to_decoder(struct dvb_demux_feed *feed, const u8 *buf, size_t len)
 {
-        struct dvb_demux *dvbdmx=dvbdmxfeed->demux;
-        av7110_t *av7110=(av7110_t *) dvbdmx->priv;
-        ipack *ipack=&av7110->ipack[dvbdmxfeed->pes_type];
+        struct dvb_demux *demux = feed->demux;
+        av7110_t *av7110 = (av7110_t *) demux->priv;
+        ipack *ipack = &av7110->ipack[feed->pes_type];
 
-        switch (dvbdmxfeed->pes_type) {
+        switch (feed->pes_type) {
         case 0:
-                if (av7110->audiostate.stream_source==AUDIO_SOURCE_MEMORY) {
+                if (av7110->audiostate.stream_source==AUDIO_SOURCE_MEMORY)
                         return -EINVAL;
-                }
                 break;
         case 1:
-                if (av7110->videostate.stream_source==VIDEO_SOURCE_MEMORY) {
+                if (av7110->videostate.stream_source==VIDEO_SOURCE_MEMORY)
                         return -EINVAL;
-                }
                 break;
         default:
                 return -1;
         }
 
-        if (!(buf[3]&0x10)) { // no payload?
+        if (!(buf[3] & 0x10)) { // no payload?
                 return -1;
         }
-        if (buf[1]&0x40)
+        if (buf[1] & 0x40)
                 dvb_filter_ipack_flush(ipack);
 
-        if (buf[3]&0x20) {  // adaptation field?
-                count-=buf[4]+1;
-                buf+=buf[4]+1;
-                if (!count) {
+        if (buf[3] & 0x20) {  // adaptation field?
+                len -= buf[4]+1;
+                buf += buf[4]+1;
+                if (!len)
                         return 0;
-                }
         }
         
-        dvb_filter_instant_repack(buf+4, count-4,
-				  &av7110->ipack[dvbdmxfeed->pes_type]);
+        dvb_filter_instant_repack(buf+4, len-4, &av7110->ipack[feed->pes_type]);
         return 0;
 }
 
+
 static void
 dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
 {
@@ -3093,102 +3090,103 @@ dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
 }
 
 static int 
-dvb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
+av7110_start_feed(struct dvb_demux_feed *feed)
 {
-        struct dvb_demux *dvbdmx=dvbdmxfeed->demux;
-        av7110_t *av7110=(av7110_t *) dvbdmx->priv;
+        struct dvb_demux *demux = feed->demux;
+        av7110_t *av7110 = (av7110_t *) demux->priv;
 
-        if (!dvbdmx->dmx.frontend)
+        if (!demux->dmx.frontend)
                 return -EINVAL;
 
-        if (av7110->card_type->type>=DVB_CARD_TT_BUDGET)
+        if (av7110->card_type->type >= DVB_CARD_TT_BUDGET)
                 return TTBStart(av7110); 
 
-        if (dvbdmxfeed->pid>0x1fff) 
-                return -1;
-
-        if (dvbdmxfeed->type == DMX_TYPE_TS) {
-	        if ((dvbdmxfeed->ts_type & TS_DECODER) 
-		    && (dvbdmxfeed->pes_type<DMX_TS_PES_OTHER)) {
+        if (feed->pid > 0x1fff) 
+                return -EINVAL;
 
-		        switch (dvbdmx->dmx.frontend->source) {
+        if (feed->type == DMX_TYPE_TS) {
+	        if ((feed->ts_type & TS_DECODER) &&
+		    (feed->pes_type < DMX_TS_PES_OTHER)) {
+		        switch (demux->dmx.frontend->source) {
 			case DMX_MEMORY_FE: 
-			        if (dvbdmxfeed->ts_type & TS_DECODER)
-				       if (dvbdmxfeed->pes_type<2 && 
-                                           !(dvbdmx->pids[0]&0x8000) &&
-					   !(dvbdmx->pids[1]&0x8000)) {
+			        if (feed->ts_type & TS_DECODER)
+				       if (feed->pes_type < 2 && 
+                                           !(demux->pids[0] & 0x8000) &&
+					   !(demux->pids[1] & 0x8000)) {
                                                ring_buffer_flush(&av7110->avout);
                                                ring_buffer_flush(&av7110->aout);
                                                AV_StartPlay(av7110,RP_AV);
-                                               dvbdmx->playing=1;
+                                               demux->playing = 1;
 					}
 				break;
 			default:
-                                dvb_feed_start_pid(dvbdmxfeed);
+                                dvb_feed_start_pid(feed);
 				break;
 			}
 		} else
-		        if ((dvbdmxfeed->ts_type & TS_PACKET) &&
-                            (dvbdmx->dmx.frontend->source!=DMX_MEMORY_FE))
-                                StartHWFilter(dvbdmxfeed->filter); 
+		        if ((feed->ts_type & TS_PACKET) &&
+                            (demux->dmx.frontend->source!=DMX_MEMORY_FE))
+                                StartHWFilter(feed->filter); 
         }
         
-        if (dvbdmxfeed->type == DMX_TYPE_SEC) {
+        if (feed->type == DMX_TYPE_SEC) {
                 int i;
 
-	        for (i=0; i<dvbdmx->filternum; i++) {
-		        if (dvbdmx->filter[i].state!=DMX_STATE_READY)
+	        for (i=0; i<demux->filternum; i++) {
+		        if (demux->filter[i].state!=DMX_STATE_READY)
 			        continue;
-			if (dvbdmx->filter[i].type!=DMX_TYPE_SEC)
+			if (demux->filter[i].type!=DMX_TYPE_SEC)
 			        continue;
-			if (dvbdmx->filter[i].filter.parent!=&dvbdmxfeed->feed.sec)
+			if (demux->filter[i].filter.parent!=&feed->feed.sec)
 			        continue;
-			dvbdmx->filter[i].state=DMX_STATE_GO;
-                        if (dvbdmx->dmx.frontend->source!=DMX_MEMORY_FE)
-                                StartHWFilter(&dvbdmx->filter[i]); 
+			demux->filter[i].state=DMX_STATE_GO;
+                        if (demux->dmx.frontend->source!=DMX_MEMORY_FE)
+                                StartHWFilter(&demux->filter[i]); 
                 }
 	}
+
         return 0;
 }
 
 
 static int 
-dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
+av7110_stop_feed(struct dvb_demux_feed *feed)
 {
-        struct dvb_demux *dvbdmx=dvbdmxfeed->demux;
-        av7110_t *av7110=(av7110_t *) dvbdmx->priv;
+        struct dvb_demux *demux = feed->demux;
+        av7110_t *av7110 = (av7110_t *) demux->priv;
 
-        if (av7110->card_type->type>=DVB_CARD_TT_BUDGET) 
+        if (av7110->card_type->type >= DVB_CARD_TT_BUDGET) 
                 return TTBStop(av7110); 
 
-        if (dvbdmxfeed->type == DMX_TYPE_TS) {
-                if (dvbdmxfeed->ts_type & TS_DECODER) {
-                        if (dvbdmxfeed->pes_type>=DMX_TS_PES_OTHER ||
-                            !dvbdmx->pesfilter[dvbdmxfeed->pes_type]) 
+        if (feed->type == DMX_TYPE_TS) {
+                if (feed->ts_type & TS_DECODER) {
+                        if (feed->pes_type >= DMX_TS_PES_OTHER ||
+                            !demux->pesfilter[feed->pes_type]) 
                                 return -EINVAL;
-                        dvbdmx->pids[dvbdmxfeed->pes_type]|=0x8000;
-                        dvbdmx->pesfilter[dvbdmxfeed->pes_type]=0;
+                        demux->pids[feed->pes_type]|=0x8000;
+                        demux->pesfilter[feed->pes_type]=0;
                 }
-                if (dvbdmxfeed->ts_type & TS_DECODER &&
-		    (dvbdmxfeed->pes_type<DMX_TS_PES_OTHER)) {
-                        dvb_feed_stop_pid(dvbdmxfeed);
+                if (feed->ts_type & TS_DECODER &&
+		    feed->pes_type < DMX_TS_PES_OTHER) {
+                        dvb_feed_stop_pid(feed);
                 } else 
-                        if ((dvbdmxfeed->ts_type & TS_PACKET) &&
-                            (dvbdmx->dmx.frontend->source!=DMX_MEMORY_FE))
-                                StopHWFilter(dvbdmxfeed->filter); 
+                        if ((feed->ts_type & TS_PACKET) &&
+                            (demux->dmx.frontend->source != DMX_MEMORY_FE))
+                                StopHWFilter(feed->filter); 
         }
         
-        if (dvbdmxfeed->type == DMX_TYPE_SEC) {
+        if (feed->type == DMX_TYPE_SEC) {
                 int i;
 
-	        for (i=0; i<dvbdmx->filternum; i++)
-		        if (dvbdmx->filter[i].state==DMX_STATE_GO && 
-			    dvbdmx->filter[i].filter.parent==&dvbdmxfeed->feed.sec) {
-			        dvbdmx->filter[i].state=DMX_STATE_READY;
-                                if (dvbdmx->dmx.frontend->source!=DMX_MEMORY_FE)
-                                        StopHWFilter(&dvbdmx->filter[i]); 
+	        for (i=0; i<demux->filternum; i++)
+		        if (demux->filter[i].state==DMX_STATE_GO && 
+			    demux->filter[i].filter.parent==&feed->feed.sec) {
+			        demux->filter[i].state=DMX_STATE_READY;
+                                if (demux->dmx.frontend->source!=DMX_MEMORY_FE)
+                                        StopHWFilter(&demux->filter[i]); 
                 }
 	}
+
         return 0;
 }
 
@@ -3208,7 +3206,7 @@ restart_feeds(av7110_t *av7110)
         for (i=0; i<dvbdmx->filternum; i++) {
                 feed=&dvbdmx->feed[i];
                 if (feed->state==DMX_STATE_GO)
-                        dvb_start_feed(feed);
+                        av7110_start_feed(feed);
         }
 
         if (mode)
@@ -4049,8 +4047,8 @@ void av7110_before_after_tune (fe_status_t s, void *data)
 }
 
 
-static int 
-dvb_register(av7110_t *av7110)
+static
+int av7110_register(av7110_t *av7110)
 {
         int ret, i;
         dmx_frontend_t *dvbfront=&av7110->hw_frontend;
@@ -4061,8 +4059,6 @@ dvb_register(av7110_t *av7110)
 
         av7110->registered=1;
 
-	av7110->dvb_adapter = av7110->dvb_adapter;
-
 	if (av7110->card_type->type==DVB_CARD_TT_SIEMENS) 
                 dvb_add_frontend_notifier (av7110->dvb_adapter,
                                            av7110_before_after_tune, av7110);
@@ -4098,9 +4094,9 @@ dvb_register(av7110_t *av7110)
 
                 dvbdemux->filternum=32;
                 dvbdemux->feednum=32;
-                dvbdemux->start_feed=dvb_start_feed;
-                dvbdemux->stop_feed=dvb_stop_feed;
-                dvbdemux->write_to_decoder=dvb_write_to_decoder;
+                dvbdemux->start_feed = av7110_start_feed;
+                dvbdemux->stop_feed = av7110_stop_feed;
+                dvbdemux->write_to_decoder = av7110_write_to_decoder;
                 
                 dvbdemux->dmx.vendor="TI";
                 dvbdemux->dmx.model="AV7110";
@@ -4127,9 +4123,9 @@ dvb_register(av7110_t *av7110)
         if (av7110->card_type->type>=DVB_CARD_TT_BUDGET) {
                 dvbdemux->filternum=256;
                 dvbdemux->feednum=256;
-                dvbdemux->start_feed=dvb_start_feed;
-                dvbdemux->stop_feed=dvb_stop_feed;
-                dvbdemux->write_to_decoder=0;
+                dvbdemux->start_feed=av7110_start_feed;
+                dvbdemux->stop_feed=av7110_stop_feed;
+                dvbdemux->write_to_decoder=NULL;
 
                 dvbdemux->dmx.vendor="CIM";
                 dvbdemux->dmx.model="sw";
@@ -4353,51 +4349,50 @@ static
 int av7110_attach (struct saa7146_dev* dev)
 {
 	av7110_t *av7110 = (av7110_t*)dev->ext_priv;
-	struct dvb_adapter *adap;
 	struct scatterlist *slist;
 	int slen = 0;
 	int length = TS_WIDTH*TS_HEIGHT;
 	int pages = (length+PAGE_SIZE-1)/PAGE_SIZE;
+	int ret = 0;
 	
 	av7110->dev=(struct saa7146_dev *)dev;
 
-	dvb_register_adapter(&adap, av7110->card_type->name);
-	av7110->dvb_adapter = adap;
+	dvb_register_adapter(&av7110->dvb_adapter, av7110->card_type->name);
+
+	av7110->i2c_bus = dvb_register_i2c_bus (master_xfer, dev,
+						av7110->dvb_adapter, 0);
 
-	/* fixme: speed ok? */
+	/* FIXME: speed ok? */
 	saa7146_i2c_adapter_prepare(dev, NULL, SAA7146_I2C_BUS_BIT_RATE_480);
 
 	av7110->i2c_bus = dvb_register_i2c_bus (master_xfer, dev, av7110->dvb_adapter, 0);
+
 	if (!av7110->i2c_bus) {
 		dvb_unregister_adapter (av7110->dvb_adapter);
 		return -ENOMEM;
 	}
 	
 	av7110->grabbing = vmalloc(length);
-	if( NULL == av7110->grabbing ) {
-		dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter, av7110->i2c_bus->id);
-		dvb_unregister_adapter (av7110->dvb_adapter);
+	if (!av7110->grabbing) {
                 printk(KERN_ERR "dvb: vmalloc() failed.\n");
-		return -ENOMEM;
+		ret = -ENOMEM;
+		goto err;
 	}
 	
-	slist =	videobuf_vmalloc_to_sg(av7110->grabbing, pages);
-	if( NULL == slist ) {
+	if (!(slist = videobuf_vmalloc_to_sg(av7110->grabbing, pages))) {
 		vfree(av7110->grabbing);
-		dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter, av7110->i2c_bus->id);
-		dvb_unregister_adapter (av7110->dvb_adapter);
                 printk(KERN_ERR "dvb: videobuf_vmalloc_to_sg() failed.\n");
-		return -ENOMEM;
+		ret = -ENOMEM;
+		goto err;
 	}
 
-	// fixme: is direction ok?
-	if( saa7146_pgtable_alloc(dev->pci, &av7110->pt)) {
+	// FIXME: is direction ok?
+	if (saa7146_pgtable_alloc(dev->pci, &av7110->pt)) {
+                printk(KERN_ERR "dvb: saa7146_pgtable_alloc() failed.\n");
 		kfree(slist);
 		vfree(av7110->grabbing);
-		dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter, av7110->i2c_bus->id);
-		dvb_unregister_adapter (av7110->dvb_adapter);
-                printk(KERN_ERR "dvb: saa7146_pgtable_alloc() failed.\n");
-		return -ENOMEM;
+		ret = -ENOMEM;
+		goto err;
 	}
 	
 	slen = pci_map_sg(dev->pci,slist,pages,PCI_DMA_FROMDEVICE);
@@ -4447,15 +4442,18 @@ int av7110_attach (struct saa7146_dev* dev)
         
 
         /* allocate and init buffers */
-
-        av7110->debi_virt=pci_alloc_consistent(dev->pci, 8192,
-					       &av7110->debi_bus);
-        if (!av7110->debi_virt) 
+        av7110->debi_virt = pci_alloc_consistent(dev->pci, 8192,
+						 &av7110->debi_bus);
+        if (!av7110->debi_virt) {
+		ret = -ENOMEM;
                 goto err;
+	}
 
-        av7110->iobuf=vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
-        if (!av7110->iobuf) 
+        av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
+        if (!av7110->iobuf) {
+		ret = -ENOMEM;
                 goto err;
+	}
 
         ring_buffer_init(&av7110->avout, av7110->iobuf, AVOUTLEN);
         ring_buffer_init(&av7110->aout, av7110->iobuf+AVOUTLEN, AOUTLEN);
@@ -4533,7 +4531,7 @@ int av7110_attach (struct saa7146_dev* dev)
 	}
 	
 	av7110_setup_irc_config (av7110, 0);
-        dvb_register(av7110);
+	av7110_register(av7110);
 	
 	printk(KERN_INFO "av7110: found av7110-%d.\n",av7110_num);
 	av7110_num++;
@@ -4542,7 +4540,7 @@ int av7110_attach (struct saa7146_dev* dev)
 err:
 	dvb_unregister_i2c_bus (master_xfer,av7110->i2c_bus->adapter, av7110->i2c_bus->id);
 	dvb_unregister_adapter (av7110->dvb_adapter);
-	return -1;
+	return ret;
 }
 
 static
@@ -4621,7 +4619,7 @@ void av7110_dec_use(struct saa7146_dev* adap)
 static
 struct saa7146_standard standard[] = {
 	{ "PAL", V4L2_STD_PAL, 0x15, 288, 576, 0x3a, 720, 721, 576, 768 },
-/* fixme: more to come here */
+/* FIXME: more to come here */
 };
 
 static
@@ -4657,17 +4655,18 @@ struct saa7146_extension av7110_extension = {
 	.irq_func	= av7110_irq,
 };	
 
+
+static
 int __init av7110_init(void) 
 {
-	int result = 0;
-
-	if( 0 != saa7146_register_extension(&av7110_extension)) {
+	if (saa7146_register_extension(&av7110_extension))
 		return -ENODEV;
-	}
 	
 	return 0;
 }
 
+
+static
 void __exit av7110_exit(void)
 {
 	if (saa7146_unregister_extension(&av7110_extension)) 
@@ -4687,17 +4686,3 @@ MODULE_PARM(vidmode,"i");
 MODULE_PARM(pids_off,"i");
 MODULE_PARM(adac,"i");
 
-/*
- * Local variables:
- * c-indent-level: 8
- * c-brace-imaginary-offset: 0
- * c-brace-offset: -8
- * c-argdecl-indent: 8
- * c-label-offset: -8
- * c-continued-statement-offset: 8
- * c-continued-brace-offset: 0
- * indent-tabs-mode: nil
- * tab-width: 8
- * End:
- */
-