diff options
Diffstat (limited to 'drivers/media')
53 files changed, 383 insertions, 2289 deletions
diff --git a/drivers/media/dvb/b2c2/Kconfig b/drivers/media/dvb/b2c2/Kconfig index 2583a865a58e..2963605c0ecc 100644 --- a/drivers/media/dvb/b2c2/Kconfig +++ b/drivers/media/dvb/b2c2/Kconfig | |||
| @@ -4,7 +4,7 @@ config DVB_B2C2_FLEXCOP | |||
| 4 | select DVB_STV0299 | 4 | select DVB_STV0299 |
| 5 | select DVB_MT352 | 5 | select DVB_MT352 |
| 6 | select DVB_MT312 | 6 | select DVB_MT312 |
| 7 | select DVB_NXT2002 | 7 | select DVB_NXT200X |
| 8 | select DVB_STV0297 | 8 | select DVB_STV0297 |
| 9 | select DVB_BCM3510 | 9 | select DVB_BCM3510 |
| 10 | select DVB_LGDT330X | 10 | select DVB_LGDT330X |
diff --git a/drivers/media/dvb/b2c2/flexcop-common.h b/drivers/media/dvb/b2c2/flexcop-common.h index 344a3c898460..7d7e1613c5a7 100644 --- a/drivers/media/dvb/b2c2/flexcop-common.h +++ b/drivers/media/dvb/b2c2/flexcop-common.h | |||
| @@ -116,11 +116,9 @@ void flexcop_dma_free(struct flexcop_dma *dma); | |||
| 116 | 116 | ||
| 117 | int flexcop_dma_control_timer_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff); | 117 | int flexcop_dma_control_timer_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff); |
| 118 | int flexcop_dma_control_size_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff); | 118 | int flexcop_dma_control_size_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff); |
| 119 | int flexcop_dma_control_packet_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff); | ||
| 120 | int flexcop_dma_config(struct flexcop_device *fc, struct flexcop_dma *dma, flexcop_dma_index_t dma_idx); | 119 | int flexcop_dma_config(struct flexcop_device *fc, struct flexcop_dma *dma, flexcop_dma_index_t dma_idx); |
| 121 | int flexcop_dma_xfer_control(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, flexcop_dma_addr_index_t index, int onoff); | 120 | int flexcop_dma_xfer_control(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, flexcop_dma_addr_index_t index, int onoff); |
| 122 | int flexcop_dma_config_timer(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, u8 cycles); | 121 | int flexcop_dma_config_timer(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, u8 cycles); |
| 123 | int flexcop_dma_config_packet_count(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, u8 packets); | ||
| 124 | 122 | ||
| 125 | /* from flexcop-eeprom.c */ | 123 | /* from flexcop-eeprom.c */ |
| 126 | /* the PCI part uses this call to get the MAC address, the USB part has its own */ | 124 | /* the PCI part uses this call to get the MAC address, the USB part has its own */ |
diff --git a/drivers/media/dvb/b2c2/flexcop-dma.c b/drivers/media/dvb/b2c2/flexcop-dma.c index cf4ed1df6086..6f592bc32d22 100644 --- a/drivers/media/dvb/b2c2/flexcop-dma.c +++ b/drivers/media/dvb/b2c2/flexcop-dma.c | |||
| @@ -169,38 +169,3 @@ int flexcop_dma_config_timer(struct flexcop_device *fc, | |||
| 169 | } | 169 | } |
| 170 | EXPORT_SYMBOL(flexcop_dma_config_timer); | 170 | EXPORT_SYMBOL(flexcop_dma_config_timer); |
| 171 | 171 | ||
| 172 | /* packet IRQ does not exist in FCII or FCIIb - according to data book and tests */ | ||
| 173 | int flexcop_dma_control_packet_irq(struct flexcop_device *fc, | ||
| 174 | flexcop_dma_index_t no, | ||
| 175 | int onoff) | ||
| 176 | { | ||
| 177 | flexcop_ibi_value v = fc->read_ibi_reg(fc,ctrl_208); | ||
| 178 | |||
| 179 | deb_rdump("reg: %03x: %x\n",ctrl_208,v.raw); | ||
| 180 | if (no & FC_DMA_1) | ||
| 181 | v.ctrl_208.DMA1_Size_IRQ_Enable_sig = onoff; | ||
| 182 | |||
| 183 | if (no & FC_DMA_2) | ||
| 184 | v.ctrl_208.DMA2_Size_IRQ_Enable_sig = onoff; | ||
| 185 | |||
| 186 | fc->write_ibi_reg(fc,ctrl_208,v); | ||
| 187 | deb_rdump("reg: %03x: %x\n",ctrl_208,v.raw); | ||
| 188 | |||
| 189 | return 0; | ||
| 190 | } | ||
| 191 | EXPORT_SYMBOL(flexcop_dma_control_packet_irq); | ||
| 192 | |||
| 193 | int flexcop_dma_config_packet_count(struct flexcop_device *fc, | ||
| 194 | flexcop_dma_index_t dma_idx, | ||
| 195 | u8 packets) | ||
| 196 | { | ||
| 197 | flexcop_ibi_register r = (dma_idx & FC_DMA_1) ? dma1_004 : dma2_014; | ||
| 198 | flexcop_ibi_value v = fc->read_ibi_reg(fc,r); | ||
| 199 | |||
| 200 | flexcop_dma_remap(fc,dma_idx,1); | ||
| 201 | |||
| 202 | v.dma_0x4_remap.DMA_maxpackets = packets; | ||
| 203 | fc->write_ibi_reg(fc,r,v); | ||
| 204 | return 0; | ||
| 205 | } | ||
| 206 | EXPORT_SYMBOL(flexcop_dma_config_packet_count); | ||
diff --git a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c index 0b940e152b79..390cc3a99ce6 100644 --- a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c +++ b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c | |||
| @@ -9,7 +9,7 @@ | |||
| 9 | 9 | ||
| 10 | #include "stv0299.h" | 10 | #include "stv0299.h" |
| 11 | #include "mt352.h" | 11 | #include "mt352.h" |
| 12 | #include "nxt2002.h" | 12 | #include "nxt200x.h" |
| 13 | #include "bcm3510.h" | 13 | #include "bcm3510.h" |
| 14 | #include "stv0297.h" | 14 | #include "stv0297.h" |
| 15 | #include "mt312.h" | 15 | #include "mt312.h" |
| @@ -343,9 +343,10 @@ static struct lgdt330x_config air2pc_atsc_hd5000_config = { | |||
| 343 | .clock_polarity_flip = 1, | 343 | .clock_polarity_flip = 1, |
| 344 | }; | 344 | }; |
| 345 | 345 | ||
| 346 | static struct nxt2002_config samsung_tbmv_config = { | 346 | static struct nxt200x_config samsung_tbmv_config = { |
| 347 | .demod_address = 0x0a, | 347 | .demod_address = 0x0a, |
| 348 | .request_firmware = flexcop_fe_request_firmware, | 348 | .pll_address = 0xc2, |
| 349 | .pll_desc = &dvb_pll_samsung_tbmv, | ||
| 349 | }; | 350 | }; |
| 350 | 351 | ||
| 351 | static struct bcm3510_config air2pc_atsc_first_gen_config = { | 352 | static struct bcm3510_config air2pc_atsc_first_gen_config = { |
| @@ -505,7 +506,7 @@ int flexcop_frontend_init(struct flexcop_device *fc) | |||
| 505 | info("found the mt352 at i2c address: 0x%02x",samsung_tdtc9251dh0_config.demod_address); | 506 | info("found the mt352 at i2c address: 0x%02x",samsung_tdtc9251dh0_config.demod_address); |
| 506 | } else | 507 | } else |
| 507 | /* try the air atsc 2nd generation (nxt2002) */ | 508 | /* try the air atsc 2nd generation (nxt2002) */ |
| 508 | if ((fc->fe = nxt2002_attach(&samsung_tbmv_config, &fc->i2c_adap)) != NULL) { | 509 | if ((fc->fe = nxt200x_attach(&samsung_tbmv_config, &fc->i2c_adap)) != NULL) { |
| 509 | fc->dev_type = FC_AIR_ATSC2; | 510 | fc->dev_type = FC_AIR_ATSC2; |
| 510 | info("found the nxt2002 at i2c address: 0x%02x",samsung_tbmv_config.demod_address); | 511 | info("found the nxt2002 at i2c address: 0x%02x",samsung_tbmv_config.demod_address); |
| 511 | } else | 512 | } else |
diff --git a/drivers/media/dvb/b2c2/flexcop-misc.c b/drivers/media/dvb/b2c2/flexcop-misc.c index 62282d8dbfa8..167583bf0621 100644 --- a/drivers/media/dvb/b2c2/flexcop-misc.c +++ b/drivers/media/dvb/b2c2/flexcop-misc.c | |||
| @@ -36,14 +36,14 @@ void flexcop_determine_revision(struct flexcop_device *fc) | |||
| 36 | /* bus parts have to decide if hw pid filtering is used or not. */ | 36 | /* bus parts have to decide if hw pid filtering is used or not. */ |
| 37 | } | 37 | } |
| 38 | 38 | ||
| 39 | const char *flexcop_revision_names[] = { | 39 | static const char *flexcop_revision_names[] = { |
| 40 | "Unkown chip", | 40 | "Unkown chip", |
| 41 | "FlexCopII", | 41 | "FlexCopII", |
| 42 | "FlexCopIIb", | 42 | "FlexCopIIb", |
| 43 | "FlexCopIII", | 43 | "FlexCopIII", |
| 44 | }; | 44 | }; |
| 45 | 45 | ||
| 46 | const char *flexcop_device_names[] = { | 46 | static const char *flexcop_device_names[] = { |
| 47 | "Unkown device", | 47 | "Unkown device", |
| 48 | "Air2PC/AirStar 2 DVB-T", | 48 | "Air2PC/AirStar 2 DVB-T", |
| 49 | "Air2PC/AirStar 2 ATSC 1st generation", | 49 | "Air2PC/AirStar 2 ATSC 1st generation", |
| @@ -54,7 +54,7 @@ const char *flexcop_device_names[] = { | |||
| 54 | "Air2PC/AirStar 2 ATSC 3rd generation (HD5000)", | 54 | "Air2PC/AirStar 2 ATSC 3rd generation (HD5000)", |
| 55 | }; | 55 | }; |
| 56 | 56 | ||
| 57 | const char *flexcop_bus_names[] = { | 57 | static const char *flexcop_bus_names[] = { |
| 58 | "USB", | 58 | "USB", |
| 59 | "PCI", | 59 | "PCI", |
| 60 | }; | 60 | }; |
diff --git a/drivers/media/dvb/b2c2/flexcop-pci.c b/drivers/media/dvb/b2c2/flexcop-pci.c index 2f76eb3fea40..9bc40bdcc282 100644 --- a/drivers/media/dvb/b2c2/flexcop-pci.c +++ b/drivers/media/dvb/b2c2/flexcop-pci.c | |||
| @@ -161,8 +161,10 @@ static irqreturn_t flexcop_pci_isr(int irq, void *dev_id, struct pt_regs *regs) | |||
| 161 | fc->read_ibi_reg(fc,dma1_008).dma_0x8.dma_cur_addr << 2; | 161 | fc->read_ibi_reg(fc,dma1_008).dma_0x8.dma_cur_addr << 2; |
| 162 | u32 cur_pos = cur_addr - fc_pci->dma[0].dma_addr0; | 162 | u32 cur_pos = cur_addr - fc_pci->dma[0].dma_addr0; |
| 163 | 163 | ||
| 164 | deb_irq("%u irq: %08x cur_addr: %08x: cur_pos: %08x, last_cur_pos: %08x ", | 164 | deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, last_cur_pos: %08x ", |
| 165 | jiffies_to_usecs(jiffies - fc_pci->last_irq),v.raw,cur_addr,cur_pos,fc_pci->last_dma1_cur_pos); | 165 | jiffies_to_usecs(jiffies - fc_pci->last_irq), |
| 166 | v.raw, (unsigned long long)cur_addr, cur_pos, | ||
| 167 | fc_pci->last_dma1_cur_pos); | ||
| 166 | fc_pci->last_irq = jiffies; | 168 | fc_pci->last_irq = jiffies; |
| 167 | 169 | ||
| 168 | /* buffer end was reached, restarted from the beginning | 170 | /* buffer end was reached, restarted from the beginning |
diff --git a/drivers/media/dvb/b2c2/flexcop-reg.h b/drivers/media/dvb/b2c2/flexcop-reg.h index 3153f9513c63..491f9bd6e195 100644 --- a/drivers/media/dvb/b2c2/flexcop-reg.h +++ b/drivers/media/dvb/b2c2/flexcop-reg.h | |||
| @@ -16,8 +16,6 @@ typedef enum { | |||
| 16 | FLEXCOP_III, | 16 | FLEXCOP_III, |
| 17 | } flexcop_revision_t; | 17 | } flexcop_revision_t; |
| 18 | 18 | ||
| 19 | extern const char *flexcop_revision_names[]; | ||
| 20 | |||
| 21 | typedef enum { | 19 | typedef enum { |
| 22 | FC_UNK = 0, | 20 | FC_UNK = 0, |
| 23 | FC_AIR_DVB, | 21 | FC_AIR_DVB, |
| @@ -34,8 +32,6 @@ typedef enum { | |||
| 34 | FC_PCI, | 32 | FC_PCI, |
| 35 | } flexcop_bus_t; | 33 | } flexcop_bus_t; |
| 36 | 34 | ||
| 37 | extern const char *flexcop_device_names[]; | ||
| 38 | |||
| 39 | /* FlexCop IBI Registers */ | 35 | /* FlexCop IBI Registers */ |
| 40 | #if defined(__LITTLE_ENDIAN) | 36 | #if defined(__LITTLE_ENDIAN) |
| 41 | #include "flexcop_ibi_value_le.h" | 37 | #include "flexcop_ibi_value_le.h" |
diff --git a/drivers/media/dvb/bt8xx/bt878.c b/drivers/media/dvb/bt8xx/bt878.c index a04bb61f21f4..34c3189a1a33 100644 --- a/drivers/media/dvb/bt8xx/bt878.c +++ b/drivers/media/dvb/bt8xx/bt878.c | |||
| @@ -381,6 +381,23 @@ bt878_device_control(struct bt878 *bt, unsigned int cmd, union dst_gpio_packet * | |||
| 381 | 381 | ||
| 382 | EXPORT_SYMBOL(bt878_device_control); | 382 | EXPORT_SYMBOL(bt878_device_control); |
| 383 | 383 | ||
| 384 | |||
| 385 | struct cards card_list[] __devinitdata = { | ||
| 386 | |||
| 387 | { 0x01010071, BTTV_BOARD_NEBULA_DIGITV, "Nebula Electronics DigiTV" }, | ||
| 388 | { 0x07611461, BTTV_BOARD_AVDVBT_761, "AverMedia AverTV DVB-T 761" }, | ||
| 389 | { 0x001c11bd, BTTV_BOARD_PINNACLESAT, "Pinnacle PCTV Sat" }, | ||
| 390 | { 0x002611bd, BTTV_BOARD_TWINHAN_DST, "Pinnacle PCTV SAT CI" }, | ||
| 391 | { 0x00011822, BTTV_BOARD_TWINHAN_DST, "Twinhan VisionPlus DVB" }, | ||
| 392 | { 0xfc00270f, BTTV_BOARD_TWINHAN_DST, "ChainTech digitop DST-1000 DVB-S" }, | ||
| 393 | { 0x07711461, BTTV_BOARD_AVDVBT_771, "AVermedia AverTV DVB-T 771" }, | ||
| 394 | { 0xdb1018ac, BTTV_BOARD_DVICO_DVBT_LITE, "DViCO FusionHDTV DVB-T Lite" }, | ||
| 395 | { 0xd50018ac, BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE, "DViCO FusionHDTV 5 Lite" }, | ||
| 396 | { 0x20007063, BTTV_BOARD_PC_HDTV, "pcHDTV HD-2000 TV"}, | ||
| 397 | { 0, -1, NULL } | ||
| 398 | }; | ||
| 399 | |||
| 400 | |||
| 384 | /***********************/ | 401 | /***********************/ |
| 385 | /* PCI device handling */ | 402 | /* PCI device handling */ |
| 386 | /***********************/ | 403 | /***********************/ |
| @@ -388,18 +405,41 @@ EXPORT_SYMBOL(bt878_device_control); | |||
| 388 | static int __devinit bt878_probe(struct pci_dev *dev, | 405 | static int __devinit bt878_probe(struct pci_dev *dev, |
| 389 | const struct pci_device_id *pci_id) | 406 | const struct pci_device_id *pci_id) |
| 390 | { | 407 | { |
| 391 | int result; | 408 | int result = 0, has_dvb = 0, i; |
| 392 | unsigned char lat; | 409 | unsigned char lat; |
| 393 | struct bt878 *bt; | 410 | struct bt878 *bt; |
| 394 | #if defined(__powerpc__) | 411 | #if defined(__powerpc__) |
| 395 | unsigned int cmd; | 412 | unsigned int cmd; |
| 396 | #endif | 413 | #endif |
| 414 | unsigned int cardid; | ||
| 415 | unsigned short id; | ||
| 416 | struct cards *dvb_cards; | ||
| 397 | 417 | ||
| 398 | printk(KERN_INFO "bt878: Bt878 AUDIO function found (%d).\n", | 418 | printk(KERN_INFO "bt878: Bt878 AUDIO function found (%d).\n", |
| 399 | bt878_num); | 419 | bt878_num); |
| 400 | if (pci_enable_device(dev)) | 420 | if (pci_enable_device(dev)) |
| 401 | return -EIO; | 421 | return -EIO; |
| 402 | 422 | ||
| 423 | pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &id); | ||
| 424 | cardid = id << 16; | ||
| 425 | pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &id); | ||
| 426 | cardid |= id; | ||
| 427 | |||
| 428 | for (i = 0, dvb_cards = card_list; i < ARRAY_SIZE(card_list); i++, dvb_cards++) { | ||
| 429 | if (cardid == dvb_cards->pci_id) { | ||
| 430 | printk("%s: card id=[0x%x],[ %s ] has DVB functions.\n", | ||
| 431 | __func__, cardid, dvb_cards->name); | ||
| 432 | has_dvb = 1; | ||
| 433 | } | ||
| 434 | } | ||
| 435 | |||
| 436 | if (!has_dvb) { | ||
| 437 | printk("%s: card id=[0x%x], Unknown card.\nExiting..\n", __func__, cardid); | ||
| 438 | result = -EINVAL; | ||
| 439 | |||
| 440 | goto fail0; | ||
| 441 | } | ||
| 442 | |||
| 403 | bt = &bt878[bt878_num]; | 443 | bt = &bt878[bt878_num]; |
| 404 | bt->dev = dev; | 444 | bt->dev = dev; |
| 405 | bt->nr = bt878_num; | 445 | bt->nr = bt878_num; |
| @@ -416,6 +456,8 @@ static int __devinit bt878_probe(struct pci_dev *dev, | |||
| 416 | 456 | ||
| 417 | pci_read_config_byte(dev, PCI_CLASS_REVISION, &bt->revision); | 457 | pci_read_config_byte(dev, PCI_CLASS_REVISION, &bt->revision); |
| 418 | pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); | 458 | pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); |
| 459 | |||
| 460 | |||
| 419 | printk(KERN_INFO "bt878(%d): Bt%x (rev %d) at %02x:%02x.%x, ", | 461 | printk(KERN_INFO "bt878(%d): Bt%x (rev %d) at %02x:%02x.%x, ", |
| 420 | bt878_num, bt->id, bt->revision, dev->bus->number, | 462 | bt878_num, bt->id, bt->revision, dev->bus->number, |
| 421 | PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)); | 463 | PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)); |
diff --git a/drivers/media/dvb/bt8xx/bt878.h b/drivers/media/dvb/bt8xx/bt878.h index a73baf00ca39..9faf93770d08 100644 --- a/drivers/media/dvb/bt8xx/bt878.h +++ b/drivers/media/dvb/bt8xx/bt878.h | |||
| @@ -88,6 +88,23 @@ | |||
| 88 | 88 | ||
| 89 | #define BT878_RISC_SYNC_MASK (1 << 15) | 89 | #define BT878_RISC_SYNC_MASK (1 << 15) |
| 90 | 90 | ||
| 91 | |||
| 92 | #define BTTV_BOARD_UNKNOWN 0x00 | ||
| 93 | #define BTTV_BOARD_PINNACLESAT 0x5e | ||
| 94 | #define BTTV_BOARD_NEBULA_DIGITV 0x68 | ||
| 95 | #define BTTV_BOARD_PC_HDTV 0x70 | ||
| 96 | #define BTTV_BOARD_TWINHAN_DST 0x71 | ||
| 97 | #define BTTV_BOARD_AVDVBT_771 0x7b | ||
| 98 | #define BTTV_BOARD_AVDVBT_761 0x7c | ||
| 99 | #define BTTV_BOARD_DVICO_DVBT_LITE 0x80 | ||
| 100 | #define BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE 0x87 | ||
| 101 | |||
| 102 | struct cards { | ||
| 103 | __u32 pci_id; | ||
| 104 | __u16 card_id; | ||
| 105 | char *name; | ||
| 106 | }; | ||
| 107 | |||
| 91 | extern int bt878_num; | 108 | extern int bt878_num; |
| 92 | 109 | ||
| 93 | struct bt878 { | 110 | struct bt878 { |
diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig index 90a69d343b79..d3df12039b06 100644 --- a/drivers/media/dvb/dvb-usb/Kconfig +++ b/drivers/media/dvb/dvb-usb/Kconfig | |||
| @@ -83,12 +83,18 @@ config DVB_USB_UMT_010 | |||
| 83 | Say Y here to support the HanfTek UMT-010 USB2.0 stick-sized DVB-T receiver. | 83 | Say Y here to support the HanfTek UMT-010 USB2.0 stick-sized DVB-T receiver. |
| 84 | 84 | ||
| 85 | config DVB_USB_CXUSB | 85 | config DVB_USB_CXUSB |
| 86 | tristate "Medion MD95700 hybrid USB2.0 (Conexant) support" | 86 | tristate "Conexant USB2.0 hybrid reference design support" |
| 87 | depends on DVB_USB | 87 | depends on DVB_USB |
| 88 | select DVB_CX22702 | 88 | select DVB_CX22702 |
| 89 | select DVB_LGDT330X | ||
| 90 | select DVB_MT352 | ||
| 89 | help | 91 | help |
| 90 | Say Y here to support the Medion MD95700 hybrid USB2.0 device. Currently | 92 | Say Y here to support the Conexant USB2.0 hybrid reference design. |
| 91 | only the DVB-T part is supported. | 93 | Currently, only DVB and ATSC modes are supported, analog mode |
| 94 | shall be added in the future. Devices that require this module: | ||
| 95 | |||
| 96 | Medion MD95700 hybrid USB2.0 device. | ||
| 97 | DViCO FusionHDTV (Bluebird) USB2.0 devices | ||
| 92 | 98 | ||
| 93 | config DVB_USB_DIGITV | 99 | config DVB_USB_DIGITV |
| 94 | tristate "Nebula Electronics uDigiTV DVB-T USB2.0 support" | 100 | tristate "Nebula Electronics uDigiTV DVB-T USB2.0 support" |
diff --git a/drivers/media/dvb/dvb-usb/cxusb.c b/drivers/media/dvb/dvb-usb/cxusb.c index a7fb06f4cd34..f327fac1688e 100644 --- a/drivers/media/dvb/dvb-usb/cxusb.c +++ b/drivers/media/dvb/dvb-usb/cxusb.c | |||
| @@ -184,7 +184,7 @@ static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | |||
| 184 | return 0; | 184 | return 0; |
| 185 | } | 185 | } |
| 186 | 186 | ||
| 187 | struct dvb_usb_rc_key dvico_mce_rc_keys[] = { | 187 | static struct dvb_usb_rc_key dvico_mce_rc_keys[] = { |
| 188 | { 0xfe, 0x02, KEY_TV }, | 188 | { 0xfe, 0x02, KEY_TV }, |
| 189 | { 0xfe, 0x0e, KEY_MP3 }, | 189 | { 0xfe, 0x0e, KEY_MP3 }, |
| 190 | { 0xfe, 0x1a, KEY_DVD }, | 190 | { 0xfe, 0x1a, KEY_DVD }, |
| @@ -234,7 +234,7 @@ struct dvb_usb_rc_key dvico_mce_rc_keys[] = { | |||
| 234 | 234 | ||
| 235 | static int cxusb_dee1601_demod_init(struct dvb_frontend* fe) | 235 | static int cxusb_dee1601_demod_init(struct dvb_frontend* fe) |
| 236 | { | 236 | { |
| 237 | static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x38 }; | 237 | static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 }; |
| 238 | static u8 reset [] = { RESET, 0x80 }; | 238 | static u8 reset [] = { RESET, 0x80 }; |
| 239 | static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 }; | 239 | static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 }; |
| 240 | static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 }; | 240 | static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 }; |
| @@ -255,7 +255,7 @@ static int cxusb_dee1601_demod_init(struct dvb_frontend* fe) | |||
| 255 | 255 | ||
| 256 | static int cxusb_mt352_demod_init(struct dvb_frontend* fe) | 256 | static int cxusb_mt352_demod_init(struct dvb_frontend* fe) |
| 257 | { /* used in both lgz201 and th7579 */ | 257 | { /* used in both lgz201 and th7579 */ |
| 258 | static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x39 }; | 258 | static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 }; |
| 259 | static u8 reset [] = { RESET, 0x80 }; | 259 | static u8 reset [] = { RESET, 0x80 }; |
| 260 | static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 }; | 260 | static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 }; |
| 261 | static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 }; | 261 | static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 }; |
| @@ -273,7 +273,7 @@ static int cxusb_mt352_demod_init(struct dvb_frontend* fe) | |||
| 273 | return 0; | 273 | return 0; |
| 274 | } | 274 | } |
| 275 | 275 | ||
| 276 | struct cx22702_config cxusb_cx22702_config = { | 276 | static struct cx22702_config cxusb_cx22702_config = { |
| 277 | .demod_address = 0x63, | 277 | .demod_address = 0x63, |
| 278 | 278 | ||
| 279 | .output_mode = CX22702_PARALLEL_OUTPUT, | 279 | .output_mode = CX22702_PARALLEL_OUTPUT, |
| @@ -282,13 +282,13 @@ struct cx22702_config cxusb_cx22702_config = { | |||
| 282 | .pll_set = dvb_usb_pll_set_i2c, | 282 | .pll_set = dvb_usb_pll_set_i2c, |
| 283 | }; | 283 | }; |
| 284 | 284 | ||
| 285 | struct lgdt330x_config cxusb_lgdt330x_config = { | 285 | static struct lgdt330x_config cxusb_lgdt330x_config = { |
| 286 | .demod_address = 0x0e, | 286 | .demod_address = 0x0e, |
| 287 | .demod_chip = LGDT3303, | 287 | .demod_chip = LGDT3303, |
| 288 | .pll_set = dvb_usb_pll_set_i2c, | 288 | .pll_set = dvb_usb_pll_set_i2c, |
| 289 | }; | 289 | }; |
| 290 | 290 | ||
| 291 | struct mt352_config cxusb_dee1601_config = { | 291 | static struct mt352_config cxusb_dee1601_config = { |
| 292 | .demod_address = 0x0f, | 292 | .demod_address = 0x0f, |
| 293 | .demod_init = cxusb_dee1601_demod_init, | 293 | .demod_init = cxusb_dee1601_demod_init, |
| 294 | .pll_set = dvb_usb_pll_set, | 294 | .pll_set = dvb_usb_pll_set, |
diff --git a/drivers/media/dvb/dvb-usb/digitv.c b/drivers/media/dvb/dvb-usb/digitv.c index e6c55c9c9417..caa1346e3063 100644 --- a/drivers/media/dvb/dvb-usb/digitv.c +++ b/drivers/media/dvb/dvb-usb/digitv.c | |||
| @@ -175,11 +175,13 @@ static int digitv_probe(struct usb_interface *intf, | |||
| 175 | if ((ret = dvb_usb_device_init(intf,&digitv_properties,THIS_MODULE,&d)) == 0) { | 175 | if ((ret = dvb_usb_device_init(intf,&digitv_properties,THIS_MODULE,&d)) == 0) { |
| 176 | u8 b[4] = { 0 }; | 176 | u8 b[4] = { 0 }; |
| 177 | 177 | ||
| 178 | b[0] = 1; | 178 | if (d != NULL) { /* do that only when the firmware is loaded */ |
| 179 | digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0); | 179 | b[0] = 1; |
| 180 | digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0); | ||
| 180 | 181 | ||
| 181 | b[0] = 0; | 182 | b[0] = 0; |
| 182 | digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0); | 183 | digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0); |
| 184 | } | ||
| 183 | } | 185 | } |
| 184 | return ret; | 186 | return ret; |
| 185 | } | 187 | } |
| @@ -194,7 +196,7 @@ static struct dvb_usb_properties digitv_properties = { | |||
| 194 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 196 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
| 195 | 197 | ||
| 196 | .usb_ctrl = CYPRESS_FX2, | 198 | .usb_ctrl = CYPRESS_FX2, |
| 197 | .firmware = "dvb-usb-digitv-01.fw", | 199 | .firmware = "dvb-usb-digitv-02.fw", |
| 198 | 200 | ||
| 199 | .size_of_priv = 0, | 201 | .size_of_priv = 0, |
| 200 | 202 | ||
| @@ -229,6 +231,7 @@ static struct dvb_usb_properties digitv_properties = { | |||
| 229 | { &digitv_table[0], NULL }, | 231 | { &digitv_table[0], NULL }, |
| 230 | { NULL }, | 232 | { NULL }, |
| 231 | }, | 233 | }, |
| 234 | { NULL }, | ||
| 232 | } | 235 | } |
| 233 | }; | 236 | }; |
| 234 | 237 | ||
diff --git a/drivers/media/dvb/dvb-usb/dtt200u.c b/drivers/media/dvb/dvb-usb/dtt200u.c index 130ea7f21f5e..12ebaf8bddca 100644 --- a/drivers/media/dvb/dvb-usb/dtt200u.c +++ b/drivers/media/dvb/dvb-usb/dtt200u.c | |||
| @@ -151,7 +151,7 @@ static struct dvb_usb_properties dtt200u_properties = { | |||
| 151 | .cold_ids = { &dtt200u_usb_table[0], NULL }, | 151 | .cold_ids = { &dtt200u_usb_table[0], NULL }, |
| 152 | .warm_ids = { &dtt200u_usb_table[1], NULL }, | 152 | .warm_ids = { &dtt200u_usb_table[1], NULL }, |
| 153 | }, | 153 | }, |
| 154 | { 0 }, | 154 | { NULL }, |
| 155 | } | 155 | } |
| 156 | }; | 156 | }; |
| 157 | 157 | ||
| @@ -192,7 +192,7 @@ static struct dvb_usb_properties wt220u_properties = { | |||
| 192 | .cold_ids = { &dtt200u_usb_table[2], NULL }, | 192 | .cold_ids = { &dtt200u_usb_table[2], NULL }, |
| 193 | .warm_ids = { &dtt200u_usb_table[3], NULL }, | 193 | .warm_ids = { &dtt200u_usb_table[3], NULL }, |
| 194 | }, | 194 | }, |
| 195 | { 0 }, | 195 | { NULL }, |
| 196 | } | 196 | } |
| 197 | }; | 197 | }; |
| 198 | 198 | ||
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c index 8535895819fb..9222b0a81f74 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c +++ b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c | |||
| @@ -24,6 +24,9 @@ static struct usb_cypress_controller cypress[] = { | |||
| 24 | { .id = CYPRESS_FX2, .name = "Cypress FX2", .cpu_cs_register = 0xe600 }, | 24 | { .id = CYPRESS_FX2, .name = "Cypress FX2", .cpu_cs_register = 0xe600 }, |
| 25 | }; | 25 | }; |
| 26 | 26 | ||
| 27 | static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, | ||
| 28 | int *pos); | ||
| 29 | |||
| 27 | /* | 30 | /* |
| 28 | * load a firmware packet to the device | 31 | * load a firmware packet to the device |
| 29 | */ | 32 | */ |
| @@ -112,7 +115,8 @@ int dvb_usb_download_firmware(struct usb_device *udev, struct dvb_usb_properties | |||
| 112 | return ret; | 115 | return ret; |
| 113 | } | 116 | } |
| 114 | 117 | ||
| 115 | int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos) | 118 | static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, |
| 119 | int *pos) | ||
| 116 | { | 120 | { |
| 117 | u8 *b = (u8 *) &fw->data[*pos]; | 121 | u8 *b = (u8 *) &fw->data[*pos]; |
| 118 | int data_offs = 4; | 122 | int data_offs = 4; |
| @@ -142,5 +146,3 @@ int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos) | |||
| 142 | 146 | ||
| 143 | return *pos; | 147 | return *pos; |
| 144 | } | 148 | } |
| 145 | EXPORT_SYMBOL(dvb_usb_get_hexline); | ||
| 146 | |||
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb.h b/drivers/media/dvb/dvb-usb/dvb-usb.h index dd568396e594..5e5d21ad93c9 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb.h +++ b/drivers/media/dvb/dvb-usb/dvb-usb.h | |||
| @@ -341,7 +341,6 @@ struct hexline { | |||
| 341 | u8 data[255]; | 341 | u8 data[255]; |
| 342 | u8 chk; | 342 | u8 chk; |
| 343 | }; | 343 | }; |
| 344 | extern int dvb_usb_get_hexline(const struct firmware *, struct hexline *, int *); | ||
| 345 | extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type); | 344 | extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type); |
| 346 | 345 | ||
| 347 | #endif | 346 | #endif |
diff --git a/drivers/media/dvb/dvb-usb/vp702x.c b/drivers/media/dvb/dvb-usb/vp702x.c index afa00fdb5ec0..4a95eca81c5c 100644 --- a/drivers/media/dvb/dvb-usb/vp702x.c +++ b/drivers/media/dvb/dvb-usb/vp702x.c | |||
| @@ -53,7 +53,8 @@ int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 | |||
| 53 | return ret; | 53 | return ret; |
| 54 | } | 54 | } |
| 55 | 55 | ||
| 56 | int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen) | 56 | static int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, |
| 57 | u16 index, u8 *b, int blen) | ||
| 57 | { | 58 | { |
| 58 | deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index); | 59 | deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index); |
| 59 | debug_dump(b,blen,deb_xfer); | 60 | debug_dump(b,blen,deb_xfer); |
| @@ -88,7 +89,8 @@ unlock: | |||
| 88 | return ret; | 89 | return ret; |
| 89 | } | 90 | } |
| 90 | 91 | ||
| 91 | int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, int olen, u8 *i, int ilen, int msec) | 92 | static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, |
| 93 | int olen, u8 *i, int ilen, int msec) | ||
| 92 | { | 94 | { |
| 93 | u8 bout[olen+2]; | 95 | u8 bout[olen+2]; |
| 94 | u8 bin[ilen+1]; | 96 | u8 bin[ilen+1]; |
diff --git a/drivers/media/dvb/dvb-usb/vp702x.h b/drivers/media/dvb/dvb-usb/vp702x.h index a808d48e7bf2..c2f97f96c21f 100644 --- a/drivers/media/dvb/dvb-usb/vp702x.h +++ b/drivers/media/dvb/dvb-usb/vp702x.h | |||
| @@ -101,8 +101,6 @@ extern int dvb_usb_vp702x_debug; | |||
| 101 | extern struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d); | 101 | extern struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d); |
| 102 | 102 | ||
| 103 | extern int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec); | 103 | extern int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec); |
| 104 | extern int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, int olen, u8 *i, int ilen, int msec); | ||
| 105 | extern int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen); | 104 | extern int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen); |
| 106 | extern int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen); | ||
| 107 | 105 | ||
| 108 | #endif | 106 | #endif |
diff --git a/drivers/media/dvb/dvb-usb/vp7045-fe.c b/drivers/media/dvb/dvb-usb/vp7045-fe.c index 5242cca5db4a..9999336aeeb6 100644 --- a/drivers/media/dvb/dvb-usb/vp7045-fe.c +++ b/drivers/media/dvb/dvb-usb/vp7045-fe.c | |||
| @@ -23,10 +23,11 @@ | |||
| 23 | 23 | ||
| 24 | struct vp7045_fe_state { | 24 | struct vp7045_fe_state { |
| 25 | struct dvb_frontend fe; | 25 | struct dvb_frontend fe; |
| 26 | struct dvb_frontend_ops ops; | ||
| 27 | |||
| 26 | struct dvb_usb_device *d; | 28 | struct dvb_usb_device *d; |
| 27 | }; | 29 | }; |
| 28 | 30 | ||
| 29 | |||
| 30 | static int vp7045_fe_read_status(struct dvb_frontend* fe, fe_status_t *status) | 31 | static int vp7045_fe_read_status(struct dvb_frontend* fe, fe_status_t *status) |
| 31 | { | 32 | { |
| 32 | struct vp7045_fe_state *state = fe->demodulator_priv; | 33 | struct vp7045_fe_state *state = fe->demodulator_priv; |
| @@ -150,7 +151,8 @@ struct dvb_frontend * vp7045_fe_attach(struct dvb_usb_device *d) | |||
| 150 | goto error; | 151 | goto error; |
| 151 | 152 | ||
| 152 | s->d = d; | 153 | s->d = d; |
| 153 | s->fe.ops = &vp7045_fe_ops; | 154 | memcpy(&s->ops, &vp7045_fe_ops, sizeof(struct dvb_frontend_ops)); |
| 155 | s->fe.ops = &s->ops; | ||
| 154 | s->fe.demodulator_priv = s; | 156 | s->fe.demodulator_priv = s; |
| 155 | 157 | ||
| 156 | goto success; | 158 | goto success; |
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c index 028204956bb0..3835235b68df 100644 --- a/drivers/media/dvb/dvb-usb/vp7045.c +++ b/drivers/media/dvb/dvb-usb/vp7045.c | |||
| @@ -247,7 +247,7 @@ static struct dvb_usb_properties vp7045_properties = { | |||
| 247 | .cold_ids = { &vp7045_usb_table[2], NULL }, | 247 | .cold_ids = { &vp7045_usb_table[2], NULL }, |
| 248 | .warm_ids = { &vp7045_usb_table[3], NULL }, | 248 | .warm_ids = { &vp7045_usb_table[3], NULL }, |
| 249 | }, | 249 | }, |
| 250 | { 0 }, | 250 | { NULL }, |
| 251 | } | 251 | } |
| 252 | }; | 252 | }; |
| 253 | 253 | ||
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig index db3a8b40031e..76b6a2aef32f 100644 --- a/drivers/media/dvb/frontends/Kconfig +++ b/drivers/media/dvb/frontends/Kconfig | |||
| @@ -28,12 +28,6 @@ config DVB_TDA8083 | |||
| 28 | help | 28 | help |
| 29 | A DVB-S tuner module. Say Y when you want to support this frontend. | 29 | A DVB-S tuner module. Say Y when you want to support this frontend. |
| 30 | 30 | ||
| 31 | config DVB_TDA80XX | ||
| 32 | tristate "Philips TDA8044 or TDA8083 based" | ||
| 33 | depends on DVB_CORE | ||
| 34 | help | ||
| 35 | A DVB-S tuner module. Say Y when you want to support this frontend. | ||
| 36 | |||
| 37 | config DVB_MT312 | 31 | config DVB_MT312 |
| 38 | tristate "Zarlink MT312 based" | 32 | tristate "Zarlink MT312 based" |
| 39 | depends on DVB_CORE | 33 | depends on DVB_CORE |
| @@ -139,12 +133,6 @@ config DVB_DIB3000MC | |||
| 139 | comment "DVB-C (cable) frontends" | 133 | comment "DVB-C (cable) frontends" |
| 140 | depends on DVB_CORE | 134 | depends on DVB_CORE |
| 141 | 135 | ||
| 142 | config DVB_ATMEL_AT76C651 | ||
| 143 | tristate "Atmel AT76C651 based" | ||
| 144 | depends on DVB_CORE | ||
| 145 | help | ||
| 146 | A DVB-C tuner module. Say Y when you want to support this frontend. | ||
| 147 | |||
| 148 | config DVB_VES1820 | 136 | config DVB_VES1820 |
| 149 | tristate "VLSI VES1820 based" | 137 | tristate "VLSI VES1820 based" |
| 150 | depends on DVB_CORE | 138 | depends on DVB_CORE |
| @@ -166,18 +154,6 @@ config DVB_STV0297 | |||
| 166 | comment "ATSC (North American/Korean Terresterial DTV) frontends" | 154 | comment "ATSC (North American/Korean Terresterial DTV) frontends" |
| 167 | depends on DVB_CORE | 155 | depends on DVB_CORE |
| 168 | 156 | ||
| 169 | config DVB_NXT2002 | ||
| 170 | tristate "Nxt2002 based" | ||
| 171 | depends on DVB_CORE | ||
| 172 | select FW_LOADER | ||
| 173 | help | ||
| 174 | An ATSC 8VSB tuner module. Say Y when you want to support this frontend. | ||
| 175 | |||
| 176 | This driver needs external firmware. Please use the command | ||
| 177 | "<kerneldir>/Documentation/dvb/get_dvb_firmware nxt2002" to | ||
| 178 | download/extract it, and then copy it to /usr/lib/hotplug/firmware | ||
| 179 | or /lib/firmware (depending on configuration of firmware hotplug). | ||
| 180 | |||
| 181 | config DVB_NXT200X | 157 | config DVB_NXT200X |
| 182 | tristate "Nextwave NXT2002/NXT2004 based" | 158 | tristate "Nextwave NXT2002/NXT2004 based" |
| 183 | depends on DVB_CORE | 159 | depends on DVB_CORE |
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile index 615ec830e1c9..1af769cd90c0 100644 --- a/drivers/media/dvb/frontends/Makefile +++ b/drivers/media/dvb/frontends/Makefile | |||
| @@ -8,7 +8,6 @@ obj-$(CONFIG_DVB_CORE) += dvb-pll.o | |||
| 8 | obj-$(CONFIG_DVB_STV0299) += stv0299.o | 8 | obj-$(CONFIG_DVB_STV0299) += stv0299.o |
| 9 | obj-$(CONFIG_DVB_SP8870) += sp8870.o | 9 | obj-$(CONFIG_DVB_SP8870) += sp8870.o |
| 10 | obj-$(CONFIG_DVB_CX22700) += cx22700.o | 10 | obj-$(CONFIG_DVB_CX22700) += cx22700.o |
| 11 | obj-$(CONFIG_DVB_ATMEL_AT76C651) += at76c651.o | ||
| 12 | obj-$(CONFIG_DVB_CX24110) += cx24110.o | 11 | obj-$(CONFIG_DVB_CX24110) += cx24110.o |
| 13 | obj-$(CONFIG_DVB_TDA8083) += tda8083.o | 12 | obj-$(CONFIG_DVB_TDA8083) += tda8083.o |
| 14 | obj-$(CONFIG_DVB_L64781) += l64781.o | 13 | obj-$(CONFIG_DVB_L64781) += l64781.o |
| @@ -22,10 +21,8 @@ obj-$(CONFIG_DVB_SP887X) += sp887x.o | |||
| 22 | obj-$(CONFIG_DVB_NXT6000) += nxt6000.o | 21 | obj-$(CONFIG_DVB_NXT6000) += nxt6000.o |
| 23 | obj-$(CONFIG_DVB_MT352) += mt352.o | 22 | obj-$(CONFIG_DVB_MT352) += mt352.o |
| 24 | obj-$(CONFIG_DVB_CX22702) += cx22702.o | 23 | obj-$(CONFIG_DVB_CX22702) += cx22702.o |
| 25 | obj-$(CONFIG_DVB_TDA80XX) += tda80xx.o | ||
| 26 | obj-$(CONFIG_DVB_TDA10021) += tda10021.o | 24 | obj-$(CONFIG_DVB_TDA10021) += tda10021.o |
| 27 | obj-$(CONFIG_DVB_STV0297) += stv0297.o | 25 | obj-$(CONFIG_DVB_STV0297) += stv0297.o |
| 28 | obj-$(CONFIG_DVB_NXT2002) += nxt2002.o | ||
| 29 | obj-$(CONFIG_DVB_NXT200X) += nxt200x.o | 26 | obj-$(CONFIG_DVB_NXT200X) += nxt200x.o |
| 30 | obj-$(CONFIG_DVB_OR51211) += or51211.o | 27 | obj-$(CONFIG_DVB_OR51211) += or51211.o |
| 31 | obj-$(CONFIG_DVB_OR51132) += or51132.o | 28 | obj-$(CONFIG_DVB_OR51132) += or51132.o |
diff --git a/drivers/media/dvb/frontends/at76c651.c b/drivers/media/dvb/frontends/at76c651.c deleted file mode 100644 index 8e0f4b3a1417..000000000000 --- a/drivers/media/dvb/frontends/at76c651.c +++ /dev/null | |||
| @@ -1,450 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * at76c651.c | ||
| 3 | * | ||
| 4 | * Atmel DVB-C Frontend Driver (at76c651/tua6010xs) | ||
| 5 | * | ||
| 6 | * Copyright (C) 2001 fnbrd <fnbrd@gmx.de> | ||
| 7 | * & 2002-2004 Andreas Oberritter <obi@linuxtv.org> | ||
| 8 | * & 2003 Wolfram Joost <dbox2@frokaschwei.de> | ||
| 9 | * | ||
| 10 | * This program is free software; you can redistribute it and/or modify | ||
| 11 | * it under the terms of the GNU General Public License as published by | ||
| 12 | * the Free Software Foundation; either version 2 of the License, or | ||
| 13 | * (at your option) any later version. | ||
| 14 | * | ||
| 15 | * This program is distributed in the hope that it will be useful, | ||
| 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 18 | * GNU General Public License for more details. | ||
| 19 | * | ||
| 20 | * You should have received a copy of the GNU General Public License | ||
| 21 | * along with this program; if not, write to the Free Software | ||
| 22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
| 23 | * | ||
| 24 | * AT76C651 | ||
| 25 | * http://www.nalanda.nitc.ac.in/industry/datasheets/atmel/acrobat/doc1293.pdf | ||
| 26 | * http://www.atmel.com/atmel/acrobat/doc1320.pdf | ||
| 27 | */ | ||
| 28 | |||
| 29 | #include <linux/init.h> | ||
| 30 | #include <linux/module.h> | ||
| 31 | #include <linux/moduleparam.h> | ||
| 32 | #include <linux/kernel.h> | ||
| 33 | #include <linux/string.h> | ||
| 34 | #include <linux/slab.h> | ||
| 35 | #include <linux/bitops.h> | ||
| 36 | #include "dvb_frontend.h" | ||
| 37 | #include "at76c651.h" | ||
| 38 | |||
| 39 | |||
| 40 | struct at76c651_state { | ||
| 41 | |||
| 42 | struct i2c_adapter* i2c; | ||
| 43 | |||
| 44 | struct dvb_frontend_ops ops; | ||
| 45 | |||
| 46 | const struct at76c651_config* config; | ||
| 47 | |||
| 48 | struct dvb_frontend frontend; | ||
| 49 | |||
| 50 | /* revision of the chip */ | ||
| 51 | u8 revision; | ||
| 52 | |||
| 53 | /* last QAM value set */ | ||
| 54 | u8 qam; | ||
| 55 | }; | ||
| 56 | |||
| 57 | static int debug; | ||
| 58 | #define dprintk(args...) \ | ||
| 59 | do { \ | ||
| 60 | if (debug) printk(KERN_DEBUG "at76c651: " args); \ | ||
| 61 | } while (0) | ||
| 62 | |||
| 63 | |||
| 64 | #if ! defined(__powerpc__) | ||
| 65 | static __inline__ int __ilog2(unsigned long x) | ||
| 66 | { | ||
| 67 | int i; | ||
| 68 | |||
| 69 | if (x == 0) | ||
| 70 | return -1; | ||
| 71 | |||
| 72 | for (i = 0; x != 0; i++) | ||
| 73 | x >>= 1; | ||
| 74 | |||
| 75 | return i - 1; | ||
| 76 | } | ||
| 77 | #endif | ||
| 78 | |||
| 79 | static int at76c651_writereg(struct at76c651_state* state, u8 reg, u8 data) | ||
| 80 | { | ||
| 81 | int ret; | ||
| 82 | u8 buf[] = { reg, data }; | ||
| 83 | struct i2c_msg msg = | ||
| 84 | { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 }; | ||
| 85 | |||
| 86 | ret = i2c_transfer(state->i2c, &msg, 1); | ||
| 87 | |||
| 88 | if (ret != 1) | ||
| 89 | dprintk("%s: writereg error " | ||
| 90 | "(reg == 0x%02x, val == 0x%02x, ret == %i)\n", | ||
| 91 | __FUNCTION__, reg, data, ret); | ||
| 92 | |||
| 93 | msleep(10); | ||
| 94 | |||
| 95 | return (ret != 1) ? -EREMOTEIO : 0; | ||
| 96 | } | ||
| 97 | |||
| 98 | static u8 at76c651_readreg(struct at76c651_state* state, u8 reg) | ||
| 99 | { | ||
| 100 | int ret; | ||
| 101 | u8 val; | ||
| 102 | struct i2c_msg msg[] = { | ||
| 103 | { .addr = state->config->demod_address, .flags = 0, .buf = ®, .len = 1 }, | ||
| 104 | { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = &val, .len = 1 } | ||
| 105 | }; | ||
| 106 | |||
| 107 | ret = i2c_transfer(state->i2c, msg, 2); | ||
| 108 | |||
| 109 | if (ret != 2) | ||
| 110 | dprintk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret); | ||
| 111 | |||
| 112 | return val; | ||
| 113 | } | ||
| 114 | |||
| 115 | static int at76c651_reset(struct at76c651_state* state) | ||
| 116 | { | ||
| 117 | return at76c651_writereg(state, 0x07, 0x01); | ||
| 118 | } | ||
| 119 | |||
| 120 | static void at76c651_disable_interrupts(struct at76c651_state* state) | ||
| 121 | { | ||
| 122 | at76c651_writereg(state, 0x0b, 0x00); | ||
| 123 | } | ||
| 124 | |||
| 125 | static int at76c651_set_auto_config(struct at76c651_state *state) | ||
| 126 | { | ||
| 127 | /* | ||
| 128 | * Autoconfig | ||
| 129 | */ | ||
| 130 | |||
| 131 | at76c651_writereg(state, 0x06, 0x01); | ||
| 132 | |||
| 133 | /* | ||
| 134 | * Performance optimizations, should be done after autoconfig | ||
| 135 | */ | ||
| 136 | |||
| 137 | at76c651_writereg(state, 0x10, 0x06); | ||
| 138 | at76c651_writereg(state, 0x11, ((state->qam == 5) || (state->qam == 7)) ? 0x12 : 0x10); | ||
| 139 | at76c651_writereg(state, 0x15, 0x28); | ||
| 140 | at76c651_writereg(state, 0x20, 0x09); | ||
| 141 | at76c651_writereg(state, 0x24, ((state->qam == 5) || (state->qam == 7)) ? 0xC0 : 0x90); | ||
| 142 | at76c651_writereg(state, 0x30, 0x90); | ||
| 143 | if (state->qam == 5) | ||
| 144 | at76c651_writereg(state, 0x35, 0x2A); | ||
| 145 | |||
| 146 | /* | ||
| 147 | * Initialize A/D-converter | ||
| 148 | */ | ||
| 149 | |||
| 150 | if (state->revision == 0x11) { | ||
| 151 | at76c651_writereg(state, 0x2E, 0x38); | ||
| 152 | at76c651_writereg(state, 0x2F, 0x13); | ||
| 153 | } | ||
| 154 | |||
| 155 | at76c651_disable_interrupts(state); | ||
| 156 | |||
| 157 | /* | ||
| 158 | * Restart operation | ||
| 159 | */ | ||
| 160 | |||
| 161 | at76c651_reset(state); | ||
| 162 | |||
| 163 | return 0; | ||
| 164 | } | ||
| 165 | |||
| 166 | static void at76c651_set_bbfreq(struct at76c651_state* state) | ||
| 167 | { | ||
| 168 | at76c651_writereg(state, 0x04, 0x3f); | ||
| 169 | at76c651_writereg(state, 0x05, 0xee); | ||
| 170 | } | ||
| 171 | |||
| 172 | static int at76c651_set_symbol_rate(struct at76c651_state* state, u32 symbol_rate) | ||
| 173 | { | ||
| 174 | u8 exponent; | ||
| 175 | u32 mantissa; | ||
| 176 | |||
| 177 | if (symbol_rate > 9360000) | ||
| 178 | return -EINVAL; | ||
| 179 | |||
| 180 | /* | ||
| 181 | * FREF = 57800 kHz | ||
| 182 | * exponent = 10 + floor (log2(symbol_rate / FREF)) | ||
| 183 | * mantissa = (symbol_rate / FREF) * (1 << (30 - exponent)) | ||
| 184 | */ | ||
| 185 | |||
| 186 | exponent = __ilog2((symbol_rate << 4) / 903125); | ||
| 187 | mantissa = ((symbol_rate / 3125) * (1 << (24 - exponent))) / 289; | ||
| 188 | |||
| 189 | at76c651_writereg(state, 0x00, mantissa >> 13); | ||
| 190 | at76c651_writereg(state, 0x01, mantissa >> 5); | ||
| 191 | at76c651_writereg(state, 0x02, (mantissa << 3) | exponent); | ||
| 192 | |||
| 193 | return 0; | ||
| 194 | } | ||
| 195 | |||
| 196 | static int at76c651_set_qam(struct at76c651_state *state, fe_modulation_t qam) | ||
| 197 | { | ||
| 198 | switch (qam) { | ||
| 199 | case QPSK: | ||
| 200 | state->qam = 0x02; | ||
| 201 | break; | ||
| 202 | case QAM_16: | ||
| 203 | state->qam = 0x04; | ||
| 204 | break; | ||
| 205 | case QAM_32: | ||
| 206 | state->qam = 0x05; | ||
| 207 | break; | ||
| 208 | case QAM_64: | ||
| 209 | state->qam = 0x06; | ||
| 210 | break; | ||
| 211 | case QAM_128: | ||
| 212 | state->qam = 0x07; | ||
| 213 | break; | ||
| 214 | case QAM_256: | ||
| 215 | state->qam = 0x08; | ||
| 216 | break; | ||
| 217 | #if 0 | ||
| 218 | case QAM_512: | ||
| 219 | state->qam = 0x09; | ||
| 220 | break; | ||
| 221 | case QAM_1024: | ||
| 222 | state->qam = 0x0A; | ||
| 223 | break; | ||
| 224 | #endif | ||
| 225 | default: | ||
| 226 | return -EINVAL; | ||
| 227 | |||
| 228 | } | ||
| 229 | |||
| 230 | return at76c651_writereg(state, 0x03, state->qam); | ||
| 231 | } | ||
| 232 | |||
| 233 | static int at76c651_set_inversion(struct at76c651_state* state, fe_spectral_inversion_t inversion) | ||
| 234 | { | ||
| 235 | u8 feciqinv = at76c651_readreg(state, 0x60); | ||
| 236 | |||
| 237 | switch (inversion) { | ||
| 238 | case INVERSION_OFF: | ||
| 239 | feciqinv |= 0x02; | ||
| 240 | feciqinv &= 0xFE; | ||
| 241 | break; | ||
| 242 | |||
| 243 | case INVERSION_ON: | ||
| 244 | feciqinv |= 0x03; | ||
| 245 | break; | ||
| 246 | |||
| 247 | case INVERSION_AUTO: | ||
| 248 | feciqinv &= 0xFC; | ||
| 249 | break; | ||
| 250 | |||
| 251 | default: | ||
| 252 | return -EINVAL; | ||
| 253 | } | ||
| 254 | |||
| 255 | return at76c651_writereg(state, 0x60, feciqinv); | ||
| 256 | } | ||
| 257 | |||
| 258 | static int at76c651_set_parameters(struct dvb_frontend* fe, | ||
| 259 | struct dvb_frontend_parameters *p) | ||
| 260 | { | ||
| 261 | int ret; | ||
| 262 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 263 | |||
| 264 | at76c651_writereg(state, 0x0c, 0xc3); | ||
| 265 | state->config->pll_set(fe, p); | ||
| 266 | at76c651_writereg(state, 0x0c, 0xc2); | ||
| 267 | |||
| 268 | if ((ret = at76c651_set_symbol_rate(state, p->u.qam.symbol_rate))) | ||
| 269 | return ret; | ||
| 270 | |||
| 271 | if ((ret = at76c651_set_inversion(state, p->inversion))) | ||
| 272 | return ret; | ||
| 273 | |||
| 274 | return at76c651_set_auto_config(state); | ||
| 275 | } | ||
| 276 | |||
| 277 | static int at76c651_set_defaults(struct dvb_frontend* fe) | ||
| 278 | { | ||
| 279 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 280 | |||
| 281 | at76c651_set_symbol_rate(state, 6900000); | ||
| 282 | at76c651_set_qam(state, QAM_64); | ||
| 283 | at76c651_set_bbfreq(state); | ||
| 284 | at76c651_set_auto_config(state); | ||
| 285 | |||
| 286 | if (state->config->pll_init) { | ||
| 287 | at76c651_writereg(state, 0x0c, 0xc3); | ||
| 288 | state->config->pll_init(fe); | ||
| 289 | at76c651_writereg(state, 0x0c, 0xc2); | ||
| 290 | } | ||
| 291 | |||
| 292 | return 0; | ||
| 293 | } | ||
| 294 | |||
| 295 | static int at76c651_read_status(struct dvb_frontend* fe, fe_status_t* status) | ||
| 296 | { | ||
| 297 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 298 | u8 sync; | ||
| 299 | |||
| 300 | /* | ||
| 301 | * Bits: FEC, CAR, EQU, TIM, AGC2, AGC1, ADC, PLL (PLL=0) | ||
| 302 | */ | ||
| 303 | sync = at76c651_readreg(state, 0x80); | ||
| 304 | *status = 0; | ||
| 305 | |||
| 306 | if (sync & (0x04 | 0x10)) /* AGC1 || TIM */ | ||
| 307 | *status |= FE_HAS_SIGNAL; | ||
| 308 | if (sync & 0x10) /* TIM */ | ||
| 309 | *status |= FE_HAS_CARRIER; | ||
| 310 | if (sync & 0x80) /* FEC */ | ||
| 311 | *status |= FE_HAS_VITERBI; | ||
| 312 | if (sync & 0x40) /* CAR */ | ||
| 313 | *status |= FE_HAS_SYNC; | ||
| 314 | if ((sync & 0xF0) == 0xF0) /* TIM && EQU && CAR && FEC */ | ||
| 315 | *status |= FE_HAS_LOCK; | ||
| 316 | |||
| 317 | return 0; | ||
| 318 | } | ||
| 319 | |||
| 320 | static int at76c651_read_ber(struct dvb_frontend* fe, u32* ber) | ||
| 321 | { | ||
| 322 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 323 | |||
| 324 | *ber = (at76c651_readreg(state, 0x81) & 0x0F) << 16; | ||
| 325 | *ber |= at76c651_readreg(state, 0x82) << 8; | ||
| 326 | *ber |= at76c651_readreg(state, 0x83); | ||
| 327 | *ber *= 10; | ||
| 328 | |||
| 329 | return 0; | ||
| 330 | } | ||
| 331 | |||
| 332 | static int at76c651_read_signal_strength(struct dvb_frontend* fe, u16* strength) | ||
| 333 | { | ||
| 334 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 335 | |||
| 336 | u8 gain = ~at76c651_readreg(state, 0x91); | ||
| 337 | *strength = (gain << 8) | gain; | ||
| 338 | |||
| 339 | return 0; | ||
| 340 | } | ||
| 341 | |||
| 342 | static int at76c651_read_snr(struct dvb_frontend* fe, u16* snr) | ||
| 343 | { | ||
| 344 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 345 | |||
| 346 | *snr = 0xFFFF - | ||
| 347 | ((at76c651_readreg(state, 0x8F) << 8) | | ||
| 348 | at76c651_readreg(state, 0x90)); | ||
| 349 | |||
| 350 | return 0; | ||
| 351 | } | ||
| 352 | |||
| 353 | static int at76c651_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks) | ||
| 354 | { | ||
| 355 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 356 | |||
| 357 | *ucblocks = at76c651_readreg(state, 0x82); | ||
| 358 | |||
| 359 | return 0; | ||
| 360 | } | ||
| 361 | |||
| 362 | static int at76c651_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *fesettings) | ||
| 363 | { | ||
| 364 | fesettings->min_delay_ms = 50; | ||
| 365 | fesettings->step_size = 0; | ||
| 366 | fesettings->max_drift = 0; | ||
| 367 | return 0; | ||
| 368 | } | ||
| 369 | |||
| 370 | static void at76c651_release(struct dvb_frontend* fe) | ||
| 371 | { | ||
| 372 | struct at76c651_state* state = fe->demodulator_priv; | ||
| 373 | kfree(state); | ||
| 374 | } | ||
| 375 | |||
| 376 | static struct dvb_frontend_ops at76c651_ops; | ||
| 377 | |||
| 378 | struct dvb_frontend* at76c651_attach(const struct at76c651_config* config, | ||
| 379 | struct i2c_adapter* i2c) | ||
| 380 | { | ||
| 381 | struct at76c651_state* state = NULL; | ||
| 382 | |||
| 383 | /* allocate memory for the internal state */ | ||
| 384 | state = kmalloc(sizeof(struct at76c651_state), GFP_KERNEL); | ||
| 385 | if (state == NULL) goto error; | ||
| 386 | |||
| 387 | /* setup the state */ | ||
| 388 | state->config = config; | ||
| 389 | state->qam = 0; | ||
| 390 | |||
| 391 | /* check if the demod is there */ | ||
| 392 | if (at76c651_readreg(state, 0x0e) != 0x65) goto error; | ||
| 393 | |||
| 394 | /* finalise state setup */ | ||
| 395 | state->i2c = i2c; | ||
| 396 | state->revision = at76c651_readreg(state, 0x0f) & 0xfe; | ||
| 397 | memcpy(&state->ops, &at76c651_ops, sizeof(struct dvb_frontend_ops)); | ||
| 398 | |||
| 399 | /* create dvb_frontend */ | ||
| 400 | state->frontend.ops = &state->ops; | ||
| 401 | state->frontend.demodulator_priv = state; | ||
| 402 | return &state->frontend; | ||
| 403 | |||
| 404 | error: | ||
| 405 | kfree(state); | ||
| 406 | return NULL; | ||
| 407 | } | ||
| 408 | |||
| 409 | static struct dvb_frontend_ops at76c651_ops = { | ||
| 410 | |||
| 411 | .info = { | ||
| 412 | .name = "Atmel AT76C651B DVB-C", | ||
| 413 | .type = FE_QAM, | ||
| 414 | .frequency_min = 48250000, | ||
| 415 | .frequency_max = 863250000, | ||
| 416 | .frequency_stepsize = 62500, | ||
| 417 | /*.frequency_tolerance = */ /* FIXME: 12% of SR */ | ||
| 418 | .symbol_rate_min = 0, /* FIXME */ | ||
| 419 | .symbol_rate_max = 9360000, /* FIXME */ | ||
| 420 | .symbol_rate_tolerance = 4000, | ||
| 421 | .caps = FE_CAN_INVERSION_AUTO | | ||
| 422 | FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | | ||
| 423 | FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 | | ||
| 424 | FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO | | ||
| 425 | FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 | FE_CAN_QAM_128 | | ||
| 426 | FE_CAN_MUTE_TS | FE_CAN_QAM_256 | FE_CAN_RECOVER | ||
| 427 | }, | ||
| 428 | |||
| 429 | .release = at76c651_release, | ||
| 430 | |||
| 431 | .init = at76c651_set_defaults, | ||
| 432 | |||
| 433 | .set_frontend = at76c651_set_parameters, | ||
| 434 | .get_tune_settings = at76c651_get_tune_settings, | ||
| 435 | |||
| 436 | .read_status = at76c651_read_status, | ||
| 437 | .read_ber = at76c651_read_ber, | ||
| 438 | .read_signal_strength = at76c651_read_signal_strength, | ||
| 439 | .read_snr = at76c651_read_snr, | ||
| 440 | .read_ucblocks = at76c651_read_ucblocks, | ||
| 441 | }; | ||
| 442 | |||
| 443 | module_param(debug, int, 0644); | ||
| 444 | MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); | ||
| 445 | |||
| 446 | MODULE_DESCRIPTION("Atmel AT76C651 DVB-C Demodulator Driver"); | ||
| 447 | MODULE_AUTHOR("Andreas Oberritter <obi@linuxtv.org>"); | ||
| 448 | MODULE_LICENSE("GPL"); | ||
| 449 | |||
| 450 | EXPORT_SYMBOL(at76c651_attach); | ||
diff --git a/drivers/media/dvb/frontends/at76c651.h b/drivers/media/dvb/frontends/at76c651.h deleted file mode 100644 index 34054df93608..000000000000 --- a/drivers/media/dvb/frontends/at76c651.h +++ /dev/null | |||
| @@ -1,47 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * at76c651.c | ||
| 3 | * | ||
| 4 | * Atmel DVB-C Frontend Driver (at76c651) | ||
| 5 | * | ||
| 6 | * Copyright (C) 2001 fnbrd <fnbrd@gmx.de> | ||
| 7 | * & 2002-2004 Andreas Oberritter <obi@linuxtv.org> | ||
| 8 | * & 2003 Wolfram Joost <dbox2@frokaschwei.de> | ||
| 9 | * | ||
| 10 | * This program is free software; you can redistribute it and/or modify | ||
| 11 | * it under the terms of the GNU General Public License as published by | ||
| 12 | * the Free Software Foundation; either version 2 of the License, or | ||
| 13 | * (at your option) any later version. | ||
| 14 | * | ||
| 15 | * This program is distributed in the hope that it will be useful, | ||
| 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 18 | * GNU General Public License for more details. | ||
| 19 | * | ||
| 20 | * You should have received a copy of the GNU General Public License | ||
| 21 | * along with this program; if not, write to the Free Software | ||
| 22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
| 23 | * | ||
| 24 | * AT76C651 | ||
| 25 | * http://www.nalanda.nitc.ac.in/industry/datasheets/atmel/acrobat/doc1293.pdf | ||
| 26 | * http://www.atmel.com/atmel/acrobat/doc1320.pdf | ||
| 27 | */ | ||
| 28 | |||
| 29 | #ifndef AT76C651_H | ||
| 30 | #define AT76C651_H | ||
| 31 | |||
| 32 | #include <linux/dvb/frontend.h> | ||
| 33 | |||
| 34 | struct at76c651_config | ||
| 35 | { | ||
| 36 | /* the demodulator's i2c address */ | ||
| 37 | u8 demod_address; | ||
| 38 | |||
| 39 | /* PLL maintenance */ | ||
| 40 | int (*pll_init)(struct dvb_frontend* fe); | ||
| 41 | int (*pll_set)(struct dvb_frontend* fe, struct dvb_frontend_parameters* params); | ||
| 42 | }; | ||
| 43 | |||
| 44 | extern struct dvb_frontend* at76c651_attach(const struct at76c651_config* config, | ||
| 45 | struct i2c_adapter* i2c); | ||
| 46 | |||
| 47 | #endif // AT76C651_H | ||
diff --git a/drivers/media/dvb/frontends/dvb-pll.c b/drivers/media/dvb/frontends/dvb-pll.c index 1b9934ea5b06..4dcb6050d4fa 100644 --- a/drivers/media/dvb/frontends/dvb-pll.c +++ b/drivers/media/dvb/frontends/dvb-pll.c | |||
| @@ -326,11 +326,11 @@ struct dvb_pll_desc dvb_pll_tuv1236d = { | |||
| 326 | }; | 326 | }; |
| 327 | EXPORT_SYMBOL(dvb_pll_tuv1236d); | 327 | EXPORT_SYMBOL(dvb_pll_tuv1236d); |
| 328 | 328 | ||
| 329 | /* Samsung TBMV30111IN | 329 | /* Samsung TBMV30111IN / TBMV30712IN1 |
| 330 | * used in Air2PC ATSC - 2nd generation (nxt2002) | 330 | * used in Air2PC ATSC - 2nd generation (nxt2002) |
| 331 | */ | 331 | */ |
| 332 | struct dvb_pll_desc dvb_pll_tbmv30111in = { | 332 | struct dvb_pll_desc dvb_pll_samsung_tbmv = { |
| 333 | .name = "Samsung TBMV30111IN", | 333 | .name = "Samsung TBMV30111IN / TBMV30712IN1", |
| 334 | .min = 54000000, | 334 | .min = 54000000, |
| 335 | .max = 860000000, | 335 | .max = 860000000, |
| 336 | .count = 6, | 336 | .count = 6, |
| @@ -343,7 +343,7 @@ struct dvb_pll_desc dvb_pll_tbmv30111in = { | |||
| 343 | { 999999999, 44000000, 166666, 0xfc, 0x02 }, | 343 | { 999999999, 44000000, 166666, 0xfc, 0x02 }, |
| 344 | } | 344 | } |
| 345 | }; | 345 | }; |
| 346 | EXPORT_SYMBOL(dvb_pll_tbmv30111in); | 346 | EXPORT_SYMBOL(dvb_pll_samsung_tbmv); |
| 347 | 347 | ||
| 348 | /* | 348 | /* |
| 349 | * Philips SD1878 Tuner. | 349 | * Philips SD1878 Tuner. |
diff --git a/drivers/media/dvb/frontends/dvb-pll.h b/drivers/media/dvb/frontends/dvb-pll.h index f682c09189b3..bb8d4b4eb183 100644 --- a/drivers/media/dvb/frontends/dvb-pll.h +++ b/drivers/media/dvb/frontends/dvb-pll.h | |||
| @@ -38,7 +38,7 @@ extern struct dvb_pll_desc dvb_pll_tded4; | |||
| 38 | 38 | ||
| 39 | extern struct dvb_pll_desc dvb_pll_tuv1236d; | 39 | extern struct dvb_pll_desc dvb_pll_tuv1236d; |
| 40 | extern struct dvb_pll_desc dvb_pll_tdhu2; | 40 | extern struct dvb_pll_desc dvb_pll_tdhu2; |
| 41 | extern struct dvb_pll_desc dvb_pll_tbmv30111in; | 41 | extern struct dvb_pll_desc dvb_pll_samsung_tbmv; |
| 42 | extern struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261; | 42 | extern struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261; |
| 43 | 43 | ||
| 44 | int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf, | 44 | int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf, |
diff --git a/drivers/media/dvb/frontends/nxt2002.c b/drivers/media/dvb/frontends/nxt2002.c deleted file mode 100644 index 4f263e65ba14..000000000000 --- a/drivers/media/dvb/frontends/nxt2002.c +++ /dev/null | |||
| @@ -1,706 +0,0 @@ | |||
| 1 | /* | ||
| 2 | Support for B2C2/BBTI Technisat Air2PC - ATSC | ||
| 3 | |||
| 4 | Copyright (C) 2004 Taylor Jacob <rtjacob@earthlink.net> | ||
| 5 | |||
| 6 | This program is free software; you can redistribute it and/or modify | ||
| 7 | it under the terms of the GNU General Public License as published by | ||
| 8 | the Free Software Foundation; either version 2 of the License, or | ||
| 9 | (at your option) any later version. | ||
| 10 | |||
| 11 | This program is distributed in the hope that it will be useful, | ||
| 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 14 | GNU General Public License for more details. | ||
| 15 | |||
| 16 | You should have received a copy of the GNU General Public License | ||
| 17 | along with this program; if not, write to the Free Software | ||
| 18 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
| 19 | |||
| 20 | */ | ||
| 21 | |||
| 22 | /* | ||
| 23 | * This driver needs external firmware. Please use the command | ||
| 24 | * "<kerneldir>/Documentation/dvb/get_dvb_firmware nxt2002" to | ||
| 25 | * download/extract it, and then copy it to /usr/lib/hotplug/firmware | ||
| 26 | * or /lib/firmware (depending on configuration of firmware hotplug). | ||
| 27 | */ | ||
| 28 | #define NXT2002_DEFAULT_FIRMWARE "dvb-fe-nxt2002.fw" | ||
| 29 | #define CRC_CCIT_MASK 0x1021 | ||
| 30 | |||
| 31 | #include <linux/init.h> | ||
| 32 | #include <linux/module.h> | ||
| 33 | #include <linux/moduleparam.h> | ||
| 34 | #include <linux/device.h> | ||
| 35 | #include <linux/firmware.h> | ||
| 36 | #include <linux/string.h> | ||
| 37 | #include <linux/slab.h> | ||
| 38 | |||
| 39 | #include "dvb_frontend.h" | ||
| 40 | #include "nxt2002.h" | ||
| 41 | |||
| 42 | struct nxt2002_state { | ||
| 43 | |||
| 44 | struct i2c_adapter* i2c; | ||
| 45 | struct dvb_frontend_ops ops; | ||
| 46 | const struct nxt2002_config* config; | ||
| 47 | struct dvb_frontend frontend; | ||
| 48 | |||
| 49 | /* demodulator private data */ | ||
| 50 | u8 initialised:1; | ||
| 51 | }; | ||
| 52 | |||
| 53 | static int debug; | ||
| 54 | #define dprintk(args...) \ | ||
| 55 | do { \ | ||
| 56 | if (debug) printk(KERN_DEBUG "nxt2002: " args); \ | ||
| 57 | } while (0) | ||
| 58 | |||
| 59 | static int i2c_writebytes (struct nxt2002_state* state, u8 reg, u8 *buf, u8 len) | ||
| 60 | { | ||
| 61 | /* probbably a much better way or doing this */ | ||
| 62 | u8 buf2 [256],x; | ||
| 63 | int err; | ||
| 64 | struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf2, .len = len + 1 }; | ||
| 65 | |||
| 66 | buf2[0] = reg; | ||
| 67 | for (x = 0 ; x < len ; x++) | ||
| 68 | buf2[x+1] = buf[x]; | ||
| 69 | |||
| 70 | if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) { | ||
| 71 | printk ("%s: i2c write error (addr %02x, err == %i)\n", | ||
| 72 | __FUNCTION__, state->config->demod_address, err); | ||
| 73 | return -EREMOTEIO; | ||
| 74 | } | ||
| 75 | |||
| 76 | return 0; | ||
| 77 | } | ||
| 78 | |||
| 79 | static u8 i2c_readbytes (struct nxt2002_state* state, u8 reg, u8* buf, u8 len) | ||
| 80 | { | ||
| 81 | u8 reg2 [] = { reg }; | ||
| 82 | |||
| 83 | struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = reg2, .len = 1 }, | ||
| 84 | { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = buf, .len = len } }; | ||
| 85 | |||
| 86 | int err; | ||
| 87 | |||
| 88 | if ((err = i2c_transfer (state->i2c, msg, 2)) != 2) { | ||
| 89 | printk ("%s: i2c read error (addr %02x, err == %i)\n", | ||
| 90 | __FUNCTION__, state->config->demod_address, err); | ||
| 91 | return -EREMOTEIO; | ||
| 92 | } | ||
| 93 | |||
| 94 | return 0; | ||
| 95 | } | ||
| 96 | |||
| 97 | static u16 nxt2002_crc(u16 crc, u8 c) | ||
| 98 | { | ||
| 99 | |||
| 100 | u8 i; | ||
| 101 | u16 input = (u16) c & 0xFF; | ||
| 102 | |||
| 103 | input<<=8; | ||
| 104 | for(i=0 ;i<8 ;i++) { | ||
| 105 | if((crc ^ input) & 0x8000) | ||
| 106 | crc=(crc<<1)^CRC_CCIT_MASK; | ||
| 107 | else | ||
| 108 | crc<<=1; | ||
| 109 | input<<=1; | ||
| 110 | } | ||
| 111 | return crc; | ||
| 112 | } | ||
| 113 | |||
| 114 | static int nxt2002_writereg_multibyte (struct nxt2002_state* state, u8 reg, u8* data, u8 len) | ||
| 115 | { | ||
| 116 | u8 buf; | ||
| 117 | dprintk("%s\n", __FUNCTION__); | ||
| 118 | |||
| 119 | /* set multi register length */ | ||
| 120 | i2c_writebytes(state,0x34,&len,1); | ||
| 121 | |||
| 122 | /* set mutli register register */ | ||
| 123 | i2c_writebytes(state,0x35,®,1); | ||
| 124 | |||
| 125 | /* send the actual data */ | ||
| 126 | i2c_writebytes(state,0x36,data,len); | ||
| 127 | |||
| 128 | /* toggle the multireg write bit*/ | ||
| 129 | buf = 0x02; | ||
| 130 | i2c_writebytes(state,0x21,&buf,1); | ||
| 131 | |||
| 132 | i2c_readbytes(state,0x21,&buf,1); | ||
| 133 | |||
| 134 | if ((buf & 0x02) == 0) | ||
| 135 | return 0; | ||
| 136 | |||
| 137 | dprintk("Error writing multireg register %02X\n",reg); | ||
| 138 | |||
| 139 | return 0; | ||
| 140 | } | ||
| 141 | |||
| 142 | static int nxt2002_readreg_multibyte (struct nxt2002_state* state, u8 reg, u8* data, u8 len) | ||
| 143 | { | ||
| 144 | u8 len2; | ||
| 145 | dprintk("%s\n", __FUNCTION__); | ||
| 146 | |||
| 147 | /* set multi register length */ | ||
| 148 | len2 = len & 0x80; | ||
| 149 | i2c_writebytes(state,0x34,&len2,1); | ||
| 150 | |||
| 151 | /* set mutli register register */ | ||
| 152 | i2c_writebytes(state,0x35,®,1); | ||
| 153 | |||
| 154 | /* send the actual data */ | ||
| 155 | i2c_readbytes(state,reg,data,len); | ||
| 156 | |||
| 157 | return 0; | ||
| 158 | } | ||
| 159 | |||
| 160 | static void nxt2002_microcontroller_stop (struct nxt2002_state* state) | ||
| 161 | { | ||
| 162 | u8 buf[2],counter = 0; | ||
| 163 | dprintk("%s\n", __FUNCTION__); | ||
| 164 | |||
| 165 | buf[0] = 0x80; | ||
| 166 | i2c_writebytes(state,0x22,buf,1); | ||
| 167 | |||
| 168 | while (counter < 20) { | ||
| 169 | i2c_readbytes(state,0x31,buf,1); | ||
| 170 | if (buf[0] & 0x40) | ||
| 171 | return; | ||
| 172 | msleep(10); | ||
| 173 | counter++; | ||
| 174 | } | ||
| 175 | |||
| 176 | dprintk("Timeout waiting for micro to stop.. This is ok after firmware upload\n"); | ||
| 177 | return; | ||
| 178 | } | ||
| 179 | |||
| 180 | static void nxt2002_microcontroller_start (struct nxt2002_state* state) | ||
| 181 | { | ||
| 182 | u8 buf; | ||
| 183 | dprintk("%s\n", __FUNCTION__); | ||
| 184 | |||
| 185 | buf = 0x00; | ||
| 186 | i2c_writebytes(state,0x22,&buf,1); | ||
| 187 | } | ||
| 188 | |||
| 189 | static int nxt2002_writetuner (struct nxt2002_state* state, u8* data) | ||
| 190 | { | ||
| 191 | u8 buf,count = 0; | ||
| 192 | |||
| 193 | dprintk("Tuner Bytes: %02X %02X %02X %02X\n",data[0],data[1],data[2],data[3]); | ||
| 194 | |||
| 195 | dprintk("%s\n", __FUNCTION__); | ||
| 196 | /* stop the micro first */ | ||
| 197 | nxt2002_microcontroller_stop(state); | ||
| 198 | |||
| 199 | /* set the i2c transfer speed to the tuner */ | ||
| 200 | buf = 0x03; | ||
| 201 | i2c_writebytes(state,0x20,&buf,1); | ||
| 202 | |||
| 203 | /* setup to transfer 4 bytes via i2c */ | ||
| 204 | buf = 0x04; | ||
| 205 | i2c_writebytes(state,0x34,&buf,1); | ||
| 206 | |||
| 207 | /* write actual tuner bytes */ | ||
| 208 | i2c_writebytes(state,0x36,data,4); | ||
| 209 | |||
| 210 | /* set tuner i2c address */ | ||
| 211 | buf = 0xC2; | ||
| 212 | i2c_writebytes(state,0x35,&buf,1); | ||
| 213 | |||
| 214 | /* write UC Opmode to begin transfer */ | ||
| 215 | buf = 0x80; | ||
| 216 | i2c_writebytes(state,0x21,&buf,1); | ||
| 217 | |||
| 218 | while (count < 20) { | ||
| 219 | i2c_readbytes(state,0x21,&buf,1); | ||
| 220 | if ((buf & 0x80)== 0x00) | ||
| 221 | return 0; | ||
| 222 | msleep(100); | ||
| 223 | count++; | ||
| 224 | } | ||
| 225 | |||
| 226 | printk("nxt2002: timeout error writing tuner\n"); | ||
| 227 | return 0; | ||
| 228 | } | ||
| 229 | |||
| 230 | static void nxt2002_agc_reset(struct nxt2002_state* state) | ||
| 231 | { | ||
| 232 | u8 buf; | ||
| 233 | dprintk("%s\n", __FUNCTION__); | ||
| 234 | |||
| 235 | buf = 0x08; | ||
| 236 | i2c_writebytes(state,0x08,&buf,1); | ||
| 237 | |||
| 238 | buf = 0x00; | ||
| 239 | i2c_writebytes(state,0x08,&buf,1); | ||
| 240 | |||
| 241 | return; | ||
| 242 | } | ||
| 243 | |||
| 244 | static int nxt2002_load_firmware (struct dvb_frontend* fe, const struct firmware *fw) | ||
| 245 | { | ||
| 246 | |||
| 247 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 248 | u8 buf[256],written = 0,chunkpos = 0; | ||
| 249 | u16 rambase,position,crc = 0; | ||
| 250 | |||
| 251 | dprintk("%s\n", __FUNCTION__); | ||
| 252 | dprintk("Firmware is %zu bytes\n",fw->size); | ||
| 253 | |||
| 254 | /* Get the RAM base for this nxt2002 */ | ||
| 255 | i2c_readbytes(state,0x10,buf,1); | ||
| 256 | |||
| 257 | if (buf[0] & 0x10) | ||
| 258 | rambase = 0x1000; | ||
| 259 | else | ||
| 260 | rambase = 0x0000; | ||
| 261 | |||
| 262 | dprintk("rambase on this nxt2002 is %04X\n",rambase); | ||
| 263 | |||
| 264 | /* Hold the micro in reset while loading firmware */ | ||
| 265 | buf[0] = 0x80; | ||
| 266 | i2c_writebytes(state,0x2B,buf,1); | ||
| 267 | |||
| 268 | for (position = 0; position < fw->size ; position++) { | ||
| 269 | if (written == 0) { | ||
| 270 | crc = 0; | ||
| 271 | chunkpos = 0x28; | ||
| 272 | buf[0] = ((rambase + position) >> 8); | ||
| 273 | buf[1] = (rambase + position) & 0xFF; | ||
| 274 | buf[2] = 0x81; | ||
| 275 | /* write starting address */ | ||
| 276 | i2c_writebytes(state,0x29,buf,3); | ||
| 277 | } | ||
| 278 | written++; | ||
| 279 | chunkpos++; | ||
| 280 | |||
| 281 | if ((written % 4) == 0) | ||
| 282 | i2c_writebytes(state,chunkpos,&fw->data[position-3],4); | ||
| 283 | |||
| 284 | crc = nxt2002_crc(crc,fw->data[position]); | ||
| 285 | |||
| 286 | if ((written == 255) || (position+1 == fw->size)) { | ||
| 287 | /* write remaining bytes of firmware */ | ||
| 288 | i2c_writebytes(state, chunkpos+4-(written %4), | ||
| 289 | &fw->data[position-(written %4) + 1], | ||
| 290 | written %4); | ||
| 291 | buf[0] = crc << 8; | ||
| 292 | buf[1] = crc & 0xFF; | ||
| 293 | |||
| 294 | /* write crc */ | ||
| 295 | i2c_writebytes(state,0x2C,buf,2); | ||
| 296 | |||
| 297 | /* do a read to stop things */ | ||
| 298 | i2c_readbytes(state,0x2A,buf,1); | ||
| 299 | |||
| 300 | /* set transfer mode to complete */ | ||
| 301 | buf[0] = 0x80; | ||
| 302 | i2c_writebytes(state,0x2B,buf,1); | ||
| 303 | |||
| 304 | written = 0; | ||
| 305 | } | ||
| 306 | } | ||
| 307 | |||
| 308 | printk ("done.\n"); | ||
| 309 | return 0; | ||
| 310 | }; | ||
| 311 | |||
| 312 | static int nxt2002_setup_frontend_parameters (struct dvb_frontend* fe, | ||
| 313 | struct dvb_frontend_parameters *p) | ||
| 314 | { | ||
| 315 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 316 | u32 freq = 0; | ||
| 317 | u16 tunerfreq = 0; | ||
| 318 | u8 buf[4]; | ||
| 319 | |||
| 320 | freq = 44000 + ( p->frequency / 1000 ); | ||
| 321 | |||
| 322 | dprintk("freq = %d p->frequency = %d\n",freq,p->frequency); | ||
| 323 | |||
| 324 | tunerfreq = freq * 24/4000; | ||
| 325 | |||
| 326 | buf[0] = (tunerfreq >> 8) & 0x7F; | ||
| 327 | buf[1] = (tunerfreq & 0xFF); | ||
| 328 | |||
| 329 | if (p->frequency <= 214000000) { | ||
| 330 | buf[2] = 0x84 + (0x06 << 3); | ||
| 331 | buf[3] = (p->frequency <= 172000000) ? 0x01 : 0x02; | ||
| 332 | } else if (p->frequency <= 721000000) { | ||
| 333 | buf[2] = 0x84 + (0x07 << 3); | ||
| 334 | buf[3] = (p->frequency <= 467000000) ? 0x02 : 0x08; | ||
| 335 | } else if (p->frequency <= 841000000) { | ||
| 336 | buf[2] = 0x84 + (0x0E << 3); | ||
| 337 | buf[3] = 0x08; | ||
| 338 | } else { | ||
| 339 | buf[2] = 0x84 + (0x0F << 3); | ||
| 340 | buf[3] = 0x02; | ||
| 341 | } | ||
| 342 | |||
| 343 | /* write frequency information */ | ||
| 344 | nxt2002_writetuner(state,buf); | ||
| 345 | |||
| 346 | /* reset the agc now that tuning has been completed */ | ||
| 347 | nxt2002_agc_reset(state); | ||
| 348 | |||
| 349 | /* set target power level */ | ||
| 350 | switch (p->u.vsb.modulation) { | ||
| 351 | case QAM_64: | ||
| 352 | case QAM_256: | ||
| 353 | buf[0] = 0x74; | ||
| 354 | break; | ||
| 355 | case VSB_8: | ||
| 356 | buf[0] = 0x70; | ||
| 357 | break; | ||
| 358 | default: | ||
| 359 | return -EINVAL; | ||
| 360 | break; | ||
| 361 | } | ||
| 362 | i2c_writebytes(state,0x42,buf,1); | ||
| 363 | |||
| 364 | /* configure sdm */ | ||
| 365 | buf[0] = 0x87; | ||
| 366 | i2c_writebytes(state,0x57,buf,1); | ||
| 367 | |||
| 368 | /* write sdm1 input */ | ||
| 369 | buf[0] = 0x10; | ||
| 370 | buf[1] = 0x00; | ||
| 371 | nxt2002_writereg_multibyte(state,0x58,buf,2); | ||
| 372 | |||
| 373 | /* write sdmx input */ | ||
| 374 | switch (p->u.vsb.modulation) { | ||
| 375 | case QAM_64: | ||
| 376 | buf[0] = 0x68; | ||
| 377 | break; | ||
| 378 | case QAM_256: | ||
| 379 | buf[0] = 0x64; | ||
| 380 | break; | ||
| 381 | case VSB_8: | ||
| 382 | buf[0] = 0x60; | ||
| 383 | break; | ||
| 384 | default: | ||
| 385 | return -EINVAL; | ||
| 386 | break; | ||
| 387 | } | ||
| 388 | buf[1] = 0x00; | ||
| 389 | nxt2002_writereg_multibyte(state,0x5C,buf,2); | ||
| 390 | |||
| 391 | /* write adc power lpf fc */ | ||
| 392 | buf[0] = 0x05; | ||
| 393 | i2c_writebytes(state,0x43,buf,1); | ||
| 394 | |||
| 395 | /* write adc power lpf fc */ | ||
| 396 | buf[0] = 0x05; | ||
| 397 | i2c_writebytes(state,0x43,buf,1); | ||
| 398 | |||
| 399 | /* write accumulator2 input */ | ||
| 400 | buf[0] = 0x80; | ||
| 401 | buf[1] = 0x00; | ||
| 402 | nxt2002_writereg_multibyte(state,0x4B,buf,2); | ||
| 403 | |||
| 404 | /* write kg1 */ | ||
| 405 | buf[0] = 0x00; | ||
| 406 | i2c_writebytes(state,0x4D,buf,1); | ||
| 407 | |||
| 408 | /* write sdm12 lpf fc */ | ||
| 409 | buf[0] = 0x44; | ||
| 410 | i2c_writebytes(state,0x55,buf,1); | ||
| 411 | |||
| 412 | /* write agc control reg */ | ||
| 413 | buf[0] = 0x04; | ||
| 414 | i2c_writebytes(state,0x41,buf,1); | ||
| 415 | |||
| 416 | /* write agc ucgp0 */ | ||
| 417 | switch (p->u.vsb.modulation) { | ||
| 418 | case QAM_64: | ||
| 419 | buf[0] = 0x02; | ||
| 420 | break; | ||
| 421 | case QAM_256: | ||
| 422 | buf[0] = 0x03; | ||
| 423 | break; | ||
| 424 | case VSB_8: | ||
| 425 | buf[0] = 0x00; | ||
| 426 | break; | ||
| 427 | default: | ||
| 428 | return -EINVAL; | ||
| 429 | break; | ||
| 430 | } | ||
| 431 | i2c_writebytes(state,0x30,buf,1); | ||
| 432 | |||
| 433 | /* write agc control reg */ | ||
| 434 | buf[0] = 0x00; | ||
| 435 | i2c_writebytes(state,0x41,buf,1); | ||
| 436 | |||
| 437 | /* write accumulator2 input */ | ||
| 438 | buf[0] = 0x80; | ||
| 439 | buf[1] = 0x00; | ||
| 440 | nxt2002_writereg_multibyte(state,0x49,buf,2); | ||
| 441 | nxt2002_writereg_multibyte(state,0x4B,buf,2); | ||
| 442 | |||
| 443 | /* write agc control reg */ | ||
| 444 | buf[0] = 0x04; | ||
| 445 | i2c_writebytes(state,0x41,buf,1); | ||
| 446 | |||
| 447 | nxt2002_microcontroller_start(state); | ||
| 448 | |||
| 449 | /* adjacent channel detection should be done here, but I don't | ||
| 450 | have any stations with this need so I cannot test it */ | ||
| 451 | |||
| 452 | return 0; | ||
| 453 | } | ||
| 454 | |||
| 455 | static int nxt2002_read_status(struct dvb_frontend* fe, fe_status_t* status) | ||
| 456 | { | ||
| 457 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 458 | u8 lock; | ||
| 459 | i2c_readbytes(state,0x31,&lock,1); | ||
| 460 | |||
| 461 | *status = 0; | ||
| 462 | if (lock & 0x20) { | ||
| 463 | *status |= FE_HAS_SIGNAL; | ||
| 464 | *status |= FE_HAS_CARRIER; | ||
| 465 | *status |= FE_HAS_VITERBI; | ||
| 466 | *status |= FE_HAS_SYNC; | ||
| 467 | *status |= FE_HAS_LOCK; | ||
| 468 | } | ||
| 469 | return 0; | ||
| 470 | } | ||
| 471 | |||
| 472 | static int nxt2002_read_ber(struct dvb_frontend* fe, u32* ber) | ||
| 473 | { | ||
| 474 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 475 | u8 b[3]; | ||
| 476 | |||
| 477 | nxt2002_readreg_multibyte(state,0xE6,b,3); | ||
| 478 | |||
| 479 | *ber = ((b[0] << 8) + b[1]) * 8; | ||
| 480 | |||
| 481 | return 0; | ||
| 482 | } | ||
| 483 | |||
| 484 | static int nxt2002_read_signal_strength(struct dvb_frontend* fe, u16* strength) | ||
| 485 | { | ||
| 486 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 487 | u8 b[2]; | ||
| 488 | u16 temp = 0; | ||
| 489 | |||
| 490 | /* setup to read cluster variance */ | ||
| 491 | b[0] = 0x00; | ||
| 492 | i2c_writebytes(state,0xA1,b,1); | ||
| 493 | |||
| 494 | /* get multreg val */ | ||
| 495 | nxt2002_readreg_multibyte(state,0xA6,b,2); | ||
| 496 | |||
| 497 | temp = (b[0] << 8) | b[1]; | ||
| 498 | *strength = ((0x7FFF - temp) & 0x0FFF) * 16; | ||
| 499 | |||
| 500 | return 0; | ||
| 501 | } | ||
| 502 | |||
| 503 | static int nxt2002_read_snr(struct dvb_frontend* fe, u16* snr) | ||
| 504 | { | ||
| 505 | |||
| 506 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 507 | u8 b[2]; | ||
| 508 | u16 temp = 0, temp2; | ||
| 509 | u32 snrdb = 0; | ||
| 510 | |||
| 511 | /* setup to read cluster variance */ | ||
| 512 | b[0] = 0x00; | ||
| 513 | i2c_writebytes(state,0xA1,b,1); | ||
| 514 | |||
| 515 | /* get multreg val from 0xA6 */ | ||
| 516 | nxt2002_readreg_multibyte(state,0xA6,b,2); | ||
| 517 | |||
| 518 | temp = (b[0] << 8) | b[1]; | ||
| 519 | temp2 = 0x7FFF - temp; | ||
| 520 | |||
| 521 | /* snr will be in db */ | ||
| 522 | if (temp2 > 0x7F00) | ||
| 523 | snrdb = 1000*24 + ( 1000*(30-24) * ( temp2 - 0x7F00 ) / ( 0x7FFF - 0x7F00 ) ); | ||
| 524 | else if (temp2 > 0x7EC0) | ||
| 525 | snrdb = 1000*18 + ( 1000*(24-18) * ( temp2 - 0x7EC0 ) / ( 0x7F00 - 0x7EC0 ) ); | ||
| 526 | else if (temp2 > 0x7C00) | ||
| 527 | snrdb = 1000*12 + ( 1000*(18-12) * ( temp2 - 0x7C00 ) / ( 0x7EC0 - 0x7C00 ) ); | ||
| 528 | else | ||
| 529 | snrdb = 1000*0 + ( 1000*(12-0) * ( temp2 - 0 ) / ( 0x7C00 - 0 ) ); | ||
| 530 | |||
| 531 | /* the value reported back from the frontend will be FFFF=32db 0000=0db */ | ||
| 532 | |||
| 533 | *snr = snrdb * (0xFFFF/32000); | ||
| 534 | |||
| 535 | return 0; | ||
| 536 | } | ||
| 537 | |||
| 538 | static int nxt2002_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks) | ||
| 539 | { | ||
| 540 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 541 | u8 b[3]; | ||
| 542 | |||
| 543 | nxt2002_readreg_multibyte(state,0xE6,b,3); | ||
| 544 | *ucblocks = b[2]; | ||
| 545 | |||
| 546 | return 0; | ||
| 547 | } | ||
| 548 | |||
| 549 | static int nxt2002_sleep(struct dvb_frontend* fe) | ||
| 550 | { | ||
| 551 | return 0; | ||
| 552 | } | ||
| 553 | |||
| 554 | static int nxt2002_init(struct dvb_frontend* fe) | ||
| 555 | { | ||
| 556 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 557 | const struct firmware *fw; | ||
| 558 | int ret; | ||
| 559 | u8 buf[2]; | ||
| 560 | |||
| 561 | if (!state->initialised) { | ||
| 562 | /* request the firmware, this will block until someone uploads it */ | ||
| 563 | printk("nxt2002: Waiting for firmware upload (%s)...\n", NXT2002_DEFAULT_FIRMWARE); | ||
| 564 | ret = state->config->request_firmware(fe, &fw, NXT2002_DEFAULT_FIRMWARE); | ||
| 565 | printk("nxt2002: Waiting for firmware upload(2)...\n"); | ||
| 566 | if (ret) { | ||
| 567 | printk("nxt2002: no firmware upload (timeout or file not found?)\n"); | ||
| 568 | return ret; | ||
| 569 | } | ||
| 570 | |||
| 571 | ret = nxt2002_load_firmware(fe, fw); | ||
| 572 | if (ret) { | ||
| 573 | printk("nxt2002: writing firmware to device failed\n"); | ||
| 574 | release_firmware(fw); | ||
| 575 | return ret; | ||
| 576 | } | ||
| 577 | printk("nxt2002: firmware upload complete\n"); | ||
| 578 | |||
| 579 | /* Put the micro into reset */ | ||
| 580 | nxt2002_microcontroller_stop(state); | ||
| 581 | |||
| 582 | /* ensure transfer is complete */ | ||
| 583 | buf[0]=0; | ||
| 584 | i2c_writebytes(state,0x2B,buf,1); | ||
| 585 | |||
| 586 | /* Put the micro into reset for real this time */ | ||
| 587 | nxt2002_microcontroller_stop(state); | ||
| 588 | |||
| 589 | /* soft reset everything (agc,frontend,eq,fec)*/ | ||
| 590 | buf[0] = 0x0F; | ||
| 591 | i2c_writebytes(state,0x08,buf,1); | ||
| 592 | buf[0] = 0x00; | ||
| 593 | i2c_writebytes(state,0x08,buf,1); | ||
| 594 | |||
| 595 | /* write agc sdm configure */ | ||
| 596 | buf[0] = 0xF1; | ||
| 597 | i2c_writebytes(state,0x57,buf,1); | ||
| 598 | |||
| 599 | /* write mod output format */ | ||
| 600 | buf[0] = 0x20; | ||
| 601 | i2c_writebytes(state,0x09,buf,1); | ||
| 602 | |||
| 603 | /* write fec mpeg mode */ | ||
| 604 | buf[0] = 0x7E; | ||
| 605 | buf[1] = 0x00; | ||
| 606 | i2c_writebytes(state,0xE9,buf,2); | ||
| 607 | |||
| 608 | /* write mux selection */ | ||
| 609 | buf[0] = 0x00; | ||
| 610 | i2c_writebytes(state,0xCC,buf,1); | ||
| 611 | |||
| 612 | state->initialised = 1; | ||
| 613 | } | ||
| 614 | |||
| 615 | return 0; | ||
| 616 | } | ||
| 617 | |||
| 618 | static int nxt2002_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings) | ||
| 619 | { | ||
| 620 | fesettings->min_delay_ms = 500; | ||
| 621 | fesettings->step_size = 0; | ||
| 622 | fesettings->max_drift = 0; | ||
| 623 | return 0; | ||
| 624 | } | ||
| 625 | |||
| 626 | static void nxt2002_release(struct dvb_frontend* fe) | ||
| 627 | { | ||
| 628 | struct nxt2002_state* state = fe->demodulator_priv; | ||
| 629 | kfree(state); | ||
| 630 | } | ||
| 631 | |||
| 632 | static struct dvb_frontend_ops nxt2002_ops; | ||
| 633 | |||
| 634 | struct dvb_frontend* nxt2002_attach(const struct nxt2002_config* config, | ||
| 635 | struct i2c_adapter* i2c) | ||
| 636 | { | ||
| 637 | struct nxt2002_state* state = NULL; | ||
| 638 | u8 buf [] = {0,0,0,0,0}; | ||
| 639 | |||
| 640 | /* allocate memory for the internal state */ | ||
| 641 | state = kmalloc(sizeof(struct nxt2002_state), GFP_KERNEL); | ||
| 642 | if (state == NULL) goto error; | ||
| 643 | |||
| 644 | /* setup the state */ | ||
| 645 | state->config = config; | ||
| 646 | state->i2c = i2c; | ||
| 647 | memcpy(&state->ops, &nxt2002_ops, sizeof(struct dvb_frontend_ops)); | ||
| 648 | state->initialised = 0; | ||
| 649 | |||
| 650 | /* Check the first 5 registers to ensure this a revision we can handle */ | ||
| 651 | |||
| 652 | i2c_readbytes(state, 0x00, buf, 5); | ||
| 653 | if (buf[0] != 0x04) goto error; /* device id */ | ||
| 654 | if (buf[1] != 0x02) goto error; /* fab id */ | ||
| 655 | if (buf[2] != 0x11) goto error; /* month */ | ||
| 656 | if (buf[3] != 0x20) goto error; /* year msb */ | ||
| 657 | if (buf[4] != 0x00) goto error; /* year lsb */ | ||
| 658 | |||
| 659 | /* create dvb_frontend */ | ||
| 660 | state->frontend.ops = &state->ops; | ||
| 661 | state->frontend.demodulator_priv = state; | ||
| 662 | return &state->frontend; | ||
| 663 | |||
| 664 | error: | ||
| 665 | kfree(state); | ||
| 666 | return NULL; | ||
| 667 | } | ||
| 668 | |||
| 669 | static struct dvb_frontend_ops nxt2002_ops = { | ||
| 670 | |||
| 671 | .info = { | ||
| 672 | .name = "Nextwave nxt2002 VSB/QAM frontend", | ||
| 673 | .type = FE_ATSC, | ||
| 674 | .frequency_min = 54000000, | ||
| 675 | .frequency_max = 860000000, | ||
| 676 | /* stepsize is just a guess */ | ||
| 677 | .frequency_stepsize = 166666, | ||
| 678 | .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | | ||
| 679 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO | | ||
| 680 | FE_CAN_8VSB | FE_CAN_QAM_64 | FE_CAN_QAM_256 | ||
| 681 | }, | ||
| 682 | |||
| 683 | .release = nxt2002_release, | ||
| 684 | |||
| 685 | .init = nxt2002_init, | ||
| 686 | .sleep = nxt2002_sleep, | ||
| 687 | |||
| 688 | .set_frontend = nxt2002_setup_frontend_parameters, | ||
| 689 | .get_tune_settings = nxt2002_get_tune_settings, | ||
| 690 | |||
| 691 | .read_status = nxt2002_read_status, | ||
| 692 | .read_ber = nxt2002_read_ber, | ||
| 693 | .read_signal_strength = nxt2002_read_signal_strength, | ||
| 694 | .read_snr = nxt2002_read_snr, | ||
| 695 | .read_ucblocks = nxt2002_read_ucblocks, | ||
| 696 | |||
| 697 | }; | ||
| 698 | |||
| 699 | module_param(debug, int, 0644); | ||
| 700 | MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); | ||
| 701 | |||
| 702 | MODULE_DESCRIPTION("NXT2002 ATSC (8VSB & ITU J83 AnnexB FEC QAM64/256) demodulator driver"); | ||
| 703 | MODULE_AUTHOR("Taylor Jacob"); | ||
| 704 | MODULE_LICENSE("GPL"); | ||
| 705 | |||
| 706 | EXPORT_SYMBOL(nxt2002_attach); | ||
diff --git a/drivers/media/dvb/frontends/nxt2002.h b/drivers/media/dvb/frontends/nxt2002.h deleted file mode 100644 index 462301f577ee..000000000000 --- a/drivers/media/dvb/frontends/nxt2002.h +++ /dev/null | |||
| @@ -1,23 +0,0 @@ | |||
| 1 | /* | ||
| 2 | Driver for the Nxt2002 demodulator | ||
| 3 | */ | ||
| 4 | |||
| 5 | #ifndef NXT2002_H | ||
| 6 | #define NXT2002_H | ||
| 7 | |||
| 8 | #include <linux/dvb/frontend.h> | ||
| 9 | #include <linux/firmware.h> | ||
| 10 | |||
| 11 | struct nxt2002_config | ||
| 12 | { | ||
| 13 | /* the demodulator's i2c address */ | ||
| 14 | u8 demod_address; | ||
| 15 | |||
| 16 | /* request firmware for device */ | ||
| 17 | int (*request_firmware)(struct dvb_frontend* fe, const struct firmware **fw, char* name); | ||
| 18 | }; | ||
| 19 | |||
| 20 | extern struct dvb_frontend* nxt2002_attach(const struct nxt2002_config* config, | ||
| 21 | struct i2c_adapter* i2c); | ||
| 22 | |||
| 23 | #endif // NXT2002_H | ||
diff --git a/drivers/media/dvb/frontends/nxt200x.c b/drivers/media/dvb/frontends/nxt200x.c index 78d2b93d35b9..9e3535394509 100644 --- a/drivers/media/dvb/frontends/nxt200x.c +++ b/drivers/media/dvb/frontends/nxt200x.c | |||
| @@ -1,9 +1,10 @@ | |||
| 1 | /* | 1 | /* |
| 2 | * Support for NXT2002 and NXT2004 - VSB/QAM | 2 | * Support for NXT2002 and NXT2004 - VSB/QAM |
| 3 | * | 3 | * |
| 4 | * Copyright (C) 2005 Kirk Lapray (kirk.lapray@gmail.com) | 4 | * Copyright (C) 2005 Kirk Lapray <kirk.lapray@gmail.com> |
| 5 | * Copyright (C) 2006 Michael Krufky <mkrufky@m1k.net> | ||
| 5 | * based on nxt2002 by Taylor Jacob <rtjacob@earthlink.net> | 6 | * based on nxt2002 by Taylor Jacob <rtjacob@earthlink.net> |
| 6 | * and nxt2004 by Jean-Francois Thibert (jeanfrancois@sagetv.com) | 7 | * and nxt2004 by Jean-Francois Thibert <jeanfrancois@sagetv.com> |
| 7 | * | 8 | * |
| 8 | * This program is free software; you can redistribute it and/or modify | 9 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License as published by | 10 | * it under the terms of the GNU General Public License as published by |
| @@ -614,7 +615,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe, | |||
| 614 | /* write sdm1 input */ | 615 | /* write sdm1 input */ |
| 615 | buf[0] = 0x10; | 616 | buf[0] = 0x10; |
| 616 | buf[1] = 0x00; | 617 | buf[1] = 0x00; |
| 617 | nxt200x_writebytes(state, 0x58, buf, 2); | 618 | switch (state->demod_chip) { |
| 619 | case NXT2002: | ||
| 620 | nxt200x_writereg_multibyte(state, 0x58, buf, 2); | ||
| 621 | break; | ||
| 622 | case NXT2004: | ||
| 623 | nxt200x_writebytes(state, 0x58, buf, 2); | ||
| 624 | break; | ||
| 625 | default: | ||
| 626 | return -EINVAL; | ||
| 627 | break; | ||
| 628 | } | ||
| 618 | 629 | ||
| 619 | /* write sdmx input */ | 630 | /* write sdmx input */ |
| 620 | switch (p->u.vsb.modulation) { | 631 | switch (p->u.vsb.modulation) { |
| @@ -632,7 +643,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe, | |||
| 632 | break; | 643 | break; |
| 633 | } | 644 | } |
| 634 | buf[1] = 0x00; | 645 | buf[1] = 0x00; |
| 635 | nxt200x_writebytes(state, 0x5C, buf, 2); | 646 | switch (state->demod_chip) { |
| 647 | case NXT2002: | ||
| 648 | nxt200x_writereg_multibyte(state, 0x5C, buf, 2); | ||
| 649 | break; | ||
| 650 | case NXT2004: | ||
| 651 | nxt200x_writebytes(state, 0x5C, buf, 2); | ||
| 652 | break; | ||
| 653 | default: | ||
| 654 | return -EINVAL; | ||
| 655 | break; | ||
| 656 | } | ||
| 636 | 657 | ||
| 637 | /* write adc power lpf fc */ | 658 | /* write adc power lpf fc */ |
| 638 | buf[0] = 0x05; | 659 | buf[0] = 0x05; |
| @@ -648,7 +669,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe, | |||
| 648 | /* write accumulator2 input */ | 669 | /* write accumulator2 input */ |
| 649 | buf[0] = 0x80; | 670 | buf[0] = 0x80; |
| 650 | buf[1] = 0x00; | 671 | buf[1] = 0x00; |
| 651 | nxt200x_writebytes(state, 0x4B, buf, 2); | 672 | switch (state->demod_chip) { |
| 673 | case NXT2002: | ||
| 674 | nxt200x_writereg_multibyte(state, 0x4B, buf, 2); | ||
| 675 | break; | ||
| 676 | case NXT2004: | ||
| 677 | nxt200x_writebytes(state, 0x4B, buf, 2); | ||
| 678 | break; | ||
| 679 | default: | ||
| 680 | return -EINVAL; | ||
| 681 | break; | ||
| 682 | } | ||
| 652 | 683 | ||
| 653 | /* write kg1 */ | 684 | /* write kg1 */ |
| 654 | buf[0] = 0x00; | 685 | buf[0] = 0x00; |
| @@ -714,8 +745,19 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe, | |||
| 714 | /* write accumulator2 input */ | 745 | /* write accumulator2 input */ |
| 715 | buf[0] = 0x80; | 746 | buf[0] = 0x80; |
| 716 | buf[1] = 0x00; | 747 | buf[1] = 0x00; |
| 717 | nxt200x_writebytes(state, 0x49, buf,2); | 748 | switch (state->demod_chip) { |
| 718 | nxt200x_writebytes(state, 0x4B, buf,2); | 749 | case NXT2002: |
| 750 | nxt200x_writereg_multibyte(state, 0x49, buf, 2); | ||
| 751 | nxt200x_writereg_multibyte(state, 0x4B, buf, 2); | ||
| 752 | break; | ||
| 753 | case NXT2004: | ||
| 754 | nxt200x_writebytes(state, 0x49, buf, 2); | ||
| 755 | nxt200x_writebytes(state, 0x4B, buf, 2); | ||
| 756 | break; | ||
| 757 | default: | ||
| 758 | return -EINVAL; | ||
| 759 | break; | ||
| 760 | } | ||
| 719 | 761 | ||
| 720 | /* write agc control reg */ | 762 | /* write agc control reg */ |
| 721 | buf[0] = 0x04; | 763 | buf[0] = 0x04; |
| @@ -1199,7 +1241,7 @@ module_param(debug, int, 0644); | |||
| 1199 | MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); | 1241 | MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); |
| 1200 | 1242 | ||
| 1201 | MODULE_DESCRIPTION("NXT200X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver"); | 1243 | MODULE_DESCRIPTION("NXT200X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver"); |
| 1202 | MODULE_AUTHOR("Kirk Lapray, Jean-Francois Thibert, and Taylor Jacob"); | 1244 | MODULE_AUTHOR("Kirk Lapray, Michael Krufky, Jean-Francois Thibert, and Taylor Jacob"); |
| 1203 | MODULE_LICENSE("GPL"); | 1245 | MODULE_LICENSE("GPL"); |
| 1204 | 1246 | ||
| 1205 | EXPORT_SYMBOL(nxt200x_attach); | 1247 | EXPORT_SYMBOL(nxt200x_attach); |
diff --git a/drivers/media/dvb/frontends/tda80xx.c b/drivers/media/dvb/frontends/tda80xx.c deleted file mode 100644 index d1cabb6a0a13..000000000000 --- a/drivers/media/dvb/frontends/tda80xx.c +++ /dev/null | |||
| @@ -1,734 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * tda80xx.c | ||
| 3 | * | ||
| 4 | * Philips TDA8044 / TDA8083 QPSK demodulator driver | ||
| 5 | * | ||
| 6 | * Copyright (C) 2001 Felix Domke <tmbinc@elitedvb.net> | ||
| 7 | * Copyright (C) 2002-2004 Andreas Oberritter <obi@linuxtv.org> | ||
| 8 | * | ||
| 9 | * This program is free software; you can redistribute it and/or modify | ||
| 10 | * it under the terms of the GNU General Public License as published by | ||
| 11 | * the Free Software Foundation; either version 2 of the License, or | ||
| 12 | * (at your option) any later version. | ||
| 13 | * | ||
| 14 | * This program is distributed in the hope that it will be useful, | ||
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 17 | * GNU General Public License for more details. | ||
| 18 | * | ||
| 19 | * You should have received a copy of the GNU General Public License | ||
| 20 | * along with this program; if not, write to the Free Software | ||
| 21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
| 22 | */ | ||
| 23 | |||
| 24 | #include <linux/config.h> | ||
| 25 | #include <linux/delay.h> | ||
| 26 | #include <linux/init.h> | ||
| 27 | #include <linux/spinlock.h> | ||
| 28 | #include <linux/threads.h> | ||
| 29 | #include <linux/interrupt.h> | ||
| 30 | #include <linux/kernel.h> | ||
| 31 | #include <linux/module.h> | ||
| 32 | #include <linux/slab.h> | ||
| 33 | #include <asm/irq.h> | ||
| 34 | #include <asm/div64.h> | ||
| 35 | |||
| 36 | #include "dvb_frontend.h" | ||
| 37 | #include "tda80xx.h" | ||
| 38 | |||
| 39 | enum { | ||
| 40 | ID_TDA8044 = 0x04, | ||
| 41 | ID_TDA8083 = 0x05, | ||
| 42 | }; | ||
| 43 | |||
| 44 | |||
| 45 | struct tda80xx_state { | ||
| 46 | |||
| 47 | struct i2c_adapter* i2c; | ||
| 48 | |||
| 49 | struct dvb_frontend_ops ops; | ||
| 50 | |||
| 51 | /* configuration settings */ | ||
| 52 | const struct tda80xx_config* config; | ||
| 53 | |||
| 54 | struct dvb_frontend frontend; | ||
| 55 | |||
| 56 | u32 clk; | ||
| 57 | int afc_loop; | ||
| 58 | struct work_struct worklet; | ||
| 59 | fe_code_rate_t code_rate; | ||
| 60 | fe_spectral_inversion_t spectral_inversion; | ||
| 61 | fe_status_t status; | ||
| 62 | u8 id; | ||
| 63 | }; | ||
| 64 | |||
| 65 | static int debug = 1; | ||
| 66 | #define dprintk if (debug) printk | ||
| 67 | |||
| 68 | static u8 tda8044_inittab_pre[] = { | ||
| 69 | 0x02, 0x00, 0x6f, 0xb5, 0x86, 0x22, 0x00, 0xea, | ||
| 70 | 0x30, 0x42, 0x98, 0x68, 0x70, 0x42, 0x99, 0x58, | ||
| 71 | 0x95, 0x10, 0xf5, 0xe7, 0x93, 0x0b, 0x15, 0x68, | ||
| 72 | 0x9a, 0x90, 0x61, 0x80, 0x00, 0xe0, 0x40, 0x00, | ||
| 73 | 0x0f, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
| 74 | 0x00, 0x00 | ||
| 75 | }; | ||
| 76 | |||
| 77 | static u8 tda8044_inittab_post[] = { | ||
| 78 | 0x04, 0x00, 0x6f, 0xb5, 0x86, 0x22, 0x00, 0xea, | ||
| 79 | 0x30, 0x42, 0x98, 0x68, 0x70, 0x42, 0x99, 0x50, | ||
| 80 | 0x95, 0x10, 0xf5, 0xe7, 0x93, 0x0b, 0x15, 0x68, | ||
| 81 | 0x9a, 0x90, 0x61, 0x80, 0x00, 0xe0, 0x40, 0x6c, | ||
| 82 | 0x0f, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
| 83 | 0x00, 0x00 | ||
| 84 | }; | ||
| 85 | |||
| 86 | static u8 tda8083_inittab[] = { | ||
| 87 | 0x04, 0x00, 0x4a, 0x79, 0x04, 0x00, 0xff, 0xea, | ||
| 88 | 0x48, 0x42, 0x79, 0x60, 0x70, 0x52, 0x9a, 0x10, | ||
| 89 | 0x0e, 0x10, 0xf2, 0xa7, 0x93, 0x0b, 0x05, 0xc8, | ||
| 90 | 0x9d, 0x00, 0x42, 0x80, 0x00, 0x60, 0x40, 0x00, | ||
| 91 | 0x00, 0x75, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, | ||
| 92 | 0x00, 0x00, 0x00, 0x00 | ||
| 93 | }; | ||
| 94 | |||
| 95 | static __inline__ u32 tda80xx_div(u32 a, u32 b) | ||
| 96 | { | ||
| 97 | return (a + (b / 2)) / b; | ||
| 98 | } | ||
| 99 | |||
| 100 | static __inline__ u32 tda80xx_gcd(u32 a, u32 b) | ||
| 101 | { | ||
| 102 | u32 r; | ||
| 103 | |||
| 104 | while ((r = a % b)) { | ||
| 105 | a = b; | ||
| 106 | b = r; | ||
| 107 | } | ||
| 108 | |||
| 109 | return b; | ||
| 110 | } | ||
| 111 | |||
| 112 | static int tda80xx_read(struct tda80xx_state* state, u8 reg, u8 *buf, u8 len) | ||
| 113 | { | ||
| 114 | int ret; | ||
| 115 | struct i2c_msg msg[] = { { .addr = state->config->demod_address, .flags = 0, .buf = ®, .len = 1 }, | ||
| 116 | { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = buf, .len = len } }; | ||
| 117 | |||
| 118 | ret = i2c_transfer(state->i2c, msg, 2); | ||
| 119 | |||
| 120 | if (ret != 2) | ||
| 121 | dprintk("%s: readreg error (reg %02x, ret == %i)\n", | ||
| 122 | __FUNCTION__, reg, ret); | ||
| 123 | |||
| 124 | mdelay(10); | ||
| 125 | |||
| 126 | return (ret == 2) ? 0 : -EREMOTEIO; | ||
| 127 | } | ||
| 128 | |||
| 129 | static int tda80xx_write(struct tda80xx_state* state, u8 reg, const u8 *buf, u8 len) | ||
| 130 | { | ||
| 131 | int ret; | ||
| 132 | u8 wbuf[len + 1]; | ||
| 133 | struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = wbuf, .len = len + 1 }; | ||
| 134 | |||
| 135 | wbuf[0] = reg; | ||
| 136 | memcpy(&wbuf[1], buf, len); | ||
| 137 | |||
| 138 | ret = i2c_transfer(state->i2c, &msg, 1); | ||
| 139 | |||
| 140 | if (ret != 1) | ||
| 141 | dprintk("%s: i2c xfer error (ret == %i)\n", __FUNCTION__, ret); | ||
| 142 | |||
| 143 | mdelay(10); | ||
| 144 | |||
| 145 | return (ret == 1) ? 0 : -EREMOTEIO; | ||
| 146 | } | ||
| 147 | |||
| 148 | static __inline__ u8 tda80xx_readreg(struct tda80xx_state* state, u8 reg) | ||
| 149 | { | ||
| 150 | u8 val; | ||
| 151 | |||
| 152 | tda80xx_read(state, reg, &val, 1); | ||
| 153 | |||
| 154 | return val; | ||
| 155 | } | ||
| 156 | |||
| 157 | static __inline__ int tda80xx_writereg(struct tda80xx_state* state, u8 reg, u8 data) | ||
| 158 | { | ||
| 159 | return tda80xx_write(state, reg, &data, 1); | ||
| 160 | } | ||
| 161 | |||
| 162 | static int tda80xx_set_parameters(struct tda80xx_state* state, | ||
| 163 | fe_spectral_inversion_t inversion, | ||
| 164 | u32 symbol_rate, | ||
| 165 | fe_code_rate_t fec_inner) | ||
| 166 | { | ||
| 167 | u8 buf[15]; | ||
| 168 | u64 ratio; | ||
| 169 | u32 clk; | ||
| 170 | u32 k; | ||
| 171 | u32 sr = symbol_rate; | ||
| 172 | u32 gcd; | ||
| 173 | u8 scd; | ||
| 174 | |||
| 175 | if (symbol_rate > (state->clk * 3) / 16) | ||
| 176 | scd = 0; | ||
| 177 | else if (symbol_rate > (state->clk * 3) / 32) | ||
| 178 | scd = 1; | ||
| 179 | else if (symbol_rate > (state->clk * 3) / 64) | ||
| 180 | scd = 2; | ||
| 181 | else | ||
| 182 | scd = 3; | ||
| 183 | |||
| 184 | clk = scd ? (state->clk / (scd * 2)) : state->clk; | ||
| 185 | |||
| 186 | /* | ||
| 187 | * Viterbi decoder: | ||
| 188 | * Differential decoding off | ||
| 189 | * Spectral inversion unknown | ||
| 190 | * QPSK modulation | ||
| 191 | */ | ||
| 192 | if (inversion == INVERSION_ON) | ||
| 193 | buf[0] = 0x60; | ||
| 194 | else if (inversion == INVERSION_OFF) | ||
| 195 | buf[0] = 0x20; | ||
| 196 | else | ||
| 197 | buf[0] = 0x00; | ||
| 198 | |||
| 199 | /* | ||
| 200 | * CLK ratio: | ||
| 201 | * system clock frequency is up to 64 or 96 MHz | ||
| 202 | * | ||
| 203 | * formula: | ||
| 204 | * r = k * clk / symbol_rate | ||
| 205 | * | ||
| 206 | * k: 2^21 for caa 0..3, | ||
| 207 | * 2^20 for caa 4..5, | ||
| 208 | * 2^19 for caa 6..7 | ||
| 209 | */ | ||
| 210 | if (symbol_rate <= (clk * 3) / 32) | ||
| 211 | k = (1 << 19); | ||
| 212 | else if (symbol_rate <= (clk * 3) / 16) | ||
| 213 | k = (1 << 20); | ||
| 214 | else | ||
| 215 | k = (1 << 21); | ||
| 216 | |||
| 217 | gcd = tda80xx_gcd(clk, sr); | ||
| 218 | clk /= gcd; | ||
| 219 | sr /= gcd; | ||
| 220 | |||
| 221 | gcd = tda80xx_gcd(k, sr); | ||
| 222 | k /= gcd; | ||
| 223 | sr /= gcd; | ||
| 224 | |||
| 225 | ratio = (u64)k * (u64)clk; | ||
| 226 | do_div(ratio, sr); | ||
| 227 | |||
| 228 | buf[1] = ratio >> 16; | ||
| 229 | buf[2] = ratio >> 8; | ||
| 230 | buf[3] = ratio; | ||
| 231 | |||
| 232 | /* nyquist filter roll-off factor 35% */ | ||
| 233 | buf[4] = 0x20; | ||
| 234 | |||
| 235 | clk = scd ? (state->clk / (scd * 2)) : state->clk; | ||
| 236 | |||
| 237 | /* Anti Alias Filter */ | ||
| 238 | if (symbol_rate < (clk * 3) / 64) | ||
| 239 | printk("tda80xx: unsupported symbol rate: %u\n", symbol_rate); | ||
| 240 | else if (symbol_rate <= clk / 16) | ||
| 241 | buf[4] |= 0x07; | ||
| 242 | else if (symbol_rate <= (clk * 3) / 32) | ||
| 243 | buf[4] |= 0x06; | ||
| 244 | else if (symbol_rate <= clk / 8) | ||
| 245 | buf[4] |= 0x05; | ||
| 246 | else if (symbol_rate <= (clk * 3) / 16) | ||
| 247 | buf[4] |= 0x04; | ||
| 248 | else if (symbol_rate <= clk / 4) | ||
| 249 | buf[4] |= 0x03; | ||
| 250 | else if (symbol_rate <= (clk * 3) / 8) | ||
| 251 | buf[4] |= 0x02; | ||
| 252 | else if (symbol_rate <= clk / 2) | ||
| 253 | buf[4] |= 0x01; | ||
| 254 | else | ||
| 255 | buf[4] |= 0x00; | ||
| 256 | |||
| 257 | /* Sigma Delta converter */ | ||
| 258 | buf[5] = 0x00; | ||
| 259 | |||
| 260 | /* FEC: Possible puncturing rates */ | ||
| 261 | if (fec_inner == FEC_NONE) | ||
| 262 | buf[6] = 0x00; | ||
| 263 | else if ((fec_inner >= FEC_1_2) && (fec_inner <= FEC_8_9)) | ||
| 264 | buf[6] = (1 << (8 - fec_inner)); | ||
| 265 | else if (fec_inner == FEC_AUTO) | ||
| 266 | buf[6] = 0xff; | ||
| 267 | else | ||
| 268 | return -EINVAL; | ||
| 269 | |||
| 270 | /* carrier lock detector threshold value */ | ||
| 271 | buf[7] = 0x30; | ||
| 272 | /* AFC1: proportional part settings */ | ||
| 273 | buf[8] = 0x42; | ||
| 274 | /* AFC1: integral part settings */ | ||
| 275 | buf[9] = 0x98; | ||
| 276 | /* PD: Leaky integrator SCPC mode */ | ||
| 277 | buf[10] = 0x28; | ||
| 278 | /* AFC2, AFC1 controls */ | ||
| 279 | buf[11] = 0x30; | ||
| 280 | /* PD: proportional part settings */ | ||
| 281 | buf[12] = 0x42; | ||
| 282 | /* PD: integral part settings */ | ||
| 283 | buf[13] = 0x99; | ||
| 284 | /* AGC */ | ||
| 285 | buf[14] = 0x50 | scd; | ||
| 286 | |||
| 287 | printk("symbol_rate=%u clk=%u\n", symbol_rate, clk); | ||
| 288 | |||
| 289 | return tda80xx_write(state, 0x01, buf, sizeof(buf)); | ||
| 290 | } | ||
| 291 | |||
| 292 | static int tda80xx_set_clk(struct tda80xx_state* state) | ||
| 293 | { | ||
| 294 | u8 buf[2]; | ||
| 295 | |||
| 296 | /* CLK proportional part */ | ||
| 297 | buf[0] = (0x06 << 5) | 0x08; /* CMP[2:0], CSP[4:0] */ | ||
| 298 | /* CLK integral part */ | ||
| 299 | buf[1] = (0x04 << 5) | 0x1a; /* CMI[2:0], CSI[4:0] */ | ||
| 300 | |||
| 301 | return tda80xx_write(state, 0x17, buf, sizeof(buf)); | ||
| 302 | } | ||
| 303 | |||
| 304 | #if 0 | ||
| 305 | static int tda80xx_set_scpc_freq_offset(struct tda80xx_state* state) | ||
| 306 | { | ||
| 307 | /* a constant value is nonsense here imho */ | ||
| 308 | return tda80xx_writereg(state, 0x22, 0xf9); | ||
| 309 | } | ||
| 310 | #endif | ||
| 311 | |||
| 312 | static int tda80xx_close_loop(struct tda80xx_state* state) | ||
| 313 | { | ||
| 314 | u8 buf[2]; | ||
| 315 | |||
| 316 | /* PD: Loop closed, LD: lock detect enable, SCPC: Sweep mode - AFC1 loop closed */ | ||
| 317 | buf[0] = 0x68; | ||
| 318 | /* AFC1: Loop closed, CAR Feedback: 8192 */ | ||
| 319 | buf[1] = 0x70; | ||
| 320 | |||
| 321 | return tda80xx_write(state, 0x0b, buf, sizeof(buf)); | ||
| 322 | } | ||
| 323 | |||
| 324 | static irqreturn_t tda80xx_irq(int irq, void *priv, struct pt_regs *pt) | ||
| 325 | { | ||
| 326 | schedule_work(priv); | ||
| 327 | |||
| 328 | return IRQ_HANDLED; | ||
| 329 | } | ||
| 330 | |||
| 331 | static void tda80xx_read_status_int(struct tda80xx_state* state) | ||
| 332 | { | ||
| 333 | u8 val; | ||
| 334 | |||
| 335 | static const fe_spectral_inversion_t inv_tab[] = { | ||
| 336 | INVERSION_OFF, INVERSION_ON | ||
| 337 | }; | ||
| 338 | |||
| 339 | static const fe_code_rate_t fec_tab[] = { | ||
| 340 | FEC_8_9, FEC_1_2, FEC_2_3, FEC_3_4, | ||
| 341 | FEC_4_5, FEC_5_6, FEC_6_7, FEC_7_8, | ||
| 342 | }; | ||
| 343 | |||
| 344 | val = tda80xx_readreg(state, 0x02); | ||
| 345 | |||
| 346 | state->status = 0; | ||
| 347 | |||
| 348 | if (val & 0x01) /* demodulator lock */ | ||
| 349 | state->status |= FE_HAS_SIGNAL; | ||
| 350 | if (val & 0x02) /* clock recovery lock */ | ||
| 351 | state->status |= FE_HAS_CARRIER; | ||
| 352 | if (val & 0x04) /* viterbi lock */ | ||
| 353 | state->status |= FE_HAS_VITERBI; | ||
| 354 | if (val & 0x08) /* deinterleaver lock (packet sync) */ | ||
| 355 | state->status |= FE_HAS_SYNC; | ||
| 356 | if (val & 0x10) /* derandomizer lock (frame sync) */ | ||
| 357 | state->status |= FE_HAS_LOCK; | ||
| 358 | if (val & 0x20) /* frontend can not lock */ | ||
| 359 | state->status |= FE_TIMEDOUT; | ||
| 360 | |||
| 361 | if ((state->status & (FE_HAS_CARRIER)) && (state->afc_loop)) { | ||
| 362 | printk("tda80xx: closing loop\n"); | ||
| 363 | tda80xx_close_loop(state); | ||
| 364 | state->afc_loop = 0; | ||
| 365 | } | ||
| 366 | |||
| 367 | if (state->status & (FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK)) { | ||
| 368 | val = tda80xx_readreg(state, 0x0e); | ||
| 369 | state->code_rate = fec_tab[val & 0x07]; | ||
| 370 | if (state->status & (FE_HAS_SYNC | FE_HAS_LOCK)) | ||
| 371 | state->spectral_inversion = inv_tab[(val >> 7) & 0x01]; | ||
| 372 | else | ||
| 373 | state->spectral_inversion = INVERSION_AUTO; | ||
| 374 | } | ||
| 375 | else { | ||
| 376 | state->code_rate = FEC_AUTO; | ||
| 377 | } | ||
| 378 | } | ||
| 379 | |||
| 380 | static void tda80xx_worklet(void *priv) | ||
| 381 | { | ||
| 382 | struct tda80xx_state *state = priv; | ||
| 383 | |||
| 384 | tda80xx_writereg(state, 0x00, 0x04); | ||
| 385 | enable_irq(state->config->irq); | ||
| 386 | |||
| 387 | tda80xx_read_status_int(state); | ||
| 388 | } | ||
| 389 | |||
| 390 | static void tda80xx_wait_diseqc_fifo(struct tda80xx_state* state) | ||
| 391 | { | ||
| 392 | size_t i; | ||
| 393 | |||
| 394 | for (i = 0; i < 100; i++) { | ||
| 395 | if (tda80xx_readreg(state, 0x02) & 0x80) | ||
| 396 | break; | ||
| 397 | msleep(10); | ||
| 398 | } | ||
| 399 | } | ||
| 400 | |||
| 401 | static int tda8044_init(struct dvb_frontend* fe) | ||
| 402 | { | ||
| 403 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 404 | int ret; | ||
| 405 | |||
| 406 | /* | ||
| 407 | * this function is a mess... | ||
| 408 | */ | ||
| 409 | |||
| 410 | if ((ret = tda80xx_write(state, 0x00, tda8044_inittab_pre, sizeof(tda8044_inittab_pre)))) | ||
| 411 | return ret; | ||
| 412 | |||
| 413 | tda80xx_writereg(state, 0x0f, 0x50); | ||
| 414 | #if 1 | ||
| 415 | tda80xx_writereg(state, 0x20, 0x8F); /* FIXME */ | ||
| 416 | tda80xx_writereg(state, 0x20, state->config->volt18setting); /* FIXME */ | ||
| 417 | //tda80xx_writereg(state, 0x00, 0x04); | ||
| 418 | tda80xx_writereg(state, 0x00, 0x0C); | ||
| 419 | #endif | ||
| 420 | //tda80xx_writereg(state, 0x00, 0x08); /* Reset AFC1 loop filter */ | ||
| 421 | |||
| 422 | tda80xx_write(state, 0x00, tda8044_inittab_post, sizeof(tda8044_inittab_post)); | ||
| 423 | |||
| 424 | if (state->config->pll_init) { | ||
| 425 | tda80xx_writereg(state, 0x1c, 0x80); | ||
| 426 | state->config->pll_init(fe); | ||
| 427 | tda80xx_writereg(state, 0x1c, 0x00); | ||
| 428 | } | ||
| 429 | |||
| 430 | return 0; | ||
| 431 | } | ||
| 432 | |||
| 433 | static int tda8083_init(struct dvb_frontend* fe) | ||
| 434 | { | ||
| 435 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 436 | |||
| 437 | tda80xx_write(state, 0x00, tda8083_inittab, sizeof(tda8083_inittab)); | ||
| 438 | |||
| 439 | if (state->config->pll_init) { | ||
| 440 | tda80xx_writereg(state, 0x1c, 0x80); | ||
| 441 | state->config->pll_init(fe); | ||
| 442 | tda80xx_writereg(state, 0x1c, 0x00); | ||
| 443 | } | ||
| 444 | |||
| 445 | return 0; | ||
| 446 | } | ||
| 447 | |||
| 448 | static int tda80xx_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage) | ||
| 449 | { | ||
| 450 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 451 | |||
| 452 | switch (voltage) { | ||
| 453 | case SEC_VOLTAGE_13: | ||
| 454 | return tda80xx_writereg(state, 0x20, state->config->volt13setting); | ||
| 455 | case SEC_VOLTAGE_18: | ||
| 456 | return tda80xx_writereg(state, 0x20, state->config->volt18setting); | ||
| 457 | case SEC_VOLTAGE_OFF: | ||
| 458 | return tda80xx_writereg(state, 0x20, 0); | ||
| 459 | default: | ||
| 460 | return -EINVAL; | ||
| 461 | } | ||
| 462 | } | ||
| 463 | |||
| 464 | static int tda80xx_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone) | ||
| 465 | { | ||
| 466 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 467 | |||
| 468 | switch (tone) { | ||
| 469 | case SEC_TONE_OFF: | ||
| 470 | return tda80xx_writereg(state, 0x29, 0x00); | ||
| 471 | case SEC_TONE_ON: | ||
| 472 | return tda80xx_writereg(state, 0x29, 0x80); | ||
| 473 | default: | ||
| 474 | return -EINVAL; | ||
| 475 | } | ||
| 476 | } | ||
| 477 | |||
| 478 | static int tda80xx_send_diseqc_msg(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *cmd) | ||
| 479 | { | ||
| 480 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 481 | |||
| 482 | if (cmd->msg_len > 6) | ||
| 483 | return -EINVAL; | ||
| 484 | |||
| 485 | tda80xx_writereg(state, 0x29, 0x08 | (cmd->msg_len - 3)); | ||
| 486 | tda80xx_write(state, 0x23, cmd->msg, cmd->msg_len); | ||
| 487 | tda80xx_writereg(state, 0x29, 0x0c | (cmd->msg_len - 3)); | ||
| 488 | tda80xx_wait_diseqc_fifo(state); | ||
| 489 | |||
| 490 | return 0; | ||
| 491 | } | ||
| 492 | |||
| 493 | static int tda80xx_send_diseqc_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t cmd) | ||
| 494 | { | ||
| 495 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 496 | |||
| 497 | switch (cmd) { | ||
| 498 | case SEC_MINI_A: | ||
| 499 | tda80xx_writereg(state, 0x29, 0x14); | ||
| 500 | break; | ||
| 501 | case SEC_MINI_B: | ||
| 502 | tda80xx_writereg(state, 0x29, 0x1c); | ||
| 503 | break; | ||
| 504 | default: | ||
| 505 | return -EINVAL; | ||
| 506 | } | ||
| 507 | |||
| 508 | tda80xx_wait_diseqc_fifo(state); | ||
| 509 | |||
| 510 | return 0; | ||
| 511 | } | ||
| 512 | |||
| 513 | static int tda80xx_sleep(struct dvb_frontend* fe) | ||
| 514 | { | ||
| 515 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 516 | |||
| 517 | tda80xx_writereg(state, 0x00, 0x02); /* enter standby */ | ||
| 518 | |||
| 519 | return 0; | ||
| 520 | } | ||
| 521 | |||
| 522 | static int tda80xx_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p) | ||
| 523 | { | ||
| 524 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 525 | |||
| 526 | tda80xx_writereg(state, 0x1c, 0x80); | ||
| 527 | state->config->pll_set(fe, p); | ||
| 528 | tda80xx_writereg(state, 0x1c, 0x00); | ||
| 529 | |||
| 530 | tda80xx_set_parameters(state, p->inversion, p->u.qpsk.symbol_rate, p->u.qpsk.fec_inner); | ||
| 531 | tda80xx_set_clk(state); | ||
| 532 | //tda80xx_set_scpc_freq_offset(state); | ||
| 533 | state->afc_loop = 1; | ||
| 534 | |||
| 535 | return 0; | ||
| 536 | } | ||
| 537 | |||
| 538 | static int tda80xx_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p) | ||
| 539 | { | ||
| 540 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 541 | |||
| 542 | if (!state->config->irq) | ||
| 543 | tda80xx_read_status_int(state); | ||
| 544 | |||
| 545 | p->inversion = state->spectral_inversion; | ||
| 546 | p->u.qpsk.fec_inner = state->code_rate; | ||
| 547 | |||
| 548 | return 0; | ||
| 549 | } | ||
| 550 | |||
| 551 | static int tda80xx_read_status(struct dvb_frontend* fe, fe_status_t* status) | ||
| 552 | { | ||
| 553 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 554 | |||
| 555 | if (!state->config->irq) | ||
| 556 | tda80xx_read_status_int(state); | ||
| 557 | *status = state->status; | ||
| 558 | |||
| 559 | return 0; | ||
| 560 | } | ||
| 561 | |||
| 562 | static int tda80xx_read_ber(struct dvb_frontend* fe, u32* ber) | ||
| 563 | { | ||
| 564 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 565 | int ret; | ||
| 566 | u8 buf[3]; | ||
| 567 | |||
| 568 | if ((ret = tda80xx_read(state, 0x0b, buf, sizeof(buf)))) | ||
| 569 | return ret; | ||
| 570 | |||
| 571 | *ber = ((buf[0] & 0x1f) << 16) | (buf[1] << 8) | buf[2]; | ||
| 572 | |||
| 573 | return 0; | ||
| 574 | } | ||
| 575 | |||
| 576 | static int tda80xx_read_signal_strength(struct dvb_frontend* fe, u16* strength) | ||
| 577 | { | ||
| 578 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 579 | |||
| 580 | u8 gain = ~tda80xx_readreg(state, 0x01); | ||
| 581 | *strength = (gain << 8) | gain; | ||
| 582 | |||
| 583 | return 0; | ||
| 584 | } | ||
| 585 | |||
| 586 | static int tda80xx_read_snr(struct dvb_frontend* fe, u16* snr) | ||
| 587 | { | ||
| 588 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 589 | |||
| 590 | u8 quality = tda80xx_readreg(state, 0x08); | ||
| 591 | *snr = (quality << 8) | quality; | ||
| 592 | |||
| 593 | return 0; | ||
| 594 | } | ||
| 595 | |||
| 596 | static int tda80xx_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks) | ||
| 597 | { | ||
| 598 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 599 | |||
| 600 | *ucblocks = tda80xx_readreg(state, 0x0f); | ||
| 601 | if (*ucblocks == 0xff) | ||
| 602 | *ucblocks = 0xffffffff; | ||
| 603 | |||
| 604 | return 0; | ||
| 605 | } | ||
| 606 | |||
| 607 | static int tda80xx_init(struct dvb_frontend* fe) | ||
| 608 | { | ||
| 609 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 610 | |||
| 611 | switch(state->id) { | ||
| 612 | case ID_TDA8044: | ||
| 613 | return tda8044_init(fe); | ||
| 614 | |||
| 615 | case ID_TDA8083: | ||
| 616 | return tda8083_init(fe); | ||
| 617 | } | ||
| 618 | return 0; | ||
| 619 | } | ||
| 620 | |||
| 621 | static void tda80xx_release(struct dvb_frontend* fe) | ||
| 622 | { | ||
| 623 | struct tda80xx_state* state = fe->demodulator_priv; | ||
| 624 | |||
| 625 | if (state->config->irq) | ||
| 626 | free_irq(state->config->irq, &state->worklet); | ||
| 627 | |||
| 628 | kfree(state); | ||
| 629 | } | ||
| 630 | |||
| 631 | static struct dvb_frontend_ops tda80xx_ops; | ||
| 632 | |||
| 633 | struct dvb_frontend* tda80xx_attach(const struct tda80xx_config* config, | ||
| 634 | struct i2c_adapter* i2c) | ||
| 635 | { | ||
| 636 | struct tda80xx_state* state = NULL; | ||
| 637 | int ret; | ||
| 638 | |||
| 639 | /* allocate memory for the internal state */ | ||
| 640 | state = kmalloc(sizeof(struct tda80xx_state), GFP_KERNEL); | ||
| 641 | if (state == NULL) goto error; | ||
| 642 | |||
| 643 | /* setup the state */ | ||
| 644 | state->config = config; | ||
| 645 | state->i2c = i2c; | ||
| 646 | memcpy(&state->ops, &tda80xx_ops, sizeof(struct dvb_frontend_ops)); | ||
| 647 | state->spectral_inversion = INVERSION_AUTO; | ||
| 648 | state->code_rate = FEC_AUTO; | ||
| 649 | state->status = 0; | ||
| 650 | state->afc_loop = 0; | ||
| 651 | |||
| 652 | /* check if the demod is there */ | ||
| 653 | if (tda80xx_writereg(state, 0x89, 0x00) < 0) goto error; | ||
| 654 | state->id = tda80xx_readreg(state, 0x00); | ||
| 655 | |||
| 656 | switch (state->id) { | ||
| 657 | case ID_TDA8044: | ||
| 658 | state->clk = 96000000; | ||
| 659 | printk("tda80xx: Detected tda8044\n"); | ||
| 660 | break; | ||
| 661 | |||
| 662 | case ID_TDA8083: | ||
| 663 | state->clk = 64000000; | ||
| 664 | printk("tda80xx: Detected tda8083\n"); | ||
| 665 | break; | ||
| 666 | |||
| 667 | default: | ||
| 668 | goto error; | ||
| 669 | } | ||
| 670 | |||
| 671 | /* setup IRQ */ | ||
| 672 | if (state->config->irq) { | ||
| 673 | INIT_WORK(&state->worklet, tda80xx_worklet, state); | ||
| 674 | if ((ret = request_irq(state->config->irq, tda80xx_irq, SA_ONESHOT, "tda80xx", &state->worklet)) < 0) { | ||
| 675 | printk(KERN_ERR "tda80xx: request_irq failed (%d)\n", ret); | ||
| 676 | goto error; | ||
| 677 | } | ||
| 678 | } | ||
| 679 | |||
| 680 | /* create dvb_frontend */ | ||
| 681 | state->frontend.ops = &state->ops; | ||
| 682 | state->frontend.demodulator_priv = state; | ||
| 683 | return &state->frontend; | ||
| 684 | |||
| 685 | error: | ||
| 686 | kfree(state); | ||
| 687 | return NULL; | ||
| 688 | } | ||
| 689 | |||
| 690 | static struct dvb_frontend_ops tda80xx_ops = { | ||
| 691 | |||
| 692 | .info = { | ||
| 693 | .name = "Philips TDA80xx DVB-S", | ||
| 694 | .type = FE_QPSK, | ||
| 695 | .frequency_min = 500000, | ||
| 696 | .frequency_max = 2700000, | ||
| 697 | .frequency_stepsize = 125, | ||
| 698 | .symbol_rate_min = 4500000, | ||
| 699 | .symbol_rate_max = 45000000, | ||
| 700 | .caps = FE_CAN_INVERSION_AUTO | | ||
| 701 | FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | | ||
| 702 | FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 | | ||
| 703 | FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO | | ||
| 704 | FE_CAN_QPSK | | ||
| 705 | FE_CAN_MUTE_TS | ||
| 706 | }, | ||
| 707 | |||
| 708 | .release = tda80xx_release, | ||
| 709 | |||
| 710 | .init = tda80xx_init, | ||
| 711 | .sleep = tda80xx_sleep, | ||
| 712 | |||
| 713 | .set_frontend = tda80xx_set_frontend, | ||
| 714 | .get_frontend = tda80xx_get_frontend, | ||
| 715 | |||
| 716 | .read_status = tda80xx_read_status, | ||
| 717 | .read_ber = tda80xx_read_ber, | ||
| 718 | .read_signal_strength = tda80xx_read_signal_strength, | ||
| 719 | .read_snr = tda80xx_read_snr, | ||
| 720 | .read_ucblocks = tda80xx_read_ucblocks, | ||
| 721 | |||
| 722 | .diseqc_send_master_cmd = tda80xx_send_diseqc_msg, | ||
| 723 | .diseqc_send_burst = tda80xx_send_diseqc_burst, | ||
| 724 | .set_tone = tda80xx_set_tone, | ||
| 725 | .set_voltage = tda80xx_set_voltage, | ||
| 726 | }; | ||
| 727 | |||
| 728 | module_param(debug, int, 0644); | ||
| 729 | |||
| 730 | MODULE_DESCRIPTION("Philips TDA8044 / TDA8083 DVB-S Demodulator driver"); | ||
| 731 | MODULE_AUTHOR("Felix Domke, Andreas Oberritter"); | ||
| 732 | MODULE_LICENSE("GPL"); | ||
| 733 | |||
| 734 | EXPORT_SYMBOL(tda80xx_attach); | ||
diff --git a/drivers/media/dvb/frontends/tda80xx.h b/drivers/media/dvb/frontends/tda80xx.h deleted file mode 100644 index cd639a0aad55..000000000000 --- a/drivers/media/dvb/frontends/tda80xx.h +++ /dev/null | |||
| @@ -1,51 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * tda80xx.c | ||
| 3 | * | ||
| 4 | * Philips TDA8044 / TDA8083 QPSK demodulator driver | ||
| 5 | * | ||
| 6 | * Copyright (C) 2001 Felix Domke <tmbinc@elitedvb.net> | ||
| 7 | * Copyright (C) 2002-2004 Andreas Oberritter <obi@linuxtv.org> | ||
| 8 | * | ||
| 9 | * This program is free software; you can redistribute it and/or modify | ||
| 10 | * it under the terms of the GNU General Public License as published by | ||
| 11 | * the Free Software Foundation; either version 2 of the License, or | ||
| 12 | * (at your option) any later version. | ||
| 13 | * | ||
| 14 | * This program is distributed in the hope that it will be useful, | ||
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 17 | * GNU General Public License for more details. | ||
| 18 | * | ||
| 19 | * You should have received a copy of the GNU General Public License | ||
| 20 | * along with this program; if not, write to the Free Software | ||
| 21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
| 22 | */ | ||
| 23 | |||
| 24 | #ifndef TDA80XX_H | ||
| 25 | #define TDA80XX_H | ||
| 26 | |||
| 27 | #include <linux/dvb/frontend.h> | ||
| 28 | |||
| 29 | struct tda80xx_config | ||
| 30 | { | ||
| 31 | /* the demodulator's i2c address */ | ||
| 32 | u8 demod_address; | ||
| 33 | |||
| 34 | /* IRQ to use (0=>no IRQ used) */ | ||
| 35 | u32 irq; | ||
| 36 | |||
| 37 | /* Register setting to use for 13v */ | ||
| 38 | u8 volt13setting; | ||
| 39 | |||
| 40 | /* Register setting to use for 18v */ | ||
| 41 | u8 volt18setting; | ||
| 42 | |||
| 43 | /* PLL maintenance */ | ||
| 44 | int (*pll_init)(struct dvb_frontend* fe); | ||
| 45 | int (*pll_set)(struct dvb_frontend* fe, struct dvb_frontend_parameters* params); | ||
| 46 | }; | ||
| 47 | |||
| 48 | extern struct dvb_frontend* tda80xx_attach(const struct tda80xx_config* config, | ||
| 49 | struct i2c_adapter* i2c); | ||
| 50 | |||
| 51 | #endif // TDA80XX_H | ||
diff --git a/drivers/media/dvb/ttpci/av7110.c b/drivers/media/dvb/ttpci/av7110.c index 27494901975f..d36369e9e88f 100644 --- a/drivers/media/dvb/ttpci/av7110.c +++ b/drivers/media/dvb/ttpci/av7110.c | |||
| @@ -2329,6 +2329,17 @@ static int frontend_init(struct av7110 *av7110) | |||
| 2329 | av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110)); | 2329 | av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110)); |
| 2330 | break; | 2330 | break; |
| 2331 | 2331 | ||
| 2332 | case 0x0004: // Galaxis DVB-S rev1.3 | ||
| 2333 | /* ALPS BSRV2 */ | ||
| 2334 | av7110->fe = ves1x93_attach(&alps_bsrv2_config, &av7110->i2c_adap); | ||
| 2335 | if (av7110->fe) { | ||
| 2336 | av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd; | ||
| 2337 | av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst; | ||
| 2338 | av7110->fe->ops->set_tone = av7110_set_tone; | ||
| 2339 | av7110->recover = dvb_s_recover; | ||
| 2340 | } | ||
| 2341 | break; | ||
| 2342 | |||
| 2332 | case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */ | 2343 | case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */ |
| 2333 | /* Grundig 29504-451 */ | 2344 | /* Grundig 29504-451 */ |
| 2334 | av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap); | 2345 | av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap); |
| @@ -2930,6 +2941,7 @@ MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE"); | |||
| 2930 | MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T"); | 2941 | MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T"); |
| 2931 | MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C"); | 2942 | MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C"); |
| 2932 | MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6"); | 2943 | MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6"); |
| 2944 | MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3"); | ||
| 2933 | 2945 | ||
| 2934 | static struct pci_device_id pci_tbl[] = { | 2946 | static struct pci_device_id pci_tbl[] = { |
| 2935 | MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000), | 2947 | MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000), |
| @@ -2937,13 +2949,13 @@ static struct pci_device_id pci_tbl[] = { | |||
| 2937 | MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001), | 2949 | MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001), |
| 2938 | MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002), | 2950 | MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002), |
| 2939 | MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003), | 2951 | MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003), |
| 2952 | MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004), | ||
| 2940 | MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006), | 2953 | MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006), |
| 2941 | MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008), | 2954 | MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008), |
| 2942 | MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a), | 2955 | MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a), |
| 2943 | MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e), | 2956 | MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e), |
| 2944 | MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002), | 2957 | MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002), |
| 2945 | 2958 | ||
| 2946 | /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0004), UNDEFINED CARD */ // Galaxis DVB PC-Sat-Carte | ||
| 2947 | /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1 | 2959 | /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1 |
| 2948 | /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v???? | 2960 | /* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v???? |
| 2949 | 2961 | ||
diff --git a/drivers/media/dvb/ttpci/av7110.h b/drivers/media/dvb/ttpci/av7110.h index 6ea30df2e823..fafd25fab835 100644 --- a/drivers/media/dvb/ttpci/av7110.h +++ b/drivers/media/dvb/ttpci/av7110.h | |||
| @@ -273,8 +273,6 @@ struct av7110 { | |||
| 273 | extern int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid, | 273 | extern int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid, |
| 274 | u16 subpid, u16 pcrpid); | 274 | u16 subpid, u16 pcrpid); |
| 275 | 275 | ||
| 276 | extern int av7110_setup_irc_config (struct av7110 *av7110, u32 ir_config); | ||
| 277 | |||
| 278 | extern int av7110_ir_init(struct av7110 *av7110); | 276 | extern int av7110_ir_init(struct av7110 *av7110); |
| 279 | extern void av7110_ir_exit(struct av7110 *av7110); | 277 | extern void av7110_ir_exit(struct av7110 *av7110); |
| 280 | 278 | ||
diff --git a/drivers/media/dvb/ttpci/av7110_ir.c b/drivers/media/dvb/ttpci/av7110_ir.c index 9138132ad25f..617e4f6c0ed7 100644 --- a/drivers/media/dvb/ttpci/av7110_ir.c +++ b/drivers/media/dvb/ttpci/av7110_ir.c | |||
| @@ -155,6 +155,19 @@ static void input_repeat_key(unsigned long data) | |||
| 155 | } | 155 | } |
| 156 | 156 | ||
| 157 | 157 | ||
| 158 | static int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config) | ||
| 159 | { | ||
| 160 | int ret = 0; | ||
| 161 | |||
| 162 | dprintk(4, "%p\n", av7110); | ||
| 163 | if (av7110) { | ||
| 164 | ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config); | ||
| 165 | av7110->ir_config = ir_config; | ||
| 166 | } | ||
| 167 | return ret; | ||
| 168 | } | ||
| 169 | |||
| 170 | |||
| 158 | static int av7110_ir_write_proc(struct file *file, const char __user *buffer, | 171 | static int av7110_ir_write_proc(struct file *file, const char __user *buffer, |
| 159 | unsigned long count, void *data) | 172 | unsigned long count, void *data) |
| 160 | { | 173 | { |
| @@ -187,19 +200,6 @@ static int av7110_ir_write_proc(struct file *file, const char __user *buffer, | |||
| 187 | } | 200 | } |
| 188 | 201 | ||
| 189 | 202 | ||
| 190 | int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config) | ||
| 191 | { | ||
| 192 | int ret = 0; | ||
| 193 | |||
| 194 | dprintk(4, "%p\n", av7110); | ||
| 195 | if (av7110) { | ||
| 196 | ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config); | ||
| 197 | av7110->ir_config = ir_config; | ||
| 198 | } | ||
| 199 | return ret; | ||
| 200 | } | ||
| 201 | |||
| 202 | |||
| 203 | static void ir_handler(struct av7110 *av7110, u32 ircom) | 203 | static void ir_handler(struct av7110 *av7110, u32 ircom) |
| 204 | { | 204 | { |
| 205 | dprintk(4, "ircommand = %08x\n", ircom); | 205 | dprintk(4, "ircommand = %08x\n", ircom); |
diff --git a/drivers/media/video/bttv-driver.c b/drivers/media/video/bttv-driver.c index aa4c4c521880..578b20085082 100644 --- a/drivers/media/video/bttv-driver.c +++ b/drivers/media/video/bttv-driver.c | |||
| @@ -214,7 +214,7 @@ const struct bttv_tvnorm bttv_tvnorms[] = { | |||
| 214 | we can capture, of the first and second field. */ | 214 | we can capture, of the first and second field. */ |
| 215 | .vbistart = { 7,320 }, | 215 | .vbistart = { 7,320 }, |
| 216 | },{ | 216 | },{ |
| 217 | .v4l2_id = V4L2_STD_NTSC_M, | 217 | .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR, |
| 218 | .name = "NTSC", | 218 | .name = "NTSC", |
| 219 | .Fsc = 28636363, | 219 | .Fsc = 28636363, |
| 220 | .swidth = 768, | 220 | .swidth = 768, |
diff --git a/drivers/media/video/compat_ioctl32.c b/drivers/media/video/compat_ioctl32.c index 297c32ab51e3..840fe0177121 100644 --- a/drivers/media/video/compat_ioctl32.c +++ b/drivers/media/video/compat_ioctl32.c | |||
| @@ -167,29 +167,32 @@ static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user | |||
| 167 | if (kp->clipcount > 2048) | 167 | if (kp->clipcount > 2048) |
| 168 | return -EINVAL; | 168 | return -EINVAL; |
| 169 | if (kp->clipcount) { | 169 | if (kp->clipcount) { |
| 170 | struct v4l2_clip32 *uclips = compat_ptr(up->clips); | 170 | struct v4l2_clip32 __user *uclips; |
| 171 | struct v4l2_clip *kclips; | 171 | struct v4l2_clip __user *kclips; |
| 172 | int n = kp->clipcount; | 172 | int n = kp->clipcount; |
| 173 | compat_caddr_t p; | ||
| 173 | 174 | ||
| 175 | if (get_user(p, &up->clips)) | ||
| 176 | return -EFAULT; | ||
| 177 | uclips = compat_ptr(p); | ||
| 174 | kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip)); | 178 | kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip)); |
| 175 | kp->clips = kclips; | 179 | kp->clips = kclips; |
| 176 | while (--n >= 0) { | 180 | while (--n >= 0) { |
| 177 | if (!access_ok(VERIFY_READ, &uclips->c, sizeof(uclips->c)) || | 181 | if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c))) |
| 178 | copy_from_user(&kclips->c, &uclips->c, sizeof(uclips->c))) | 182 | return -EFAULT; |
| 183 | if (put_user(n ? kclips + 1 : NULL, &kclips->next)) | ||
| 179 | return -EFAULT; | 184 | return -EFAULT; |
| 180 | kclips->next = n ? kclips + 1 : 0; | ||
| 181 | uclips += 1; | 185 | uclips += 1; |
| 182 | kclips += 1; | 186 | kclips += 1; |
| 183 | } | 187 | } |
| 184 | } else | 188 | } else |
| 185 | kp->clips = 0; | 189 | kp->clips = NULL; |
| 186 | return 0; | 190 | return 0; |
| 187 | } | 191 | } |
| 188 | 192 | ||
| 189 | static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) | 193 | static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) |
| 190 | { | 194 | { |
| 191 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_window32)) || | 195 | if (copy_to_user(&up->w, &kp->w, sizeof(up->w)) || |
| 192 | copy_to_user(&up->w, &kp->w, sizeof(up->w)) || | ||
| 193 | put_user(kp->field, &up->field) || | 196 | put_user(kp->field, &up->field) || |
| 194 | put_user(kp->chromakey, &up->chromakey) || | 197 | put_user(kp->chromakey, &up->chromakey) || |
| 195 | put_user(kp->clipcount, &up->clipcount)) | 198 | put_user(kp->clipcount, &up->clipcount)) |
| @@ -199,33 +202,29 @@ static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user | |||
| 199 | 202 | ||
| 200 | static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) | 203 | static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) |
| 201 | { | 204 | { |
| 202 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_pix_format)) || | 205 | if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format))) |
| 203 | copy_from_user(kp, up, sizeof(struct v4l2_pix_format))) | 206 | return -EFAULT; |
| 204 | return -EFAULT; | ||
| 205 | return 0; | 207 | return 0; |
| 206 | } | 208 | } |
| 207 | 209 | ||
| 208 | static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) | 210 | static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) |
| 209 | { | 211 | { |
| 210 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_pix_format)) || | 212 | if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format))) |
| 211 | copy_to_user(up, kp, sizeof(struct v4l2_pix_format))) | 213 | return -EFAULT; |
| 212 | return -EFAULT; | ||
| 213 | return 0; | 214 | return 0; |
| 214 | } | 215 | } |
| 215 | 216 | ||
| 216 | static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) | 217 | static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) |
| 217 | { | 218 | { |
| 218 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_vbi_format)) || | 219 | if (copy_from_user(kp, up, sizeof(struct v4l2_vbi_format))) |
| 219 | copy_from_user(kp, up, sizeof(struct v4l2_vbi_format))) | 220 | return -EFAULT; |
| 220 | return -EFAULT; | ||
| 221 | return 0; | 221 | return 0; |
| 222 | } | 222 | } |
| 223 | 223 | ||
| 224 | static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) | 224 | static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) |
| 225 | { | 225 | { |
| 226 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_vbi_format)) || | 226 | if (copy_to_user(up, kp, sizeof(struct v4l2_vbi_format))) |
| 227 | copy_to_user(up, kp, sizeof(struct v4l2_vbi_format))) | 227 | return -EFAULT; |
| 228 | return -EFAULT; | ||
| 229 | return 0; | 228 | return 0; |
| 230 | } | 229 | } |
| 231 | 230 | ||
| @@ -279,18 +278,16 @@ static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user | |||
| 279 | 278 | ||
| 280 | static inline int get_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up) | 279 | static inline int get_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up) |
| 281 | { | 280 | { |
| 282 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard)) || | 281 | if (copy_from_user(kp, up, sizeof(struct v4l2_standard))) |
| 283 | copy_from_user(kp, up, sizeof(struct v4l2_standard))) | 282 | return -EFAULT; |
| 284 | return -EFAULT; | ||
| 285 | return 0; | 283 | return 0; |
| 286 | 284 | ||
| 287 | } | 285 | } |
| 288 | 286 | ||
| 289 | static inline int put_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up) | 287 | static inline int put_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up) |
| 290 | { | 288 | { |
| 291 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard)) || | 289 | if (copy_to_user(up, kp, sizeof(struct v4l2_standard))) |
| 292 | copy_to_user(up, kp, sizeof(struct v4l2_standard))) | 290 | return -EFAULT; |
| 293 | return -EFAULT; | ||
| 294 | return 0; | 291 | return 0; |
| 295 | } | 292 | } |
| 296 | 293 | ||
| @@ -328,18 +325,16 @@ static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 | |||
| 328 | 325 | ||
| 329 | static inline int get_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up) | 326 | static inline int get_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up) |
| 330 | { | 327 | { |
| 331 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_tuner)) || | 328 | if (copy_from_user(kp, up, sizeof(struct v4l2_tuner))) |
| 332 | copy_from_user(kp, up, sizeof(struct v4l2_tuner))) | 329 | return -EFAULT; |
| 333 | return -EFAULT; | ||
| 334 | return 0; | 330 | return 0; |
| 335 | 331 | ||
| 336 | } | 332 | } |
| 337 | 333 | ||
| 338 | static inline int put_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up) | 334 | static inline int put_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up) |
| 339 | { | 335 | { |
| 340 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_tuner)) || | 336 | if (copy_to_user(up, kp, sizeof(struct v4l2_tuner))) |
| 341 | copy_to_user(up, kp, sizeof(struct v4l2_tuner))) | 337 | return -EFAULT; |
| 342 | return -EFAULT; | ||
| 343 | return 0; | 338 | return 0; |
| 344 | } | 339 | } |
| 345 | 340 | ||
| @@ -380,11 +375,13 @@ static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user | |||
| 380 | break; | 375 | break; |
| 381 | case V4L2_MEMORY_USERPTR: | 376 | case V4L2_MEMORY_USERPTR: |
| 382 | { | 377 | { |
| 383 | unsigned long tmp = (unsigned long)compat_ptr(up->m.userptr); | 378 | compat_long_t tmp; |
| 384 | 379 | ||
| 385 | if(get_user(kp->length, &up->length) || | 380 | if (get_user(kp->length, &up->length) || |
| 386 | get_user(kp->m.userptr, &tmp)) | 381 | get_user(tmp, &up->m.userptr)) |
| 387 | return -EFAULT; | 382 | return -EFAULT; |
| 383 | |||
| 384 | kp->m.userptr = (unsigned long)compat_ptr(tmp); | ||
| 388 | } | 385 | } |
| 389 | break; | 386 | break; |
| 390 | case V4L2_MEMORY_OVERLAY: | 387 | case V4L2_MEMORY_OVERLAY: |
| @@ -468,33 +465,29 @@ static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_frame | |||
| 468 | 465 | ||
| 469 | static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up) | 466 | static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up) |
| 470 | { | 467 | { |
| 471 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_input) - 4) || | 468 | if (copy_from_user(kp, up, sizeof(struct v4l2_input) - 4)) |
| 472 | copy_from_user(kp, up, sizeof(struct v4l2_input) - 4)) | 469 | return -EFAULT; |
| 473 | return -EFAULT; | ||
| 474 | return 0; | 470 | return 0; |
| 475 | } | 471 | } |
| 476 | 472 | ||
| 477 | static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up) | 473 | static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up) |
| 478 | { | 474 | { |
| 479 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_input) - 4) || | 475 | if (copy_to_user(up, kp, sizeof(struct v4l2_input) - 4)) |
| 480 | copy_to_user(up, kp, sizeof(struct v4l2_input) - 4)) | 476 | return -EFAULT; |
| 481 | return -EFAULT; | ||
| 482 | return 0; | 477 | return 0; |
| 483 | } | 478 | } |
| 484 | 479 | ||
| 485 | static inline int get_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up) | 480 | static inline int get_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up) |
| 486 | { | 481 | { |
| 487 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_input)) || | 482 | if (copy_from_user(kp, up, sizeof(struct v4l2_input))) |
| 488 | copy_from_user(kp, up, sizeof(struct v4l2_input))) | 483 | return -EFAULT; |
| 489 | return -EFAULT; | ||
| 490 | return 0; | 484 | return 0; |
| 491 | } | 485 | } |
| 492 | 486 | ||
| 493 | static inline int put_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up) | 487 | static inline int put_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up) |
| 494 | { | 488 | { |
| 495 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_input)) || | 489 | if (copy_to_user(up, kp, sizeof(struct v4l2_input))) |
| 496 | copy_to_user(up, kp, sizeof(struct v4l2_input))) | 490 | return -EFAULT; |
| 497 | return -EFAULT; | ||
| 498 | return 0; | 491 | return 0; |
| 499 | } | 492 | } |
| 500 | 493 | ||
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c index c66c2c1f4809..08ffd1f325fc 100644 --- a/drivers/media/video/cx25840/cx25840-core.c +++ b/drivers/media/video/cx25840/cx25840-core.c | |||
| @@ -220,33 +220,23 @@ static void input_change(struct i2c_client *client) | |||
| 220 | cx25840_write(client, 0x808, 0xff); | 220 | cx25840_write(client, 0x808, 0xff); |
| 221 | cx25840_write(client, 0x80b, 0x10); | 221 | cx25840_write(client, 0x80b, 0x10); |
| 222 | } else if (std & V4L2_STD_NTSC) { | 222 | } else if (std & V4L2_STD_NTSC) { |
| 223 | /* NTSC */ | 223 | /* Certain Hauppauge PVR150 models have a hardware bug |
| 224 | if (state->pvr150_workaround) { | 224 | that causes audio to drop out. For these models the |
| 225 | /* Certain Hauppauge PVR150 models have a hardware bug | 225 | audio standard must be set explicitly. |
| 226 | that causes audio to drop out. For these models the | 226 | To be precise: it affects cards with tuner models |
| 227 | audio standard must be set explicitly. | 227 | 85, 99 and 112 (model numbers from tveeprom). */ |
| 228 | To be precise: it affects cards with tuner models | 228 | int hw_fix = state->pvr150_workaround; |
| 229 | 85, 99 and 112 (model numbers from tveeprom). */ | 229 | |
| 230 | if (std == V4L2_STD_NTSC_M_JP) { | 230 | if (std == V4L2_STD_NTSC_M_JP) { |
| 231 | /* Japan uses EIAJ audio standard */ | ||
| 232 | cx25840_write(client, 0x808, 0x2f); | ||
| 233 | } else { | ||
| 234 | /* Others use the BTSC audio standard */ | ||
| 235 | cx25840_write(client, 0x808, 0x1f); | ||
| 236 | } | ||
| 237 | /* South Korea uses the A2-M (aka Zweiton M) audio | ||
| 238 | standard, and should set 0x808 to 0x3f, but I don't | ||
| 239 | know how to detect this. */ | ||
| 240 | } else if (std == V4L2_STD_NTSC_M_JP) { | ||
| 241 | /* Japan uses EIAJ audio standard */ | 231 | /* Japan uses EIAJ audio standard */ |
| 242 | cx25840_write(client, 0x808, 0xf7); | 232 | cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7); |
| 233 | } else if (std == V4L2_STD_NTSC_M_KR) { | ||
| 234 | /* South Korea uses A2 audio standard */ | ||
| 235 | cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8); | ||
| 243 | } else { | 236 | } else { |
| 244 | /* Others use the BTSC audio standard */ | 237 | /* Others use the BTSC audio standard */ |
| 245 | cx25840_write(client, 0x808, 0xf6); | 238 | cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6); |
| 246 | } | 239 | } |
| 247 | /* South Korea uses the A2-M (aka Zweiton M) audio standard, | ||
| 248 | and should set 0x808 to 0xf8, but I don't know how to | ||
| 249 | detect this. */ | ||
| 250 | cx25840_write(client, 0x80b, 0x00); | 240 | cx25840_write(client, 0x80b, 0x00); |
| 251 | } | 241 | } |
| 252 | 242 | ||
| @@ -330,17 +320,17 @@ static int set_v4lstd(struct i2c_client *client, v4l2_std_id std) | |||
| 330 | u8 fmt=0; /* zero is autodetect */ | 320 | u8 fmt=0; /* zero is autodetect */ |
| 331 | 321 | ||
| 332 | /* First tests should be against specific std */ | 322 | /* First tests should be against specific std */ |
| 333 | if (std & V4L2_STD_NTSC_M_JP) { | 323 | if (std == V4L2_STD_NTSC_M_JP) { |
| 334 | fmt=0x2; | 324 | fmt=0x2; |
| 335 | } else if (std & V4L2_STD_NTSC_443) { | 325 | } else if (std == V4L2_STD_NTSC_443) { |
| 336 | fmt=0x3; | 326 | fmt=0x3; |
| 337 | } else if (std & V4L2_STD_PAL_M) { | 327 | } else if (std == V4L2_STD_PAL_M) { |
| 338 | fmt=0x5; | 328 | fmt=0x5; |
| 339 | } else if (std & V4L2_STD_PAL_N) { | 329 | } else if (std == V4L2_STD_PAL_N) { |
| 340 | fmt=0x6; | 330 | fmt=0x6; |
| 341 | } else if (std & V4L2_STD_PAL_Nc) { | 331 | } else if (std == V4L2_STD_PAL_Nc) { |
| 342 | fmt=0x7; | 332 | fmt=0x7; |
| 343 | } else if (std & V4L2_STD_PAL_60) { | 333 | } else if (std == V4L2_STD_PAL_60) { |
| 344 | fmt=0x8; | 334 | fmt=0x8; |
| 345 | } else { | 335 | } else { |
| 346 | /* Then, test against generic ones */ | 336 | /* Then, test against generic ones */ |
| @@ -369,7 +359,7 @@ v4l2_std_id cx25840_get_v4lstd(struct i2c_client * client) | |||
| 369 | } | 359 | } |
| 370 | 360 | ||
| 371 | switch (fmt) { | 361 | switch (fmt) { |
| 372 | case 0x1: return V4L2_STD_NTSC_M; | 362 | case 0x1: return V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR; |
| 373 | case 0x2: return V4L2_STD_NTSC_M_JP; | 363 | case 0x2: return V4L2_STD_NTSC_M_JP; |
| 374 | case 0x3: return V4L2_STD_NTSC_443; | 364 | case 0x3: return V4L2_STD_NTSC_443; |
| 375 | case 0x4: return V4L2_STD_PAL; | 365 | case 0x4: return V4L2_STD_PAL; |
diff --git a/drivers/media/video/cx88/Kconfig b/drivers/media/video/cx88/Kconfig index 53308911ae6e..e99dfbbf3e95 100644 --- a/drivers/media/video/cx88/Kconfig +++ b/drivers/media/video/cx88/Kconfig | |||
| @@ -32,6 +32,7 @@ config VIDEO_CX88_DVB | |||
| 32 | config VIDEO_CX88_ALSA | 32 | config VIDEO_CX88_ALSA |
| 33 | tristate "ALSA DMA audio support" | 33 | tristate "ALSA DMA audio support" |
| 34 | depends on VIDEO_CX88 && SND && EXPERIMENTAL | 34 | depends on VIDEO_CX88 && SND && EXPERIMENTAL |
| 35 | select SND_PCM | ||
| 35 | ---help--- | 36 | ---help--- |
| 36 | This is a video4linux driver for direct (DMA) audio on | 37 | This is a video4linux driver for direct (DMA) audio on |
| 37 | Conexant 2388x based TV cards. | 38 | Conexant 2388x based TV cards. |
| @@ -48,6 +49,7 @@ config VIDEO_CX88_DVB_ALL_FRONTENDS | |||
| 48 | default y | 49 | default y |
| 49 | depends on VIDEO_CX88_DVB | 50 | depends on VIDEO_CX88_DVB |
| 50 | select DVB_MT352 | 51 | select DVB_MT352 |
| 52 | select VIDEO_CX88_VP3054 | ||
| 51 | select DVB_OR51132 | 53 | select DVB_OR51132 |
| 52 | select DVB_CX22702 | 54 | select DVB_CX22702 |
| 53 | select DVB_LGDT330X | 55 | select DVB_LGDT330X |
| @@ -69,6 +71,16 @@ config VIDEO_CX88_DVB_MT352 | |||
| 69 | This adds DVB-T support for cards based on the | 71 | This adds DVB-T support for cards based on the |
| 70 | Connexant 2388x chip and the MT352 demodulator. | 72 | Connexant 2388x chip and the MT352 demodulator. |
| 71 | 73 | ||
| 74 | config VIDEO_CX88_VP3054 | ||
| 75 | tristate "VP-3054 Secondary I2C Bus Support" | ||
| 76 | default m | ||
| 77 | depends on DVB_MT352 | ||
| 78 | ---help--- | ||
| 79 | This adds DVB-T support for cards based on the | ||
| 80 | Connexant 2388x chip and the MT352 demodulator, | ||
| 81 | which also require support for the VP-3054 | ||
| 82 | Secondary I2C bus, such at DNTV Live! DVB-T Pro. | ||
| 83 | |||
| 72 | config VIDEO_CX88_DVB_OR51132 | 84 | config VIDEO_CX88_DVB_OR51132 |
| 73 | bool "OR51132 ATSC Support" | 85 | bool "OR51132 ATSC Support" |
| 74 | default y | 86 | default y |
diff --git a/drivers/media/video/cx88/Makefile b/drivers/media/video/cx88/Makefile index 6e5eaa22619e..2b902784facc 100644 --- a/drivers/media/video/cx88/Makefile +++ b/drivers/media/video/cx88/Makefile | |||
| @@ -4,8 +4,9 @@ cx8800-objs := cx88-video.o cx88-vbi.o | |||
| 4 | cx8802-objs := cx88-mpeg.o | 4 | cx8802-objs := cx88-mpeg.o |
| 5 | 5 | ||
| 6 | obj-$(CONFIG_VIDEO_CX88) += cx88xx.o cx8800.o cx8802.o cx88-blackbird.o | 6 | obj-$(CONFIG_VIDEO_CX88) += cx88xx.o cx8800.o cx8802.o cx88-blackbird.o |
| 7 | obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o cx88-vp3054-i2c.o | 7 | obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o |
| 8 | obj-$(CONFIG_VIDEO_CX88_ALSA) += cx88-alsa.o | 8 | obj-$(CONFIG_VIDEO_CX88_ALSA) += cx88-alsa.o |
| 9 | obj-$(CONFIG_VIDEO_CX88_VP3054) += cx88-vp3054-i2c.o | ||
| 9 | 10 | ||
| 10 | EXTRA_CFLAGS += -I$(src)/.. | 11 | EXTRA_CFLAGS += -I$(src)/.. |
| 11 | EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core | 12 | EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core |
| @@ -18,6 +19,6 @@ extra-cflags-$(CONFIG_DVB_LGDT330X) += -DHAVE_LGDT330X=1 | |||
| 18 | extra-cflags-$(CONFIG_DVB_MT352) += -DHAVE_MT352=1 | 19 | extra-cflags-$(CONFIG_DVB_MT352) += -DHAVE_MT352=1 |
| 19 | extra-cflags-$(CONFIG_DVB_NXT200X) += -DHAVE_NXT200X=1 | 20 | extra-cflags-$(CONFIG_DVB_NXT200X) += -DHAVE_NXT200X=1 |
| 20 | extra-cflags-$(CONFIG_DVB_CX24123) += -DHAVE_CX24123=1 | 21 | extra-cflags-$(CONFIG_DVB_CX24123) += -DHAVE_CX24123=1 |
| 21 | extra-cflags-$(CONFIG_VIDEO_CX88_DVB)+= -DHAVE_VP3054_I2C=1 | 22 | extra-cflags-$(CONFIG_VIDEO_CX88_VP3054)+= -DHAVE_VP3054_I2C=1 |
| 22 | 23 | ||
| 23 | EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m) | 24 | EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m) |
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c index a2e36a1e5f59..2acccd6d49bc 100644 --- a/drivers/media/video/cx88/cx88-alsa.c +++ b/drivers/media/video/cx88/cx88-alsa.c | |||
| @@ -128,7 +128,7 @@ MODULE_PARM_DESC(debug,"enable debug messages"); | |||
| 128 | * BOARD Specific: Sets audio DMA | 128 | * BOARD Specific: Sets audio DMA |
| 129 | */ | 129 | */ |
| 130 | 130 | ||
| 131 | int _cx88_start_audio_dma(snd_cx88_card_t *chip) | 131 | static int _cx88_start_audio_dma(snd_cx88_card_t *chip) |
| 132 | { | 132 | { |
| 133 | struct cx88_buffer *buf = chip->buf; | 133 | struct cx88_buffer *buf = chip->buf; |
| 134 | struct cx88_core *core=chip->core; | 134 | struct cx88_core *core=chip->core; |
| @@ -173,7 +173,7 @@ int _cx88_start_audio_dma(snd_cx88_card_t *chip) | |||
| 173 | /* | 173 | /* |
| 174 | * BOARD Specific: Resets audio DMA | 174 | * BOARD Specific: Resets audio DMA |
| 175 | */ | 175 | */ |
| 176 | int _cx88_stop_audio_dma(snd_cx88_card_t *chip) | 176 | static int _cx88_stop_audio_dma(snd_cx88_card_t *chip) |
| 177 | { | 177 | { |
| 178 | struct cx88_core *core=chip->core; | 178 | struct cx88_core *core=chip->core; |
| 179 | dprintk(1, "Stopping audio DMA\n"); | 179 | dprintk(1, "Stopping audio DMA\n"); |
| @@ -613,7 +613,7 @@ static snd_kcontrol_new_t snd_cx88_capture_volume = { | |||
| 613 | * Only boards with eeprom and byte 1 at eeprom=1 have it | 613 | * Only boards with eeprom and byte 1 at eeprom=1 have it |
| 614 | */ | 614 | */ |
| 615 | 615 | ||
| 616 | struct pci_device_id cx88_audio_pci_tbl[] = { | 616 | static struct pci_device_id cx88_audio_pci_tbl[] = { |
| 617 | {0x14f1,0x8801,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, | 617 | {0x14f1,0x8801,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, |
| 618 | {0x14f1,0x8811,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, | 618 | {0x14f1,0x8811,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, |
| 619 | {0, } | 619 | {0, } |
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c index ad2f565f522c..1bc999247fdc 100644 --- a/drivers/media/video/cx88/cx88-cards.c +++ b/drivers/media/video/cx88/cx88-cards.c | |||
| @@ -1246,6 +1246,11 @@ struct cx88_subid cx88_subids[] = { | |||
| 1246 | .card = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL, | 1246 | .card = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL, |
| 1247 | },{ | 1247 | },{ |
| 1248 | .subvendor = 0x18ac, | 1248 | .subvendor = 0x18ac, |
| 1249 | .subdevice = 0xdb54, | ||
| 1250 | .card = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL, | ||
| 1251 | /* Re-branded DViCO: DigitalNow DVB-T Dual */ | ||
| 1252 | },{ | ||
| 1253 | .subvendor = 0x18ac, | ||
| 1249 | .subdevice = 0xdb11, | 1254 | .subdevice = 0xdb11, |
| 1250 | .card = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS, | 1255 | .card = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS, |
| 1251 | /* Re-branded DViCO: UltraView DVB-T Plus */ | 1256 | /* Re-branded DViCO: UltraView DVB-T Plus */ |
| @@ -1293,6 +1298,7 @@ static void hauppauge_eeprom(struct cx88_core *core, u8 *eeprom_data) | |||
| 1293 | switch (tv.model) | 1298 | switch (tv.model) |
| 1294 | { | 1299 | { |
| 1295 | case 28552: /* WinTV-PVR 'Roslyn' (No IR) */ | 1300 | case 28552: /* WinTV-PVR 'Roslyn' (No IR) */ |
| 1301 | case 34519: /* WinTV-PCI-FM */ | ||
| 1296 | case 90002: /* Nova-T-PCI (9002) */ | 1302 | case 90002: /* Nova-T-PCI (9002) */ |
| 1297 | case 92001: /* Nova-S-Plus (Video and IR) */ | 1303 | case 92001: /* Nova-S-Plus (Video and IR) */ |
| 1298 | case 92002: /* Nova-S-Plus (Video and IR) */ | 1304 | case 92002: /* Nova-S-Plus (Video and IR) */ |
diff --git a/drivers/media/video/cx88/cx88-core.c b/drivers/media/video/cx88/cx88-core.c index 8d6d6a6cf785..3720f24a25cf 100644 --- a/drivers/media/video/cx88/cx88-core.c +++ b/drivers/media/video/cx88/cx88-core.c | |||
| @@ -787,12 +787,14 @@ static int set_pll(struct cx88_core *core, int prescale, u32 ofreq) | |||
| 787 | 787 | ||
| 788 | int cx88_start_audio_dma(struct cx88_core *core) | 788 | int cx88_start_audio_dma(struct cx88_core *core) |
| 789 | { | 789 | { |
| 790 | /* constant 128 made buzz in analog Nicam-stereo for bigger fifo_size */ | ||
| 791 | int bpl = cx88_sram_channels[SRAM_CH25].fifo_size/4; | ||
| 790 | /* setup fifo + format */ | 792 | /* setup fifo + format */ |
| 791 | cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], 128, 0); | 793 | cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], bpl, 0); |
| 792 | cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], 128, 0); | 794 | cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], bpl, 0); |
| 793 | 795 | ||
| 794 | cx_write(MO_AUDD_LNGTH, 128); /* fifo bpl size */ | 796 | cx_write(MO_AUDD_LNGTH, bpl); /* fifo bpl size */ |
| 795 | cx_write(MO_AUDR_LNGTH, 128); /* fifo bpl size */ | 797 | cx_write(MO_AUDR_LNGTH, bpl); /* fifo bpl size */ |
| 796 | 798 | ||
| 797 | /* start dma */ | 799 | /* start dma */ |
| 798 | cx_write(MO_AUD_DMACNTRL, 0x0003); /* Up and Down fifo enable */ | 800 | cx_write(MO_AUD_DMACNTRL, 0x0003); /* Up and Down fifo enable */ |
diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c index da2ad5c4b553..165d948624a3 100644 --- a/drivers/media/video/cx88/cx88-input.c +++ b/drivers/media/video/cx88/cx88-input.c | |||
| @@ -482,6 +482,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci) | |||
| 482 | switch (core->board) { | 482 | switch (core->board) { |
| 483 | case CX88_BOARD_DNTV_LIVE_DVB_T: | 483 | case CX88_BOARD_DNTV_LIVE_DVB_T: |
| 484 | case CX88_BOARD_KWORLD_DVB_T: | 484 | case CX88_BOARD_KWORLD_DVB_T: |
| 485 | case CX88_BOARD_KWORLD_DVB_T_CX22702: | ||
| 485 | ir_codes = ir_codes_dntv_live_dvb_t; | 486 | ir_codes = ir_codes_dntv_live_dvb_t; |
| 486 | ir->gpio_addr = MO_GP1_IO; | 487 | ir->gpio_addr = MO_GP1_IO; |
| 487 | ir->mask_keycode = 0x1f; | 488 | ir->mask_keycode = 0x1f; |
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c index dff3893f32fd..e5ee8bceb210 100644 --- a/drivers/media/video/em28xx/em28xx-core.c +++ b/drivers/media/video/em28xx/em28xx-core.c | |||
| @@ -139,6 +139,9 @@ int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg, | |||
| 139 | { | 139 | { |
| 140 | int ret, byte; | 140 | int ret, byte; |
| 141 | 141 | ||
| 142 | if (dev->state & DEV_DISCONNECTED) | ||
| 143 | return(-ENODEV); | ||
| 144 | |||
| 142 | em28xx_regdbg("req=%02x, reg=%02x ", req, reg); | 145 | em28xx_regdbg("req=%02x, reg=%02x ", req, reg); |
| 143 | 146 | ||
| 144 | ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req, | 147 | ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req, |
| @@ -165,6 +168,9 @@ int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg) | |||
| 165 | u8 val; | 168 | u8 val; |
| 166 | int ret; | 169 | int ret; |
| 167 | 170 | ||
| 171 | if (dev->state & DEV_DISCONNECTED) | ||
| 172 | return(-ENODEV); | ||
| 173 | |||
| 168 | em28xx_regdbg("req=%02x, reg=%02x:", req, reg); | 174 | em28xx_regdbg("req=%02x, reg=%02x:", req, reg); |
| 169 | 175 | ||
| 170 | ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req, | 176 | ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req, |
| @@ -195,7 +201,12 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf, | |||
| 195 | int ret; | 201 | int ret; |
| 196 | 202 | ||
| 197 | /*usb_control_msg seems to expect a kmalloced buffer */ | 203 | /*usb_control_msg seems to expect a kmalloced buffer */ |
| 198 | unsigned char *bufs = kmalloc(len, GFP_KERNEL); | 204 | unsigned char *bufs; |
| 205 | |||
| 206 | if (dev->state & DEV_DISCONNECTED) | ||
| 207 | return(-ENODEV); | ||
| 208 | |||
| 209 | bufs = kmalloc(len, GFP_KERNEL); | ||
| 199 | 210 | ||
| 200 | em28xx_regdbg("req=%02x reg=%02x:", req, reg); | 211 | em28xx_regdbg("req=%02x reg=%02x:", req, reg); |
| 201 | 212 | ||
| @@ -212,7 +223,7 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf, | |||
| 212 | ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req, | 223 | ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req, |
| 213 | USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, | 224 | USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, |
| 214 | 0x0000, reg, bufs, len, HZ); | 225 | 0x0000, reg, bufs, len, HZ); |
| 215 | mdelay(5); /* FIXME: magic number */ | 226 | msleep(5); /* FIXME: magic number */ |
| 216 | kfree(bufs); | 227 | kfree(bufs); |
| 217 | return ret; | 228 | return ret; |
| 218 | } | 229 | } |
| @@ -253,7 +264,7 @@ int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 * val) | |||
| 253 | if ((ret = em28xx_read_reg(dev, AC97BUSY_REG)) < 0) | 264 | if ((ret = em28xx_read_reg(dev, AC97BUSY_REG)) < 0) |
| 254 | return ret; | 265 | return ret; |
| 255 | else if (((u8) ret) & 0x01) { | 266 | else if (((u8) ret) & 0x01) { |
| 256 | em28xx_warn ("AC97 command still being exectuted: not handled properly!\n"); | 267 | em28xx_warn ("AC97 command still being executed: not handled properly!\n"); |
| 257 | } | 268 | } |
| 258 | return 0; | 269 | return 0; |
| 259 | } | 270 | } |
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c index 0591a705b7a1..6ca8631bc36d 100644 --- a/drivers/media/video/em28xx/em28xx-i2c.c +++ b/drivers/media/video/em28xx/em28xx-i2c.c | |||
| @@ -78,7 +78,7 @@ static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr, | |||
| 78 | ret = dev->em28xx_read_reg(dev, 0x05); | 78 | ret = dev->em28xx_read_reg(dev, 0x05); |
| 79 | if (ret == 0x80 + len - 1) | 79 | if (ret == 0x80 + len - 1) |
| 80 | return len; | 80 | return len; |
| 81 | mdelay(5); | 81 | msleep(5); |
| 82 | } | 82 | } |
| 83 | em28xx_warn("i2c write timed out\n"); | 83 | em28xx_warn("i2c write timed out\n"); |
| 84 | return -EIO; | 84 | return -EIO; |
| @@ -138,7 +138,7 @@ static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr) | |||
| 138 | return -ENODEV; | 138 | return -ENODEV; |
| 139 | else if (msg == 0x84) | 139 | else if (msg == 0x84) |
| 140 | return 0; | 140 | return 0; |
| 141 | mdelay(5); | 141 | msleep(5); |
| 142 | } | 142 | } |
| 143 | return -ENODEV; | 143 | return -ENODEV; |
| 144 | } | 144 | } |
| @@ -278,9 +278,9 @@ static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap, | |||
| 278 | msgs[i].buf, | 278 | msgs[i].buf, |
| 279 | msgs[i].len, | 279 | msgs[i].len, |
| 280 | i == num - 1); | 280 | i == num - 1); |
| 281 | if (rc < 0) | ||
| 282 | goto err; | ||
| 283 | } | 281 | } |
| 282 | if (rc < 0) | ||
| 283 | goto err; | ||
| 284 | if (i2c_debug>=2) | 284 | if (i2c_debug>=2) |
| 285 | printk("\n"); | 285 | printk("\n"); |
| 286 | } | 286 | } |
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c index eea304f75176..94a14a2bb6d6 100644 --- a/drivers/media/video/em28xx/em28xx-video.c +++ b/drivers/media/video/em28xx/em28xx-video.c | |||
| @@ -6,6 +6,9 @@ | |||
| 6 | Mauro Carvalho Chehab <mchehab@brturbo.com.br> | 6 | Mauro Carvalho Chehab <mchehab@brturbo.com.br> |
| 7 | Sascha Sommer <saschasommer@freenet.de> | 7 | Sascha Sommer <saschasommer@freenet.de> |
| 8 | 8 | ||
| 9 | Some parts based on SN9C10x PC Camera Controllers GPL driver made | ||
| 10 | by Luca Risolia <luca.risolia@studio.unibo.it> | ||
| 11 | |||
| 9 | This program is free software; you can redistribute it and/or modify | 12 | This program is free software; you can redistribute it and/or modify |
| 10 | it under the terms of the GNU General Public License as published by | 13 | it under the terms of the GNU General Public License as published by |
| 11 | the Free Software Foundation; either version 2 of the License, or | 14 | the Free Software Foundation; either version 2 of the License, or |
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c index c64718aec9cb..5a35d3b6550d 100644 --- a/drivers/media/video/saa7134/saa7134-cards.c +++ b/drivers/media/video/saa7134/saa7134-cards.c | |||
| @@ -136,7 +136,7 @@ struct saa7134_board saa7134_boards[] = { | |||
| 136 | }, | 136 | }, |
| 137 | [SAA7134_BOARD_FLYVIDEO2000] = { | 137 | [SAA7134_BOARD_FLYVIDEO2000] = { |
| 138 | /* "TC Wan" <tcwan@cs.usm.my> */ | 138 | /* "TC Wan" <tcwan@cs.usm.my> */ |
| 139 | .name = "LifeView FlyVIDEO2000", | 139 | .name = "LifeView/Typhoon FlyVIDEO2000", |
| 140 | .audio_clock = 0x00200000, | 140 | .audio_clock = 0x00200000, |
| 141 | .tuner_type = TUNER_LG_PAL_NEW_TAPC, | 141 | .tuner_type = TUNER_LG_PAL_NEW_TAPC, |
| 142 | .radio_type = UNSET, | 142 | .radio_type = UNSET, |
| @@ -1884,44 +1884,38 @@ struct saa7134_board saa7134_boards[] = { | |||
| 1884 | .gpio = 0x000, | 1884 | .gpio = 0x000, |
| 1885 | }, | 1885 | }, |
| 1886 | }, | 1886 | }, |
| 1887 | [SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS] = { | 1887 | [SAA7134_BOARD_FLYDVBT_DUO_CARDBUS] = { |
| 1888 | .name = "Typhoon DVB-T Duo Digital/Analog Cardbus", | 1888 | .name = "LifeView/Typhoon FlyDVB-T Duo Cardbus", |
| 1889 | .audio_clock = 0x00200000, | 1889 | .audio_clock = 0x00200000, |
| 1890 | .tuner_type = TUNER_PHILIPS_TDA8290, | 1890 | .tuner_type = TUNER_PHILIPS_TDA8290, |
| 1891 | .radio_type = UNSET, | 1891 | .radio_type = UNSET, |
| 1892 | .tuner_addr = ADDR_UNSET, | 1892 | .tuner_addr = ADDR_UNSET, |
| 1893 | .radio_addr = ADDR_UNSET, | 1893 | .radio_addr = ADDR_UNSET, |
| 1894 | .mpeg = SAA7134_MPEG_DVB, | 1894 | .mpeg = SAA7134_MPEG_DVB, |
| 1895 | /* .gpiomask = 0xe000, */ | 1895 | .gpiomask = 0x00200000, |
| 1896 | .inputs = {{ | 1896 | .inputs = {{ |
| 1897 | .name = name_tv, | 1897 | .name = name_tv, |
| 1898 | .vmux = 1, | 1898 | .vmux = 1, |
| 1899 | .amux = TV, | 1899 | .amux = TV, |
| 1900 | /* .gpio = 0x0000, */ | 1900 | .gpio = 0x200000, /* GPIO21=High for TV input */ |
| 1901 | .tv = 1, | 1901 | .tv = 1, |
| 1902 | },{ | 1902 | },{ |
| 1903 | .name = name_svideo, /* S-Video signal on S-Video input */ | ||
| 1904 | .vmux = 8, | ||
| 1905 | .amux = LINE2, | ||
| 1906 | },{ | ||
| 1903 | .name = name_comp1, /* Composite signal on S-Video input */ | 1907 | .name = name_comp1, /* Composite signal on S-Video input */ |
| 1904 | .vmux = 0, | 1908 | .vmux = 0, |
| 1905 | .amux = LINE2, | 1909 | .amux = LINE2, |
| 1906 | /* .gpio = 0x4000, */ | ||
| 1907 | },{ | 1910 | },{ |
| 1908 | .name = name_comp2, /* Composite input */ | 1911 | .name = name_comp2, /* Composite input */ |
| 1909 | .vmux = 3, | 1912 | .vmux = 3, |
| 1910 | .amux = LINE2, | 1913 | .amux = LINE2, |
| 1911 | /* .gpio = 0x4000, */ | ||
| 1912 | },{ | ||
| 1913 | .name = name_svideo, /* S-Video signal on S-Video input */ | ||
| 1914 | .vmux = 8, | ||
| 1915 | .amux = LINE2, | ||
| 1916 | /* .gpio = 0x4000, */ | ||
| 1917 | }}, | 1914 | }}, |
| 1918 | .radio = { | 1915 | .radio = { |
| 1919 | .name = name_radio, | 1916 | .name = name_radio, |
| 1920 | .amux = LINE2, | 1917 | .amux = TV, |
| 1921 | }, | 1918 | .gpio = 0x000000, /* GPIO21=Low for FM radio antenna */ |
| 1922 | .mute = { | ||
| 1923 | .name = name_mute, | ||
| 1924 | .amux = LINE1, | ||
| 1925 | }, | 1919 | }, |
| 1926 | }, | 1920 | }, |
| 1927 | [SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII] = { | 1921 | [SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII] = { |
| @@ -2701,6 +2695,12 @@ struct pci_device_id saa7134_pci_tbl[] = { | |||
| 2701 | .driver_data = SAA7134_BOARD_FLYVIDEO2000, | 2695 | .driver_data = SAA7134_BOARD_FLYVIDEO2000, |
| 2702 | },{ | 2696 | },{ |
| 2703 | .vendor = PCI_VENDOR_ID_PHILIPS, | 2697 | .vendor = PCI_VENDOR_ID_PHILIPS, |
| 2698 | .device = PCI_DEVICE_ID_PHILIPS_SAA7130, | ||
| 2699 | .subvendor = 0x4e42, /* Typhoon */ | ||
| 2700 | .subdevice = 0x0138, /* LifeView FlyTV Prime30 OEM */ | ||
| 2701 | .driver_data = SAA7134_BOARD_FLYVIDEO2000, | ||
| 2702 | },{ | ||
| 2703 | .vendor = PCI_VENDOR_ID_PHILIPS, | ||
| 2704 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, | 2704 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, |
| 2705 | .subvendor = 0x5168, | 2705 | .subvendor = 0x5168, |
| 2706 | .subdevice = 0x0212, /* minipci, LR212 */ | 2706 | .subdevice = 0x0212, /* minipci, LR212 */ |
| @@ -2935,7 +2935,7 @@ struct pci_device_id saa7134_pci_tbl[] = { | |||
| 2935 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, | 2935 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, |
| 2936 | .subvendor = 0x5168, | 2936 | .subvendor = 0x5168, |
| 2937 | .subdevice = 0x0502, /* Cardbus version */ | 2937 | .subdevice = 0x0502, /* Cardbus version */ |
| 2938 | .driver_data = SAA7134_BOARD_FLYDVBTDUO, | 2938 | .driver_data = SAA7134_BOARD_FLYDVBT_DUO_CARDBUS, |
| 2939 | },{ | 2939 | },{ |
| 2940 | .vendor = PCI_VENDOR_ID_PHILIPS, | 2940 | .vendor = PCI_VENDOR_ID_PHILIPS, |
| 2941 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, | 2941 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, |
| @@ -2980,12 +2980,12 @@ struct pci_device_id saa7134_pci_tbl[] = { | |||
| 2980 | .subdevice = 0x1370, /* cardbus version */ | 2980 | .subdevice = 0x1370, /* cardbus version */ |
| 2981 | .driver_data = SAA7134_BOARD_ADS_INSTANT_TV, | 2981 | .driver_data = SAA7134_BOARD_ADS_INSTANT_TV, |
| 2982 | 2982 | ||
| 2983 | },{ /* Typhoon DVB-T Duo Digital/Analog Cardbus */ | 2983 | },{ |
| 2984 | .vendor = PCI_VENDOR_ID_PHILIPS, | 2984 | .vendor = PCI_VENDOR_ID_PHILIPS, |
| 2985 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, | 2985 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, |
| 2986 | .subvendor = 0x4e42, | 2986 | .subvendor = 0x4e42, /* Typhoon */ |
| 2987 | .subdevice = 0x0502, | 2987 | .subdevice = 0x0502, /* LifeView LR502 OEM */ |
| 2988 | .driver_data = SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS, | 2988 | .driver_data = SAA7134_BOARD_FLYDVBT_DUO_CARDBUS, |
| 2989 | },{ | 2989 | },{ |
| 2990 | .vendor = PCI_VENDOR_ID_PHILIPS, | 2990 | .vendor = PCI_VENDOR_ID_PHILIPS, |
| 2991 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, | 2991 | .device = PCI_DEVICE_ID_PHILIPS_SAA7133, |
| @@ -3206,8 +3206,7 @@ int saa7134_board_init1(struct saa7134_dev *dev) | |||
| 3206 | saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x00040000, 0x00040000); | 3206 | saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x00040000, 0x00040000); |
| 3207 | saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00040000, 0x00000004); | 3207 | saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00040000, 0x00000004); |
| 3208 | break; | 3208 | break; |
| 3209 | case SAA7134_BOARD_FLYDVBTDUO: | 3209 | case SAA7134_BOARD_FLYDVBT_DUO_CARDBUS: |
| 3210 | case SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS: | ||
| 3211 | /* turn the fan on */ | 3210 | /* turn the fan on */ |
| 3212 | saa_writeb(SAA7134_GPIO_GPMODE3, 0x08); | 3211 | saa_writeb(SAA7134_GPIO_GPMODE3, 0x08); |
| 3213 | saa_writeb(SAA7134_GPIO_GPSTATUS3, 0x06); | 3212 | saa_writeb(SAA7134_GPIO_GPSTATUS3, 0x06); |
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c index 399f9952596c..1a536e865277 100644 --- a/drivers/media/video/saa7134/saa7134-dvb.c +++ b/drivers/media/video/saa7134/saa7134-dvb.c | |||
| @@ -861,7 +861,7 @@ static int dvb_init(struct saa7134_dev *dev) | |||
| 861 | dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config, | 861 | dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config, |
| 862 | &dev->i2c_adap); | 862 | &dev->i2c_adap); |
| 863 | break; | 863 | break; |
| 864 | case SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS: | 864 | case SAA7134_BOARD_FLYDVBT_DUO_CARDBUS: |
| 865 | dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config, | 865 | dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config, |
| 866 | &dev->i2c_adap); | 866 | &dev->i2c_adap); |
| 867 | break; | 867 | break; |
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h index e70eae8d29bb..3261d8bebdd1 100644 --- a/drivers/media/video/saa7134/saa7134.h +++ b/drivers/media/video/saa7134/saa7134.h | |||
| @@ -185,7 +185,7 @@ struct saa7134_format { | |||
| 185 | #define SAA7134_BOARD_AVERMEDIA_GO_007_FM 57 | 185 | #define SAA7134_BOARD_AVERMEDIA_GO_007_FM 57 |
| 186 | #define SAA7134_BOARD_ADS_INSTANT_TV 58 | 186 | #define SAA7134_BOARD_ADS_INSTANT_TV 58 |
| 187 | #define SAA7134_BOARD_KWORLD_VSTREAM_XPERT 59 | 187 | #define SAA7134_BOARD_KWORLD_VSTREAM_XPERT 59 |
| 188 | #define SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS 60 | 188 | #define SAA7134_BOARD_FLYDVBT_DUO_CARDBUS 60 |
| 189 | #define SAA7134_BOARD_PHILIPS_TOUGH 61 | 189 | #define SAA7134_BOARD_PHILIPS_TOUGH 61 |
| 190 | #define SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII 62 | 190 | #define SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII 62 |
| 191 | #define SAA7134_BOARD_KWORLD_XPERT 63 | 191 | #define SAA7134_BOARD_KWORLD_XPERT 63 |
diff --git a/drivers/media/video/stradis.c b/drivers/media/video/stradis.c index 54fc33011ffb..9d769264a329 100644 --- a/drivers/media/video/stradis.c +++ b/drivers/media/video/stradis.c | |||
| @@ -2012,7 +2012,6 @@ static int __devinit init_saa7146(struct pci_dev *pdev) | |||
| 2012 | { | 2012 | { |
| 2013 | struct saa7146 *saa = pci_get_drvdata(pdev); | 2013 | struct saa7146 *saa = pci_get_drvdata(pdev); |
| 2014 | 2014 | ||
| 2015 | memset(saa, 0, sizeof(*saa)); | ||
| 2016 | saa->user = 0; | 2015 | saa->user = 0; |
| 2017 | /* reset the saa7146 */ | 2016 | /* reset the saa7146 */ |
| 2018 | saawrite(0xffff0000, SAA7146_MC1); | 2017 | saawrite(0xffff0000, SAA7146_MC1); |
| @@ -2062,16 +2061,16 @@ static int __devinit init_saa7146(struct pci_dev *pdev) | |||
| 2062 | } | 2061 | } |
| 2063 | if (saa->audbuf == NULL && (saa->audbuf = vmalloc(65536)) == NULL) { | 2062 | if (saa->audbuf == NULL && (saa->audbuf = vmalloc(65536)) == NULL) { |
| 2064 | dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr); | 2063 | dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr); |
| 2065 | goto errvid; | 2064 | goto errfree; |
| 2066 | } | 2065 | } |
| 2067 | if (saa->osdbuf == NULL && (saa->osdbuf = vmalloc(131072)) == NULL) { | 2066 | if (saa->osdbuf == NULL && (saa->osdbuf = vmalloc(131072)) == NULL) { |
| 2068 | dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr); | 2067 | dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr); |
| 2069 | goto erraud; | 2068 | goto errfree; |
| 2070 | } | 2069 | } |
| 2071 | /* allocate 81920 byte buffer for clipping */ | 2070 | /* allocate 81920 byte buffer for clipping */ |
| 2072 | if ((saa->dmavid2 = kzalloc(VIDEO_CLIPMAP_SIZE, GFP_KERNEL)) == NULL) { | 2071 | if ((saa->dmavid2 = kzalloc(VIDEO_CLIPMAP_SIZE, GFP_KERNEL)) == NULL) { |
| 2073 | dev_err(&pdev->dev, "%d: clip kmalloc failed\n", saa->nr); | 2072 | dev_err(&pdev->dev, "%d: clip kmalloc failed\n", saa->nr); |
| 2074 | goto errosd; | 2073 | goto errfree; |
| 2075 | } | 2074 | } |
| 2076 | /* setup clipping registers */ | 2075 | /* setup clipping registers */ |
| 2077 | saawrite(virt_to_bus(saa->dmavid2), SAA7146_BASE_EVEN2); | 2076 | saawrite(virt_to_bus(saa->dmavid2), SAA7146_BASE_EVEN2); |
| @@ -2085,15 +2084,11 @@ static int __devinit init_saa7146(struct pci_dev *pdev) | |||
| 2085 | I2CBusScan(saa); | 2084 | I2CBusScan(saa); |
| 2086 | 2085 | ||
| 2087 | return 0; | 2086 | return 0; |
| 2088 | errosd: | 2087 | errfree: |
| 2089 | vfree(saa->osdbuf); | 2088 | vfree(saa->osdbuf); |
| 2090 | saa->osdbuf = NULL; | ||
| 2091 | erraud: | ||
| 2092 | vfree(saa->audbuf); | 2089 | vfree(saa->audbuf); |
| 2093 | saa->audbuf = NULL; | ||
| 2094 | errvid: | ||
| 2095 | vfree(saa->vidbuf); | 2090 | vfree(saa->vidbuf); |
| 2096 | saa->vidbuf = NULL; | 2091 | saa->audbuf = saa->osdbuf = saa->vidbuf = NULL; |
| 2097 | err: | 2092 | err: |
| 2098 | return -ENOMEM; | 2093 | return -ENOMEM; |
| 2099 | } | 2094 | } |
diff --git a/drivers/media/video/tda9887.c b/drivers/media/video/tda9887.c index 5815649bdc78..0d54f6c1982b 100644 --- a/drivers/media/video/tda9887.c +++ b/drivers/media/video/tda9887.c | |||
| @@ -231,7 +231,7 @@ static struct tvnorm tvnorms[] = { | |||
| 231 | cAudioIF_6_5 | | 231 | cAudioIF_6_5 | |
| 232 | cVideoIF_38_90 ), | 232 | cVideoIF_38_90 ), |
| 233 | },{ | 233 | },{ |
| 234 | .std = V4L2_STD_NTSC_M, | 234 | .std = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR, |
| 235 | .name = "NTSC-M", | 235 | .name = "NTSC-M", |
| 236 | .b = ( cNegativeFmTV | | 236 | .b = ( cNegativeFmTV | |
| 237 | cQSS ), | 237 | cQSS ), |
| @@ -619,6 +619,11 @@ static int tda9887_fixup_std(struct tda9887 *t) | |||
| 619 | tda9887_dbg("insmod fixup: NTSC => NTSC_M_JP\n"); | 619 | tda9887_dbg("insmod fixup: NTSC => NTSC_M_JP\n"); |
| 620 | t->std = V4L2_STD_NTSC_M_JP; | 620 | t->std = V4L2_STD_NTSC_M_JP; |
| 621 | break; | 621 | break; |
| 622 | case 'k': | ||
| 623 | case 'K': | ||
| 624 | tda9887_dbg("insmod fixup: NTSC => NTSC_M_KR\n"); | ||
| 625 | t->std = V4L2_STD_NTSC_M_KR; | ||
| 626 | break; | ||
| 622 | case '-': | 627 | case '-': |
| 623 | /* default parameter, do nothing */ | 628 | /* default parameter, do nothing */ |
| 624 | break; | 629 | break; |
| @@ -876,7 +881,7 @@ static int tda9887_resume(struct device * dev) | |||
| 876 | /* ----------------------------------------------------------------------- */ | 881 | /* ----------------------------------------------------------------------- */ |
| 877 | 882 | ||
| 878 | static struct i2c_driver driver = { | 883 | static struct i2c_driver driver = { |
| 879 | .id = -1, /* FIXME */ | 884 | .id = I2C_DRIVERID_TDA9887, |
| 880 | .attach_adapter = tda9887_probe, | 885 | .attach_adapter = tda9887_probe, |
| 881 | .detach_client = tda9887_detach, | 886 | .detach_client = tda9887_detach, |
| 882 | .command = tda9887_command, | 887 | .command = tda9887_command, |
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c index 2995b22acb43..e7ee619d62c5 100644 --- a/drivers/media/video/tuner-core.c +++ b/drivers/media/video/tuner-core.c | |||
| @@ -216,6 +216,7 @@ static void set_type(struct i2c_client *c, unsigned int type, | |||
| 216 | buffer[3] = 0xa4; | 216 | buffer[3] = 0xa4; |
| 217 | i2c_master_send(c,buffer,4); | 217 | i2c_master_send(c,buffer,4); |
| 218 | default_tuner_init(c); | 218 | default_tuner_init(c); |
| 219 | break; | ||
| 219 | default: | 220 | default: |
| 220 | default_tuner_init(c); | 221 | default_tuner_init(c); |
| 221 | break; | 222 | break; |
| @@ -365,6 +366,11 @@ static int tuner_fixup_std(struct tuner *t) | |||
| 365 | tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n"); | 366 | tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n"); |
| 366 | t->std = V4L2_STD_NTSC_M_JP; | 367 | t->std = V4L2_STD_NTSC_M_JP; |
| 367 | break; | 368 | break; |
| 369 | case 'k': | ||
| 370 | case 'K': | ||
| 371 | tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n"); | ||
| 372 | t->std = V4L2_STD_NTSC_M_KR; | ||
| 373 | break; | ||
| 368 | case '-': | 374 | case '-': |
| 369 | /* default parameter, do nothing */ | 375 | /* default parameter, do nothing */ |
| 370 | break; | 376 | break; |
| @@ -448,7 +454,7 @@ static int tuner_attach(struct i2c_adapter *adap, int addr, int kind) | |||
| 448 | printk("%02x ",buffer[i]); | 454 | printk("%02x ",buffer[i]); |
| 449 | printk("\n"); | 455 | printk("\n"); |
| 450 | } | 456 | } |
| 451 | /* TEA5767 autodetection code - only for addr = 0xc0 */ | 457 | /* autodetection code based on the i2c addr */ |
| 452 | if (!no_autodetect) { | 458 | if (!no_autodetect) { |
| 453 | switch (addr) { | 459 | switch (addr) { |
| 454 | case 0x42: | 460 | case 0x42: |
diff --git a/drivers/media/video/tvaudio.c b/drivers/media/video/tvaudio.c index 6d03b9b05c6e..c8e5ad0e8185 100644 --- a/drivers/media/video/tvaudio.c +++ b/drivers/media/video/tvaudio.c | |||
| @@ -390,6 +390,14 @@ static void tda9840_setmode(struct CHIPSTATE *chip, int mode) | |||
| 390 | chip_write(chip, TDA9840_SW, t); | 390 | chip_write(chip, TDA9840_SW, t); |
| 391 | } | 391 | } |
| 392 | 392 | ||
| 393 | static int tda9840_checkit(struct CHIPSTATE *chip) | ||
| 394 | { | ||
| 395 | int rc; | ||
| 396 | rc = chip_read(chip); | ||
| 397 | /* lower 5 bits should be 0 */ | ||
| 398 | return ((rc & 0x1f) == 0) ? 1 : 0; | ||
| 399 | } | ||
| 400 | |||
| 393 | /* ---------------------------------------------------------------------- */ | 401 | /* ---------------------------------------------------------------------- */ |
| 394 | /* audio chip descriptions - defines+functions for tda985x */ | 402 | /* audio chip descriptions - defines+functions for tda985x */ |
| 395 | 403 | ||
| @@ -1264,6 +1272,7 @@ static struct CHIPDESC chiplist[] = { | |||
| 1264 | .addr_hi = I2C_TDA9840 >> 1, | 1272 | .addr_hi = I2C_TDA9840 >> 1, |
| 1265 | .registers = 5, | 1273 | .registers = 5, |
| 1266 | 1274 | ||
| 1275 | .checkit = tda9840_checkit, | ||
| 1267 | .getmode = tda9840_getmode, | 1276 | .getmode = tda9840_getmode, |
| 1268 | .setmode = tda9840_setmode, | 1277 | .setmode = tda9840_setmode, |
| 1269 | .checkmode = generic_checkmode, | 1278 | .checkmode = generic_checkmode, |
diff --git a/drivers/media/video/tvp5150.c b/drivers/media/video/tvp5150.c index fad9ea0ae4f2..1864423b3046 100644 --- a/drivers/media/video/tvp5150.c +++ b/drivers/media/video/tvp5150.c | |||
| @@ -746,24 +746,27 @@ static int tvp5150_set_std(struct i2c_client *c, v4l2_std_id std) | |||
| 746 | 746 | ||
| 747 | static inline void tvp5150_reset(struct i2c_client *c) | 747 | static inline void tvp5150_reset(struct i2c_client *c) |
| 748 | { | 748 | { |
| 749 | u8 type, ver_656, msb_id, lsb_id, msb_rom, lsb_rom; | 749 | u8 msb_id, lsb_id, msb_rom, lsb_rom; |
| 750 | struct tvp5150 *decoder = i2c_get_clientdata(c); | 750 | struct tvp5150 *decoder = i2c_get_clientdata(c); |
| 751 | 751 | ||
| 752 | type=tvp5150_read(c,TVP5150_AUTOSW_MSK); | ||
| 753 | msb_id=tvp5150_read(c,TVP5150_MSB_DEV_ID); | 752 | msb_id=tvp5150_read(c,TVP5150_MSB_DEV_ID); |
| 754 | lsb_id=tvp5150_read(c,TVP5150_LSB_DEV_ID); | 753 | lsb_id=tvp5150_read(c,TVP5150_LSB_DEV_ID); |
| 755 | msb_rom=tvp5150_read(c,TVP5150_ROM_MAJOR_VER); | 754 | msb_rom=tvp5150_read(c,TVP5150_ROM_MAJOR_VER); |
| 756 | lsb_rom=tvp5150_read(c,TVP5150_ROM_MINOR_VER); | 755 | lsb_rom=tvp5150_read(c,TVP5150_ROM_MINOR_VER); |
| 757 | 756 | ||
| 758 | if (type==0xdc) { | 757 | if ((msb_rom==4)&&(lsb_rom==0)) { /* Is TVP5150AM1 */ |
| 759 | ver_656=tvp5150_read(c,TVP5150_REV_SELECT); | 758 | tvp5150_info("tvp%02x%02xam1 detected.\n",msb_id, lsb_id); |
| 760 | tvp5150_info("tvp%02x%02xam1 detected 656 version is %d.\n",msb_id, lsb_id,ver_656); | 759 | |
| 761 | } else if (type==0xfc) { | 760 | /* ITU-T BT.656.4 timing */ |
| 762 | tvp5150_info("tvp%02x%02xa detected.\n",msb_id, lsb_id); | 761 | tvp5150_write(c,TVP5150_REV_SELECT,0); |
| 763 | } else { | 762 | } else { |
| 764 | tvp5150_info("unknown tvp%02x%02x chip detected(%d).\n",msb_id,lsb_id,type); | 763 | if ((msb_rom==3)||(lsb_rom==0x21)) { /* Is TVP5150A */ |
| 764 | tvp5150_info("tvp%02x%02xa detected.\n",msb_id, lsb_id); | ||
| 765 | } else { | ||
| 766 | tvp5150_info("*** unknown tvp%02x%02x chip detected.\n",msb_id,lsb_id); | ||
| 767 | tvp5150_info("*** Rom ver is %d.%d\n",msb_rom,lsb_rom); | ||
| 768 | } | ||
| 765 | } | 769 | } |
| 766 | tvp5150_info("Rom ver is %d.%d\n",msb_rom,lsb_rom); | ||
| 767 | 770 | ||
| 768 | /* Initializes TVP5150 to its default values */ | 771 | /* Initializes TVP5150 to its default values */ |
| 769 | tvp5150_write_inittab(c, tvp5150_init_default); | 772 | tvp5150_write_inittab(c, tvp5150_init_default); |
| @@ -893,6 +896,17 @@ static int tvp5150_command(struct i2c_client *c, | |||
| 893 | } | 896 | } |
| 894 | case DECODER_GET_STATUS: | 897 | case DECODER_GET_STATUS: |
| 895 | { | 898 | { |
| 899 | int *iarg = arg; | ||
| 900 | int status; | ||
| 901 | int res=0; | ||
| 902 | status = tvp5150_read(c, 0x88); | ||
| 903 | if(status&0x08){ | ||
| 904 | res |= DECODER_STATUS_COLOR; | ||
| 905 | } | ||
| 906 | if(status&0x04 && status&0x02){ | ||
| 907 | res |= DECODER_STATUS_GOOD; | ||
| 908 | } | ||
| 909 | *iarg=res; | ||
| 896 | break; | 910 | break; |
| 897 | } | 911 | } |
| 898 | 912 | ||
