int ncDescribeResourceStub (ncStub *st, ncMetadata *meta, char *resourceType, ncResource **outRes)
{
int ret=0;
ncResource *res;
loadNcStuff();
if (myconfig->res.memorySizeMax <= 0) {
// not initialized?
res = allocate_resource ("OK", "iqn.1993-08.org.debian:01:736a4e92c588", 1024000, 1024000, 30000000, 30000000, 4096, 4096, "none");
if (!res) {
logprintfl(EUCAERROR, "fakeNC: describeResource(): failed to allocate fake resource\n");
ret=1;
} else {
memcpy(&(myconfig->res), res, sizeof(ncResource));
free(res);
}
}
if (!ret) {
res = malloc(sizeof(ncResource));
memcpy(res, &(myconfig->res), sizeof(ncResource));
*outRes = res;
} else {
*outRes = NULL;
}
saveNcStuff();
return(ret);
}
//!
//! Handle the client describe resource request
//!
//! @param[in] pStub a pointer to the node controller (NC) stub structure
//! @param[in] pMeta a pointer to the node controller (NC) metadata structure
//! @param[in] resourceType UNUSED
//! @param[out] outRes a list of resources we retrieved data for
//!
//! @return EUCA_OK on success or EUCA_ERROR on failure.
//!
int ncDescribeResourceStub(ncStub * pStub, ncMetadata * pMeta, char *resourceType, ncResource ** outRes)
{
int ret = EUCA_OK;
ncResource *res = NULL;
loadNcStuff();
if (myconfig->res.memorySizeMax <= 0) {
// not initialized?
res = allocate_resource("OK", "iqn.1993-08.org.debian:01:736a4e92c588", 1024000, 1024000, 30000000, 30000000, 4096, 4096, "none");
if (!res) {
LOGERROR("fakeNC: describeResource(): failed to allocate fake resource\n");
ret = EUCA_ERROR;
} else {
memcpy(&(myconfig->res), res, sizeof(ncResource));
EUCA_FREE(res);
}
}
if (!ret) {
res = EUCA_ALLOC(1, sizeof(ncResource));
memcpy(res, &(myconfig->res), sizeof(ncResource));
*outRes = res;
} else {
*outRes = NULL;
}
saveNcStuff();
return (ret);
}
/* Move head of userqueue to feedback queues */
void enqueue_roundrobin() {
PcbPtr process;
while (user_queue) { // while there are items in the user queue
if (check_resource(io_resources,user_queue) == 1 && memChk(memory,user_queue->mbytes)){ // if resources/memory can be allocated for the given process
process = pcb_dequeue(&user_queue);
process->memory = memAlloc(memory,process->mbytes); // allocating memory
if (process->memory) { // making sure it is not null
process->memory->id = process->id;
}
io_resources = allocate_resource(io_resources,process);
switch (process->priority) {
case 0:
break;
case 1:
p1_queue = pcb_enqueue(p1_queue,process);
break;
case 2:
p2_queue = pcb_enqueue(p2_queue,process);
break;
case 3:
p3_queue = pcb_enqueue(p3_queue,process);
break;
default:
fprintf(stderr, "Error. Priority not correctly set. Process ID: %d Priority: %d\n",process->id,process->priority);
break;
}
}
else { // leave the while loop when the above condition fails
break;
}
}
}
static int make_period_modifier(struct iforce* iforce,
struct resource* mod_chunk, int no_alloc,
__s16 magnitude, __s16 offset, u16 period, u16 phase)
{
unsigned char data[7];
period = TIME_SCALE(period);
if (!no_alloc) {
mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0c,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
mutex_unlock(&iforce->mem_mutex);
return -ENOSPC;
}
mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
data[1] = HI(mod_chunk->start);
data[2] = HIFIX80(magnitude);
data[3] = HIFIX80(offset);
data[4] = HI(phase);
data[5] = LO(period);
data[6] = HI(period);
iforce_send_packet(iforce, FF_CMD_PERIOD, data);
return 0;
}
struct isp_mem_obj *isp_mem_create(struct fthd_private *dev_priv,
unsigned int type, resource_size_t size)
{
struct isp_mem_obj *obj;
struct resource *root = dev_priv->mem;
int ret;
obj = kzalloc(sizeof(struct isp_mem_obj), GFP_KERNEL);
if (!obj)
return NULL;
obj->type = type;
obj->base.name = "S2 ISP";
ret = allocate_resource(root, &obj->base, size, root->start, root->end,
PAGE_SIZE, NULL, NULL);
if (ret) {
dev_err(&dev_priv->pdev->dev,
"Failed to allocate resource (size: %Ld, start: %Ld, end: %Ld)\n",
size, root->start, root->end);
kfree(obj);
obj = NULL;
}
obj->offset = obj->base.start - root->start;
obj->size = size;
obj->size_aligned = obj->base.end - obj->base.start;
return obj;
}
/*
* Allocate space from the specified PCI window mapping resource. On
* success record information about the allocation in the supplied window
* allocation cookie (if non-NULL) and return the address of the allocated
* window. On failure return NULL.
*
* The "size" parameter is usually from a PCI device's Base Address Register
* (BAR) decoder. As such, the allocation must be aligned to be a multiple of
* that. The "align" parameter acts as a ``minimum alignment'' allocation
* constraint. The alignment contraint reflects system or device addressing
* restrictions such as the inability to share higher level ``windows''
* between devices, etc. The returned PCI address allocation will be a
* multiple of the alignment constraint both in alignment and size. Thus, the
* returned PCI address block is aligned to the maximum of the requested size
* and alignment.
*/
iopaddr_t
pciio_device_win_alloc(struct resource *root_resource,
pciio_win_alloc_t win_alloc,
size_t start, size_t size, size_t align)
{
struct resource *new_res;
int status = 0;
new_res = (struct resource *) kmalloc( sizeof(struct resource), KM_NOSLEEP);
status = allocate_resource( root_resource, new_res,
size, align /* Min start addr. */,
root_resource->end, align,
NULL, NULL);
if (status) {
kfree(new_res);
return((iopaddr_t) NULL);
}
/*
* If a window allocation cookie has been supplied, use it to keep
* track of all the allocated space assigned to this window.
*/
if (win_alloc) {
win_alloc->wa_resource = new_res;
win_alloc->wa_base = new_res->start;
win_alloc->wa_pages = size;
}
return new_res->start;;
}
int32_t define_resource(const resource *base) {
GPR_ASSERT(base != NULL && base->name != NULL && base->n_numerators > 0 &&
base->numerators != NULL);
gpr_mu_lock(&resource_lock);
size_t id = allocate_resource();
size_t len = strlen(base->name) + 1;
resources[id]->name = (char *)gpr_malloc(len);
memcpy(resources[id]->name, base->name, len);
if (base->description) {
len = strlen(base->description) + 1;
resources[id]->description = (char *)gpr_malloc(len);
memcpy(resources[id]->description, base->description, len);
}
resources[id]->prefix = base->prefix;
resources[id]->n_numerators = base->n_numerators;
len = (size_t)base->n_numerators * sizeof(*base->numerators);
resources[id]->numerators =
(google_census_Resource_BasicUnit *)gpr_malloc(len);
memcpy(resources[id]->numerators, base->numerators, len);
resources[id]->n_denominators = base->n_denominators;
if (base->n_denominators != 0) {
len = (size_t)base->n_denominators * sizeof(*base->denominators);
resources[id]->denominators =
(google_census_Resource_BasicUnit *)gpr_malloc(len);
memcpy(resources[id]->denominators, base->denominators, len);
}
gpr_mu_unlock(&resource_lock);
return (int32_t)id;
}
void *atari_stram_alloc(unsigned long size, const char *owner)
{
struct resource *res;
int error;
pr_debug("atari_stram_alloc: allocate %lu bytes\n", size);
/* */
size = PAGE_ALIGN(size);
res = kzalloc(sizeof(struct resource), GFP_KERNEL);
if (!res)
return NULL;
res->name = owner;
error = allocate_resource(&stram_pool, res, size, 0, UINT_MAX,
PAGE_SIZE, NULL, NULL);
if (error < 0) {
pr_err("atari_stram_alloc: allocate_resource() failed %d!\n",
error);
kfree(res);
return NULL;
}
pr_debug("atari_stram_alloc: returning %pR\n", res);
return (void *)res->start;
}
static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz)
{
unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
unsigned long va;
unsigned int psz;
if (allocate_resource(&shmedia_iomap, res, round_sz,
shmedia_iomap.start, shmedia_iomap.end,
PAGE_SIZE, NULL, NULL) != 0) {
panic("alloc_io_res(%s): cannot occupy\n",
(res->name != NULL)? res->name: "???");
}
va = res->start;
pa &= PAGE_MASK;
psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
/* log at boot time ... */
printk("mapioaddr: %6s [%2d page%s] va 0x%08lx pa 0x%08x\n",
((res->name != NULL) ? res->name : "???"),
psz, psz == 1 ? " " : "s", va, pa);
for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
shmedia_mapioaddr(pa, va);
va += PAGE_SIZE;
pa += PAGE_SIZE;
}
res->start += offset;
res->end = res->start + sz - 1; /* not strictly necessary.. */
return res->start;
}
static struct resource *iodyn_find_io_region(unsigned long base, int num,
unsigned long align, struct pcmcia_socket *s)
{
struct resource *res = make_resource(0, num, IORESOURCE_IO,
dev_name(&s->dev));
struct pcmcia_align_data data;
unsigned long min = base;
int ret;
if (align == 0)
align = 0x10000;
data.mask = align - 1;
data.offset = base & data.mask;
#ifdef CONFIG_PCI
if (s->cb_dev) {
ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
min, 0, pcmcia_align, &data);
} else
#endif
ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
1, pcmcia_align, &data);
if (ret != 0) {
kfree(res);
res = NULL;
}
return res;
}
/*
* Given the PCI bus a device resides on, try to
* find an acceptable resource allocation for a
* specific device resource..
*/
static int pci_assign_bus_resource(const struct pci_bus *bus,
struct pci_dev *dev,
struct resource *res,
unsigned long size,
unsigned long min,
int resno)
{
unsigned int type_mask;
int i;
type_mask = IORESOURCE_IO | IORESOURCE_MEM;
for (i = 0 ; i < 4; i++) {
struct resource *r = bus->resource[i];
if (!r)
continue;
/* type_mask must match */
if ((res->flags ^ r->flags) & type_mask)
continue;
/* Ok, try it out.. */
if (allocate_resource(r, res, size, min, -1, size, NULL, NULL) < 0)
continue;
/* PCI config space updated by caller. */
return 0;
}
return -EBUSY;
}
int pci_assign_resource(struct pci_dev *pdev, int resource)
{
struct pcidev_cookie *pcp = pdev->sysdata;
struct pci_pbm_info *pbm = pcp->pbm;
struct resource *res = &pdev->resource[resource];
struct resource *root;
unsigned long min, max, size, align;
int err;
if (res->flags & IORESOURCE_IO) {
root = &pbm->io_space;
min = root->start + 0x400UL;
max = root->end;
} else {
root = &pbm->mem_space;
min = root->start;
max = min + 0x80000000UL;
}
size = res->end - res->start;
align = size + 1;
err = allocate_resource(root, res, size + 1, min, max, align, NULL, NULL);
if (err < 0) {
printk("PCI: Failed to allocate resource %d for %s\n",
resource, pdev->name);
} else {
pbm->parent->base_address_update(pdev, resource);
}
return err;
}
static void __iomem *shmedia_ioremap(struct resource *res, u32 pa, int sz,
unsigned long flags)
{
unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
unsigned long va;
unsigned int psz;
if (allocate_resource(&shmedia_iomap, res, round_sz,
shmedia_iomap.start, shmedia_iomap.end,
PAGE_SIZE, NULL, NULL) != 0) {
panic("alloc_io_res(%s): cannot occupy\n",
(res->name != NULL) ? res->name : "???");
}
va = res->start;
pa &= PAGE_MASK;
psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
shmedia_mapioaddr(pa, va, flags);
va += PAGE_SIZE;
pa += PAGE_SIZE;
}
return (void __iomem *)(unsigned long)(res->start + offset);
}
void *amiga_chip_alloc(unsigned long size, const char *name)
{
struct resource *res;
/* round up */
size = PAGE_ALIGN(size);
#ifdef DEBUG
printk("amiga_chip_alloc: allocate %ld bytes\n", size);
#endif
res = kzalloc(sizeof(struct resource), GFP_KERNEL);
if (!res)
return NULL;
res->name = name;
if (allocate_resource(&chipram_res, res, size, 0, UINT_MAX, PAGE_SIZE, NULL, NULL) < 0) {
kfree(res);
return NULL;
}
chipavail -= size;
#ifdef DEBUG
printk("amiga_chip_alloc: returning %lx\n", res->start);
#endif
return (void *)ZTWO_VADDR(res->start);
}
static int make_magnitude_modifier(struct iforce* iforce,
struct resource* mod_chunk, int no_alloc, __s16 level)
{
unsigned char data[3];
if (!no_alloc) {
mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 2,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
mutex_unlock(&iforce->mem_mutex);
return -ENOSPC;
}
mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
data[1] = HI(mod_chunk->start);
data[2] = HIFIX80(level);
iforce_send_packet(iforce, FF_CMD_MAGNITUDE, data);
iforce_dump_packet("magnitude: ", FF_CMD_MAGNITUDE, data);
return 0;
}
static struct resource *nonstatic_find_io_region(unsigned long base, int num,
unsigned long align, struct pcmcia_socket *s)
{
struct resource *res = make_resource(0, num, IORESOURCE_IO, s->dev.class_id);
struct socket_data *s_data = s->resource_data;
struct pcmcia_align_data data;
unsigned long min = base;
int ret;
if (align == 0)
align = 0x10000;
data.mask = align - 1;
data.offset = base & data.mask;
data.map = &s_data->io_db;
down(&rsrc_sem);
#ifdef CONFIG_PCI
if (s->cb_dev) {
ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
min, 0, pcmcia_align, &data);
} else
#endif
ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
1, pcmcia_align, &data);
up(&rsrc_sem);
if (ret != 0) {
kfree(res);
res = NULL;
}
return res;
}
struct iommu_obj *iommu_allocate_sgtable(struct fthd_private *dev_priv, struct sg_table *sgtable)
{
struct iommu_obj *obj;
struct resource *root = dev_priv->iommu;
struct scatterlist *sg;
int ret, i, pos;
int total_len = 0, dma_length;
dma_addr_t dma_addr;
for(i = 0; i < sgtable->nents; i++)
total_len += sg_dma_len(sgtable->sgl + i);
if (!total_len)
return NULL;
total_len += 4095;
total_len /= 4096;
obj = kzalloc(sizeof(struct iommu_obj), GFP_KERNEL);
if (!obj)
return NULL;
obj->base.name = "S2 IOMMU";
ret = allocate_resource(root, &obj->base, total_len, root->start, root->end,
1, NULL, NULL);
if (ret) {
dev_err(&dev_priv->pdev->dev,
"Failed to allocate resource (size: %d, start: %Ld, end: %Ld)\n",
total_len, root->start, root->end);
kfree(obj);
obj = NULL;
return NULL;
}
obj->offset = obj->base.start - root->start;
obj->size = total_len;
pos = 0x9000 + obj->offset * 4;
for(i = 0; i < sgtable->nents; i++) {
sg = sgtable->sgl + i;
WARN_ON(sg->offset);
dma_addr = sg_dma_address(sg);
WARN_ON(dma_addr & 0xfff);
dma_addr >>= 12;
for(dma_length = 0; dma_length < sg_dma_len(sg); dma_length += 0x1000) {
// pr_debug("IOMMU %08x -> %08llx (dma length %d)\n", pos, dma_addr, dma_length);
FTHD_S2_REG_WRITE(dma_addr++, pos);
pos += 4;
}
}
pr_debug("allocated %d pages @ %p / offset %d\n", obj->size, obj, obj->offset);
return obj;
}
int ncDescribeResourceStub (ncStub *st, ncMetadata *meta, char *resourceType, ncResource **outRes)
{
axutil_env_t * env = st->env;
axis2_stub_t * stub = st->stub;
adb_ncDescribeResource_t * input = adb_ncDescribeResource_create(env);
adb_ncDescribeResourceType_t * request = adb_ncDescribeResourceType_create(env);
/* set input fields */
adb_ncDescribeResourceType_set_nodeName(request, env, st->node_name);
if (meta) {
adb_ncDescribeResourceType_set_correlationId(request, env, CORRELATION_ID);
adb_ncDescribeResourceType_set_userId(request, env, meta->userId);
}
if (resourceType) {
adb_ncDescribeResourceType_set_resourceType(request, env, resourceType);
}
adb_ncDescribeResource_set_ncDescribeResource(input, env, request);
int status = 0;
{
adb_ncDescribeResourceResponse_t * output = axis2_stub_op_EucalyptusNC_ncDescribeResource(stub, env, input);
if (!output) {
logprintfl (EUCAERROR, "ERROR: DescribeResource" NULL_ERROR_MSG);
status = -1;
} else {
adb_ncDescribeResourceResponseType_t * response = adb_ncDescribeResourceResponse_get_ncDescribeResourceResponse(output, env);
if ( adb_ncDescribeResourceResponseType_get_return(response, env) == AXIS2_FALSE ) {
logprintfl (EUCAERROR, "ERROR: DescribeResource returned an error\n");
status = 1;
}
ncResource * res = allocate_resource(
(char *)adb_ncDescribeResourceResponseType_get_nodeStatus(response, env),
(int)adb_ncDescribeResourceResponseType_get_memorySizeMax(response, env),
(int)adb_ncDescribeResourceResponseType_get_memorySizeAvailable(response, env),
(int)adb_ncDescribeResourceResponseType_get_diskSizeMax(response, env),
(int)adb_ncDescribeResourceResponseType_get_diskSizeAvailable(response, env),
(int)adb_ncDescribeResourceResponseType_get_numberOfCoresMax(response, env),
(int)adb_ncDescribeResourceResponseType_get_numberOfCoresAvailable(response, env),
(char *)adb_ncDescribeResourceResponseType_get_publicSubnets(response, env));
if (!res) {
logprintfl (EUCAERROR, "ERROR: out of memory in ncDescribeResourceStub()\n");
status = 2;
}
* outRes = res;
}
}
return status;
}
void * __init amiga_chip_alloc_res(unsigned long size, struct resource *res)
{
unsigned long start;
/* round up */
size = PAGE_ALIGN(size);
/* dmesg into chipmem prefers memory at the safe end */
start = CHIP_PHYSADDR + chipavail - size;
#ifdef DEBUG
printk("amiga_chip_alloc_res: allocate %ld bytes\n", size);
#endif
if (allocate_resource(&chipram_res, res, size, start, UINT_MAX, PAGE_SIZE, NULL, NULL) < 0) {
printk("amiga_chip_alloc_res: first alloc failed!\n");
if (allocate_resource(&chipram_res, res, size, 0, UINT_MAX, PAGE_SIZE, NULL, NULL) < 0)
return NULL;
}
chipavail -= size;
#ifdef DEBUG
printk("amiga_chip_alloc_res: returning %lx\n", res->start);
#endif
return (void *)ZTWO_VADDR(res->start);
}
int32_t census_define_resource(const uint8_t *resource_pb,
size_t resource_pb_size) {
if (resource_pb == NULL) {
return -1;
}
gpr_mu_lock(&resource_lock);
size_t id = allocate_resource();
// Validate pb, extract name.
if (!validate_resource_pb(resource_pb, resource_pb_size, id)) {
delete_resource_locked(id);
gpr_mu_unlock(&resource_lock);
return -1;
}
gpr_mu_unlock(&resource_lock);
return (int32_t)id;
}
static struct resource * nonstatic_find_mem_region(u_long base, u_long num,
u_long align, int low, struct pcmcia_socket *s)
{
struct resource *res = make_resource(0, num, IORESOURCE_MEM, s->dev.class_id);
struct socket_data *s_data = s->resource_data;
struct pcmcia_align_data data;
unsigned long min, max;
int ret, i;
low = low || !(s->features & SS_CAP_PAGE_REGS);
data.mask = align - 1;
data.offset = base & data.mask;
data.map = &s_data->mem_db;
for (i = 0; i < 2; i++) {
if (low) {
max = 0x100000UL;
min = base < max ? base : 0;
} else {
max = ~0UL;
min = 0x100000UL + base;
}
down(&rsrc_sem);
#ifdef CONFIG_PCI
if (s->cb_dev) {
ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num,
1, min, 0,
pcmcia_align, &data);
} else
#endif
ret = allocate_resource(&iomem_resource, res, num, min,
max, 1, pcmcia_align, &data);
up(&rsrc_sem);
if (ret == 0 || low)
break;
low = 1;
}
if (ret != 0) {
kfree(res);
res = NULL;
}
return res;
}
void *amiga_chip_alloc_res(unsigned long size, struct resource *res)
{
int error;
/* round up */
size = PAGE_ALIGN(size);
pr_debug("amiga_chip_alloc_res: allocate %lu bytes\n", size);
error = allocate_resource(&chipram_res, res, size, 0, UINT_MAX,
PAGE_SIZE, NULL, NULL);
if (error < 0) {
pr_err("amiga_chip_alloc_res: allocate_resource() failed %d!\n",
error);
return NULL;
}
atomic_sub(size, &chipavail);
pr_debug("amiga_chip_alloc_res: returning %pR\n", res);
return (void *)ZTWO_VADDR(res->start);
}
int f1() {
int * a = NULL;
int b = 35;
struct foo * bar = allocate_resource();
a = g();
b = f();
if (ERR_PTR == a) {
printk("stuff that went wrong");
release_resource(bar);
return a;
}
if (12 < b) {
initialise_resource(bar);
}
return 0;
}
static int make_condition_modifier(struct iforce* iforce,
struct resource* mod_chunk, int no_alloc,
__u16 rsat, __u16 lsat, __s16 rk, __s16 lk, u16 db, __s16 center)
{
unsigned char data[10];
if (!no_alloc) {
mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 8,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
mutex_unlock(&iforce->mem_mutex);
return -ENOSPC;
}
mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
data[1] = HI(mod_chunk->start);
data[2] = (100 * rk) >> 15;
data[3] = (100 * lk) >> 15;
center = (500 * center) >> 15;
data[4] = LO(center);
data[5] = HI(center);
db = (1000 * db) >> 16;
data[6] = LO(db);
data[7] = HI(db);
data[8] = (100 * rsat) >> 16;
data[9] = (100 * lsat) >> 16;
iforce_send_packet(iforce, FF_CMD_CONDITION, data);
iforce_dump_packet("condition", FF_CMD_CONDITION, data);
return 0;
}
static int make_condition_modifier(struct iforce* iforce,
struct resource* mod_chunk, int no_alloc,
__u16 rsat, __u16 lsat, __s16 rk, __s16 lk, u16 db, __s16 center)
{
unsigned char data[10];
if (!no_alloc) {
mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 8,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
mutex_unlock(&iforce->mem_mutex);
return -ENOSPC;
}
mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
data[1] = HI(mod_chunk->start);
data[2] = (100 * rk) >> 15; /* Dangerous: the sign is extended by gcc on plateforms providing an arith shift */
data[3] = (100 * lk) >> 15; /* This code is incorrect on cpus lacking arith shift */
center = (500 * center) >> 15;
data[4] = LO(center);
data[5] = HI(center);
db = (1000 * db) >> 16;
data[6] = LO(db);
data[7] = HI(db);
data[8] = (100 * rsat) >> 16;
data[9] = (100 * lsat) >> 16;
iforce_send_packet(iforce, FF_CMD_CONDITION, data);
iforce_dump_packet("condition", FF_CMD_CONDITION, data);
return 0;
}
static int make_envelope_modifier(struct iforce* iforce,
struct resource* mod_chunk, int no_alloc,
u16 attack_duration, __s16 initial_level,
u16 fade_duration, __s16 final_level)
{
unsigned char data[8];
attack_duration = TIME_SCALE(attack_duration);
fade_duration = TIME_SCALE(fade_duration);
if (!no_alloc) {
mutex_lock(&iforce->mem_mutex);
if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0e,
iforce->device_memory.start, iforce->device_memory.end, 2L,
NULL, NULL)) {
mutex_unlock(&iforce->mem_mutex);
return -ENOSPC;
}
mutex_unlock(&iforce->mem_mutex);
}
data[0] = LO(mod_chunk->start);
data[1] = HI(mod_chunk->start);
data[2] = LO(attack_duration);
data[3] = HI(attack_duration);
data[4] = HI(initial_level);
data[5] = LO(fade_duration);
data[6] = HI(fade_duration);
data[7] = HI(final_level);
iforce_send_packet(iforce, FF_CMD_ENVELOPE, data);
return 0;
}
static int
doDescribeResource( struct nc_state_t *nc,
ncMetadata *meta,
char *resourceType,
ncResource **outRes)
{
ncResource * res;
ncInstance * inst;
/* stats to re-calculate now */
long long mem_free;
long long disk_free;
int cores_free;
/* intermediate sums */
long long sum_mem = 0; /* for known domains: sum of requested memory */
long long sum_disk = 0; /* for known domains: sum of requested disk sizes */
int sum_cores = 0; /* for known domains: sum of requested cores */
*outRes = NULL;
sem_p (inst_sem);
while ((inst=get_instance(&global_instances))!=NULL) {
if (inst->state == TEARDOWN) continue; /* they don't take up resources */
sum_mem += inst->params.memorySize;
sum_disk += (inst->params.diskSize + SWAP_SIZE);
sum_cores += inst->params.numberOfCores;
}
sem_v (inst_sem);
disk_free = nc->disk_max - sum_disk;
if ( disk_free < 0 ) disk_free = 0; /* should not happen */
mem_free = nc->mem_max - sum_mem;
if ( mem_free < 0 ) mem_free = 0; /* should not happen */
cores_free = nc->cores_max - sum_cores; /* TODO: should we -1 for dom0? */
if ( cores_free < 0 ) cores_free = 0; /* due to timesharing */
/* check for potential overflow - should not happen */
if (nc->mem_max > INT_MAX ||
mem_free > INT_MAX ||
nc->disk_max > INT_MAX ||
disk_free > INT_MAX) {
logprintfl (EUCAERROR, "stats integer overflow error (bump up the units?)\n");
logprintfl (EUCAERROR, " memory: max=%-10lld free=%-10lld\n", nc->mem_max, mem_free);
logprintfl (EUCAERROR, " disk: max=%-10lld free=%-10lld\n", nc->disk_max, disk_free);
logprintfl (EUCAERROR, " cores: max=%-10d free=%-10d\n", nc->cores_max, cores_free);
logprintfl (EUCAERROR, " INT_MAX=%-10d\n", INT_MAX);
return 10;
}
res = allocate_resource ("OK", nc->mem_max, mem_free, nc->disk_max, disk_free, nc->cores_max, cores_free, "none");
if (res == NULL) {
logprintfl (EUCAERROR, "Out of memory\n");
return 1;
}
*outRes = res;
return OK;
}
static int wdt_probe(struct pci_dev *pdev,
const struct pci_device_id *ent)
{
unsigned char conf;
int ret = -ENODEV;
if (pci_enable_device(pdev)) {
dev_err(&pdev->dev, "cannot enable PCI device\n");
return -ENODEV;
}
/*
* Allocate a MMIO region which contains watchdog control register
* and counter, then configure the watchdog to use this region.
* This is possible only if PnP is properly enabled in BIOS.
* If not, the watchdog must be configured in BIOS manually.
*/
if (allocate_resource(&iomem_resource, &wdt_res, VIA_WDT_MMIO_LEN,
0xf0000000, 0xffffff00, 0xff, NULL, NULL)) {
dev_err(&pdev->dev, "MMIO allocation failed\n");
goto err_out_disable_device;
}
pci_write_config_dword(pdev, VIA_WDT_MMIO_BASE, wdt_res.start);
pci_read_config_byte(pdev, VIA_WDT_CONF, &conf);
conf |= VIA_WDT_CONF_ENABLE | VIA_WDT_CONF_MMIO;
pci_write_config_byte(pdev, VIA_WDT_CONF, conf);
pci_read_config_dword(pdev, VIA_WDT_MMIO_BASE, &mmio);
if (mmio) {
dev_info(&pdev->dev, "VIA Chipset watchdog MMIO: %x\n", mmio);
} else {
dev_err(&pdev->dev, "MMIO setting failed. Check BIOS.\n");
goto err_out_resource;
}
if (!request_mem_region(mmio, VIA_WDT_MMIO_LEN, "via_wdt")) {
dev_err(&pdev->dev, "MMIO region busy\n");
goto err_out_resource;
}
wdt_mem = ioremap(mmio, VIA_WDT_MMIO_LEN);
if (wdt_mem == NULL) {
dev_err(&pdev->dev, "cannot remap VIA wdt MMIO registers\n");
goto err_out_release;
}
if (timeout < 1 || timeout > WDT_TIMEOUT_MAX)
timeout = WDT_TIMEOUT;
wdt_dev.timeout = timeout;
wdt_dev.parent = &pdev->dev;
watchdog_set_nowayout(&wdt_dev, nowayout);
if (readl(wdt_mem) & VIA_WDT_FIRED)
wdt_dev.bootstatus |= WDIOF_CARDRESET;
ret = watchdog_register_device(&wdt_dev);
if (ret)
goto err_out_iounmap;
/* start triggering, in case of watchdog already enabled by BIOS */
mod_timer(&timer, jiffies + WDT_HEARTBEAT);
return 0;
err_out_iounmap:
iounmap(wdt_mem);
err_out_release:
release_mem_region(mmio, VIA_WDT_MMIO_LEN);
err_out_resource:
release_resource(&wdt_res);
err_out_disable_device:
pci_disable_device(pdev);
return ret;
}
void *roadmap_res_get (unsigned int type, unsigned int flags,
const char *name) {
void *data = NULL;
int mem;
RoadMapResource *res = &Resources[type];
int slot;
if (name == NULL || (name[0] == 0))
return NULL;
if (Resources[type].hash == NULL) allocate_resource (type);
if (! (flags & RES_NOCACHE))
{
int slot;
slot = find_resource ( type, name );
if ( slot >= 0 )
{
roadmap_res_cache_set_MRU( res, slot );
data = res->slots[slot].data;
return data;
}
}
if (flags & RES_NOCREATE) return NULL;
switch (type) {
case RES_BITMAP:
case RES_NATIVE_IMAGE:
if ( strchr (name, '.') )
{
if ( !data )
{
data = load_resource( type, flags, name, &mem );
}
}
else
{
char *full_name = malloc (strlen (name) + 5);
data = NULL;
if ( flags & RES_DOWNLOADED_IMAGE){
#ifdef RIMAPI
/* Try BIN */
if ( !data )
{
sprintf( full_name, "%s.bin", name );
data = load_resource (type, flags, full_name, &mem);
}
#endif
}
/* Try PNG */
if ( !data )
{
sprintf( full_name, "%s.png", name );
data = load_resource (type, flags, full_name, &mem);
}
#if defined (ANDROID) || defined (RIMAPI)
/* Try BIN */
if ( !data )
{
sprintf( full_name, "%s.bin", name );
data = load_resource (type, flags, full_name, &mem);
}
#endif
free (full_name);
}
break;
default:
data = load_resource (type, flags, name, &mem);
}
if (!data) {
if (type != RES_SOUND)
roadmap_log (ROADMAP_ERROR, "roadmap_res_get - resource %s type=%d not found.", name, type);
return NULL;
}
if ( flags & RES_NOCACHE )
{
if ( type == RES_BITMAP )
{
roadmap_canvas_unmanaged_list_add( data );
}
return data;
}
slot = roadmap_res_cache_add( res, roadmap_hash_string( name ) );
roadmap_log( ROADMAP_DEBUG, "Placing the resource at Slot: %d, Flags: %d, ", slot, flags );
res->slots[slot].data = data;
res->slots[slot].name = strdup(name);
res->slots[slot].flags = flags;
res->used_mem += mem;
return data;
}
/* Get framebuffer memory from Hyper-V video pci space */
static int hvfb_getmem(struct fb_info *info)
{
struct hvfb_par *par = info->par;
struct pci_dev *pdev = NULL;
void __iomem *fb_virt;
int gen2vm = efi_enabled(EFI_BOOT);
int ret;
par->mem.name = KBUILD_MODNAME;
par->mem.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
if (gen2vm) {
ret = allocate_resource(&hyperv_mmio, &par->mem,
screen_fb_size,
0, -1,
screen_fb_size,
NULL, NULL);
if (ret != 0) {
pr_err("Unable to allocate framebuffer memory\n");
return -ENODEV;
}
} else {
pdev = pci_get_device(PCI_VENDOR_ID_MICROSOFT,
PCI_DEVICE_ID_HYPERV_VIDEO, NULL);
if (!pdev) {
pr_err("Unable to find PCI Hyper-V video\n");
return -ENODEV;
}
if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM) ||
pci_resource_len(pdev, 0) < screen_fb_size)
goto err1;
par->mem.end = pci_resource_end(pdev, 0);
par->mem.start = par->mem.end - screen_fb_size + 1;
ret = request_resource(&pdev->resource[0], &par->mem);
if (ret != 0) {
pr_err("Unable to request framebuffer memory\n");
goto err1;
}
}
fb_virt = ioremap(par->mem.start, screen_fb_size);
if (!fb_virt)
goto err2;
info->apertures = alloc_apertures(1);
if (!info->apertures)
goto err3;
if (gen2vm) {
info->apertures->ranges[0].base = screen_info.lfb_base;
info->apertures->ranges[0].size = screen_info.lfb_size;
remove_conflicting_framebuffers(info->apertures,
KBUILD_MODNAME, false);
} else {
info->apertures->ranges[0].base = pci_resource_start(pdev, 0);
info->apertures->ranges[0].size = pci_resource_len(pdev, 0);
}
info->fix.smem_start = par->mem.start;
info->fix.smem_len = screen_fb_size;
info->screen_base = fb_virt;
info->screen_size = screen_fb_size;
if (!gen2vm)
pci_dev_put(pdev);
return 0;
err3:
iounmap(fb_virt);
err2:
release_resource(&par->mem);
err1:
if (!gen2vm)
pci_dev_put(pdev);
return -ENOMEM;
}
