← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/media/dvb/ngene/ngene-core.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/dvb/ngene/ngene-core.c
45
45
module_param(one_adapter, int, 0444);
46
46
MODULE_PARM_DESC(one_adapter, "Use only one adapter.");
47
47
 
 
48
static int shutdown_workaround;
 
49
module_param(shutdown_workaround, int, 0644);
 
50
MODULE_PARM_DESC(shutdown_workaround, "Activate workaround for shutdown problem with some chipsets.");
48
51
 
49
52
static int debug;
50
53
module_param(debug, int, 0444);
119
122
                                                Cur->ngeneBuffer.SR.Flags &=
120
123
                                                        ~0x40;
121
124
                                                break;
122
 
                                                /* Stop proccessing stream */
 
125
                                                /* Stop processing stream */
123
126
                                        }
124
127
                                } else {
125
128
                                        /* We got a valid buffer,
130
133
                                printk(KERN_ERR DEVICE_NAME ": OOPS\n");
131
134
                                if (chan->HWState == HWSTATE_RUN) {
132
135
                                        Cur->ngeneBuffer.SR.Flags &= ~0x40;
133
 
                                        break;  /* Stop proccessing stream */
 
136
                                        break;  /* Stop processing stream */
134
137
                                }
135
138
                        }
136
139
                        if (chan->AudioDTOUpdated) {
143
146
                        }
