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)
339 id |= (u64)(pt1_read_reg(pt1, 0) >> 30 & 1) << i;
340 pt1_write_reg(pt1, 0, 0x00000008);
345 static int pt1_unlock(struct pt1 *pt1)
348 pt1_write_reg(pt1, 0, 0x00000008);
350 if (pt1_read_reg(pt1, 0) & 0x80000000)
354 dev_err(&pt1->pdev->dev, "could not unlock\n");
358 static int pt1_reset_pci(struct pt1 *pt1)
361 pt1_write_reg(pt1, 0, 0x01010000);
362 pt1_write_reg(pt1, 0, 0x01000000);
364 if (pt1_read_reg(pt1, 0) & 0x00000001)
368 dev_err(&pt1->pdev->dev, "could not reset PCI\n");
372 static int pt1_reset_ram(struct pt1 *pt1)
375 pt1_write_reg(pt1, 0, 0x02020000);
376 pt1_write_reg(pt1, 0, 0x02000000);
378 if (pt1_read_reg(pt1, 0) & 0x00000002)
382 dev_err(&pt1->pdev->dev, "could not reset RAM\n");
386 static int pt1_do_enable_ram(struct pt1 *pt1)
390 status = pt1_read_reg(pt1, 0) & 0x00000004;
391 pt1_write_reg(pt1, 0, 0x00000002);
394 if ((pt1_read_reg(pt1, 0) & 0x00000004) != status)
399 dev_err(&pt1->pdev->dev, "could not enable RAM\n");
403 static int pt1_enable_ram(struct pt1 *pt1)
408 phase = pt1->pdev->device == 0x211a ? 128 : 166;
410 ret = pt1_do_enable_ram(pt1);
417 static void pt1_disable_ram(struct pt1 *pt1)
419 pt1_write_reg(pt1, 0, 0x0b0b0000);
422 static void pt1_set_stream(struct pt1 *pt1, int index, int enabled)
424 pt1_write_reg(pt1, 2, 1 << (index + 8) | enabled << index);
427 static void pt1_init_streams(struct pt1 *pt1)
431 pt1_set_stream(pt1, i, 0);
434 static int pt1_filter(struct pt1 *pt1, struct pt1_buffer_page *page)
453 adap = pt1->adaps[index];
460 printk_ratelimited(KERN_INFO "earth-pt1: device buffer overflowing. table[%d] buf[%d]\n",
461 pt1->table_index, pt1->buf_index);
464 printk_ratelimited(KERN_INFO "earth-pt1: data loss in streamID(adapter)[%d]\n",
490 struct pt1 *pt1;
497 pt1 = data;
505 pt1_set_stream(pt1, i, !!pt1->adaps[i]->users);
508 page = pt1->tables[pt1->table_index].bufs[pt1->buf_index].page;
509 if (!pt1_filter(pt1, page)) {
520 if (++pt1->buf_index >= PT1_NR_BUFS) {
521 pt1_increment_table_count(pt1);
522 pt1->buf_index = 0;
523 if (++pt1->table_index >= pt1_nr_tables)
524 pt1->table_index = 0;
531 static void pt1_free_page(struct pt1 *pt1, void *page, dma_addr_t addr)
533 dma_free_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, page, addr);
536 static void *pt1_alloc_page(struct pt1 *pt1, dma_addr_t *addrp, u32 *pfnp)
541 page = dma_alloc_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, &addr,
554 static void pt1_cleanup_buffer(struct pt1 *pt1, struct pt1_buffer *buf)
556 pt1_free_page(pt1, buf->page, buf->addr);
560 pt1_init_buffer(struct pt1 *pt1, struct pt1_buffer *buf, u32 *pfnp)
565 page = pt1_alloc_page(pt1, &addr, pfnp);
576 static void pt1_cleanup_table(struct pt1 *pt1, struct pt1_table *table)
581 pt1_cleanup_buffer(pt1, &table->bufs[i]);
583 pt1_free_page(pt1, table->page, table->addr);
587 pt1_init_table(struct pt1 *pt1, struct pt1_table *table, u32 *pfnp)
594 page = pt1_alloc_page(pt1, &addr, pfnp);
599 ret = pt1_init_buffer(pt1, &table->bufs[i], &buf_pfn);
606 pt1_increment_table_count(pt1);
613 pt1_cleanup_buffer(pt1, &table->bufs[i]);
615 pt1_free_page(pt1, page, addr);
619 static void pt1_cleanup_tables(struct pt1 *pt1)
624 tables = pt1->tables;
625 pt1_unregister_tables(pt1);
628 pt1_cleanup_table(pt1, &tables[i]);
633 static int pt1_init_tables(struct pt1 *pt1)
646 pt1_init_table_count(pt1);
649 ret = pt1_init_table(pt1, &tables[0], &first_pfn);
655 ret = pt1_init_table(pt1, &tables[i], &pfn);
664 pt1_register_tables(pt1, first_pfn);
665 pt1->tables = tables;
670 pt1_cleanup_table(pt1, &tables[i]);
676 static int pt1_start_polling(struct pt1 *pt1)
680 mutex_lock(&pt1->lock);
681 if (!pt1->kthread) {
682 pt1->kthread = kthread_run(pt1_thread, pt1, "earth-pt1");
683 if (IS_ERR(pt1->kthread)) {
684 ret = PTR_ERR(pt1->kthread);
685 pt1->kthread = NULL;
688 mutex_unlock(&pt1->lock);
699 ret = pt1_start_polling(adap->pt1);
702 pt1_set_stream(adap->pt1, adap->index, 1);
707 static void pt1_stop_polling(struct pt1 *pt1)
711 mutex_lock(&pt1->lock);
713 count += pt1->adaps[i]->users;
715 if (count == 0 && pt1->kthread) {
716 kthread_stop(pt1->kthread);
717 pt1->kthread = NULL;
719 mutex_unlock(&pt1->lock);
727 pt1_set_stream(adap->pt1, adap->index, 0);
728 pt1_stop_polling(adap->pt1);
734 pt1_update_power(struct pt1 *pt1)
746 bits = pt1->power | !pt1->reset << 3;
747 mutex_lock(&pt1->lock);
749 adap = pt1->adaps[i];
764 pt1_write_reg(pt1, 1, bits);
765 mutex_unlock(&pt1->lock);
774 pt1_update_power(adap->pt1);
794 pt1_update_power(adap->pt1);
805 pt1_update_power(adap->pt1);
808 ret = config_demod(adap->demod_i2c_client, adap->pt1->fe_clk);
827 pt1_alloc_adapter(struct pt1 *pt1)
842 adap->pt1 = pt1;
861 &pt1->pdev->dev, adapter_nr);
899 static void pt1_cleanup_adapters(struct pt1 *pt1)
903 pt1_free_adapter(pt1->adaps[i]);
906 static int pt1_init_adapters(struct pt1 *pt1)
913 adap = pt1_alloc_adapter(pt1);
920 pt1->adaps[i] = adap;
926 pt1_free_adapter(pt1->adaps[i]);
957 static void pt1_cleanup_frontends(struct pt1 *pt1)
961 pt1_cleanup_frontend(pt1->adaps[i]);
964 static int pt1_init_frontends(struct pt1 *pt1)
979 cl = dvb_module_probe("tc90522", info->type, &pt1->i2c_adap,
983 pt1->adaps[i]->demod_i2c_client = cl;
1007 pt1->adaps[i]->tuner_i2c_client = cl;
1009 ret = pt1_init_frontend(pt1->adaps[i], dcfg.fe);
1014 ret = pt1_demod_block_init(pt1);
1021 dvb_module_release(pt1->adaps[i]->tuner_i2c_client);
1023 dvb_module_release(pt1->adaps[i]->demod_i2c_client);
1025 dev_warn(&pt1->pdev->dev, "failed to init FE(%d).\n", i);
1028 dvb_unregister_frontend(pt1->adaps[i]->fe);
1029 dvb_module_release(pt1->adaps[i]->tuner_i2c_client);
1030 dvb_module_release(pt1->adaps[i]->demod_i2c_client);
1035 static void pt1_i2c_emit(struct pt1 *pt1, int addr, int busy, int read_enable,
1038 pt1_write_reg(pt1, 4, addr << 18 | busy << 13 | read_enable << 12 |
1042 static void pt1_i2c_write_bit(struct pt1 *pt1, int addr, int *addrp, int data)
1044 pt1_i2c_emit(pt1, addr, 1, 0, 0, data, addr + 1);
1045 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, data, addr + 2);
1046 pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, data, addr + 3);
1050 static void pt1_i2c_read_bit(struct pt1 *pt1, int addr, int *addrp)
1052 pt1_i2c_emit(pt1, addr, 1, 0, 0, 1, addr + 1);
1053 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 1, addr + 2);
1054 pt1_i2c_emit(pt1, addr + 2, 1, 1, 1, 1, addr + 3);
1055 pt1_i2c_emit(pt1, addr + 3, 1, 0, 0, 1, addr + 4);
1059 static void pt1_i2c_write_byte(struct pt1 *pt1, int addr, int *addrp, int data)
1063 pt1_i2c_write_bit(pt1, addr, &addr, data >> (7 - i) & 1);
1064 pt1_i2c_write_bit(pt1, addr, &addr, 1);
1068 static void pt1_i2c_read_byte(struct pt1 *pt1, int addr, int *addrp, int last)
1072 pt1_i2c_read_bit(pt1, addr, &addr);
1073 pt1_i2c_write_bit(pt1, addr, &addr, last);
1077 static void pt1_i2c_prepare(struct pt1 *pt1, int addr, int *addrp)
1079 pt1_i2c_emit(pt1, addr, 1, 0, 1, 1, addr + 1);
1080 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
1081 pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, 0, addr + 3);
1086 pt1_i2c_write_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
1089 pt1_i2c_prepare(pt1, addr, &addr);
1090 pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1);
1092 pt1_i2c_write_byte(pt1, addr, &addr, msg->buf[i]);
1097 pt1_i2c_read_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
1100 pt1_i2c_prepare(pt1, addr, &addr);
1101 pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1 | 1);
1103 pt1_i2c_read_byte(pt1, addr, &addr, i == msg->len - 1);
1107 static int pt1_i2c_end(struct pt1 *pt1, int addr)
1109 pt1_i2c_emit(pt1, addr, 1, 0, 0, 0, addr + 1);
1110 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
1111 pt1_i2c_emit(pt1, addr + 2, 1, 0, 1, 1, 0);
1113 pt1_write_reg(pt1, 0, 0x00000004);
1118 } while (pt1_read_reg(pt1, 0) & 0x00000080);
1122 static void pt1_i2c_begin(struct pt1 *pt1, int *addrp)
1126 pt1_i2c_emit(pt1, addr, 0, 0, 1, 1, addr /* itself */);
1129 if (!pt1->i2c_running) {
1130 pt1_i2c_emit(pt1, addr, 1, 0, 1, 1, addr + 1);
1131 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
1133 pt1->i2c_running = 1;
1140 struct pt1 *pt1;
1147 pt1 = i2c_get_adapdata(adap);
1166 pt1_i2c_begin(pt1, &addr);
1167 pt1_i2c_write_msg(pt1, addr, &addr, msg);
1168 pt1_i2c_read_msg(pt1, addr, &addr, next_msg);
1169 ret = pt1_i2c_end(pt1, addr);
1173 word = pt1_read_reg(pt1, 2);
1179 pt1_i2c_begin(pt1, &addr);
1180 pt1_i2c_write_msg(pt1, addr, &addr, msg);
1181 ret = pt1_i2c_end(pt1, addr);
1200 static void pt1_i2c_wait(struct pt1 *pt1)
1204 pt1_i2c_emit(pt1, 0, 0, 0, 1, 1, 0);
1207 static void pt1_i2c_init(struct pt1 *pt1)
1211 pt1_i2c_emit(pt1, i, 0, 0, 1, 1, 0);
1218 struct pt1 *pt1 = dev_get_drvdata(dev);
1220 pt1_init_streams(pt1);
1221 pt1_disable_ram(pt1);
1222 pt1->power = 0;
1223 pt1->reset = 1;
1224 pt1_update_power(pt1);
1230 struct pt1 *pt1 = dev_get_drvdata(dev);
1234 pt1->power = 0;
1235 pt1->reset = 1;
1236 pt1_update_power(pt1);
1238 pt1_i2c_init(pt1);
1239 pt1_i2c_wait(pt1);
1241 ret = pt1_sync(pt1);
1245 pt1_identify(pt1);
1247 ret = pt1_unlock(pt1);
1251 ret = pt1_reset_pci(pt1);
1255 ret = pt1_reset_ram(pt1);
1259 ret = pt1_enable_ram(pt1);
1263 pt1_init_streams(pt1);
1265 pt1->power = 1;
1266 pt1_update_power(pt1);
1269 pt1->reset = 0;
1270 pt1_update_power(pt1);
1273 ret = pt1_demod_block_init(pt1);
1278 dvb_frontend_reinitialise(pt1->adaps[i]->fe);
1280 pt1_init_table_count(pt1);
1285 pt1->tables[i].bufs[j].page->upackets[PT1_NR_UPACKETS-1]
1287 pt1_increment_table_count(pt1);
1289 pt1_register_tables(pt1, pt1->tables[0].addr >> PT1_PAGE_SHIFT);
1291 pt1->table_index = 0;
1292 pt1->buf_index = 0;
1294 pt1->adaps[i]->upacket_count = 0;
1295 pt1->adaps[i]->packet_count = 0;
1296 pt1->adaps[i]->st_count = -1;
1302 dev_info(&pt1->pdev->dev, "failed to resume PT1/PT2.");
1310 struct pt1 *pt1;
1313 pt1 = pci_get_drvdata(pdev);
1314 regs = pt1->regs;
1316 if (pt1->kthread)
1317 kthread_stop(pt1->kthread);
1318 pt1_cleanup_tables(pt1);
1319 pt1_cleanup_frontends(pt1);
1320 pt1_disable_ram(pt1);
1321 pt1->power = 0;
1322 pt1->reset = 1;
1323 pt1_update_power(pt1);
1324 pt1_cleanup_adapters(pt1);
1325 i2c_del_adapter(&pt1->i2c_adap);
1326 kfree(pt1);
1336 struct pt1 *pt1;
1359 pt1 = kzalloc(sizeof(struct pt1), GFP_KERNEL);
1360 if (!pt1) {
1365 mutex_init(&pt1->lock);
1366 pt1->pdev = pdev;
1367 pt1->regs = regs;
1368 pt1->fe_clk = (pdev->device == 0x211a) ?
1370 pci_set_drvdata(pdev, pt1);
1372 ret = pt1_init_adapters(pt1);
1376 mutex_init(&pt1->lock);
1378 pt1->power = 0;
1379 pt1->reset = 1;
1380 pt1_update_power(pt1);
1382 i2c_adap = &pt1->i2c_adap;
1387 i2c_set_adapdata(i2c_adap, pt1);
1392 pt1_i2c_init(pt1);
1393 pt1_i2c_wait(pt1);
1395 ret = pt1_sync(pt1);
1399 pt1_identify(pt1);
1401 ret = pt1_unlock(pt1);
1405 ret = pt1_reset_pci(pt1);
1409 ret = pt1_reset_ram(pt1);
1413 ret = pt1_enable_ram(pt1);
1417 pt1_init_streams(pt1);
1419 pt1->power = 1;
1420 pt1_update_power(pt1);
1423 pt1->reset = 0;
1424 pt1_update_power(pt1);
1427 ret = pt1_init_frontends(pt1);
1431 ret = pt1_init_tables(pt1);
1438 pt1_cleanup_frontends(pt1);
1440 pt1_disable_ram(pt1);
1441 pt1->power = 0;
1442 pt1->reset = 1;
1443 pt1_update_power(pt1);
1447 pt1_cleanup_adapters(pt1);
1449 kfree(pt1);