/* registers a block r,g,b and returns it's id */
int js_register_block(duk_context *ctx) {
/* get r, g, b values */
const int r = duk_get_int(ctx, 0);
const int g = duk_get_int(ctx, 1);
const int b = duk_get_int(ctx, 2);
/* registers block, may allocate more memory */
register_block(r, g, b);
/* return block's id */
duk_push_int(ctx, blocks_len - 1);
return 1;
}
static bool_t register_romdisk(const char * name, void * start, void * end)
{
struct block_t * blk;
struct romdisk_t * romdisk;
u64_t size;
if(!name)
return FALSE;
size = (u64_t)(end - start);
size = (size + SZ_512) / SZ_512;
if(size <= 0)
return FALSE;
blk = malloc(sizeof(struct block_t));
if(!blk)
return FALSE;
romdisk = malloc(sizeof(struct romdisk_t));
if(!romdisk)
{
free(blk);
return FALSE;
}
romdisk->name = strdup(name);
romdisk->start = start;
romdisk->end = end;
blk->name = romdisk->name;
blk->blksz = SZ_512;
blk->blkcnt = size;
blk->read = romdisk_read;
blk->write = romdisk_write;
blk->sync = romdisk_sync;
blk->suspend = romdisk_suspend;
blk->resume = romdisk_resume;
blk->priv = romdisk;
if(!register_block(blk))
{
free(romdisk->name);
free(romdisk);
free(blk);
return FALSE;
}
return TRUE;
}
static bool_t register_application(const char * name, void * start, void * end)
{
struct block_t * blk;
struct application_t * app;
u64_t size;
if(!name)
return FALSE;
size = (u64_t)(end - start);
size = (size + SZ_512) / SZ_512;
if(size <= 0)
return FALSE;
blk = malloc(sizeof(struct block_t));
if(!blk)
return FALSE;
app = malloc(sizeof(struct application_t));
if(!app)
{
free(blk);
return FALSE;
}
app->name = strdup(name);
app->start = start;
app->end = end;
blk->name = app->name;
blk->blksz = SZ_512;
blk->blkcnt = size;
blk->read = application_read;
blk->write = application_write;
blk->sync = application_sync;
blk->suspend = application_suspend;
blk->resume = application_resume;
blk->priv = app;
if(!register_block(blk))
{
free(app->name);
free(app);
free(blk);
return FALSE;
}
return TRUE;
}
static struct device_t * romdisk_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct romdisk_pdata_t * pdat;
struct block_t * blk;
struct device_t * dev;
virtual_addr_t addr = strtoull(dt_read_string(n, "address", "0"), NULL, 0);
virtual_size_t size = strtoull(dt_read_string(n, "size", "0"), NULL, 0);
if(size <= 0)
return NULL;
size = (size + SZ_512) / SZ_512;
pdat = malloc(sizeof(struct romdisk_pdata_t));
if(!pdat)
return NULL;
blk = malloc(sizeof(struct block_t));
if(!blk)
{
free(pdat);
return NULL;
}
pdat->addr = addr;
pdat->size = size;
blk->name = alloc_device_name(dt_read_name(n), dt_read_id(n));
blk->blksz = SZ_512;
blk->blkcnt = (u64_t)size;
blk->read = romdisk_read;
blk->write = romdisk_write;
blk->sync = romdisk_sync;
blk->priv = pdat;
if(!register_block(&dev, blk))
{
free_device_name(blk->name);
free(blk->priv);
free(blk);
return NULL;
}
dev->driver = drv;
return dev;
}
static bool_t spi_flash_register(struct resource_t * res)
{
struct spi_flash_data_t * rdat = (struct spi_flash_data_t *)res->data;
struct spi_flash_private_data_t * dat;
struct spi_device_t * dev;
struct spi_flash_id_t * id;
struct block_t * blk;
char name[64];
dev = spi_device_alloc(rdat->spibus, rdat->mode, 8, rdat->speed);
if(!dev)
return FALSE;
id = spi_flash_read_id(dev);
if(!id)
{
spi_device_free(dev);
return FALSE;
}
dat = malloc(sizeof(struct spi_flash_private_data_t));
if(!dat)
{
spi_device_free(dev);
return FALSE;
}
blk = malloc(sizeof(struct block_t));
if(!blk)
{
spi_device_free(dev);
free(dat);
return FALSE;
}
snprintf(name, sizeof(name), "%s.%d", res->name, res->id);
dat->dev = dev;
dat->id = id;
blk->name = strdup(name);
if(id->flags & SECTOR_4K)
{
blk->blksz = 4096;
blk->blkcnt = id->sector_size * id->sector_count / 4096;
}
else
{
blk->blksz = id->sector_size;
blk->blkcnt = id->sector_count;
}
blk->read = spi_flash_read;
blk->write = spi_flash_write;
blk->sync = spi_flash_sync;
blk->suspend = spi_flash_suspend;
blk->resume = spi_flash_resume;
blk->priv = dat;
spi_flash_write_enable(dev);
spi_flash_write_status_register(dev, 0);
if(register_block(blk))
return TRUE;
spi_device_free(dev);
free(blk->priv);
free(blk->name);
free(blk);
return FALSE;
}
