Auto merge with /home/aegl/GIT/linus

1 files changed, 153 insertions, 98 deletions

diff --git a/drivers/media/dvb/ttpci/av7110.c b/drivers/media/dvb/ttpci/av7110.c
index 8e33a850e13e..e4c6e87f6c5d 100644
--- a/drivers/media/dvb/ttpci/av7110.c
+++ b/drivers/media/dvb/ttpci/av7110.c
@@ -116,13 +116,18 @@ static int av7110_num = 0;
 
 static void init_av7110_av(struct av7110 *av7110)
 {
+        int ret;
         struct saa7146_dev *dev = av7110->dev;
 
         /* set internal volume control to maximum */
         av7110->adac_type = DVB_ADAC_TI;
-        av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
+        ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
+        if (ret < 0)
+                printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
 
-        av7710_set_video_mode(av7110, vidmode);
+        ret = av7710_set_video_mode(av7110, vidmode);
+        if (ret < 0)
+                printk("dvb-ttpci:cannot set video mode:%d\n",ret);
 
         /* handle different card types */
         /* remaining inits according to card and frontend type */
@@ -156,8 +161,12 @@ static void init_av7110_av(struct av7110 *av7110)
 
         if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP) {
                 // switch DVB SCART on
-                av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
-                av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
+                ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, MainSwitch, 1, 0);
+                if (ret < 0)
+                        printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
+                ret = av7110_fw_cmd(av7110, COMTYPE_AUDIODAC, ADSwitch, 1, 1);
+                if (ret < 0)
+                        printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
                 if (rgb_on &&
                     (av7110->dev->pci->subsystem_vendor == 0x110a) && (av7110->dev->pci->subsystem_device == 0x0000)) {
                         saa7146_setgpio(dev, 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
@@ -165,8 +174,12 @@ static void init_av7110_av(struct av7110 *av7110)
                 }
         }
 
-        av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
-        av7110_setup_irc_config(av7110, 0);
+        ret = av7110_set_volume(av7110, av7110->mixer.volume_left, av7110->mixer.volume_right);
+        if (ret < 0)
+                printk("dvb-ttpci:cannot set volume :%d\n",ret);
+        ret = av7110_setup_irc_config(av7110, 0);
+        if (ret < 0)
+                printk("dvb-ttpci:cannot setup irc config :%d\n",ret);
 }
 
 static void recover_arm(struct av7110 *av7110)
@@ -258,8 +271,9 @@ static int arm_thread(void *data)
  *
  *  If we want to support multiple controls we would have to do much more...
  */
-void av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
+int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
 {
+        int ret = 0;
         static struct av7110 *last;
 
         dprintk(4, "%p\n", av7110);
@@ -270,9 +284,10 @@ void av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
                 last = av7110;
 
         if (av7110) {
-                av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
+                ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
                 av7110->ir_config = ir_config;
         }
+        return ret;
 }
 
 static void (*irc_handler)(u32);
@@ -765,13 +780,14 @@ static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
                              pcrpid, vpid, apid, ttpid, subpid);
 }
 
-void ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
+int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
                 u16 subpid, u16 pcrpid)
 {
+        int ret = 0;
         dprintk(4, "%p\n", av7110);
 
         if (down_interruptible(&av7110->pid_mutex))
-                return;
+                return -ERESTARTSYS;
 
         if (!(vpid & 0x8000))
                 av7110->pids[DMX_PES_VIDEO] = vpid;
@@ -786,10 +802,11 @@ void ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
 
         if (av7110->fe_synced) {
                 pcrpid = av7110->pids[DMX_PES_PCR];
-                SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
+                ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
         }
 
         up(&av7110->pid_mutex);
+        return ret;
 }
 
 