144
147
                } else {
145
148
                        if (chan->HWState == HWSTATE_RUN) {
146
 
                                u32 Flags = 0;
 
149
                                u32 Flags = chan->DataFormatFlags;
147
150
                                IBufferExchange *exch1 = chan->pBufferExchange;
148
151
                                IBufferExchange *exch2 = chan->pBufferExchange2;
149
152
                                if (Cur->ngeneBuffer.SR.Flags & 0x01)
474
477
 
475
478
/* Set NGENE I2S Config to transport stream compatible mode */
476
479
 
477
 
static u8 TS_I2SConfiguration[4] = { 0x3E, 0x1A, 0x00, 0x00 }; /*3e 18 00 00 ?*/
 
480
static u8 TS_I2SConfiguration[4] = { 0x3E, 0x18, 0x00, 0x00 };
478
481
 
479
 
static u8 TS_I2SOutConfiguration[4] = { 0x80, 0x20, 0x00, 0x00 };
 
482
static u8 TS_I2SOutConfiguration[4] = { 0x80, 0x04, 0x00, 0x00 };
480
483
 
481
484
static u8 ITUDecoderSetup[4][16] = {
482
485
        {0x1c, 0x13, 0x01, 0x68, 0x3d, 0x90, 0x14, 0x20,  /* SDTV */
749
752
                if (chan->mode & NGENE_IO_TSOUT) {
750
753
                        chan->pBufferExchange = tsout_exchange;
751
754
                        /* 0x66666666 = 50MHz *2^33 /250MHz */
752
 
                        chan->AudioDTOValue = 0x66666666;
753
 
                        /* set_dto(chan, 38810700+1000); */
754
 
                        /* set_dto(chan, 19392658); */
 
755
                        chan->AudioDTOValue = 0x80000000;
 
756
                        chan->AudioDTOUpdated = 1;
755
757
                }
756
758
                if (chan->mode & NGENE_IO_TSIN)
757
759
                        chan->pBufferExchange = tsin_exchange;
758
 
                /* ngwritel(0, 0x9310); */
759
760
                spin_unlock_irq(&chan->state_lock);
760
761
        } else
761
762
                ;/* printk(KERN_INFO DEVICE_NAME ": lock=%08x\n",
1168
1169
                iounmap(dev->iomem);
1169
1170
        free_common_buffers(dev);
1170
1171
        vfree(dev->tsout_buf);
 
1172
        vfree(dev->tsin_buf);
1171
1173
        vfree(dev->ain_buf);
1172
1174
        vfree(dev->vin_buf);
1173
1175
        vfree(dev);
1184
1186
                dvb_ringbuffer_init(&dev->tsout_rbuf,
1185
1187
                                    dev->tsout_buf, TSOUT_BUF_SIZE);
1186
1188
        }
 
1189
        if (dev->card_info->io_type[2]&NGENE_IO_TSIN) {
 
1190
                dev->tsin_buf = vmalloc(TSIN_BUF_SIZE);
 
1191
                if (!dev->tsin_buf)
 
1192
                        return -ENOMEM;
 
1193
                dvb_ringbuffer_init(&dev->tsin_rbuf,
 
1194
                                    dev->tsin_buf, TSIN_BUF_SIZE);
 
1195
        }
1187
1196
        if (dev->card_info->io_type[2] & NGENE_IO_AIN) {
1188
1197
                dev->ain_buf = vmalloc(AIN_BUF_SIZE);
1189
1198
                if (!dev->ain_buf)
1257
1266
                fw_name = "ngene_17.fw";
1258
1267
                dev->cmd_timeout_workaround = true;
1259
1268
                break;
 
1269
        case 18:
 
1270
                size = 0;
 
1271
                fw_name = "ngene_18.fw";
 
1272
                break;
1260
1273
        }
1261
1274
 
1262
1275
        if (request_firmware(&fw, fw_name, &dev->pci_dev->dev) < 0) {
1266
1279
                        ": Copy %s to your hotplug directory!\n", fw_name);
1267
1280
                return -1;
1268
1281
        }
 
1282
        if (size == 0)
 
1283
                size = fw->size;
1269
1284
        if (size != fw->size) {
1270
1285
                printk(KERN_ERR DEVICE_NAME
1271
1286
                        ": Firmware %s has invalid size!", fw_name);
1301
1316
#endif
1302
1317
}
1303
1318
 
 
1319
static int ngene_buffer_config(struct ngene *dev)
 
1320
{
 
1321
        int stat;
 
1322
 
 
1323
        if (dev->card_info->fw_version >= 17) {
 
1324
                u8 tsin12_config[6]   = { 0x60, 0x60, 0x00, 0x00, 0x00, 0x00 };
 
1325
                u8 tsin1234_config[6] = { 0x30, 0x30, 0x00, 0x30, 0x30, 0x00 };
 
1326
                u8 tsio1235_config[6] = { 0x30, 0x30, 0x00, 0x28, 0x00, 0x38 };
 
1327
                u8 *bconf = tsin12_config;
 
1328
 
 
1329
                if (dev->card_info->io_type[2]&NGENE_IO_TSIN &&
 
1330
                    dev->card_info->io_type[3]&NGENE_IO_TSIN) {
 
1331
                        bconf = tsin1234_config;
 
1332
                        if (dev->card_info->io_type[4]&NGENE_IO_TSOUT &&
 
1333
                            dev->ci.en)
 
1334
                                bconf = tsio1235_config;
 
1335
                }
 
1336
                stat = ngene_command_config_free_buf(dev, bconf);
 
1337
        } else {
 
1338
                int bconf = BUFFER_CONFIG_4422;
 
1339
 
 
1340
                if (dev->card_info->io_type[3] == NGENE_IO_TSIN)
 
1341
                        bconf = BUFFER_CONFIG_3333;
 
1342
                stat = ngene_command_config_buf(dev, bconf);
 
1343
        }
 
1344
        return stat;
 
1345
}
 
1346
 
 
1347
 
1304
1348
static int ngene_start(struct ngene *dev)
1305
1349
{
1306
1350
        int stat;
1365
1409
        if (stat < 0)
1366
1410
                goto fail;
1367
1411
 
1368
 
        if (dev->card_info->fw_version == 17) {
1369
 
                u8 tsin4_config[6] = {
1370
 
                        3072 / 64, 3072 / 64, 0, 3072 / 64, 3072 / 64, 0};
1371
 
                u8 default_config[6] = {
1372
 
                        4096 / 64, 4096 / 64, 0, 2048 / 64, 2048 / 64, 0};
1373
 
                u8 *bconf = default_config;
1374
 
 
1375
 
                if (dev->card_info->io_type[3] == NGENE_IO_TSIN)
1376
 
                        bconf = tsin4_config;
1377
 
                dprintk(KERN_DEBUG DEVICE_NAME ": FW 17 buffer config\n");
1378
 
                stat = ngene_command_config_free_buf(dev, bconf);
1379
 
        } else {
1380
 
                int bconf = BUFFER_CONFIG_4422;
1381
 
                if (dev->card_info->io_type[3] == NGENE_IO_TSIN)
1382
 
                        bconf = BUFFER_CONFIG_3333;
1383
 
                stat = ngene_command_config_buf(dev, bconf);
1384
 
        }
1385
1412
        if (!stat)
1386
1413
                return stat;
1387
1414
 
1397
1424
        return stat;
1398
1425
}
1399
1426
 
1400
 
 
1401
 
 
1402
 
 
1403
1427
/****************************************************************************/
1404
1428
/****************************************************************************/
1405
1429
/****************************************************************************/
1408
1432
{
1409
1433
        struct dvb_demux *dvbdemux = &chan->demux;
1410
1434
        struct ngene *dev = chan->dev;
1411
 
        struct ngene_info *ni = dev->card_info;
1412
 
        int io = ni->io_type[chan->number];
1413
1435
 
1414
 
        if (chan->dev->cmd_timeout_workaround && chan->running)
 
1436
        if (chan->running)
1415
1437
                set_transfer(chan, 0);
1416
1438
 
1417
1439
        tasklet_kill(&chan->demux_tasklet);
1418
1440
 
1419
 
        if (io & (NGENE_IO_TSIN | NGENE_IO_TSOUT)) {
1420
 
                if (chan->fe) {
1421
 
                        dvb_unregister_frontend(chan->fe);
1422
 
                        dvb_frontend_detach(chan->fe);
1423
 
                        chan->fe = NULL;
1424
 
                }
 
1441
        if (chan->ci_dev) {
 
1442
                dvb_unregister_device(chan->ci_dev);
 
1443
                chan->ci_dev = NULL;
 
1444
        }
 
1445
 
 
1446
        if (chan->fe) {
 
1447
                dvb_unregister_frontend(chan->fe);
 
1448
                dvb_frontend_detach(chan->fe);
 
1449
                chan->fe = NULL;
 
1450
        }
 
1451
 
 
1452
        if (chan->has_demux) {
 
1453
                dvb_net_release(&chan->dvbnet);
1425
1454
                dvbdemux->dmx.close(&dvbdemux->dmx);
1426
1455
                dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1427
1456
                                              &chan->hw_frontend);
1429
1458
                                              &chan->mem_frontend);
1430
1459
                dvb_dmxdev_release(&chan->dmxdev);
1431
1460
                dvb_dmx_release(&chan->demux);
 
1461
                chan->has_demux = false;
 
1462
        }
1432
1463
 
1433
 
                if (chan->number == 0 || !one_adapter)
1434
 
                        dvb_unregister_adapter(&dev->adapter[chan->number]);
 
1464
        if (chan->has_adapter) {
 
1465
                dvb_unregister_adapter(&dev->adapter[chan->number]);
 
1466
                chan->has_adapter = false;
1435
1467
        }
1436
1468
}
1437
1469
 
1449
1481
        chan->type = io;
1450
1482
        chan->mode = chan->type;        /* for now only one mode */
1451
1483
 
 
1484
        if (io & NGENE_IO_TSIN) {
 
1485
                chan->fe = NULL;
 
1486
                if (ni->demod_attach[nr]) {
 
1487
                        ret = ni->demod_attach[nr](chan);
 
1488
                        if (ret < 0)
 
1489
                                goto err;
 
1490
                }
 
1491
                if (chan->fe && ni->tuner_attach[nr]) {
 
1492
                        ret = ni->tuner_attach[nr](chan);
 
1493
                        if (ret < 0)
 
1494
                                goto err;
 
1495
                }
 
1496
        }
 
1497
 
 
1498
        if (!dev->ci.en && (io & NGENE_IO_TSOUT))
 
1499
                return 0;
 
1500
 
1452
1501
        if (io & (NGENE_IO_TSIN | NGENE_IO_TSOUT)) {
1453
1502
                if (nr >= STREAM_AUDIOIN1)
1454
1503
                        chan->DataFormatFlags = DF_SWAP32;
 
1504
 
1455
1505
                if (nr == 0 || !one_adapter || dev->first_adapter == NULL) {
1456
1506
                        adapter = &dev->adapter[nr];
1457
1507
                        ret = dvb_register_adapter(adapter, "nGene",
1459
1509
                                                   &chan->dev->pci_dev->dev,
1460
1510
                                                   adapter_nr);
1461
1511
                        if (ret < 0)
1462
 
                                return ret;
 
1512
                                goto err;
1463
1513
                        if (dev->first_adapter == NULL)
1464
1514
                                dev->first_adapter = adapter;
1465
 
                } else {
 
1515
                        chan->has_adapter = true;
 
1516
                } else
1466
1517
                        adapter = dev->first_adapter;
1467
 
                }
1468
 
 
 
1518
        }
 
1519
 
 
1520
        if (dev->ci.en && (io & NGENE_IO_TSOUT)) {
 
1521
                dvb_ca_en50221_init(adapter, dev->ci.en, 0, 1);
 
1522
                set_transfer(chan, 1);
 
1523
                chan->dev->channel[2].DataFormatFlags = DF_SWAP32;
 
1524
                set_transfer(&chan->dev->channel[2], 1);
 
1525
                dvb_register_device(adapter, &chan->ci_dev,
 
1526
                                    &ngene_dvbdev_ci, (void *) chan,
 
1527
                                    DVB_DEVICE_SEC);
 
1528
                if (!chan->ci_dev)
 
1529
                        goto err;
 
1530
        }
 
1531
 
 
1532
        if (chan->fe) {
 
1533
                if (dvb_register_frontend(adapter, chan->fe) < 0)
 
1534
                        goto err;
 
1535
                chan->has_demux = true;
 
1536
        }
 
1537
 
 
1538
        if (chan->has_demux) {
1469
1539
                ret = my_dvb_dmx_ts_card_init(dvbdemux, "SW demux",
1470
1540
                                              ngene_start_feed,
1471
1541
                                              ngene_stop_feed, chan);
1472
1542
                ret = my_dvb_dmxdev_ts_card_init(&chan->dmxdev, &chan->demux,
1473
1543
                                                 &chan->hw_frontend,
1474
1544
                                                 &chan->mem_frontend, adapter);
 
1545
                ret = dvb_net_init(adapter, &chan->dvbnet, &chan->demux.dmx);
1475
1546
        }
1476
1547
 
1477
 
        if (io & NGENE_IO_TSIN) {
1478
 
                chan->fe = NULL;
1479
 
                if (ni->demod_attach[nr])
1480
 
                        ni->demod_attach[nr](chan);
1481
 
                if (chan->fe) {
1482
 
                        if (dvb_register_frontend(adapter, chan->fe) < 0) {
1483
 
                                if (chan->fe->ops.release)
1484
 
                                        chan->fe->ops.release(chan->fe);
1485
 
                                chan->fe = NULL;
1486
 
                        }
1487
 
                }
1488
 
                if (chan->fe && ni->tuner_attach[nr])
1489
 
                        if (ni->tuner_attach[nr] (chan) < 0) {
1490
 
                                printk(KERN_ERR DEVICE_NAME
1491
 
                                       ": Tuner attach failed on channel %d!\n",
1492
 
                                       nr);
1493
 
                        }
1494
 
        }
1495
1548
        return ret;
 
1549
 
 
1550
err:
 
1551
        if (chan->fe) {
 
1552
                dvb_frontend_detach(chan->fe);
 
1553
                chan->fe = NULL;
 
1554
        }
 
1555
        release_channel(chan);
 
1556
        return 0;
1496
1557
}
1497
1558
 
