Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Driver for the NXP SAA7164 PCIe bridge
0004  *
0005  *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
0006  */
0007 
0008 #include "saa7164.h"
0009 
0010 #include "tda10048.h"
0011 #include "tda18271.h"
0012 #include "s5h1411.h"
0013 #include "si2157.h"
0014 #include "si2168.h"
0015 #include "lgdt3306a.h"
0016 
0017 #define DRIVER_NAME "saa7164"
0018 
0019 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0020 
0021 /* addr is in the card struct, get it from there */
0022 static struct tda10048_config hauppauge_hvr2200_1_config = {
0023     .demod_address    = 0x10 >> 1,
0024     .output_mode      = TDA10048_SERIAL_OUTPUT,
0025     .fwbulkwritelen   = TDA10048_BULKWRITE_200,
0026     .inversion        = TDA10048_INVERSION_ON,
0027     .dtv6_if_freq_khz = TDA10048_IF_3300,
0028     .dtv7_if_freq_khz = TDA10048_IF_3500,
0029     .dtv8_if_freq_khz = TDA10048_IF_4000,
0030     .clk_freq_khz     = TDA10048_CLK_16000,
0031 };
0032 static struct tda10048_config hauppauge_hvr2200_2_config = {
0033     .demod_address    = 0x12 >> 1,
0034     .output_mode      = TDA10048_SERIAL_OUTPUT,
0035     .fwbulkwritelen   = TDA10048_BULKWRITE_200,
0036     .inversion        = TDA10048_INVERSION_ON,
0037     .dtv6_if_freq_khz = TDA10048_IF_3300,
0038     .dtv7_if_freq_khz = TDA10048_IF_3500,
0039     .dtv8_if_freq_khz = TDA10048_IF_4000,
0040     .clk_freq_khz     = TDA10048_CLK_16000,
0041 };
0042 
0043 static struct tda18271_std_map hauppauge_tda18271_std_map = {
0044     .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 3,
0045               .if_lvl = 6, .rfagc_top = 0x37 },
0046     .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 0,
0047               .if_lvl = 6, .rfagc_top = 0x37 },
0048 };
0049 
0050 static struct tda18271_config hauppauge_hvr22x0_tuner_config = {
0051     .std_map    = &hauppauge_tda18271_std_map,
0052     .gate       = TDA18271_GATE_ANALOG,
0053     .role       = TDA18271_MASTER,
0054 };
0055 
0056 static struct tda18271_config hauppauge_hvr22x0s_tuner_config = {
0057     .std_map    = &hauppauge_tda18271_std_map,
0058     .gate       = TDA18271_GATE_ANALOG,
0059     .role       = TDA18271_SLAVE,
0060     .output_opt     = TDA18271_OUTPUT_LT_OFF,
0061     .rf_cal_on_startup = 1
0062 };
0063 
0064 static struct s5h1411_config hauppauge_s5h1411_config = {
0065     .output_mode   = S5H1411_SERIAL_OUTPUT,
0066     .gpio          = S5H1411_GPIO_ON,
0067     .qam_if        = S5H1411_IF_4000,
0068     .vsb_if        = S5H1411_IF_3250,
0069     .inversion     = S5H1411_INVERSION_ON,
0070     .status_mode   = S5H1411_DEMODLOCKING,
0071     .mpeg_timing   = S5H1411_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK,
0072 };
0073 
0074 static struct lgdt3306a_config hauppauge_hvr2255a_config = {
0075     .i2c_addr               = 0xb2 >> 1,
0076     .qam_if_khz             = 4000,
0077     .vsb_if_khz             = 3250,
0078     .deny_i2c_rptr          = 1, /* Disabled */
0079     .spectral_inversion     = 0, /* Disabled */
0080     .mpeg_mode              = LGDT3306A_MPEG_SERIAL,
0081     .tpclk_edge             = LGDT3306A_TPCLK_RISING_EDGE,
0082     .tpvalid_polarity       = LGDT3306A_TP_VALID_HIGH,
0083     .xtalMHz                = 25, /* 24 or 25 */
0084 };
0085 
0086 static struct lgdt3306a_config hauppauge_hvr2255b_config = {
0087     .i2c_addr               = 0x1c >> 1,
0088     .qam_if_khz             = 4000,
0089     .vsb_if_khz             = 3250,
0090     .deny_i2c_rptr          = 1, /* Disabled */
0091     .spectral_inversion     = 0, /* Disabled */
0092     .mpeg_mode              = LGDT3306A_MPEG_SERIAL,
0093     .tpclk_edge             = LGDT3306A_TPCLK_RISING_EDGE,
0094     .tpvalid_polarity       = LGDT3306A_TP_VALID_HIGH,
0095     .xtalMHz                = 25, /* 24 or 25 */
0096 };
0097 
0098 static struct si2157_config hauppauge_hvr2255_tuner_config = {
0099     .inversion = 1,
0100     .if_port = 1,
0101 };
0102 
0103 static int si2157_attach(struct saa7164_port *port, struct i2c_adapter *adapter,
0104     struct dvb_frontend *fe, u8 addr8bit, struct si2157_config *cfg)
0105 {
0106     struct i2c_board_info bi;
0107     struct i2c_client *tuner;
0108 
0109     cfg->fe = fe;
0110 
0111     memset(&bi, 0, sizeof(bi));
0112 
0113     strscpy(bi.type, "si2157", I2C_NAME_SIZE);
0114     bi.platform_data = cfg;
0115     bi.addr = addr8bit >> 1;
0116 
0117     request_module(bi.type);
0118 
0119     tuner = i2c_new_client_device(adapter, &bi);
0120     if (!i2c_client_has_driver(tuner))
0121         return -ENODEV;
0122 
0123     if (!try_module_get(tuner->dev.driver->owner)) {
0124         i2c_unregister_device(tuner);
0125         return -ENODEV;
0126     }
0127 
0128     port->i2c_client_tuner = tuner;
0129 
0130     return 0;
0131 }
0132 
0133 static int saa7164_dvb_stop_port(struct saa7164_port *port)
0134 {
0135     struct saa7164_dev *dev = port->dev;
0136     int ret;
0137 
0138     ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
0139     if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
0140         printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
0141             __func__, ret);
0142         ret = -EIO;
0143     } else {
0144         dprintk(DBGLVL_DVB, "%s()    Stopped\n", __func__);
0145         ret = 0;
0146     }
0147 
0148     return ret;
0149 }
0150 
0151 static int saa7164_dvb_acquire_port(struct saa7164_port *port)
0152 {
0153     struct saa7164_dev *dev = port->dev;
0154     int ret;
0155 
0156     ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
0157     if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
0158         printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
0159             __func__, ret);
0160         ret = -EIO;
0161     } else {
0162         dprintk(DBGLVL_DVB, "%s() Acquired\n", __func__);
0163         ret = 0;
0164     }
0165 
0166     return ret;
0167 }
0168 
0169 static int saa7164_dvb_pause_port(struct saa7164_port *port)
0170 {
0171     struct saa7164_dev *dev = port->dev;
0172     int ret;
0173 
0174     ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
0175     if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
0176         printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
0177             __func__, ret);
0178         ret = -EIO;
0179     } else {
0180         dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
0181         ret = 0;
0182     }
0183 
0184     return ret;
0185 }
0186 
0187 /* Firmware is very windows centric, meaning you have to transition
0188  * the part through AVStream / KS Windows stages, forwards or backwards.
0189  * States are: stopped, acquired (h/w), paused, started.
0190  */
0191 static int saa7164_dvb_stop_streaming(struct saa7164_port *port)
0192 {
0193     struct saa7164_dev *dev = port->dev;
0194     struct saa7164_buffer *buf;
0195     struct list_head *p, *q;
0196     int ret;
0197 
0198     dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
0199 
0200     ret = saa7164_dvb_pause_port(port);
0201     ret = saa7164_dvb_acquire_port(port);
0202     ret = saa7164_dvb_stop_port(port);
0203 
0204     /* Mark the hardware buffers as free */
0205     mutex_lock(&port->dmaqueue_lock);
0206     list_for_each_safe(p, q, &port->dmaqueue.list) {
0207         buf = list_entry(p, struct saa7164_buffer, list);
0208         buf->flags = SAA7164_BUFFER_FREE;
0209     }
0210     mutex_unlock(&port->dmaqueue_lock);
0211 
0212     return ret;
0213 }
0214 
0215 static int saa7164_dvb_start_port(struct saa7164_port *port)
0216 {
0217     struct saa7164_dev *dev = port->dev;
0218     int ret = 0, result;
0219 
0220     dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
0221 
0222     saa7164_buffer_cfg_port(port);
0223 
0224     /* Acquire the hardware */
0225     result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
0226     if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
0227         printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
0228             __func__, result);
0229 
0230         /* Stop the hardware, regardless */
0231         result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
0232         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
0233             printk(KERN_ERR "%s() acquire/forced stop transition failed, res = 0x%x\n",
0234                    __func__, result);
0235         }
0236         ret = -EIO;
0237         goto out;
0238     } else
0239         dprintk(DBGLVL_DVB, "%s()   Acquired\n", __func__);
0240 
0241     /* Pause the hardware */
0242     result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
0243     if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
0244         printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
0245                 __func__, result);
0246 
0247         /* Stop the hardware, regardless */
0248         result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
0249         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
0250             printk(KERN_ERR "%s() pause/forced stop transition failed, res = 0x%x\n",
0251                    __func__, result);
0252         }
0253 
0254         ret = -EIO;
0255         goto out;
0256     } else
0257         dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
0258 
0259     /* Start the hardware */
0260     result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
0261     if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
0262         printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
0263                 __func__, result);
0264 
0265         /* Stop the hardware, regardless */
0266         result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
0267         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
0268             printk(KERN_ERR "%s() run/forced stop transition failed, res = 0x%x\n",
0269                    __func__, result);
0270         }
0271 
0272         ret = -EIO;
0273     } else
0274         dprintk(DBGLVL_DVB, "%s()   Running\n", __func__);
0275 
0276 out:
0277     return ret;
0278 }
0279 
0280 static int saa7164_dvb_start_feed(struct dvb_demux_feed *feed)
0281 {
0282     struct dvb_demux *demux = feed->demux;
0283     struct saa7164_port *port = (struct saa7164_port *) demux->priv;
0284     struct saa7164_dvb *dvb = &port->dvb;
0285     struct saa7164_dev *dev = port->dev;
0286     int ret = 0;
0287 
0288     dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
0289 
0290     if (!demux->dmx.frontend)
0291         return -EINVAL;
0292 
0293     if (dvb) {
0294         mutex_lock(&dvb->lock);
0295         if (dvb->feeding++ == 0) {
0296             /* Start transport */
0297             ret = saa7164_dvb_start_port(port);
0298         }
0299         mutex_unlock(&dvb->lock);
0300         dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
0301             __func__, port->nr, dvb->feeding);
0302     }
0303 
0304     return ret;
0305 }
0306 
0307 static int saa7164_dvb_stop_feed(struct dvb_demux_feed *feed)
0308 {
0309     struct dvb_demux *demux = feed->demux;
0310     struct saa7164_port *port = (struct saa7164_port *) demux->priv;
0311     struct saa7164_dvb *dvb = &port->dvb;
0312     struct saa7164_dev *dev = port->dev;
0313     int ret = 0;
0314 
0315     dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
0316 
0317     if (dvb) {
0318         mutex_lock(&dvb->lock);
0319         if (--dvb->feeding == 0) {
0320             /* Stop transport */
0321             ret = saa7164_dvb_stop_streaming(port);
0322         }
0323         mutex_unlock(&dvb->lock);
0324         dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
0325             __func__, port->nr, dvb->feeding);
0326     }
0327 
0328     return ret;
0329 }
0330 
0331 static int dvb_register(struct saa7164_port *port)
0332 {
0333     struct saa7164_dvb *dvb = &port->dvb;
0334     struct saa7164_dev *dev = port->dev;
0335     struct saa7164_buffer *buf;
0336     int result, i;
0337 
0338     dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
0339 
0340     BUG_ON(port->type != SAA7164_MPEG_DVB);
0341 
0342     /* Sanity check that the PCI configuration space is active */
0343     if (port->hwcfg.BARLocation == 0) {
0344         result = -ENOMEM;
0345         printk(KERN_ERR "%s: dvb_register_adapter failed (errno = %d), NO PCI configuration\n",
0346             DRIVER_NAME, result);
0347         goto fail_adapter;
0348     }
0349 
0350     /* Init and establish defaults */
0351     port->hw_streamingparams.bitspersample = 8;
0352     port->hw_streamingparams.samplesperline = 188;
0353     port->hw_streamingparams.numberoflines =
0354         (SAA7164_TS_NUMBER_OF_LINES * 188) / 188;
0355 
0356     port->hw_streamingparams.pitch = 188;
0357     port->hw_streamingparams.linethreshold = 0;
0358     port->hw_streamingparams.pagetablelistvirt = NULL;
0359     port->hw_streamingparams.pagetablelistphys = NULL;
0360     port->hw_streamingparams.numpagetables = 2 +
0361         ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
0362 
0363     port->hw_streamingparams.numpagetableentries = port->hwcfg.buffercount;
0364 
0365     /* Allocate the PCI resources */
0366     for (i = 0; i < port->hwcfg.buffercount; i++) {
0367         buf = saa7164_buffer_alloc(port,
0368             port->hw_streamingparams.numberoflines *
0369             port->hw_streamingparams.pitch);
0370 
0371         if (!buf) {
0372             result = -ENOMEM;
0373             printk(KERN_ERR "%s: dvb_register_adapter failed (errno = %d), unable to allocate buffers\n",
0374                 DRIVER_NAME, result);
0375             goto fail_adapter;
0376         }
0377 
0378         mutex_lock(&port->dmaqueue_lock);
0379         list_add_tail(&buf->list, &port->dmaqueue.list);
0380         mutex_unlock(&port->dmaqueue_lock);
0381     }
0382 
0383     /* register adapter */
0384     result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE,
0385             &dev->pci->dev, adapter_nr);
0386     if (result < 0) {
0387         printk(KERN_ERR "%s: dvb_register_adapter failed (errno = %d)\n",
0388                DRIVER_NAME, result);
0389         goto fail_adapter;
0390     }
0391     dvb->adapter.priv = port;
0392 
0393     /* register frontend */
0394     result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
0395     if (result < 0) {
0396         printk(KERN_ERR "%s: dvb_register_frontend failed (errno = %d)\n",
0397                DRIVER_NAME, result);
0398         goto fail_frontend;
0399     }
0400 
0401     /* register demux stuff */
0402     dvb->demux.dmx.capabilities =
0403         DMX_TS_FILTERING | DMX_SECTION_FILTERING |
0404         DMX_MEMORY_BASED_FILTERING;
0405     dvb->demux.priv       = port;
0406     dvb->demux.filternum  = 256;
0407     dvb->demux.feednum    = 256;
0408     dvb->demux.start_feed = saa7164_dvb_start_feed;
0409     dvb->demux.stop_feed  = saa7164_dvb_stop_feed;
0410     result = dvb_dmx_init(&dvb->demux);
0411     if (result < 0) {
0412         printk(KERN_ERR "%s: dvb_dmx_init failed (errno = %d)\n",
0413                DRIVER_NAME, result);
0414         goto fail_dmx;
0415     }
0416 
0417     dvb->dmxdev.filternum    = 256;
0418     dvb->dmxdev.demux        = &dvb->demux.dmx;
0419     dvb->dmxdev.capabilities = 0;
0420     result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
0421     if (result < 0) {
0422         printk(KERN_ERR "%s: dvb_dmxdev_init failed (errno = %d)\n",
0423                DRIVER_NAME, result);
0424         goto fail_dmxdev;
0425     }
0426 
0427     dvb->fe_hw.source = DMX_FRONTEND_0;
0428     result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0429     if (result < 0) {
0430         printk(KERN_ERR "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
0431                DRIVER_NAME, result);
0432         goto fail_fe_hw;
0433     }
0434 
0435     dvb->fe_mem.source = DMX_MEMORY_FE;
0436     result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
0437     if (result < 0) {
0438         printk(KERN_ERR "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
0439                DRIVER_NAME, result);
0440         goto fail_fe_mem;
0441     }
0442 
0443     result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0444     if (result < 0) {
0445         printk(KERN_ERR "%s: connect_frontend failed (errno = %d)\n",
0446                DRIVER_NAME, result);
0447         goto fail_fe_conn;
0448     }
0449 
0450     /* register network adapter */
0451     dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
0452     return 0;
0453 
0454 fail_fe_conn:
0455     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
0456 fail_fe_mem:
0457     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0458 fail_fe_hw:
0459     dvb_dmxdev_release(&dvb->dmxdev);
0460 fail_dmxdev:
0461     dvb_dmx_release(&dvb->demux);
0462 fail_dmx:
0463     dvb_unregister_frontend(dvb->frontend);
0464 fail_frontend:
0465     dvb_frontend_detach(dvb->frontend);
0466     dvb_unregister_adapter(&dvb->adapter);
0467 fail_adapter:
0468     return result;
0469 }
0470 
0471 int saa7164_dvb_unregister(struct saa7164_port *port)
0472 {
0473     struct saa7164_dvb *dvb = &port->dvb;
0474     struct saa7164_dev *dev = port->dev;
0475     struct saa7164_buffer *b;
0476     struct list_head *c, *n;
0477     struct i2c_client *client;
0478 
0479     dprintk(DBGLVL_DVB, "%s()\n", __func__);
0480 
0481     BUG_ON(port->type != SAA7164_MPEG_DVB);
0482 
0483     /* Remove any allocated buffers */
0484     mutex_lock(&port->dmaqueue_lock);
0485     list_for_each_safe(c, n, &port->dmaqueue.list) {
0486         b = list_entry(c, struct saa7164_buffer, list);
0487         list_del(c);
0488         saa7164_buffer_dealloc(b);
0489     }
0490     mutex_unlock(&port->dmaqueue_lock);
0491 
0492     if (dvb->frontend == NULL)
0493         return 0;
0494 
0495     /* remove I2C client for tuner */
0496     client = port->i2c_client_tuner;
0497     if (client) {
0498         module_put(client->dev.driver->owner);
0499         i2c_unregister_device(client);
0500     }
0501 
0502     /* remove I2C client for demodulator */
0503     client = port->i2c_client_demod;
0504     if (client) {
0505         module_put(client->dev.driver->owner);
0506         i2c_unregister_device(client);
0507     }
0508 
0509     dvb_net_release(&dvb->net);
0510     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
0511     dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
0512     dvb_dmxdev_release(&dvb->dmxdev);
0513     dvb_dmx_release(&dvb->demux);
0514     dvb_unregister_frontend(dvb->frontend);
0515     dvb_frontend_detach(dvb->frontend);
0516     dvb_unregister_adapter(&dvb->adapter);
0517     return 0;
0518 }
0519 
0520 /* All the DVB attach calls go here, this function gets modified
0521  * for each new card.
0522  */
0523 int saa7164_dvb_register(struct saa7164_port *port)
0524 {
0525     struct saa7164_dev *dev = port->dev;
0526     struct saa7164_dvb *dvb = &port->dvb;
0527     struct saa7164_i2c *i2c_bus = NULL;
0528     struct si2168_config si2168_config;
0529     struct si2157_config si2157_config;
0530     struct i2c_adapter *adapter;
0531     struct i2c_board_info info;
0532     struct i2c_client *client_demod;
0533     struct i2c_client *client_tuner;
0534     int ret;
0535 
0536     dprintk(DBGLVL_DVB, "%s()\n", __func__);
0537 
0538     /* init frontend */
0539     switch (dev->board) {
0540     case SAA7164_BOARD_HAUPPAUGE_HVR2200:
0541     case SAA7164_BOARD_HAUPPAUGE_HVR2200_2:
0542     case SAA7164_BOARD_HAUPPAUGE_HVR2200_3:
0543     case SAA7164_BOARD_HAUPPAUGE_HVR2200_4:
0544     case SAA7164_BOARD_HAUPPAUGE_HVR2200_5:
0545         i2c_bus = &dev->i2c_bus[port->nr + 1];
0546         switch (port->nr) {
0547         case 0:
0548             port->dvb.frontend = dvb_attach(tda10048_attach,
0549                 &hauppauge_hvr2200_1_config,
0550                 &i2c_bus->i2c_adap);
0551 
0552             if (port->dvb.frontend != NULL) {
0553                 /* TODO: addr is in the card struct */
0554                 dvb_attach(tda18271_attach, port->dvb.frontend,
0555                     0xc0 >> 1, &i2c_bus->i2c_adap,
0556                     &hauppauge_hvr22x0_tuner_config);
0557             }
0558 
0559             break;
0560         case 1:
0561             port->dvb.frontend = dvb_attach(tda10048_attach,
0562                 &hauppauge_hvr2200_2_config,
0563                 &i2c_bus->i2c_adap);
0564 
0565             if (port->dvb.frontend != NULL) {
0566                 /* TODO: addr is in the card struct */
0567                 dvb_attach(tda18271_attach, port->dvb.frontend,
0568                     0xc0 >> 1, &i2c_bus->i2c_adap,
0569                     &hauppauge_hvr22x0s_tuner_config);
0570             }
0571 
0572             break;
0573         }
0574         break;
0575     case SAA7164_BOARD_HAUPPAUGE_HVR2250:
0576     case SAA7164_BOARD_HAUPPAUGE_HVR2250_2:
0577     case SAA7164_BOARD_HAUPPAUGE_HVR2250_3:
0578         i2c_bus = &dev->i2c_bus[port->nr + 1];
0579 
0580         port->dvb.frontend = dvb_attach(s5h1411_attach,
0581             &hauppauge_s5h1411_config,
0582             &i2c_bus->i2c_adap);
0583 
0584         if (port->dvb.frontend != NULL) {
0585             if (port->nr == 0) {
0586                 /* Master TDA18271 */
0587                 /* TODO: addr is in the card struct */
0588                 dvb_attach(tda18271_attach, port->dvb.frontend,
0589                     0xc0 >> 1, &i2c_bus->i2c_adap,
0590                     &hauppauge_hvr22x0_tuner_config);
0591             } else {
0592                 /* Slave TDA18271 */
0593                 dvb_attach(tda18271_attach, port->dvb.frontend,
0594                     0xc0 >> 1, &i2c_bus->i2c_adap,
0595                     &hauppauge_hvr22x0s_tuner_config);
0596             }
0597         }
0598 
0599         break;
0600     case SAA7164_BOARD_HAUPPAUGE_HVR2255proto:
0601     case SAA7164_BOARD_HAUPPAUGE_HVR2255:
0602         i2c_bus = &dev->i2c_bus[2];
0603 
0604         if (port->nr == 0) {
0605             port->dvb.frontend = dvb_attach(lgdt3306a_attach,
0606                 &hauppauge_hvr2255a_config, &i2c_bus->i2c_adap);
0607         } else {
0608             port->dvb.frontend = dvb_attach(lgdt3306a_attach,
0609                 &hauppauge_hvr2255b_config, &i2c_bus->i2c_adap);
0610         }
0611 
0612         if (port->dvb.frontend != NULL) {
0613 
0614             if (port->nr == 0) {
0615                 si2157_attach(port, &dev->i2c_bus[0].i2c_adap,
0616                           port->dvb.frontend, 0xc0,
0617                           &hauppauge_hvr2255_tuner_config);
0618             } else {
0619                 si2157_attach(port, &dev->i2c_bus[1].i2c_adap,
0620                           port->dvb.frontend, 0xc0,
0621                           &hauppauge_hvr2255_tuner_config);
0622             }
0623         }
0624         break;
0625     case SAA7164_BOARD_HAUPPAUGE_HVR2205:
0626 
0627         if (port->nr == 0) {
0628             /* attach frontend */
0629             memset(&si2168_config, 0, sizeof(si2168_config));
0630             si2168_config.i2c_adapter = &adapter;
0631             si2168_config.fe = &port->dvb.frontend;
0632             si2168_config.ts_mode = SI2168_TS_SERIAL;
0633             memset(&info, 0, sizeof(struct i2c_board_info));
0634             strscpy(info.type, "si2168", I2C_NAME_SIZE);
0635             info.addr = 0xc8 >> 1;
0636             info.platform_data = &si2168_config;
0637             request_module(info.type);
0638             client_demod = i2c_new_client_device(&dev->i2c_bus[2].i2c_adap, &info);
0639             if (!i2c_client_has_driver(client_demod))
0640                 goto frontend_detach;
0641 
0642             if (!try_module_get(client_demod->dev.driver->owner)) {
0643                 i2c_unregister_device(client_demod);
0644                 goto frontend_detach;
0645             }
0646             port->i2c_client_demod = client_demod;
0647 
0648             /* attach tuner */
0649             memset(&si2157_config, 0, sizeof(si2157_config));
0650             si2157_config.if_port = 1;
0651             si2157_config.fe = port->dvb.frontend;
0652             memset(&info, 0, sizeof(struct i2c_board_info));
0653             strscpy(info.type, "si2157", I2C_NAME_SIZE);
0654             info.addr = 0xc0 >> 1;
0655             info.platform_data = &si2157_config;
0656             request_module(info.type);
0657             client_tuner = i2c_new_client_device(&dev->i2c_bus[0].i2c_adap, &info);
0658             if (!i2c_client_has_driver(client_tuner)) {
0659                 module_put(client_demod->dev.driver->owner);
0660                 i2c_unregister_device(client_demod);
0661                 goto frontend_detach;
0662             }
0663             if (!try_module_get(client_tuner->dev.driver->owner)) {
0664                 i2c_unregister_device(client_tuner);
0665                 module_put(client_demod->dev.driver->owner);
0666                 i2c_unregister_device(client_demod);
0667                 goto frontend_detach;
0668             }
0669             port->i2c_client_tuner = client_tuner;
0670         } else {
0671             /* attach frontend */
0672             memset(&si2168_config, 0, sizeof(si2168_config));
0673             si2168_config.i2c_adapter = &adapter;
0674             si2168_config.fe = &port->dvb.frontend;
0675             si2168_config.ts_mode = SI2168_TS_SERIAL;
0676             memset(&info, 0, sizeof(struct i2c_board_info));
0677             strscpy(info.type, "si2168", I2C_NAME_SIZE);
0678             info.addr = 0xcc >> 1;
0679             info.platform_data = &si2168_config;
0680             request_module(info.type);
0681             client_demod = i2c_new_client_device(&dev->i2c_bus[2].i2c_adap, &info);
0682             if (!i2c_client_has_driver(client_demod))
0683                 goto frontend_detach;
0684 
0685             if (!try_module_get(client_demod->dev.driver->owner)) {
0686                 i2c_unregister_device(client_demod);
0687                 goto frontend_detach;
0688             }
0689             port->i2c_client_demod = client_demod;
0690 
0691             /* attach tuner */
0692             memset(&si2157_config, 0, sizeof(si2157_config));
0693             si2157_config.fe = port->dvb.frontend;
0694             si2157_config.if_port = 1;
0695             memset(&info, 0, sizeof(struct i2c_board_info));
0696             strscpy(info.type, "si2157", I2C_NAME_SIZE);
0697             info.addr = 0xc0 >> 1;
0698             info.platform_data = &si2157_config;
0699             request_module(info.type);
0700             client_tuner = i2c_new_client_device(&dev->i2c_bus[1].i2c_adap, &info);
0701             if (!i2c_client_has_driver(client_tuner)) {
0702                 module_put(client_demod->dev.driver->owner);
0703                 i2c_unregister_device(client_demod);
0704                 goto frontend_detach;
0705             }
0706             if (!try_module_get(client_tuner->dev.driver->owner)) {
0707                 i2c_unregister_device(client_tuner);
0708                 module_put(client_demod->dev.driver->owner);
0709                 i2c_unregister_device(client_demod);
0710                 goto frontend_detach;
0711             }
0712             port->i2c_client_tuner = client_tuner;
0713         }
0714 
0715         break;
0716     default:
0717         printk(KERN_ERR "%s: The frontend isn't supported\n",
0718                dev->name);
0719         break;
0720     }
0721     if (NULL == dvb->frontend) {
0722         printk(KERN_ERR "%s() Frontend initialization failed\n",
0723                __func__);
0724         return -1;
0725     }
0726 
0727     /* register everything */
0728     ret = dvb_register(port);
0729     if (ret < 0) {
0730         if (dvb->frontend->ops.release)
0731             dvb->frontend->ops.release(dvb->frontend);
0732         return ret;
0733     }
0734 
0735     return 0;
0736 
0737 frontend_detach:
0738     printk(KERN_ERR "%s() Frontend/I2C initialization failed\n", __func__);
0739     return -1;
0740 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!