@@ -832,11 +849,13 @@ static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
         ret = av7110_fw_request(av7110, buf, 20, &handle, 1);
         if (ret != 0 || handle >= 32) {
                 printk("dvb-ttpci: %s error  buf %04x %04x %04x %04x  "
-                                "ret %x  handle %04x\n",
+                                "ret %d  handle %04x\n",
                                 __FUNCTION__, buf[0], buf[1], buf[2], buf[3],
                                 ret, handle);
                 dvbdmxfilter->hw_handle = 0xffff;
-                return -1;
+                if (!ret)
+                        ret = -1;
+                return ret;
         }
 
         av7110->handle2filter[handle] = dvbdmxfilter;
@@ -859,7 +878,7 @@ static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
         if (handle >= 32) {
                 printk("%s tried to stop invalid filter %04x, filter type = %x\n",
                                 __FUNCTION__, handle, dvbdmxfilter->type);
-                return 0;
+                return -EINVAL;
         }
 
         av7110->handle2filter[handle] = NULL;
@@ -873,18 +892,20 @@ static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
                                 "resp %04x %04x  pid %d\n",
                                 __FUNCTION__, buf[0], buf[1], buf[2], ret,
                                 answ[0], answ[1], dvbdmxfilter->feed->pid);
-                ret = -1;
+                if (!ret)
+                        ret = -1;
         }
         return ret;
 }
 
 
-static void dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
+static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
 {
         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
         struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
         u16 *pid = dvbdmx->pids, npids[5];
         int i;
+        int ret = 0;
 
         dprintk(4, "%p\n", av7110);
 
@@ -893,36 +914,49 @@ static void dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
         npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
         if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
                 npids[i] = 0;
-                ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
-                StartHWFilter(dvbdmxfeed->filter);
-                return;
+                ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
+                if (!ret)
+                        ret = StartHWFilter(dvbdmxfeed->filter);
+                return ret;
+        }
+        if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4) {
+                ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
+                if (ret)
+                        return ret;
         }
-        if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4)
-                ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
 
         if (dvbdmxfeed->pes_type < 2 && npids[0])
                 if (av7110->fe_synced)
-                        av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
+                {
+                        ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
+                        if (ret)
+                                return ret;
+                }
 
         if ((dvbdmxfeed->ts_type & TS_PACKET)) {
                 if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
-                        av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
+                        ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
                 if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
-                        av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
+                        ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
         }
+        return ret;
 }
 
-static void dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
+static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
 {
         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
         struct av7110 *av7110 = (struct av7110 *) dvbdmx->priv;
         u16 *pid = dvbdmx->pids, npids[5];
         int i;
 
+        int ret = 0;
+
         dprintk(4, "%p\n", av7110);
 
         if (dvbdmxfeed->pes_type <= 1) {
-                av7110_av_stop(av7110, dvbdmxfeed->pes_type ?  RP_VIDEO : RP_AUDIO);
+                ret = av7110_av_stop(av7110, dvbdmxfeed->pes_type ?  RP_VIDEO : RP_AUDIO);
+                if (ret)
+                        return ret;
                 if (!av7110->rec_mode)
                         dvbdmx->recording = 0;
                 if (!av7110->playing)
@@ -933,24 +967,27 @@ static void dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
         switch (i) {
         case 2: //teletext
                 if (dvbdmxfeed->ts_type & TS_PACKET)
-                        StopHWFilter(dvbdmxfeed->filter);
+                        ret = StopHWFilter(dvbdmxfeed->filter);
                 npids[2] = 0;
                 break;
         case 0:
         case 1:
         case 4:
                 if (!pids_off)
-                        return;
+                        return 0;
                 npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
                 break;
         }
-        ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
+        if (!ret)
+                ret = ChangePIDs(av7110, npids[1], npids[0], npids[2], npids[3], npids[4]);
+        return ret;
 }
 
 static int av7110_start_feed(struct dvb_demux_feed *feed)
 {
         struct dvb_demux *demux = feed->demux;
         struct av7110 *av7110 = demux->priv;
+        int ret = 0;
 
         dprintk(4, "%p\n", av7110);
 
@@ -971,21 +1008,22 @@ static int av7110_start_feed(struct dvb_demux_feed *feed)
                                            !(demux->pids[1] & 0x8000)) {
                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
                                                dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
-                                               av7110_av_start_play(av7110,RP_AV);
-                                               demux->playing = 1;
+                                               ret = av7110_av_start_play(av7110,RP_AV);
+                                               if (!ret)
+                                                       demux->playing = 1;
                                         }
                                 break;
                         default:
-                                dvb_feed_start_pid(feed);
+                                ret = dvb_feed_start_pid(feed);
                                 break;
                         }
                 } else if ((feed->ts_type & TS_PACKET) &&
                            (demux->dmx.frontend->source != DMX_MEMORY_FE)) {
-                        StartHWFilter(feed->filter);
+                        ret = StartHWFilter(feed->filter);
                 }
         }
 
