Diff for /qemu/hw/parallel.c between versions 1.1.1.9 and 1.1.1.10

version 1.1.1.9, 2018/04/24 19:00:12 version 1.1.1.10, 2018/04/24 19:27:52
Line 120  parallel_ioport_write_sw(void *opaque, u Line 120  parallel_ioport_write_sw(void *opaque, u
             if (val & PARA_CTR_STROBE) {              if (val & PARA_CTR_STROBE) {
                 s->status &= ~PARA_STS_BUSY;                  s->status &= ~PARA_STS_BUSY;
                 if ((s->control & PARA_CTR_STROBE) == 0)                  if ((s->control & PARA_CTR_STROBE) == 0)
                     qemu_chr_write(s->chr, &s->dataw, 1);                      qemu_chr_fe_write(s->chr, &s->dataw, 1);
             } else {              } else {
                 if (s->control & PARA_CTR_INTEN) {                  if (s->control & PARA_CTR_INTEN) {
                     s->irq_pending = 1;                      s->irq_pending = 1;
Line 150  static void parallel_ioport_write_hw(voi Line 150  static void parallel_ioport_write_hw(voi
         if (s->dataw == val)          if (s->dataw == val)
             return;              return;
         pdebug("wd%02x\n", val);          pdebug("wd%02x\n", val);
         qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_WRITE_DATA, &parm);          qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_WRITE_DATA, &parm);
         s->dataw = val;          s->dataw = val;
         break;          break;
     case PARA_REG_STS:      case PARA_REG_STS:
Line 170  static void parallel_ioport_write_hw(voi Line 170  static void parallel_ioport_write_hw(voi
             } else {              } else {
                 dir = 0;                  dir = 0;
             }              }
             qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_DATA_DIR, &dir);              qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_DATA_DIR, &dir);
             parm &= ~PARA_CTR_DIR;              parm &= ~PARA_CTR_DIR;
         }          }
   
         qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_WRITE_CONTROL, &parm);          qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_WRITE_CONTROL, &parm);
         s->control = val;          s->control = val;
         break;          break;
     case PARA_REG_EPP_ADDR:      case PARA_REG_EPP_ADDR:
Line 183  static void parallel_ioport_write_hw(voi Line 183  static void parallel_ioport_write_hw(voi
             pdebug("wa%02x s\n", val);              pdebug("wa%02x s\n", val);
         else {          else {
             struct ParallelIOArg ioarg = { .buffer = &parm, .count = 1 };              struct ParallelIOArg ioarg = { .buffer = &parm, .count = 1 };
             if (qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE_ADDR, &ioarg)) {              if (qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE_ADDR, &ioarg)) {
                 s->epp_timeout = 1;                  s->epp_timeout = 1;
                 pdebug("wa%02x t\n", val);                  pdebug("wa%02x t\n", val);
             }              }
Line 197  static void parallel_ioport_write_hw(voi Line 197  static void parallel_ioport_write_hw(voi
             pdebug("we%02x s\n", val);              pdebug("we%02x s\n", val);
         else {          else {
             struct ParallelIOArg ioarg = { .buffer = &parm, .count = 1 };              struct ParallelIOArg ioarg = { .buffer = &parm, .count = 1 };
             if (qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE, &ioarg)) {              if (qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE, &ioarg)) {
                 s->epp_timeout = 1;                  s->epp_timeout = 1;
                 pdebug("we%02x t\n", val);                  pdebug("we%02x t\n", val);
             }              }
Line 222  parallel_ioport_eppdata_write_hw2(void * Line 222  parallel_ioport_eppdata_write_hw2(void *
         pdebug("we%04x s\n", val);          pdebug("we%04x s\n", val);
         return;          return;
     }      }
     err = qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE, &ioarg);      err = qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE, &ioarg);
     if (err) {      if (err) {
         s->epp_timeout = 1;          s->epp_timeout = 1;
         pdebug("we%04x t\n", val);          pdebug("we%04x t\n", val);
Line 245  parallel_ioport_eppdata_write_hw4(void * Line 245  parallel_ioport_eppdata_write_hw4(void *
         pdebug("we%08x s\n", val);          pdebug("we%08x s\n", val);
         return;          return;
     }      }
     err = qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE, &ioarg);      err = qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_WRITE, &ioarg);
     if (err) {      if (err) {
         s->epp_timeout = 1;          s->epp_timeout = 1;
         pdebug("we%08x t\n", val);          pdebug("we%08x t\n", val);
Line 297  static uint32_t parallel_ioport_read_hw( Line 297  static uint32_t parallel_ioport_read_hw(
     addr &= 7;      addr &= 7;
     switch(addr) {      switch(addr) {
     case PARA_REG_DATA:      case PARA_REG_DATA:
         qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_READ_DATA, &ret);          qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_READ_DATA, &ret);
         if (s->last_read_offset != addr || s->datar != ret)          if (s->last_read_offset != addr || s->datar != ret)
             pdebug("rd%02x\n", ret);              pdebug("rd%02x\n", ret);
         s->datar = ret;          s->datar = ret;
         break;          break;
     case PARA_REG_STS:      case PARA_REG_STS:
         qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_READ_STATUS, &ret);          qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_READ_STATUS, &ret);
         ret &= ~PARA_STS_TMOUT;          ret &= ~PARA_STS_TMOUT;
         if (s->epp_timeout)          if (s->epp_timeout)
             ret |= PARA_STS_TMOUT;              ret |= PARA_STS_TMOUT;
Line 315  static uint32_t parallel_ioport_read_hw( Line 315  static uint32_t parallel_ioport_read_hw(
         /* s->control has some bits fixed to 1. It is zero only when          /* s->control has some bits fixed to 1. It is zero only when
            it has not been yet written to.  */             it has not been yet written to.  */
         if (s->control == 0) {          if (s->control == 0) {
             qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_READ_CONTROL, &ret);              qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_READ_CONTROL, &ret);
             if (s->last_read_offset != addr)              if (s->last_read_offset != addr)
                 pdebug("rc%02x\n", ret);                  pdebug("rc%02x\n", ret);
             s->control = ret;              s->control = ret;
Line 332  static uint32_t parallel_ioport_read_hw( Line 332  static uint32_t parallel_ioport_read_hw(
             pdebug("ra%02x s\n", ret);              pdebug("ra%02x s\n", ret);
         else {          else {
             struct ParallelIOArg ioarg = { .buffer = &ret, .count = 1 };              struct ParallelIOArg ioarg = { .buffer = &ret, .count = 1 };
             if (qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ_ADDR, &ioarg)) {              if (qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ_ADDR, &ioarg)) {
                 s->epp_timeout = 1;                  s->epp_timeout = 1;
                 pdebug("ra%02x t\n", ret);                  pdebug("ra%02x t\n", ret);
             }              }
Line 346  static uint32_t parallel_ioport_read_hw( Line 346  static uint32_t parallel_ioport_read_hw(
             pdebug("re%02x s\n", ret);              pdebug("re%02x s\n", ret);
         else {          else {
             struct ParallelIOArg ioarg = { .buffer = &ret, .count = 1 };              struct ParallelIOArg ioarg = { .buffer = &ret, .count = 1 };
             if (qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ, &ioarg)) {              if (qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ, &ioarg)) {
                 s->epp_timeout = 1;                  s->epp_timeout = 1;
                 pdebug("re%02x t\n", ret);                  pdebug("re%02x t\n", ret);
             }              }
Line 374  parallel_ioport_eppdata_read_hw2(void *o Line 374  parallel_ioport_eppdata_read_hw2(void *o
         pdebug("re%04x s\n", eppdata);          pdebug("re%04x s\n", eppdata);
         return eppdata;          return eppdata;
     }      }
     err = qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ, &ioarg);      err = qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ, &ioarg);
     ret = le16_to_cpu(eppdata);      ret = le16_to_cpu(eppdata);
   
     if (err) {      if (err) {
Line 401  parallel_ioport_eppdata_read_hw4(void *o Line 401  parallel_ioport_eppdata_read_hw4(void *o
         pdebug("re%08x s\n", eppdata);          pdebug("re%08x s\n", eppdata);
         return eppdata;          return eppdata;
     }      }
     err = qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ, &ioarg);      err = qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_EPP_READ, &ioarg);
     ret = le32_to_cpu(eppdata);      ret = le32_to_cpu(eppdata);
   
     if (err) {      if (err) {
Line 448  static void parallel_reset(void *opaque) Line 448  static void parallel_reset(void *opaque)
   
 static const int isa_parallel_io[MAX_PARALLEL_PORTS] = { 0x378, 0x278, 0x3bc };  static const int isa_parallel_io[MAX_PARALLEL_PORTS] = { 0x378, 0x278, 0x3bc };
   
   static const MemoryRegionPortio isa_parallel_portio_hw_list[] = {
       { 0, 8, 1,
         .read = parallel_ioport_read_hw,
         .write = parallel_ioport_write_hw },
       { 4, 1, 2,
         .read = parallel_ioport_eppdata_read_hw2,
         .write = parallel_ioport_eppdata_write_hw2 },
       { 4, 1, 4,
         .read = parallel_ioport_eppdata_read_hw4,
         .write = parallel_ioport_eppdata_write_hw4 },
       { 0x400, 8, 1,
         .read = parallel_ioport_ecp_read,
         .write = parallel_ioport_ecp_write },
       PORTIO_END_OF_LIST(),
   };
   
   static const MemoryRegionPortio isa_parallel_portio_sw_list[] = {
       { 0, 8, 1,
         .read = parallel_ioport_read_sw,
         .write = parallel_ioport_write_sw },
       PORTIO_END_OF_LIST(),
   };
   
 static int parallel_isa_initfn(ISADevice *dev)  static int parallel_isa_initfn(ISADevice *dev)
 {  {
     static int index;      static int index;
Line 473  static int parallel_isa_initfn(ISADevice Line 496  static int parallel_isa_initfn(ISADevice
     isa_init_irq(dev, &s->irq, isa->isairq);      isa_init_irq(dev, &s->irq, isa->isairq);
     qemu_register_reset(parallel_reset, s);      qemu_register_reset(parallel_reset, s);
   
     if (qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_READ_STATUS, &dummy) == 0) {      if (qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_PP_READ_STATUS, &dummy) == 0) {
         s->hw_driver = 1;          s->hw_driver = 1;
         s->status = dummy;          s->status = dummy;
     }      }
   
     if (s->hw_driver) {      isa_register_portio_list(dev, base,
         register_ioport_write(base, 8, 1, parallel_ioport_write_hw, s);                               (s->hw_driver
         register_ioport_read(base, 8, 1, parallel_ioport_read_hw, s);                                ? &isa_parallel_portio_hw_list[0]
         isa_init_ioport_range(dev, base, 8);                                : &isa_parallel_portio_sw_list[0]),
                                s, "parallel");
         register_ioport_write(base+4, 1, 2, parallel_ioport_eppdata_write_hw2, s);  
         register_ioport_read(base+4, 1, 2, parallel_ioport_eppdata_read_hw2, s);  
         register_ioport_write(base+4, 1, 4, parallel_ioport_eppdata_write_hw4, s);  
         register_ioport_read(base+4, 1, 4, parallel_ioport_eppdata_read_hw4, s);  
         isa_init_ioport(dev, base+4);  
         register_ioport_write(base+0x400, 8, 1, parallel_ioport_ecp_write, s);  
         register_ioport_read(base+0x400, 8, 1, parallel_ioport_ecp_read, s);  
         isa_init_ioport_range(dev, base+0x400, 8);  
     }  
     else {  
         register_ioport_write(base, 8, 1, parallel_ioport_write_sw, s);  
         register_ioport_read(base, 8, 1, parallel_ioport_read_sw, s);  
         isa_init_ioport_range(dev, base, 8);  
     }  
     return 0;      return 0;
 }  }
   
Line 565  bool parallel_mm_init(target_phys_addr_t Line 574  bool parallel_mm_init(target_phys_addr_t
     ParallelState *s;      ParallelState *s;
     int io_sw;      int io_sw;
   
     s = qemu_mallocz(sizeof(ParallelState));      s = g_malloc0(sizeof(ParallelState));
     s->irq = irq;      s->irq = irq;
     s->chr = chr;      s->chr = chr;
     s->it_shift = it_shift;      s->it_shift = it_shift;

Removed from v.1.1.1.9  
changed lines
  Added in v.1.1.1.10


unix.superglobalmegacorp.com