Revision bbca72c6

b/dma-helpers.c
42 42 
    BlockDriverAIOCB *acb;
43 43 
    QEMUSGList *sg;
44 44 
    uint64_t sector_num;
45 
    int is_write;
45 
    bool to_dev;
46 46 
    int sg_cur_index;
47 47 
    target_phys_addr_t sg_cur_byte;
48 48 
    QEMUIOVector iov;
......
75 75 

  		





  76
  76
  
    
    for (i = 0; i < dbs->iov.niov; ++i) {


  		





  77
  77
  
    
        cpu_physical_memory_unmap(dbs->iov.iov[i].iov_base,


  		





  78
  
  
    
                                  dbs->iov.iov[i].iov_len, !dbs->is_write,


  		





  
  78
  
    
                                  dbs->iov.iov[i].iov_len, !dbs->to_dev,


  		





  79
  79
  
    
                                  dbs->iov.iov[i].iov_len);


  		





  80
  80
  
    
    }


  		





  81
  81
  
    
}


  		





  ......




  101
  101
  
    
    while (dbs->sg_cur_index < dbs->sg->nsg) {


  		





  102
  102
  
    
        cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;


  		





  103
  103
  
    
        cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;


  		





  104
  
  
    
        mem = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->is_write);


  		





  
  104
  
    
        mem = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->to_dev);


  		





  105
  105
  
    
        if (!mem)


  		





  106
  106
  
    
            break;


  		





  107
  107
  
    
        qemu_iovec_add(&dbs->iov, mem, cur_len);


  		





  ......




  143
  143
  
    
BlockDriverAIOCB *dma_bdrv_io(


  		





  144
  144
  
    
    BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num,


  		





  145
  145
  
    
    DMAIOFunc *io_func, BlockDriverCompletionFunc *cb,


  		





  146
  
  
    
    void *opaque, int is_write)


  		





  
  146
  
    
    void *opaque, bool to_dev)


  		





  147
  147
  
    
{


  		





  148
  148
  
    
    DMAAIOCB *dbs = qemu_aio_get(&dma_aio_pool, bs, cb, opaque);


  		





  149
  149
  
    

  		





  ......




  153
  153
  
    
    dbs->sector_num = sector_num;


  		





  154
  154
  
    
    dbs->sg_cur_index = 0;


  		





  155
  155
  
    
    dbs->sg_cur_byte = 0;


  		





  156
  
  
    
    dbs->is_write = is_write;


  		





  
  156
  
    
    dbs->to_dev = to_dev;


  		





  157
  157
  
    
    dbs->io_func = io_func;


  		





  158
  158
  
    
    dbs->bh = NULL;


  		





  159
  159
  
    
    qemu_iovec_init(&dbs->iov, sg->nsg);


  		





  ......




  170
  170
  
    
                                QEMUSGList *sg, uint64_t sector,


  		





  171
  171
  
    
                                void (*cb)(void *opaque, int ret), void *opaque)


  		





  172
  172
  
    
{


  		





  173
  
  
    
    return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, 0);


  		





  
  173
  
    
    return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, false);


  		





  174
  174
  
    
}


  		





  175
  175
  
    

  		





  176
  176
  
    
BlockDriverAIOCB *dma_bdrv_write(BlockDriverState *bs,


  		





  177
  177
  
    
                                 QEMUSGList *sg, uint64_t sector,


  		





  178
  178
  
    
                                 void (*cb)(void *opaque, int ret), void *opaque)


  		





  179
  179
  
    
{


  		





  180
  
  
    
    return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, 1);


  		





  
  180
  
    
    return dma_bdrv_io(bs, sg, sector, bdrv_aio_writev, cb, opaque, true);


  		





  181
  181
  
    
}


  		












  

    
      b/dma.h
    
  






  39
  39
  
    
BlockDriverAIOCB *dma_bdrv_io(BlockDriverState *bs,


  		





  40
  40
  
    
                              QEMUSGList *sg, uint64_t sector_num,


  		





  41
  41
  
    
                              DMAIOFunc *io_func, BlockDriverCompletionFunc *cb,


  		





  42
  
  
    
                              void *opaque, int is_write);


  		





  
  42
  
    
                              void *opaque, bool to_dev);


  		





  43
  43
  
    
BlockDriverAIOCB *dma_bdrv_read(BlockDriverState *bs,


  		





  44
  44
  
    
                                QEMUSGList *sg, uint64_t sector,


  		





  45
  45
  
    
                                BlockDriverCompletionFunc *cb, void *opaque);


  		












  

    
      b/hw/ide/core.c
    
  






  603
  603
  
    
        break;


  		





  604
  604
  
    
    case IDE_DMA_TRIM:


  		





  605
  605
  
    
        s->bus->dma->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num,


  		





  606
  
  
    
                                         ide_issue_trim, ide_dma_cb, s, 1);


  		





  
  606
  
    
                                         ide_issue_trim, ide_dma_cb, s, true);


  		





  607
  607
  
    
        break;


  		





  608
  608
  
    
    }


  		





  609
  609
  
    

  		












  

    
      b/hw/ide/macio.c
    
  






  156
  156
  
    
        break;


  		





  157
  157
  
    
    case IDE_DMA_TRIM:


  		





  158
  158
  
    
        m->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num,


  		





  159
  
  
    
                               ide_issue_trim, pmac_ide_transfer_cb, s, 1);


  		





  
  159
  
    
                               ide_issue_trim, pmac_ide_transfer_cb, s, true);


  		





  160
  160
  
    
        break;


  		





  161
  161
  
    
    }


  		





  162
  162
  
    

  		












Also available in:
  Unified diff