-        if (feed->type == DMX_TYPE_SEC) {
+        else if (feed->type == DMX_TYPE_SEC) {
                 int i;
 
                 for (i = 0; i < demux->filternum; i++) {
@@ -996,12 +1034,15 @@ static int av7110_start_feed(struct dvb_demux_feed *feed)
                         if (demux->filter[i].filter.parent != &feed->feed.sec)
                                 continue;
                         demux->filter[i].state = DMX_STATE_GO;
-                        if (demux->dmx.frontend->source != DMX_MEMORY_FE)
-                                StartHWFilter(&demux->filter[i]);
+                        if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
+                                ret = StartHWFilter(&demux->filter[i]);
+                                if (ret)
+                                        break;
+                        }
                 }
         }
 
-        return 0;
+        return ret;
 }
 
 
@@ -1009,7 +1050,7 @@ static int av7110_stop_feed(struct dvb_demux_feed *feed)
 {
         struct dvb_demux *demux = feed->demux;
         struct av7110 *av7110 = demux->priv;
-
+        int i, rc, ret = 0;
         dprintk(4, "%p\n", av7110);
 
         if (feed->type == DMX_TYPE_TS) {
@@ -1022,26 +1063,29 @@ static int av7110_stop_feed(struct dvb_demux_feed *feed)
                 }
                 if (feed->ts_type & TS_DECODER &&
                     feed->pes_type < DMX_TS_PES_OTHER) {
-                        dvb_feed_stop_pid(feed);
+                        ret = dvb_feed_stop_pid(feed);
                 } else
                         if ((feed->ts_type & TS_PACKET) &&
                             (demux->dmx.frontend->source != DMX_MEMORY_FE))
-                                StopHWFilter(feed->filter);
+                                ret = StopHWFilter(feed->filter);
         }
 
-        if (feed->type == DMX_TYPE_SEC) {
-                int i;
-
-                for (i = 0; i<demux->filternum; i++)
+        if (!ret && feed->type == DMX_TYPE_SEC) {
+                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]);
+                                if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
+                                        rc = StopHWFilter(&demux->filter[i]);
+                                        if (!ret)
+                                                ret = rc;
+                                        /* keep going, stop as many filters as possible */
+                                }
+                        }
                 }
         }
 
-        return 0;
+        return ret;
 }
 
 
@@ -1093,7 +1137,7 @@ static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
         ret = av7110_fw_request(av7110, &tag, 0, fwstc, 4);
         if (ret) {
                 printk(KERN_ERR "%s: av7110_fw_request error\n", __FUNCTION__);
-                return -EIO;
+                return ret;
         }
         dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
                 fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
@@ -1119,18 +1163,14 @@ static int av7110_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 
         switch (tone) {
         case SEC_TONE_ON:
-                Set22K(av7110, 1);
-                break;
+                return Set22K(av7110, 1);
 
         case SEC_TONE_OFF:
-                Set22K(av7110, 0);
-                break;
+                return Set22K(av7110, 0);
 
         default:
                 return -EINVAL;
         }
