Lines Matching defs:pt1
36 #define DRIVER_NAME "earth-pt1"
72 struct pt1 {
91 struct pt1 *pt1;
254 static int pt1_demod_block_init(struct pt1 *pt1)
263 cl = pt1->adaps[i]->demod_i2c_client;
275 cl = pt1->adaps[i]->demod_i2c_client;
288 static void pt1_write_reg(struct pt1 *pt1, int reg, u32 data)
290 writel(data, pt1->regs + reg * 4);
293 static u32 pt1_read_reg(struct pt1 *pt1, int reg)
295 return readl(pt1->regs + reg * 4);
301 static void pt1_increment_table_count(struct pt1 *pt1)
303 pt1_write_reg(pt1, 0, 0x00000020);
306 static void pt1_init_table_count(struct pt1 *pt1)
308 pt1_write_reg(pt1, 0, 0x00000010);
311 static void pt1_register_tables(struct pt1 *pt1, u32 first_pfn)
313 pt1_write_reg(pt1, 5, first_pfn);
314 pt1_write_reg(pt1, 0, 0x0c000040);
317 static void pt1_unregister_tables(struct pt1 *pt1)
319 pt1_write_reg(pt1, 0, 0x08080000);
322 static int pt1_sync(struct pt1 *pt1)
326 if (pt1_read_reg(pt1, 0) & 0x20000000)
328 pt1_write_reg(pt1, 0, 0x00000008);
330 dev_err(&pt1->pdev->dev, "could not sync\n");
334 static u64 pt1_identify(struct pt1 *pt1)
340 id |= (u64)(pt1_read_reg(pt1, 0) >> 30 & 1) << i;
341 pt1_write_reg(pt1, 0, 0x00000008);
346 static int pt1_unlock(struct pt1 *pt1)
349 pt1_write_reg(pt1, 0, 0x00000008);
351 if (pt1_read_reg(pt1, 0) & 0x80000000)
355 dev_err(&pt1->pdev->dev, "could not unlock\n");
359 static int pt1_reset_pci(struct pt1 *pt1)
362 pt1_write_reg(pt1, 0, 0x01010000);
363 pt1_write_reg(pt1, 0, 0x01000000);
365 if (pt1_read_reg(pt1, 0) & 0x00000001)
369 dev_err(&pt1->pdev->dev, "could not reset PCI\n");
373 static int pt1_reset_ram(struct pt1 *pt1)
376 pt1_write_reg(pt1, 0, 0x02020000);
377 pt1_write_reg(pt1, 0, 0x02000000);
379 if (pt1_read_reg(pt1, 0) & 0x00000002)
383 dev_err(&pt1->pdev->dev, "could not reset RAM\n");
387 static int pt1_do_enable_ram(struct pt1 *pt1)
391 status = pt1_read_reg(pt1, 0) & 0x00000004;
392 pt1_write_reg(pt1, 0, 0x00000002);
395 if ((pt1_read_reg(pt1, 0) & 0x00000004) != status)
400 dev_err(&pt1->pdev->dev, "could not enable RAM\n");
404 static int pt1_enable_ram(struct pt1 *pt1)
409 phase = pt1->pdev->device == 0x211a ? 128 : 166;
411 ret = pt1_do_enable_ram(pt1);
418 static void pt1_disable_ram(struct pt1 *pt1)
420 pt1_write_reg(pt1, 0, 0x0b0b0000);
423 static void pt1_set_stream(struct pt1 *pt1, int index, int enabled)
425 pt1_write_reg(pt1, 2, 1 << (index + 8) | enabled << index);
428 static void pt1_init_streams(struct pt1 *pt1)
432 pt1_set_stream(pt1, i, 0);
435 static int pt1_filter(struct pt1 *pt1, struct pt1_buffer_page *page)
454 adap = pt1->adaps[index];
461 printk_ratelimited(KERN_INFO "earth-pt1: device buffer overflowing. table[%d] buf[%d]\n",
462 pt1->table_index, pt1->buf_index);
465 printk_ratelimited(KERN_INFO "earth-pt1: data loss in streamID(adapter)[%d]\n",
491 struct pt1 *pt1;
498 pt1 = data;
506 pt1_set_stream(pt1, i, !!pt1->adaps[i]->users);
509 page = pt1->tables[pt1->table_index].bufs[pt1->buf_index].page;
510 if (!pt1_filter(pt1, page)) {
521 if (++pt1->buf_index >= PT1_NR_BUFS) {
522 pt1_increment_table_count(pt1);
523 pt1->buf_index = 0;
524 if (++pt1->table_index >= pt1_nr_tables)
525 pt1->table_index = 0;
532 static void pt1_free_page(struct pt1 *pt1, void *page, dma_addr_t addr)
534 dma_free_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, page, addr);
537 static void *pt1_alloc_page(struct pt1 *pt1, dma_addr_t *addrp, u32 *pfnp)
542 page = dma_alloc_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, &addr,
555 static void pt1_cleanup_buffer(struct pt1 *pt1, struct pt1_buffer *buf)
557 pt1_free_page(pt1, buf->page, buf->addr);
561 pt1_init_buffer(struct pt1 *pt1, struct pt1_buffer *buf, u32 *pfnp)
566 page = pt1_alloc_page(pt1, &addr, pfnp);
577 static void pt1_cleanup_table(struct pt1 *pt1, struct pt1_table *table)
582 pt1_cleanup_buffer(pt1, &table->bufs[i]);
584 pt1_free_page(pt1, table->page, table->addr);
588 pt1_init_table(struct pt1 *pt1, struct pt1_table *table, u32 *pfnp)
595 page = pt1_alloc_page(pt1, &addr, pfnp);
600 ret = pt1_init_buffer(pt1, &table->bufs[i], &buf_pfn);
607 pt1_increment_table_count(pt1);
614 pt1_cleanup_buffer(pt1, &table->bufs[i]);
616 pt1_free_page(pt1, page, addr);
620 static void pt1_cleanup_tables(struct pt1 *pt1)
625 tables = pt1->tables;
626 pt1_unregister_tables(pt1);
629 pt1_cleanup_table(pt1, &tables[i]);
634 static int pt1_init_tables(struct pt1 *pt1)
647 pt1_init_table_count(pt1);
650 ret = pt1_init_table(pt1, &tables[0], &first_pfn);
656 ret = pt1_init_table(pt1, &tables[i], &pfn);
665 pt1_register_tables(pt1, first_pfn);
666 pt1->tables = tables;
671 pt1_cleanup_table(pt1, &tables[i]);
677 static int pt1_start_polling(struct pt1 *pt1)
681 mutex_lock(&pt1->lock);
682 if (!pt1->kthread) {
683 pt1->kthread = kthread_run(pt1_thread, pt1, "earth-pt1");
684 if (IS_ERR(pt1->kthread)) {
685 ret = PTR_ERR(pt1->kthread);
686 pt1->kthread = NULL;
689 mutex_unlock(&pt1->lock);
700 ret = pt1_start_polling(adap->pt1);
703 pt1_set_stream(adap->pt1, adap->index, 1);
708 static void pt1_stop_polling(struct pt1 *pt1)
712 mutex_lock(&pt1->lock);
714 count += pt1->adaps[i]->users;
716 if (count == 0 && pt1->kthread) {
717 kthread_stop(pt1->kthread);
718 pt1->kthread = NULL;
720 mutex_unlock(&pt1->lock);
728 pt1_set_stream(adap->pt1, adap->index, 0);
729 pt1_stop_polling(adap->pt1);
735 pt1_update_power(struct pt1 *pt1)
747 bits = pt1->power | !pt1->reset << 3;
748 mutex_lock(&pt1->lock);
750 adap = pt1->adaps[i];
765 pt1_write_reg(pt1, 1, bits);
766 mutex_unlock(&pt1->lock);
775 pt1_update_power(adap->pt1);
795 pt1_update_power(adap->pt1);
806 pt1_update_power(adap->pt1);
809 ret = config_demod(adap->demod_i2c_client, adap->pt1->fe_clk);
828 pt1_alloc_adapter(struct pt1 *pt1)
843 adap->pt1 = pt1;
862 &pt1->pdev->dev, adapter_nr);
900 static void pt1_cleanup_adapters(struct pt1 *pt1)
904 pt1_free_adapter(pt1->adaps[i]);
907 static int pt1_init_adapters(struct pt1 *pt1)
914 adap = pt1_alloc_adapter(pt1);
921 pt1->adaps[i] = adap;
927 pt1_free_adapter(pt1->adaps[i]);
958 static void pt1_cleanup_frontends(struct pt1 *pt1)
962 pt1_cleanup_frontend(pt1->adaps[i]);
965 static int pt1_init_frontends(struct pt1 *pt1)
980 cl = dvb_module_probe("tc90522", info->type, &pt1->i2c_adap,
984 pt1->adaps[i]->demod_i2c_client = cl;
1008 pt1->adaps[i]->tuner_i2c_client = cl;
1010 ret = pt1_init_frontend(pt1->adaps[i], dcfg.fe);
1015 ret = pt1_demod_block_init(pt1);
1022 dvb_module_release(pt1->adaps[i]->tuner_i2c_client);
1024 dvb_module_release(pt1->adaps[i]->demod_i2c_client);
1026 dev_warn(&pt1->pdev->dev, "failed to init FE(%d).\n", i);
1029 dvb_unregister_frontend(pt1->adaps[i]->fe);
1030 dvb_module_release(pt1->adaps[i]->tuner_i2c_client);
1031 dvb_module_release(pt1->adaps[i]->demod_i2c_client);
1036 static void pt1_i2c_emit(struct pt1 *pt1, int addr, int busy, int read_enable,
1039 pt1_write_reg(pt1, 4, addr << 18 | busy << 13 | read_enable << 12 |
1043 static void pt1_i2c_write_bit(struct pt1 *pt1, int addr, int *addrp, int data)
1045 pt1_i2c_emit(pt1, addr, 1, 0, 0, data, addr + 1);
1046 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, data, addr + 2);
1047 pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, data, addr + 3);
1051 static void pt1_i2c_read_bit(struct pt1 *pt1, int addr, int *addrp)
1053 pt1_i2c_emit(pt1, addr, 1, 0, 0, 1, addr + 1);
1054 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 1, addr + 2);
1055 pt1_i2c_emit(pt1, addr + 2, 1, 1, 1, 1, addr + 3);
1056 pt1_i2c_emit(pt1, addr + 3, 1, 0, 0, 1, addr + 4);
1060 static void pt1_i2c_write_byte(struct pt1 *pt1, int addr, int *addrp, int data)
1064 pt1_i2c_write_bit(pt1, addr, &addr, data >> (7 - i) & 1);
1065 pt1_i2c_write_bit(pt1, addr, &addr, 1);
1069 static void pt1_i2c_read_byte(struct pt1 *pt1, int addr, int *addrp, int last)
1073 pt1_i2c_read_bit(pt1, addr, &addr);
1074 pt1_i2c_write_bit(pt1, addr, &addr, last);
1078 static void pt1_i2c_prepare(struct pt1 *pt1, int addr, int *addrp)
1080 pt1_i2c_emit(pt1, addr, 1, 0, 1, 1, addr + 1);
1081 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
1082 pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, 0, addr + 3);
1087 pt1_i2c_write_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
1090 pt1_i2c_prepare(pt1, addr, &addr);
1091 pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1);
1093 pt1_i2c_write_byte(pt1, addr, &addr, msg->buf[i]);
1098 pt1_i2c_read_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
1101 pt1_i2c_prepare(pt1, addr, &addr);
1102 pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1 | 1);
1104 pt1_i2c_read_byte(pt1, addr, &addr, i == msg->len - 1);
1108 static int pt1_i2c_end(struct pt1 *pt1, int addr)
1110 pt1_i2c_emit(pt1, addr, 1, 0, 0, 0, addr + 1);
1111 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
1112 pt1_i2c_emit(pt1, addr + 2, 1, 0, 1, 1, 0);
1114 pt1_write_reg(pt1, 0, 0x00000004);
1119 } while (pt1_read_reg(pt1, 0) & 0x00000080);
1123 static void pt1_i2c_begin(struct pt1 *pt1, int *addrp)
1128 pt1_i2c_emit(pt1, addr, 0, 0, 1, 1, addr /* itself */);
1131 if (!pt1->i2c_running) {
1132 pt1_i2c_emit(pt1, addr, 1, 0, 1, 1, addr + 1);
1133 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
1135 pt1->i2c_running = 1;
1142 struct pt1 *pt1;
1149 pt1 = i2c_get_adapdata(adap);
1168 pt1_i2c_begin(pt1, &addr);
1169 pt1_i2c_write_msg(pt1, addr, &addr, msg);
1170 pt1_i2c_read_msg(pt1, addr, &addr, next_msg);
1171 ret = pt1_i2c_end(pt1, addr);
1175 word = pt1_read_reg(pt1, 2);
1181 pt1_i2c_begin(pt1, &addr);
1182 pt1_i2c_write_msg(pt1, addr, &addr, msg);
1183 ret = pt1_i2c_end(pt1, addr);
1202 static void pt1_i2c_wait(struct pt1 *pt1)
1206 pt1_i2c_emit(pt1, 0, 0, 0, 1, 1, 0);
1209 static void pt1_i2c_init(struct pt1 *pt1)
1213 pt1_i2c_emit(pt1, i, 0, 0, 1, 1, 0);
1220 struct pt1 *pt1 = dev_get_drvdata(dev);
1222 pt1_init_streams(pt1);
1223 pt1_disable_ram(pt1);
1224 pt1->power = 0;
1225 pt1->reset = 1;
1226 pt1_update_power(pt1);
1232 struct pt1 *pt1 = dev_get_drvdata(dev);
1236 pt1->power = 0;
1237 pt1->reset = 1;
1238 pt1_update_power(pt1);
1240 pt1_i2c_init(pt1);
1241 pt1_i2c_wait(pt1);
1243 ret = pt1_sync(pt1);
1247 pt1_identify(pt1);
1249 ret = pt1_unlock(pt1);
1253 ret = pt1_reset_pci(pt1);
1257 ret = pt1_reset_ram(pt1);
1261 ret = pt1_enable_ram(pt1);
1265 pt1_init_streams(pt1);
1267 pt1->power = 1;
1268 pt1_update_power(pt1);
1271 pt1->reset = 0;
1272 pt1_update_power(pt1);
1275 ret = pt1_demod_block_init(pt1);
1280 dvb_frontend_reinitialise(pt1->adaps[i]->fe);
1282 pt1_init_table_count(pt1);
1287 pt1->tables[i].bufs[j].page->upackets[PT1_NR_UPACKETS-1]
1289 pt1_increment_table_count(pt1);
1291 pt1_register_tables(pt1, pt1->tables[0].addr >> PT1_PAGE_SHIFT);
1293 pt1->table_index = 0;
1294 pt1->buf_index = 0;
1296 pt1->adaps[i]->upacket_count = 0;
1297 pt1->adaps[i]->packet_count = 0;
1298 pt1->adaps[i]->st_count = -1;
1304 dev_info(&pt1->pdev->dev, "failed to resume PT1/PT2.");
1312 struct pt1 *pt1;
1315 pt1 = pci_get_drvdata(pdev);
1316 regs = pt1->regs;
1318 if (pt1->kthread)
1319 kthread_stop(pt1->kthread);
1320 pt1_cleanup_tables(pt1);
1321 pt1_cleanup_frontends(pt1);
1322 pt1_disable_ram(pt1);
1323 pt1->power = 0;
1324 pt1->reset = 1;
1325 pt1_update_power(pt1);
1326 pt1_cleanup_adapters(pt1);
1327 i2c_del_adapter(&pt1->i2c_adap);
1328 kfree(pt1);
1338 struct pt1 *pt1;
1361 pt1 = kzalloc(sizeof(struct pt1), GFP_KERNEL);
1362 if (!pt1) {
1367 mutex_init(&pt1->lock);
1368 pt1->pdev = pdev;
1369 pt1->regs = regs;
1370 pt1->fe_clk = (pdev->device == 0x211a) ?
1372 pci_set_drvdata(pdev, pt1);
1374 ret = pt1_init_adapters(pt1);
1378 mutex_init(&pt1->lock);
1380 pt1->power = 0;
1381 pt1->reset = 1;
1382 pt1_update_power(pt1);
1384 i2c_adap = &pt1->i2c_adap;
1389 i2c_set_adapdata(i2c_adap, pt1);
1394 pt1_i2c_init(pt1);
1395 pt1_i2c_wait(pt1);
1397 ret = pt1_sync(pt1);
1401 pt1_identify(pt1);
1403 ret = pt1_unlock(pt1);
1407 ret = pt1_reset_pci(pt1);
1411 ret = pt1_reset_ram(pt1);
1415 ret = pt1_enable_ram(pt1);
1419 pt1_init_streams(pt1);
1421 pt1->power = 1;
1422 pt1_update_power(pt1);
1425 pt1->reset = 0;
1426 pt1_update_power(pt1);
1429 ret = pt1_init_frontends(pt1);
1433 ret = pt1_init_tables(pt1);
1440 pt1_cleanup_frontends(pt1);
1442 pt1_disable_ram(pt1);
1443 pt1->power = 0;
1444 pt1->reset = 1;
1445 pt1_update_power(pt1);
1449 pt1_cleanup_adapters(pt1);
1451 kfree(pt1);