physical_entry
size_t numBytes, physical_entry *table,
physical_entry *table, int32 numEntries);
physical_entry *vectors, size_t vectorCount,
status_t (*prepare_dma)(void *channelCookie, const physical_entry *sg_list,
const physical_entry *sg_list; // scatter/gather list
const physical_entry *orig_sg_list;
status_t (*prepare_dma)(ata_adapter_channel_info *channel, const physical_entry *sg_list,
uint64 offset, size_t numBlocks, physical_entry* vecs, size_t vecCount,
const physical_entry* readEntry,
const physical_entry* writtenEntry, void* cookie);
const physical_entry* vector,
physical_entry wakeVector;
physical_entry entry;
physical_entry entry;
const physical_entry *entry = request->CurrentSGElement();
const physical_entry *sgList = ccb->sg_list;
const physical_entry *CurrentSGElement() const
const physical_entry *fCurrentSGElement;
physical_entry pe;
physical_entry entry;
physical_entry entry;
physical_entry *map, // resulting memory map
total_size = SCSI_MAX_SENSE_SIZE + sizeof(physical_entry);
request->sg_list = (physical_entry *)(buffer + SCSI_MAX_SENSE_SIZE);
(physical_entry *)request->sg_list, 1);
const physical_entry *sg_list = buffer->sg_list_orig;
size_t sg_list_size = buffer->size / B_PAGE_SIZE * sizeof( physical_entry );
size_t sg_list_entries = sg_list_size / sizeof(physical_entry);
size = (size * sizeof(physical_entry) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
buffer->sg_count_max_orig = size / sizeof(physical_entry);
dump_sg_table(const physical_entry *sg_list,
request->sg_count * sizeof(physical_entry));
const physical_entry *sg_list = request->sg_list;
const physical_entry *sg_list = request->sg_list;
physical_entry map[1];
total_size = (buffer_size + sizeof(physical_entry) + B_PAGE_SIZE - 1)
device->buffer_sg_list = (physical_entry*)((char*)address + buffer_size);
physical_entry *temp_sg;
ccb->sg_list = temp_sg = (physical_entry*)object_cache_alloc(sTempScatterGatherPool,
MAX_TEMP_SG_FRAGMENTS * sizeof(physical_entry), 0);
physical_entry *temp_sg = (physical_entry *)ccb->sg_list;
(num_entries - 1 - cur_idx) * sizeof(physical_entry));
physical_entry *sg_list; // address of S/G list
physical_entry *sg_list_orig; // S/G list to original data
const physical_entry *orig_sg_list; // original S/G list
physical_entry *buffer_sg_list;
physical_entry *map, uint32 max_entries, uint32 *num_entries, size_t *mapped_len)
physical_entry physicalEntry;
BulkPipe::QueueBulkV(physical_entry *vector, size_t vectorCount,
physical_entry physicalEntry;
Transfer::SetVector(physical_entry *vector, size_t vectorCount)
queue_bulk_v_physical(usb_pipe pipe, physical_entry *vector, size_t vectorCount,
status_t QueueBulkV(physical_entry *vector, size_t vectorCount,
void SetVector(physical_entry *vector, size_t vectorCount);
physical_entry fEntry;
virtio_queue_request_v(virtio_queue _queue, const physical_entry* vector,
virtio_queue_request(virtio_queue _queue, const physical_entry *readEntry,
const physical_entry *writtenEntry, void *cookie)
physical_entry entries[2];
status_t QueueRequest(const physical_entry* vector,
const physical_entry* vector,
const physical_entry* vector,
physical_entry pe;
VirtioQueue::QueueRequest(const physical_entry* vector, size_t readVectorCount,
VirtioQueue::QueueRequestIndirect(const physical_entry* vector,
const physical_entry* vector, size_t readVectorCount,
physical_entry entry;
const physical_entry *sg_list, size_t sg_list_count,
prepare_dma(void *channel_cookie, const physical_entry *sg_list,
prepare_dma(void *channel_cookie, const physical_entry *sg_list,
it8211_prepare_dma(void *channelCookie, const physical_entry *sgList,
dma_prepare(void *channel_cookie, const physical_entry *sg_list,
prepare_dma(void *channel_cookie, const physical_entry *sg_list,
physical_entry entry;
dma_prepare(void *channelCookie, const physical_entry *sg_list,
physical_entry pe;
physical_entry entry;
physical_entry entries[2];
physical_entry *pe = (physical_entry *) &(st->priv->table[1]);
physical_entry pe[2];
physical_entry entries[maxEntries];
const physical_entry* sgTable, int sgCount, size_t dataSize)
status_t FillPrdTable(volatile prd *prdTable, int *prdCount, int prdMax, const physical_entry *sgTable, int sgCount, size_t dataSize);
physical_entry pe;
sg_memcpy(const physical_entry *sgTable, int sgCount, const void *data,
status_t sg_memcpy(const physical_entry *sgTable, int sgCount, const void *data, size_t dataSize);
physical_entry entries[2];
physical_entry *scratch;
scratch = (physical_entry *) priv->sg;
physical_entry entries[5];
physical_entry entry;
HyperVSCSIRequest::_FillGPARange(const physical_entry* sgList, uint32 sgCount, uint32 dataLength)
physical_entry entry;
status_t _FillGPARange(const physical_entry* sgList, uint32 sgCount,
BStackOrHeapArray<physical_entry, 16> entries(inCount + outCount);
physical_entry entry;
const physical_entry *sgList = ccb->sg_list;
physical_entry *entries);
physical_entry *entries)
* sizeof(physical_entry));
* sizeof(physical_entry));
VirtioQueue::Enqueue(const physical_entry* vector,
physical_entry pe;
const physical_entry* vector,
const physical_entry* vector,
const physical_entry* readEntry,
const physical_entry* writtenEntry, void* cookie)
physical_entry vector[2];
physical_entry* vectorEnd = vector;
physical_entry pe;
physical_entry PhysEntry;
physical_entry where;
physical_entry pe;
physical_entry pe;
physical_entry pe;
physical_entry phys_pb;
physical_entry phys_rec;
alloc_mem(physical_entry *phy, addr_t *log, size_t size, const char *name)
area_id alloc_mem(physical_entry *phy, addr_t *log, size_t size,
physical_entry entry;
physical_entry* iovecs;
nvme_request.iovecs = (physical_entry*)operation.Vecs();
physical_entry* vtophys = NULL;
vtophys = (physical_entry*)alloca(sizeof(physical_entry) * vtophysLength);
vtophys = (physical_entry*)malloc(sizeof(physical_entry) * vtophysLength);
nvme_request.iovecs = (physical_entry*)buffer->Vecs();
physical_entry* entry = &nvme_request.iovecs[0];
physical_entry* entry = &nvme_request.iovecs[0];
physical_entry entries[4];
data.phys_vecs = (physical_entry*)operation->Vecs();
physical_entry* phys_vecs;
BStackOrHeapArray<physical_entry, 16> entries(operation->VecCount() + 2);
* sizeof(physical_entry));
physical_entry entry;
physical_entry pe;
physical_entry entry;
physical_entry map[1];
physical_entry map[16];
physical_entry *map;
physical_entry PTB_map[1];
map_area_size = map_count * sizeof(physical_entry);
physical_entry map[1];
physical_entry entries[] {
physical_entry entries[16] = {};
physical_entry entry;
physical_entry pe;
static const physical_entry
physical_entry pe;
physical_entry pe = PacketPhysEntry(info, pkt);
physical_entry pe = PacketPhysEntry(info, pkt);
physical_entry table;
physical_entry entries[2];
physical_entry entries[3];
physical_entry entry;
physical_entry hdrEntry;
physical_entry entries[2];
physical_entry table;
const physical_entry *sgList, size_t sgListCount, bool writeToDevice)
physical_entry pe[1];
physical_entry* vecs, size_t vecCount, bool isWrite,
uint64 offset, size_t numBlocks, physical_entry* vecs, size_t vecCount,
(physical_entry *)operation->Vecs(), operation->VecCount(),
const physical_entry *backup_sg_list;
const physical_entry *backup_sg_list;
uint64 offset, size_t numBlocks, physical_entry* vecs, size_t vecCount,
physical_entry entry;
physical_entry physicalEntry;
physical_entry entries[kEntryCount];
const physical_entry& entry = entries[i];
physical_entry entries[kEntryCount];
const physical_entry& entry = entries[i];
physical_entry entry;
physical_entry entry;
physical_entry* table, uint32* _numEntries)
physical_entry* table, int32 numEntries)
physical_entry entry;
get_memory_map(const void* address, ulong numBytes, physical_entry* table,
physical_entry entry[2];
physical_entry entry;