-
-        return 0;
 }
 
 static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
@@ -1138,9 +1178,7 @@ static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
-
-        return 0;
+        return av7110_diseqc_send(av7110, cmd->msg_len, cmd->msg, -1);
 }
 
 static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
@@ -1148,9 +1186,7 @@ static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_diseqc_send(av7110, 0, NULL, minicmd);
-
-        return 0;
+        return av7110_diseqc_send(av7110, 0, NULL, minicmd);
 }
 
 /* simplified code from budget-core.c */
@@ -1992,76 +2028,85 @@ static struct l64781_config grundig_29504_401_config = {
 
 
 
-static void av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
+static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
 {
+        int ret = 0;
         int synced = (status & FE_HAS_LOCK) ? 1 : 0;
 
         av7110->fe_status = status;
 
         if (av7110->fe_synced == synced)
-                return;
-
-        av7110->fe_synced = synced;
+                return 0;
 
         if (av7110->playing)
-                return;
+                return 0;
 
         if (down_interruptible(&av7110->pid_mutex))
-                return;
+                return -ERESTARTSYS;
 
-        if (av7110->fe_synced) {
-                SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
+        if (synced) {
+                ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
                         av7110->pids[DMX_PES_AUDIO],
                         av7110->pids[DMX_PES_TELETEXT], 0,
                         av7110->pids[DMX_PES_PCR]);
-                av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
+                if (!ret)
+                        ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
         } else {
-                SetPIDs(av7110, 0, 0, 0, 0, 0);
-                av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
-                av7110_wait_msgstate(av7110, GPMQBusy);
+                ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
+                if (!ret) {
+                        ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
+                        if (!ret)
+                                ret = av7110_wait_msgstate(av7110, GPMQBusy);
+                }
         }
 
+        if (!ret)
+                av7110->fe_synced = synced;
+
         up(&av7110->pid_mutex);
+        return ret;
 }
 
 static int av7110_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
 {
         struct av7110* av7110 = fe->dvb->priv;
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_set_frontend(fe, params);
+
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_set_frontend(fe, params);
+        return ret;
 }
 
 static int av7110_fe_init(struct dvb_frontend* fe)
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_init(fe);
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_init(fe);
+        return ret;
 }
 
 static int av7110_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
 {
         struct av7110* av7110 = fe->dvb->priv;
-        int ret;
 
         /* call the real implementation */
-        ret = av7110->fe_read_status(fe, status);
-        if (ret)
-                return ret;
-
-        if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK)) {
-                av7110_fe_lock_fix(av7110, *status);
-        }
-
-        return 0;
+        int ret = av7110->fe_read_status(fe, status);
+        if (!ret)
+                if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
+                        ret = av7110_fe_lock_fix(av7110, *status);
+        return ret;
 }
 
 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_diseqc_reset_overload(fe);
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_diseqc_reset_overload(fe);
+        return ret;
 }
 
 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
@@ -2069,40 +2114,50 @@ static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_diseqc_send_master_cmd(fe, cmd);
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
+        return ret;
 }
 
 static int av7110_fe_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t minicmd)
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_diseqc_send_burst(fe, minicmd);
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_diseqc_send_burst(fe, minicmd);
+        return ret;
 }
 
 static int av7110_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_set_tone(fe, tone);
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_set_tone(fe, tone);
+        return ret;
 }
 
 static int av7110_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_set_voltage(fe, voltage);
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_set_voltage(fe, voltage);
+        return ret;
 }
 
 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned int cmd)
 {
         struct av7110* av7110 = fe->dvb->priv;
 
-        av7110_fe_lock_fix(av7110, 0);
-        return av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
+        int ret = av7110_fe_lock_fix(av7110, 0);
+        if (!ret)
+                ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
+        return ret;
 }
 
 static u8 read_pwm(struct av7110* av7110)