1498
1559
static int init_channels(struct ngene *dev)
1510
1571
        return 0;
1511
1572
}
1512
1573
 
 
1574
static void cxd_attach(struct ngene *dev)
 
1575
{
 
1576
        struct ngene_ci *ci = &dev->ci;
 
1577
 
 
1578
        ci->en = cxd2099_attach(0x40, dev, &dev->channel[0].i2c_adapter);
 
1579
        ci->dev = dev;
 
1580
        return;
 
1581
}
 
1582
 
 
1583
static void cxd_detach(struct ngene *dev)
 
1584
{
 
1585
        struct ngene_ci *ci = &dev->ci;
 
1586
 
 
1587
        dvb_ca_en50221_release(ci->en);
 
1588
        kfree(ci->en);
 
1589
        ci->en = 0;
 
1590
}
 
1591
 
 
1592
/***********************************/
 
1593
/* workaround for shutdown failure */
 
1594
/***********************************/
 
1595
 
 
1596
static void ngene_unlink(struct ngene *dev)
 
1597
{
 
1598
        struct ngene_command com;
 
1599
 
 
1600
        com.cmd.hdr.Opcode = CMD_MEM_WRITE;
 
1601
        com.cmd.hdr.Length = 3;
 
1602
        com.cmd.MemoryWrite.address = 0x910c;
 
1603
        com.cmd.MemoryWrite.data = 0xff;
 
1604
        com.in_len = 3;
 
1605
        com.out_len = 1;
 
1606
 
 
1607
        down(&dev->cmd_mutex);
 
1608
        ngwritel(0, NGENE_INT_ENABLE);
 
1609
        ngene_command_mutex(dev, &com);
 
1610
        up(&dev->cmd_mutex);
 
1611
}
 
