You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
chan-capi/divastreaming/segment_alloc.c

440 lines
12 KiB

/*
*
Copyright (c) Dialogic (R) 2009 - 2010
*
This source file is supplied for the use with
Eicon Networks range of DIVA Server Adapters.
*
Dialogic (R) File Revision : 1.9
*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
*
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
*
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
/*
* vim:ts=2:
*/
#include "platform.h"
#include "dlist.h"
#include "diva_segment_alloc_ifc.h"
#ifdef DIVA_USERMODE
#include "xdi_msg.h"
#else
#include "pc.h"
#include "di_defs.h"
#include "divasync.h"
#endif
#include "debuglib.h"
#if defined(LINUX) && defined(DIVA_USERMODE)
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#endif
typedef struct _diva_map_entry {
diva_entity_link_t link;
int entry_nr;
dword dma_lo;
dword dma_hi;
void* mem;
} diva_map_entry_t;
typedef struct _diva_segment_alloc {
diva_segment_alloc_access_t ifc;
#if defined(DIVA_USERMODE)
#if defined(LINUX)
int fd;
int fd_mem;
int fd_xdi;
#endif
#else
DESCRIPTOR* d;
#endif
diva_entity_queue_t free_q;
diva_entity_queue_t busy_q;
#if !defined(DIVA_USERMODE)
IDI_SYNC_REQ syncReq;
#endif
} diva_segment_alloc_t;
/*
* LOCALS
*/
static void release_proc(struct _diva_segment_alloc**);
static void* segment_alloc_proc(struct _diva_segment_alloc*, dword* lo, dword* hi);
static void segment_free_proc(struct _diva_segment_alloc*, void* addr, dword lo, dword hi);
static dword get_segment_length_proc(struct _diva_segment_alloc*);
#if defined(DIVA_USERMODE)
static int map_entry (struct _diva_segment_alloc* pI, diva_map_entry_t* pE);
#endif
static void* map_address (struct _diva_segment_alloc* ifc, dword lo, dword hi, int map_host);
static void* umap_address (struct _diva_segment_alloc* ifc, dword lo, dword hi, void* local);
static int write_address (struct _diva_segment_alloc* ifc, dword lo, dword hi, dword data);
static void resource_removed (struct _diva_segment_alloc* ifc);
#if !defined(DIVA_USERMODE)
static void diva_segment_allloc_resource_removed_request(ENTITY* e) { }
static DESCRIPTOR diva_segment_alloc_resource_removed_descriptor =
{ 0, 0, 0, diva_segment_allloc_resource_removed_request };
#endif
static diva_segment_alloc_access_t ifc_ref = {
release_proc,
segment_alloc_proc,
segment_free_proc,
get_segment_length_proc,
map_address,
umap_address,
write_address,
resource_removed
};
#if defined(DIVA_SHARED_SEGMENT_ALLOC)
static struct _diva_segment_alloc* shared_segment_alloc;
static int shared_segment_alloc_count;
#endif
int diva_create_segment_alloc (void* os_context, struct _diva_segment_alloc** segment_alloc)
{
diva_segment_alloc_t* pI = diva_os_malloc(0, sizeof(*pI));
#if defined(DIVA_SHARED_SEGMENT_ALLOC)
if (shared_segment_alloc != 0) {
shared_segment_alloc_count++;
*segment_alloc = shared_segment_alloc;
DBG_TRC(("shared %d segment alloc [%p]", shared_segment_alloc_count, pI))
return (0);
}
#endif
pI = diva_os_malloc(0, sizeof(*pI));
if (pI != 0) {
memset (pI, 0x00, sizeof(*pI));
pI->ifc = ifc_ref;
diva_q_init (&pI->free_q);
diva_q_init (&pI->busy_q);
#if defined(DIVA_USERMODE) /* { */
#if defined(LINUX) /* { */
pI->fd = open ("/dev/DivasMAP", O_RDWR | O_NONBLOCK); /** \todo use hardware related DMA entry, needs update of XDI driver */
pI->fd_mem = open ("/dev/mem", O_RDWR | O_NONBLOCK); /* /dev/mem is optional */
pI->fd_xdi = open ("/dev/DivasXDI", O_RDWR | O_NONBLOCK); /* /dev/mem is optional */
if (pI->fd >= 0 && (pI->fd_mem >= 0 || pI->fd_xdi >= 0)) {
*segment_alloc = pI;
} else {
diva_destroy_segment_alloc (&pI);
pI = 0;
}
#endif /* } */
#else /* } { */
pI->d = (DESCRIPTOR*)os_context;
*segment_alloc = pI;
#endif /* } */
}
if (pI != 0) {
#if defined(DIVA_SHARED_SEGMENT_ALLOC)
shared_segment_alloc = pI;
shared_segment_alloc_count = 1;
#if defined(DIVA_SHARED_SEGMENT_LOCK)
shared_segment_alloc_count++;
#endif
#endif
DBG_TRC(("created segment alloc [%p]", pI))
}
return ((pI != 0) ? 0 : -1);
}
int diva_destroy_segment_alloc (struct _diva_segment_alloc** segment_alloc) {
diva_segment_alloc_t* pI = (segment_alloc != 0) ? *segment_alloc : 0;
#if defined(DIVA_SHARED_SEGMENT_ALLOC)
shared_segment_alloc_count--;
if (shared_segment_alloc_count > 0) {
if (segment_alloc != 0)
*segment_alloc = 0;
DBG_TRC(("unshare %d segment alloc [%p]", shared_segment_alloc_count, segment_alloc))
return (0);
}
#endif
DBG_TRC(("destroy segment alloc [%p]", segment_alloc))
if (pI != 0) {
diva_entity_link_t* link;
shared_segment_alloc = 0;
shared_segment_alloc_count = 0;
while ((link = diva_q_get_head (&pI->busy_q)) != 0) {
diva_q_remove (&pI->busy_q, link);
diva_q_add_tail (&pI->free_q, link);
}
while ((link = diva_q_get_head (&pI->free_q)) != 0) {
diva_map_entry_t* pE = DIVAS_CONTAINING_RECORD(link, diva_map_entry_t, link);
#if defined(DIVA_USERMODE)
#if defined(LINUX)
munmap (pE->mem, 4*1024);
#endif
#else
pI->syncReq.diva_xdi_streaming_mapping_req.Req = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.Rc = IDI_SYNC_REQ_PROCESS_STREAMING_MAPPING;
pI->syncReq.diva_xdi_streaming_mapping_req.info.request = IDI_SYNC_REQ_PROCESS_STREAMING_MAPPING_FREE_COMMAND;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_lo = pE->dma_lo;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_hi = pE->dma_hi;
pI->syncReq.diva_xdi_streaming_mapping_req.info.addr = pE->mem;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_handle = pE->entry_nr;
pI->d->request((ENTITY*)&pI->syncReq);
#endif
diva_q_remove (&pI->free_q, link);
diva_os_free (0, pE);
}
#if defined(DIVA_USERMODE)
#if defined(LINUX)
if (pI->fd >= 0)
close (pI->fd);
if (pI->fd_mem >= 0)
close (pI->fd_mem);
if (pI->fd_xdi >= 0)
close (pI->fd_xdi);
#endif
#else
#endif
diva_os_free (0, pI);
*segment_alloc = 0;
}
return (0);
}
void release_proc(struct _diva_segment_alloc** pI) {
diva_destroy_segment_alloc (pI);
}
void* segment_alloc_proc(struct _diva_segment_alloc* pI, dword* lo, dword* hi) {
diva_entity_link_t* link = diva_q_get_head(&pI->free_q);
void* addr = 0;
if (link != 0) {
diva_map_entry_t* pE = DIVAS_CONTAINING_RECORD(link, diva_map_entry_t, link);
diva_q_remove (&pI->free_q, link);
diva_q_add_tail (&pI->busy_q, link);
*lo = pE->dma_lo;
*hi = pE->dma_hi;
return (pE->mem);
} else if ((link = diva_os_malloc (0, sizeof(diva_map_entry_t))) != 0) {
diva_map_entry_t* pE = (diva_map_entry_t*)link;
#if defined(DIVA_USERMODE)
#if defined(LINUX)
dword data[5];
int ret;
data[0] = DIVA_XDI_UM_CMD_CREATE_XDI_DESCRIPTORS;
data[1] = 1;
{ int tmp = write (pI->fd, data, 2*sizeof(dword)); tmp++; }
ret = read (pI->fd, data, sizeof(data));
if (ret == sizeof(data) || ret == (sizeof(data)-sizeof(data[0]))) {
if (data[0] == DIVA_XDI_UM_CMD_CREATE_XDI_DESCRIPTORS && data[1] == 1) {
pE->dma_lo = data[3];
pE->dma_hi = (data[2] == 8) ? data[4] : 0;
if (map_entry(pI, pE) == 0) {
diva_q_add_tail (&pI->busy_q, &pE->link);
*lo = pE->dma_lo;
*hi = pE->dma_hi;
addr = pE->mem;
} else {
diva_os_free (0, pE);
}
}
}
#endif
#else
pI->syncReq.diva_xdi_streaming_mapping_req.Req = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.Rc = IDI_SYNC_REQ_PROCESS_STREAMING_MAPPING;
pI->syncReq.diva_xdi_streaming_mapping_req.info.request = IDI_SYNC_REQ_PROCESS_STREAMING_MAPPING_ALLOC_COMMAND;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_lo = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_hi = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.addr = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_handle = -1;
pI->d->request((ENTITY*)&pI->syncReq);
if (pI->syncReq.diva_xdi_streaming_mapping_req.info.request == IDI_SYNC_REQ_PROCESS_STREAMING_COMMAND_OK &&
pI->syncReq.diva_xdi_streaming_mapping_req.info.addr != 0) {
pE->entry_nr = pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_handle;
pE->dma_lo = pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_lo;
pE->dma_hi = pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_hi;
pE->mem = pI->syncReq.diva_xdi_streaming_mapping_req.info.addr;
*lo = pE->dma_lo;
*hi = pE->dma_hi;
addr = pE->mem;
memset (addr, 0x00, 4*1024);
diva_q_add_tail (&pI->busy_q, &pE->link);
} else {
diva_os_free (0, pE);
}
#endif
}
return (addr);
}
#if defined(DIVA_USERMODE)
static int map_entry (struct _diva_segment_alloc* pI, diva_map_entry_t* pE) {
void* addr;
if (pE->dma_hi != 0) {
qword i = ((qword)pE->dma_lo) | (((qword)pE->dma_hi) << 32);
#if defined(LINUX)
addr = mmap (0, 4*1024, PROT_READ|PROT_WRITE, MAP_SHARED, pI->fd, i);
#endif
} else {
#if defined(LINUX)
addr = mmap (0, 4*1024, PROT_READ|PROT_WRITE, MAP_SHARED, pI->fd, pE->dma_lo);
#endif
}
if (addr == 0 || addr == ((void*)-1)) {
DBG_ERR(("failed to map %08x:%08x [%p]", pE->dma_lo, pE->dma_hi, pI))
return (-1);
}
pE->mem = addr;
return (0);
}
#endif
static void* map_address (struct _diva_segment_alloc* pI, dword lo, dword hi, int map_host) {
void* ret = 0;
#if defined(DIVA_USERMODE)
#if defined(LINUX)
qword addr = ((qword)lo) | (((qword)hi) << 32);
int effective_map_fd = (map_host == 0) ? pI->fd_mem : pI->fd;
if (effective_map_fd >= 0) {
ret = mmap (0, 4*1024, PROT_READ|PROT_WRITE, MAP_SHARED, effective_map_fd, addr);
if (ret == ((void*)-1)) {
ret = 0;
}
}
#endif
#else
pI->syncReq.diva_xdi_streaming_mapping_req.Req = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.Rc = IDI_SYNC_REQ_PROCESS_STREAMING_MAPPING;
pI->syncReq.diva_xdi_streaming_mapping_req.info.request = IDI_SYNC_REQ_PROCESS_STREAMING_SYSTEM_MAP_COMMAND;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_lo = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_hi = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.addr = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_handle = -1;
pI->d->request((ENTITY*)&pI->syncReq);
if (pI->syncReq.diva_xdi_streaming_mapping_req.info.request == IDI_SYNC_REQ_PROCESS_STREAMING_COMMAND_OK) {
byte* p = pI->syncReq.diva_xdi_streaming_mapping_req.info.addr;
dword offset = lo - pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_lo;
pI->syncReq.diva_xdi_streaming_mapping_req.info.addr = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_lo = 0;
pI->syncReq.diva_xdi_streaming_mapping_req.info.dma_hi = 0;
ret = p + offset;
}
#endif
return (ret);
}
static void* umap_address (struct _diva_segment_alloc* ifc, dword lo, dword hi, void* local) {
#if defined(DIVA_USERMODE)
#if defined(LINUX)
munmap (local, 4*1024);
#endif
#else
#endif
return (0);
}
static int write_address (struct _diva_segment_alloc* pI, dword lo, dword hi, dword data) {
diva_xdi_direct_access_cmd_t cmd;
int ret;
if (unlikely(pI->fd_xdi < 0))
return (-1);
cmd.hdr.ident = DIVA_XDI_DIRECT_ACCESS_CMD_IDENT;
cmd.hdr.cmd = DIVA_XDI_DIRECT_ACCESS_CMD_WRITE_BY_ADDRESS;
cmd.cmd.write_by_address.address = lo;
cmd.cmd.write_by_address.value = data;
ret = write (pI->fd_xdi, &cmd, sizeof(cmd.hdr)+sizeof(cmd.cmd.write_by_address)) ==
sizeof(cmd.hdr)+sizeof(cmd.cmd.write_by_address) ? 0 : -1;
return (ret);
}
static void resource_removed (struct _diva_segment_alloc* pI) {
#if defined(DIVA_USERMODE)
#else
pI->d = &diva_segment_alloc_resource_removed_descriptor;
#endif
}
void segment_free_proc(struct _diva_segment_alloc* pI, void* addr, dword lo, dword hi) {
diva_entity_link_t* link;
for (link = diva_q_get_head(&pI->busy_q); link != 0; link = diva_q_get_next(link)) {
diva_map_entry_t* pE = DIVAS_CONTAINING_RECORD(link, diva_map_entry_t, link);
if (pE->mem == addr && pE->dma_lo == lo && pE->dma_hi == hi) {
diva_q_remove (&pI->busy_q, link);
diva_q_add_tail (&pI->free_q, link);
return;
}
}
DBG_ERR(("segment not found: %p %08x:%08x [%p]", addr, lo, hi, pI))
}
dword get_segment_length_proc(struct _diva_segment_alloc* pI) {
return (4*1024);
}
diva_segment_alloc_access_t* diva_get_segment_alloc_ifc (struct _diva_segment_alloc* segment_alloc) {
return ((segment_alloc != 0) ? &segment_alloc->ifc : 0);
}