OSDN -- オープンソース・ソフトウェアの開発とダウンロード
日本語の翻訳状況 translation status for ja
編集 | ページ一覧 |  最近の更新  | 

解析用ツール類

QEMU用のPT1エミュレータ部分を追加しました。
以下の機能があります。
I2C部分に関して0x10に書き込むと0x10以外に書き込む迄の１ブロックを
"/tmp/reg_all_%03d.data（ブロック番号）"として作成されます。

作成されたファイルの内容として、

FIFO COUNT(082:88)
0000: 0000 0000 2002 0000 2403 0000 2c04 0000
0010: 2c05 0000 2406 0000 2c07 0000 2c08 0000
0020: 2409 0000 2c0a 0000 280b 0000 200c 0000

と作成されます。

FIFO COUNTが何ブロック目かと最大アドレスとなります。
表示された内容として、
PCIのwriteされた上位16ビットをアドレスとし、値が下位16ビットとなります。

例えば
0000: 0000 0000 2002 0000 2403 0000 2004 0000
の場合、
00000000
00042002
00082002
000C2002
とかかれた事になります。

/tmp/isdb-sにファイルを作成した場合 ISDB-Sのチャネルスキャンで正常な値が返る様になります。

:

pt1.c
  1.  /*
  2.   */
  3.  #include "hw.h"
  4.  #include "pci.h"
  5.  #include "pc.h"
  6.  
  7.  #define DEBUG_PT1
  8.  
  9.  /* lspci -xxx の結果
  10.  Multimedia controller: Xilinx Corporation Device 211a (rev 01)
  11.  00: ee 10 1a 21 06 00 00 02 01 00 80 04 00 20 00 00
  12.  10: 00 c0 5f fd 00 00 00 00 00 00 00 00 00 00 00 00
  13.  20: 00 00 00 00 00 00 00 00 00 00 00 00 11 ef e5 de
  14.  30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  15.  40: 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00
  16.  50: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  17.  60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  18.  70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  19.  80: ee 10 1a 21 06 00 00 02 01 00 80 04 00 20 00 00
  20.  90: 00 c0 5f fd 00 00 00 00 00 00 00 00 00 00 00 00
  21.  a0: 00 00 00 00 00 00 00 00 00 00 00 00 11 ef e5 de
  22.  b0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  23.  c0: 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00
  24.  d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  25.  e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  26.  f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  27.   */
  28.  
  29.  // lspci結果の情報
  30.  char    pci_copy [256] = {
  31.   0xee ,0x10 ,0x1a ,0x21 ,0x06 ,0x00 ,0x00 ,0x02 ,0x01 ,0x00 ,0x80 ,0x04 ,0x00 ,0x20 ,0x00 ,0x00
  32.   ,0x00 ,0xc0 ,0x5f ,0xfd ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  33.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x11 ,0xef ,0xe5 ,0xde
  34.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  35.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x01 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  36.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  37.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  38.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  39.   ,0xee ,0x10 ,0x1a ,0x21 ,0x06 ,0x00 ,0x00 ,0x02 ,0x01 ,0x00 ,0x80 ,0x04 ,0x00 ,0x20 ,0x00 ,0x00
  40.   ,0x00 ,0xc0 ,0x5f ,0xfd ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  41.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x11 ,0xef ,0xe5 ,0xde
  42.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  43.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x01 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  44.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  45.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  46.   ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
  47.  
  48.  };
  49.  /* PCI PT1 definitions */
  50.  
  51.  /***********************************************************/
  52.  static          FILE    *fp = NULL;                                     // FIFOに書いたデータ
  53.  typedef struct PT1State {
  54.      PCIDevice dev;
  55.      char        buf[(1024 * 4)];
  56.          int     mmio_index ;
  57.          uint32_t        region[3];
  58.  }PT1State;
  59.  
  60.  uint16_t        fifo_data[(64 * 1024)];                         // FIFOに書くもの
  61.  static          int             fifo_max_addr = 0 ;                     // FIFOに書いた最大アドレス
  62.  static          int             reg_count = 0 ;                         // Scan時に書いた個数
  63.  static          int             reg_pos_count = 0 ;                     // FIFOに書いた個数
  64.  static          int             fifo_write_count = 1 ;          // FIFOに書いて実行した個数
  65.  
  66.  typedef struct PCIPT1State {
  67.      PCIDevice dev;
  68.          PT1State state ;
  69.  } PCIPT1State;
  70.  /***********************************************************/
  71.          void            DumpWords(FILE *fp, int reg_pos_count)
  72.  {
  73.          int             lp ;
  74.  
  75.          if(fp == NULL){
  76.                  return ;
  77.          }
  78.          fprintf(fp, "\n========= FIFO COUNT(%03d:%d) =========\n", fifo_write_count,
  79.                          reg_pos_count);
  80.          // 初期化時のバカ避け
  81.          if(fifo_max_addr >= 1024){
  82.                  fifo_max_addr = 256 ;
  83.          }
  84.          for(lp = 0 ; lp < (fifo_max_addr / 2) ; lp++){
  85.                  if((lp) && (!(lp % 8))){
  86.                          fprintf(fp, "\n");
  87.                  }
  88.                  if((!(lp % 8))){
  89.                          fprintf(fp, "%04x: ", (lp * 2));
  90.                  }
  91.                  fprintf(fp, "%04x ", fifo_data[lp]);
  92.          }
  93.          fflush(fp);
  94.          fifo_write_count += 1 ;
  95.  }
  96.  static void pt1_save(QEMUFile* f,void* opaque)
  97.  {
  98.      printf("%s: \n", __FUNCTION__);
  99.  }
  100.  
  101.  static int pt1_load(QEMUFile* f,void* opaque,int version_id)
  102.  {
  103.      printf("%s: \n", __FUNCTION__);
  104.          return 0;
  105.  }
  106.  
  107.  /***********************************************************/
  108.  static void PT1pci_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
  109.  {
  110.      PT1State *s = opaque;
  111.      addr -= s->region[0];
  112.      printf("%s: addr=%08lx value=%lx\n", __FUNCTION__, addr, val);
  113.  }
  114.  
  115.  static void PT1pci_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
  116.  {
  117.      PT1State *s = opaque;
  118.      addr -= s->region[0];
  119.      printf("%s: addr=%08lx value=%lx\n", __FUNCTION__, addr, val);
  120.  }
  121.  
  122.  static void PT1pci_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
  123.  {
  124.      PT1State *s = opaque;
  125.          static  int                     rc = 0;
  126.          static  int                     fifo_cnt = 0;
  127.          uint32_t        *ptr = (uint32_t *)s->buf ;
  128.          char            fname[256];
  129.          union{
  130.                  struct {
  131.                          uint16_t        value ;
  132.                          uint16_t        offset ;
  133.                  }ui;
  134.                  uint32_t value ;
  135.          }ui;
  136.  
  137.      addr -= s->region[0];
  138.  
  139.          if(addr == 0x10){
  140.                  if(fp == NULL){
  141.                          memset(fname, '\0', sizeof(fname));
  142.                          sprintf(fname, "/tmp/reg_all_%03d.data", fifo_write_count);
  143.                          fp = fopen(fname, "w+");
  144.                          fifo_max_addr = 0 ;
  145.                  }
  146.                  //オフセットを求める。
  147.                  reg_pos_count += 1 ;
  148.                  ui.value = val;
  149.                  if(fifo_data[(ui.ui.offset / 2)] != ui.ui.value){
  150.                          if(fp != NULL){
  151.                                  fprintf(fp, "Addr:%04x Change %04x To %04x\n",
  152.                                          ui.ui.offset, fifo_data[(ui.ui.offset / 2)], ui.ui.value);
  153.                          }
  154.                          fifo_data[(ui.ui.offset / 2)] = ui.ui.value ;
  155.                  }
  156.                  if(fifo_max_addr < ui.ui.offset){
  157.                          fifo_max_addr = ui.ui.offset;
  158.                  }
  159.          }else{
  160.                  if(reg_pos_count){
  161.                          DumpWords(fp, reg_pos_count);
  162.                          fclose(fp);
  163.                          fp = NULL ;
  164.                  }
  165.                  reg_pos_count = 0 ;
  166.                  printf("%s: addr=%08lx value=%lx\n", __FUNCTION__, addr, val);
  167.          }
  168.  
  169.          if(access("/tmp/isdb-s", 0) == F_OK){
  170.                  if(rc == 0){
  171.                          if(fp != NULL){
  172.                                  fprintf(fp, "Scan Channels\n");
  173.                          }
  174.                          rc += 1 ;
  175.                  }
  176.                  if(addr != 0x10){
  177.                          reg_count += 1 ;
  178.                  }
  179.          }
  180.          ptr[(addr % sizeof(uint32_t))] = val ;
  181.  //    printf("%s: addr=%08lx value=%lx\n", __FUNCTION__, addr, val);
  182.  }
  183.  
  184.  static uint32_t PT1pci_mmio_readb(void *opaque, target_phys_addr_t addr)
  185.  {
  186.      PT1State *s = opaque;
  187.      addr -= s->region[0];
  188.      printf("%s: addr=%08lx \n", __FUNCTION__, addr);
  189.          return 0 ;
  190.  }
  191.  
  192.  static uint32_t PT1pci_mmio_readw(void *opaque, target_phys_addr_t addr)
  193.  {
  194.      PT1State *s = opaque;
  195.      addr -= s->region[0];
  196.      printf("%s: addr=%08lx \n", __FUNCTION__, addr);
  197.  
  198.          return 0 ;
  199.  }
  200.  
  201.  static uint32_t PT1pci_mmio_readl(void *opaque, target_phys_addr_t addr)
  202.  {
  203.          static  uint32_t        rc = 0;
  204.          static          int             f_f_f = 0;
  205.          static          int             f = 0;
  206.  #define         MAX_CNT         16
  207.          static  uint32_t        rc_rec[MAX_CNT] ={
  208.                  // LOCK      TMCCのはず。正常な値って何？
  209.                  0xff414100, 0xe0208871, 0x40024001,
  210.                  //                      ↑ここの値が判らない。TMCCのリトライ時に取る値
  211.                  // TSID        TSID        TSID       TSID
  212.                  0x40024001, 0xFFFFFFFF, 0XFFFFFFFF, 0xFFFFFFFF,
  213.                  // CN?      CN?         AGC(下8BIT)
  214.                  0x00110022, 0x00330044, 0x00000066,
  215.                  // 各TS情報
  216.                  // 取得したTSID
  217.                  //       Mode Slot
  218.                  //        上位2バイト：モード
  219.                  //                      高層モード、低層モード
  220.                  //        下位2バイト：スロット数
  221.                  //                      高層モード、低層モード
  222.                  0x4002, 0x0403110D,
  223.                  0x4001, 0x0403110D,
  224.                  // ここがクロック周波数誤差とキャリア周波数誤差？
  225.                  // 正常な値が判らない
  226.                  10, 11
  227.  };
  228.  
  229.      PT1State *s = opaque;
  230.          uint32_t        *ptr = (uint32_t *)s->buf ;
  231.  
  232.      addr -= s->region[0];
  233.          if(access("/tmp/isdb-s", 0) == F_OK){
  234.                  printf("Scan Channels\n");
  235.                  if(addr == 0x08){
  236.                          printf("Data ?(%d)\n", f_f_f);
  237.                          rc = rc_rec[(f_f_f % MAX_CNT)] ;
  238.                          if(!(f_f_f % MAX_CNT)){
  239.                                  if(fp != NULL){
  240.                                          fprintf(fp, "Line Scan Start\n");
  241.                                  }
  242.                          }
  243.                          f_f_f += 1 ;
  244.                  }else{
  245.                          rc = 0x00000041;
  246.                  }
  247.          }else{
  248.                  if(ptr[(addr % sizeof(uint32_t))] == 0){
  249.                          rc = 0x20;
  250.                  }else if(ptr[(addr % sizeof(uint32_t))] == 0x08){
  251.                          rc = 0x80000020;
  252.                  }else if(ptr[(addr % sizeof(uint32_t))] == 0x1000000){
  253.                          rc = 0x80000021;
  254.                  }else if(ptr[(addr % sizeof(uint32_t))] == 0x2000000){
  255.                          rc = 0x80000023;
  256.                  }else if(ptr[(addr % sizeof(uint32_t))] == 0x02){
  257.                          if(f != 0){
  258.                                  rc = 0x80000027;
  259.                                  f = 0 ;
  260.                          }else{
  261.                                  f += 1 ;
  262.                                  rc = 0x80000023;
  263.                          }
  264.                  }else{
  265.                          if(addr == 8){
  266.                                  rc = 0x00000041;
  267.                                  f = 0 ;
  268.                          }
  269.                  }
  270.          }
  271.          return rc;
  272.  }
  273.  /***********************************************************/
  274.  static CPUWriteMemoryFunc *pt1_pci_mmio_write[] = {
  275.      PT1pci_mmio_writeb,
  276.      PT1pci_mmio_writew,
  277.      PT1pci_mmio_writel
  278.  };
  279.  static CPUWriteMemoryFunc *pt1_pci_mmio_read[] = {
  280.      PT1pci_mmio_readb,
  281.      PT1pci_mmio_readw,
  282.      PT1pci_mmio_readl
  283.  };
  284.  /***********************************************************/
  285.  
  286.  static void pt1_map(PCIDevice *pci_dev, int region_num,
  287.                         uint32_t addr, uint32_t size, int type)
  288.  {
  289.          PCIPT1State *d = (PCIPT1State *) pci_dev;
  290.      uint8_t *pci_conf;
  291.          int             lp ;
  292.  
  293.      printf("pt1_map: region_num=%d addr=%x size = %d  type=%d\n",
  294.                          region_num, addr, size, type);
  295.  
  296.      pci_conf = d->dev.config;
  297.  
  298.          // Dump PCI Config
  299.          printf(" Dump PCI Config\n");
  300.          printf("00: ");
  301.          for(lp = 0 ; lp < 64 ; lp++){
  302.                  if((!(lp % 16)) && (lp > 0)){
  303.                          printf("\n");
  304.                          printf("%02x: ", lp);
  305.                  }
  306.                  printf("%02x ", pci_conf[lp]);
  307.          }
  308.          printf("\n");
  309.          if(region_num == 0) {
  310.                  cpu_register_physical_memory(addr, size, d->state.mmio_index);
  311.                  d->state.region[region_num] = addr;
  312.          }
  313.  }
  314.  
  315.  void pci_pt1_init(PCIBus *bus, int devfn)
  316.  {
  317.      PCIPT1State *d;
  318.          PT1State        *s ;
  319.      uint8_t *pci_conf;
  320.          printf("pci_pt1_init: Start\n");
  321.  
  322.      d = (PCIPT1State *)pci_register_device(bus,
  323.                                                "PT1_DEV", sizeof(PCIPT1State),
  324.                                                devfn,
  325.                                                NULL, NULL);
  326.          printf("pci_pt1_init: pci_register_device End\n");
  327.      pci_conf = d->dev.config;
  328.  
  329.          memcpy(pci_conf, pci_copy, 256);
  330.  
  331.          s = &d->state;
  332.          printf("pci_pt1_init: cpu_register_io_memory Start\n");
  333.      d->state.mmio_index =
  334.                  cpu_register_io_memory(0, pt1_pci_mmio_read, pt1_pci_mmio_write,s);
  335.  
  336.          printf("pci_pt1_init: cpu_register_io_memory\n");
  337.      pci_register_io_region(&d->dev, 0, 0x1000,
  338.                             PCI_ADDRESS_SPACE_MEM, pt1_map);
  339.          printf("pci_pt1_init: pci_register_io_region\n");
  340.  /*
  341.      s = &d->pt1;
  342.      s->irq = d->dev.irq[0];
  343.      s->pci_dev = (PCIDevice *)d;
  344.      pt1_reset(s);
  345.   */
  346.      register_savevm("pt1", 0, 3, pt1_save, pt1_load, d);
  347.          printf("pci_pt1_init: End\n");
  348.  }

編集 履歴 削除
設定

[ページ情報]  更新日時: 2008-12-10 23:20:38, 更新者: tomy
[権限]  表示:無制限, 編集:無制限, 削除/設定:ログインユーザ
[IRI]  https://ja.osdn.net/projects/pt1dvr/wiki/tools