1612
 
 
1613
void ngene_shutdown(struct pci_dev *pdev)
 
1614
{
 
1615
        struct ngene *dev = (struct ngene *)pci_get_drvdata(pdev);
 
1616
 
 
1617
        if (!dev || !shutdown_workaround)
 
1618
                return;
 
1619
 
 
1620
        printk(KERN_INFO DEVICE_NAME ": shutdown workaround...\n");
 
1621
        ngene_unlink(dev);
 
1622
        pci_disable_device(pdev);
 
1623
}
 
1624
 
1513
1625
/****************************************************************************/
1514
1626
/* device probe/remove calls ************************************************/
1515
1627
/****************************************************************************/
1522
1634
        tasklet_kill(&dev->event_tasklet);
1523
1635
        for (i = MAX_STREAM - 1; i >= 0; i--)
1524
1636
                release_channel(&dev->channel[i]);
 
1637
        if (dev->ci.en)
 
1638
                cxd_detach(dev);
1525
1639
        ngene_stop(dev);
1526
1640
        ngene_release_buffers(dev);
1527
1641
        pci_set_drvdata(pdev, NULL);
1557
1671
        if (stat < 0)
1558
1672
                goto fail1;
1559
1673
 
 
1674
        cxd_attach(dev);
 
1675
 
 
1676
        stat = ngene_buffer_config(dev);
 
1677
        if (stat < 0)
 
1678
                goto fail1;
 
1679
 
 
1680
 
1560
1681
        dev->i2c_current_bus = -1;
1561
1682
 
1562
1683
        /* Register DVB adapters and devices for both channels */