[Qemu-devel] [6676] DB-DMA cleanup

[Aurelien Jarno]

Revision: 6676
          http://svn.sv.gnu.org/viewvc/?view=rev&root=qemu&revision=6676
Author:   aurel32
Date:     2009-03-03 09:14:10 +0000 (Tue, 03 Mar 2009)
Log Message:
-----------
DB-DMA cleanup

Signed-off-by: Laurent Vivier <address@hidden>
Signed-off-by: Aurelien Jarno <address@hidden>

Modified Paths:
--------------
    trunk/hw/ide.c
    trunk/hw/mac_dbdma.c
    trunk/hw/mac_dbdma.h

Modified: trunk/hw/ide.c
===================================================================
--- trunk/hw/ide.c      2009-03-03 09:14:01 UTC (rev 6675)
+++ trunk/hw/ide.c      2009-03-03 09:14:10 UTC (rev 6676)
@@ -3429,71 +3429,69 @@
 
 typedef struct MACIOIDEState {
     IDEState ide_if[2];
-    void *dbdma;
     int stream_index;
 } MACIOIDEState;
 
-static int pmac_atapi_read(DBDMA_transfer *info, DBDMA_transfer_cb cb)
+static void pmac_atapi_read(DBDMA_io *io)
 {
-    MACIOIDEState *m = info->opaque;
+    MACIOIDEState *m = io->opaque;
     IDEState *s = m->ide_if->cur_drive;
-    int ret;
+    int ret, len;
 
-    if (s->lba == -1)
-        return 0;
+    while (io->len > 0 &&
+           s->packet_transfer_size > 0) {
 
-    info->buf_pos = 0;
-
-    while (info->buf_pos < info->len && s->packet_transfer_size > 0) {
-
-        ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
+        len = s->cd_sector_size;
+        ret = cd_read_sector(s->bs, s->lba, s->io_buffer, len);
         if (ret < 0) {
+            io->dma_end(io);
             ide_transfer_stop(s);
             ide_atapi_io_error(s, ret);
-            return info->buf_pos;
+            return;
         }
 
-        info->buf = s->io_buffer + m->stream_index;
+        if (len > io->len)
+            len = io->len;
 
-        info->buf_len = s->cd_sector_size;
-        if (info->buf_pos + info->buf_len > info->len)
-            info->buf_len = info->len - info->buf_pos;
+        cpu_physical_memory_write(io->addr,
+                                  s->io_buffer + m->stream_index, len);
 
-        cb(info);
-
        /* db-dma can ask for 512 bytes whereas block size is 2048... */
 
-        m->stream_index += info->buf_len;
+        m->stream_index += len;
         s->lba += m->stream_index / s->cd_sector_size;
         m->stream_index %= s->cd_sector_size;
 
-        info->buf_pos += info->buf_len;
-        s->packet_transfer_size -= info->buf_len;
+        io->len -= len;
+        io->addr += len;
+        s->packet_transfer_size -= len;
     }
+
+    if (io->len <= 0)
+        io->dma_end(io);
+
     if (s->packet_transfer_size <= 0) {
         s->status = READY_STAT | SEEK_STAT;
         s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO
                                        | ATAPI_INT_REASON_CD;
         ide_set_irq(s);
     }
-
-    return info->buf_pos;
 }
 
-static int pmac_ide_transfer(DBDMA_transfer *info,
-                             DBDMA_transfer_cb cb)
+static void pmac_ide_transfer(DBDMA_io *io)
 {
-    MACIOIDEState *m = info->opaque;
+    MACIOIDEState *m = io->opaque;
     IDEState *s = m->ide_if->cur_drive;
     int64_t sector_num;
     int ret, n;
+    int len;
 
-    if (s->is_cdrom)
-        return pmac_atapi_read(info, cb);
+    if (s->is_cdrom) {
+        pmac_atapi_read(io);
+        return;
+    }
 
-    info->buf = s->io_buffer;
-    info->buf_pos = 0;
-    while (info->buf_pos < info->len && s->nsector > 0) {
+    while (io->len > 0 && s->nsector > 0) {
 
         sector_num = ide_get_sector(s);
 
@@ -3501,36 +3499,40 @@
         if (n > IDE_DMA_BUF_SECTORS)
             n = IDE_DMA_BUF_SECTORS;
 
-        info->buf_len = n << 9;
-        if (info->buf_pos + info->buf_len > info->len)
-            info->buf_len = info->len - info->buf_pos;
-        n = info->buf_len >> 9;
+        len = n << 9;
+        if (len > io->len)
+            len = io->len;
+        n = (len + 511) >> 9;
 
         if (s->is_read) {
             ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
-            if (ret == 0)
-                cb(info);
+            cpu_physical_memory_write(io->addr, s->io_buffer, len);
         } else {
-            cb(info);
+            cpu_physical_memory_read(io->addr, s->io_buffer, len);
             ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
         }
 
         if (ret != 0) {
+            io->dma_end(io);
             ide_rw_error(s);
-            return info->buf_pos;
+            return;
         }
 
-        info->buf_pos += n << 9;
+        io->len -= len;
+        io->addr += len;
         ide_set_sector(s, sector_num + n);
         s->nsector -= n;
     }
 
+    if (io->len <= 0)
+        io->dma_end(io);
+
     if (s->nsector <= 0) {
         s->status = READY_STAT | SEEK_STAT;
         ide_set_irq(s);
     }
 
-    return info->buf_pos;
+    return;
 }
 
 /* PowerMac IDE memory IO */
@@ -3709,10 +3711,8 @@
     d = qemu_mallocz(sizeof(MACIOIDEState));
     ide_init2(d->ide_if, hd_table[0], hd_table[1], irq);
 
-    if (dbdma) {
-        d->dbdma = dbdma;
+    if (dbdma)
         DBDMA_register_channel(dbdma, channel, dma_irq, pmac_ide_transfer, d);
-    }
 
     pmac_ide_memory = cpu_register_io_memory(0, pmac_ide_read,
                                              pmac_ide_write, d);

Modified: trunk/hw/mac_dbdma.c
===================================================================
--- trunk/hw/mac_dbdma.c        2009-03-03 09:14:01 UTC (rev 6675)
+++ trunk/hw/mac_dbdma.c        2009-03-03 09:14:10 UTC (rev 6676)
@@ -158,9 +158,10 @@
     int channel;
     uint32_t regs[DBDMA_REGS];
     qemu_irq irq;
-    DBDMA_transfer io;
-    DBDMA_transfer_handler transfer_handler;
+    DBDMA_io io;
+    DBDMA_rw rw;
     dbdma_cmd current;
+    int processing;
 } DBDMA_channel;
 
 #ifdef DEBUG_DBDMA
@@ -218,7 +219,7 @@
 
     DBDMA_DPRINTF("conditional_interrupt\n");
 
-    intr = be16_to_cpu(current->command) & INTR_MASK;
+    intr = le16_to_cpu(current->command) & INTR_MASK;
 
     switch(intr) {
     case INTR_NEVER:  /* don't interrupt */
@@ -257,7 +258,7 @@
 
     DBDMA_DPRINTF("conditional_wait\n");
 
-    wait = be16_to_cpu(current->command) & WAIT_MASK;
+    wait = le16_to_cpu(current->command) & WAIT_MASK;
 
     switch(wait) {
     case WAIT_NEVER:  /* don't wait */
@@ -318,7 +319,7 @@
 
     /* check if we must branch */
 
-    br = be16_to_cpu(current->command) & BR_MASK;
+    br = le16_to_cpu(current->command) & BR_MASK;
 
     switch(br) {
     case BR_NEVER:  /* don't branch */
@@ -352,38 +353,35 @@
     }
 }
 
-static int dbdma_read_memory(DBDMA_transfer *io)
-{
-    DBDMA_channel *ch = io->channel;
-    dbdma_cmd *current = &ch->current;
+static QEMUBH *dbdma_bh;
+static void channel_run(DBDMA_channel *ch);
 
-    DBDMA_DPRINTF("DBDMA_read_memory\n");
-
-    cpu_physical_memory_read(le32_to_cpu(current->phy_addr) + io->buf_pos,
-                             io->buf, io->buf_len);
-
-    return io->buf_len;
-}
-
-static int dbdma_write_memory(DBDMA_transfer *io)
+static void dbdma_end(DBDMA_io *io)
 {
     DBDMA_channel *ch = io->channel;
     dbdma_cmd *current = &ch->current;
 
-    DBDMA_DPRINTF("DBDMA_write_memory\n");
+    if (conditional_wait(ch))
+        goto wait;
 
-    cpu_physical_memory_write(le32_to_cpu(current->phy_addr) + io->buf_pos,
-                              io->buf, io->buf_len);
+    current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
+    current->res_count = cpu_to_le16(be32_to_cpu(io->len));
+    dbdma_cmdptr_save(ch);
+    ch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);
 
-    return io->buf_len;
+    conditional_interrupt(ch);
+    conditional_branch(ch);
+
+wait:
+    ch->processing = 0;
+    if ((ch->regs[DBDMA_STATUS] & cpu_to_be32(RUN)) &&
+        (ch->regs[DBDMA_STATUS] & cpu_to_be32(ACTIVE)))
+        channel_run(ch);
 }
 
-static int start_output(DBDMA_channel *ch, int key, uint32_t addr,
+static void start_output(DBDMA_channel *ch, int key, uint32_t addr,
                         uint16_t req_count, int is_last)
 {
-    dbdma_cmd *current = &ch->current;
-    uint32_t n;
-
     DBDMA_DPRINTF("start_output\n");
 
     /* KEY_REGS, KEY_DEVICE and KEY_STREAM
@@ -393,35 +391,21 @@
     DBDMA_DPRINTF("addr 0x%x key 0x%x\n", addr, key);
     if (!addr || key > KEY_STREAM3) {
         kill_channel(ch);
-        return 0;
+        return;
     }
 
-    ch->io.buf = NULL;
-    ch->io.buf_pos = 0;
-    ch->io.buf_len = 0;
+    ch->io.addr = addr;
     ch->io.len = req_count;
     ch->io.is_last = is_last;
-    n = ch->transfer_handler(&ch->io, dbdma_read_memory);
-
-    if (conditional_wait(ch))
-        return 1;
-
-    current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
-    current->res_count = cpu_to_le16(0);
-    dbdma_cmdptr_save(ch);
-
-    conditional_interrupt(ch);
-    conditional_branch(ch);
-
-    return 1;
+    ch->io.dma_end = dbdma_end;
+    ch->io.is_dma_out = 1;
+    ch->processing = 1;
+    ch->rw(&ch->io);
 }
 
-static int start_input(DBDMA_channel *ch, int key, uint32_t addr,
+static void start_input(DBDMA_channel *ch, int key, uint32_t addr,
                        uint16_t req_count, int is_last)
 {
-    dbdma_cmd *current = &ch->current;
-    uint32_t n;
-
     DBDMA_DPRINTF("start_input\n");
 
     /* KEY_REGS, KEY_DEVICE and KEY_STREAM
@@ -430,30 +414,19 @@
 
     if (!addr || key > KEY_STREAM3) {
         kill_channel(ch);
-        return 0;
+        return;
     }
 
-    ch->io.buf = NULL;
-    ch->io.buf_pos = 0;
-    ch->io.buf_len = 0;
+    ch->io.addr = addr;
     ch->io.len = req_count;
     ch->io.is_last = is_last;
-    n = ch->transfer_handler(&ch->io, dbdma_write_memory);
-
-    if (conditional_wait(ch))
-        return 1;
-
-    current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
-    current->res_count = cpu_to_le16(0);
-    dbdma_cmdptr_save(ch);
-
-    conditional_interrupt(ch);
-    conditional_branch(ch);
-
-    return 1;
+    ch->io.dma_end = dbdma_end;
+    ch->io.is_dma_out = 0;
+    ch->processing = 1;
+    ch->rw(&ch->io);
 }
 
-static int load_word(DBDMA_channel *ch, int key, uint32_t addr,
+static void load_word(DBDMA_channel *ch, int key, uint32_t addr,
                      uint16_t len)
 {
     dbdma_cmd *current = &ch->current;
@@ -466,7 +439,7 @@
     if (key != KEY_SYSTEM) {
         printf("DBDMA: LOAD_WORD, unimplemented key %x\n", key);
         kill_channel(ch);
-        return 0;
+        return;
     }
 
     cpu_physical_memory_read(addr, (uint8_t*)&val, len);
@@ -479,18 +452,20 @@
     current->cmd_dep = val;
 
     if (conditional_wait(ch))
-        return 1;
+        goto wait;
 
     current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
     dbdma_cmdptr_save(ch);
+    ch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);
 
     conditional_interrupt(ch);
     next(ch);
 
-    return 1;
+wait:
+    qemu_bh_schedule(dbdma_bh);
 }
 
-static int store_word(DBDMA_channel *ch, int key, uint32_t addr,
+static void store_word(DBDMA_channel *ch, int key, uint32_t addr,
                       uint16_t len)
 {
     dbdma_cmd *current = &ch->current;
@@ -503,7 +478,7 @@
     if (key != KEY_SYSTEM) {
         printf("DBDMA: STORE_WORD, unimplemented key %x\n", key);
         kill_channel(ch);
-        return 0;
+        return;
     }
 
     val = current->cmd_dep;
@@ -515,23 +490,25 @@
     cpu_physical_memory_write(addr, (uint8_t*)&val, len);
 
     if (conditional_wait(ch))
-        return 1;
+        goto wait;
 
     current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
     dbdma_cmdptr_save(ch);
+    ch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);
 
     conditional_interrupt(ch);
     next(ch);
 
-    return 1;
+wait:
+    qemu_bh_schedule(dbdma_bh);
 }
 
-static int nop(DBDMA_channel *ch)
+static void nop(DBDMA_channel *ch)
 {
     dbdma_cmd *current = &ch->current;
 
     if (conditional_wait(ch))
-        return 1;
+        goto wait;
 
     current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
     dbdma_cmdptr_save(ch);
@@ -539,19 +516,18 @@
     conditional_interrupt(ch);
     conditional_branch(ch);
 
-    return 1;
+wait:
+    qemu_bh_schedule(dbdma_bh);
 }
 
-static int stop(DBDMA_channel *ch)
+static void stop(DBDMA_channel *ch)
 {
-    ch->regs[DBDMA_STATUS] &= cpu_to_be32(~(ACTIVE|DEAD));
+    ch->regs[DBDMA_STATUS] &= cpu_to_be32(~(ACTIVE|DEAD|FLUSH));
 
     /* the stop command does not increment command pointer */
-
-    return 0;
 }
 
-static int channel_run(DBDMA_channel *ch)
+static void channel_run(DBDMA_channel *ch)
 {
     dbdma_cmd *current = &ch->current;
     uint16_t cmd, key;
@@ -569,10 +545,12 @@
 
     switch (cmd) {
     case DBDMA_NOP:
-        return nop(ch);
+        nop(ch);
+       return;
 
     case DBDMA_STOP:
-        return stop(ch);
+        stop(ch);
+       return;
     }
 
     key = le16_to_cpu(current->command) & 0x0700;
@@ -582,21 +560,25 @@
     if (key == KEY_STREAM4) {
         printf("command %x, invalid key 4\n", cmd);
         kill_channel(ch);
-        return 0;
+        return;
     }
 
     switch (cmd) {
     case OUTPUT_MORE:
-        return start_output(ch, key, phy_addr, req_count, 0);
+        start_output(ch, key, phy_addr, req_count, 0);
+       return;
 
     case OUTPUT_LAST:
-        return start_output(ch, key, phy_addr, req_count, 1);
+        start_output(ch, key, phy_addr, req_count, 1);
+       return;
 
     case INPUT_MORE:
-        return start_input(ch, key, phy_addr, req_count, 0);
+        start_input(ch, key, phy_addr, req_count, 0);
+       return;
 
     case INPUT_LAST:
-        return start_input(ch, key, phy_addr, req_count, 1);
+        start_input(ch, key, phy_addr, req_count, 1);
+       return;
     }
 
     if (key < KEY_REGS) {
@@ -620,35 +602,24 @@
 
     switch (cmd) {
     case LOAD_WORD:
-        return load_word(ch, key, phy_addr, req_count);
+        load_word(ch, key, phy_addr, req_count);
+       return;
 
     case STORE_WORD:
-        return store_word(ch, key, phy_addr, req_count);
+        store_word(ch, key, phy_addr, req_count);
+       return;
     }
-
-    return 0;
 }
 
-static QEMUBH *dbdma_bh;
-
 static void DBDMA_run (DBDMA_channel *ch)
 {
     int channel;
-    int rearm = 0;
 
     for (channel = 0; channel < DBDMA_CHANNELS; channel++, ch++) {
             uint32_t status = be32_to_cpu(ch->regs[DBDMA_STATUS]);
-            if ((status & RUN) && (status & ACTIVE)) {
-               if (status & FLUSH)
-                    while (channel_run(ch));
-                else if (channel_run(ch))
-                    rearm = 1;
-            }
-            ch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);
+            if (!ch->processing && (status & RUN) && (status & ACTIVE))
+                channel_run(ch);
     }
-
-    if (rearm)
-        qemu_bh_schedule_idle(dbdma_bh);
 }
 
 static void DBDMA_run_bh(void *opaque)
@@ -661,7 +632,7 @@
 }
 
 void DBDMA_register_channel(void *dbdma, int nchan, qemu_irq irq,
-                            DBDMA_transfer_handler transfer_handler,
+                            DBDMA_rw rw,
                             void *opaque)
 {
     DBDMA_channel *ch = ( DBDMA_channel *)dbdma + nchan;
@@ -670,7 +641,7 @@
 
     ch->irq = irq;
     ch->channel = nchan;
-    ch->transfer_handler = transfer_handler;
+    ch->rw = rw;
     ch->io.opaque = opaque;
     ch->io.channel = ch;
 }
@@ -714,11 +685,8 @@
 
     ch->regs[DBDMA_STATUS] = cpu_to_be32(status);
 
-    if (status & ACTIVE) {
-        qemu_bh_schedule_idle(dbdma_bh);
-        if (status & FLUSH)
-            DBDMA_schedule();
-    }
+    if (status & ACTIVE)
+        qemu_bh_schedule(dbdma_bh);
 }
 
 static void dbdma_writel (void *opaque,

Modified: trunk/hw/mac_dbdma.h
===================================================================
--- trunk/hw/mac_dbdma.h        2009-03-03 09:14:01 UTC (rev 6675)
+++ trunk/hw/mac_dbdma.h        2009-03-03 09:14:10 UTC (rev 6676)
@@ -20,22 +20,23 @@
  * THE SOFTWARE.
  */
 
-typedef struct {
+typedef struct DBDMA_io DBDMA_io;
+
+typedef void (*DBDMA_rw)(DBDMA_io *io);
+typedef void (*DBDMA_end)(DBDMA_io *io);
+struct DBDMA_io {
     void *opaque;
     void *channel;
+    target_phys_addr_t addr;
     int len;
     int is_last;
-    void *buf;
-    int buf_pos;
-    int buf_len;
-} DBDMA_transfer;
+    int is_dma_out;
+    DBDMA_end dma_end;
+};
 
-typedef int (*DBDMA_transfer_cb)(DBDMA_transfer *info);
-typedef int (*DBDMA_transfer_handler)(DBDMA_transfer *info,
-                                      DBDMA_transfer_cb cb);
 
 void DBDMA_register_channel(void *dbdma, int nchan, qemu_irq irq,
-                            DBDMA_transfer_handler transfer_handler,
+                            DBDMA_rw rw,
                             void *opaque);
 void DBDMA_schedule(void);
 void* DBDMA_init (int *dbdma_mem_index);