140 lines
3.0 KiB
C
140 lines
3.0 KiB
C
#include <device/device.h>
|
|
#include <device/storage/partitions.h>
|
|
#include <device/storage/ramdrv.h>
|
|
#include <devices.h>
|
|
#include <libk/align.h>
|
|
#include <libk/std.h>
|
|
#include <libk/string.h>
|
|
#include <mm/malloc.h>
|
|
#include <status.h>
|
|
#include <sys/debug.h>
|
|
|
|
DEFINE_DEVICE_INIT (ramdrv_init) {
|
|
struct ramdrv_init* init = arg;
|
|
|
|
struct ramdrv* ramdrv = malloc (sizeof (*ramdrv));
|
|
|
|
if (ramdrv == NULL)
|
|
return false;
|
|
|
|
ramdrv->sector_size = init->sector_size;
|
|
ramdrv->total_size = align_up (init->total_size, ramdrv->sector_size);
|
|
|
|
ramdrv->buffer = malloc (ramdrv->total_size);
|
|
|
|
if (ramdrv->buffer == NULL) {
|
|
free (ramdrv);
|
|
return false;
|
|
}
|
|
|
|
memset (ramdrv->buffer, 0, ramdrv->total_size);
|
|
|
|
if (init->buffer != NULL)
|
|
memcpy (ramdrv->buffer, init->buffer, init->total_size);
|
|
|
|
device->udata = ramdrv;
|
|
|
|
return true;
|
|
}
|
|
|
|
DEFINE_DEVICE_FINI (ramdrv_fini) {
|
|
struct ramdrv* ramdrv = device->udata;
|
|
|
|
free (ramdrv->buffer);
|
|
free (ramdrv);
|
|
}
|
|
|
|
DEFINE_DEVICE_OP (ramdrv_get_device_type) {
|
|
if (a1 == NULL)
|
|
return -ST_BAD_ADDRESS_SPACE;
|
|
|
|
int* device_type = (int*)a1;
|
|
|
|
*device_type = XDRV_TYPE_RAMDRV;
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
DEFINE_DEVICE_OP (ramdrv_get_size) {
|
|
if (a1 == NULL)
|
|
return -ST_BAD_ADDRESS_SPACE;
|
|
|
|
size_t* size = (size_t*)a1;
|
|
|
|
struct ramdrv* ramdrv = device->udata;
|
|
|
|
*size = ramdrv->total_size;
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
DEFINE_DEVICE_OP (ramdrv_get_sector_size) {
|
|
if (a1 == NULL)
|
|
return -ST_BAD_ADDRESS_SPACE;
|
|
|
|
size_t* secsize = (size_t*)a1;
|
|
|
|
struct ramdrv* ramdrv = device->udata;
|
|
|
|
*secsize = ramdrv->sector_size;
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
DEFINE_DEVICE_OP (ramdrv_read) {
|
|
if (a1 == NULL || a2 == NULL || a3 == NULL)
|
|
return -ST_BAD_ADDRESS_SPACE;
|
|
|
|
size_t sector = *(size_t*)a1;
|
|
size_t sector_count = *(size_t*)a2;
|
|
uint8_t* buffer = a3;
|
|
|
|
struct ramdrv* ramdrv = device->udata;
|
|
size_t pos = sector * ramdrv->sector_size;
|
|
size_t size = sector_count * ramdrv->sector_size;
|
|
|
|
memcpy (buffer, (void*)(((uintptr_t)ramdrv->buffer) + pos), size);
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
DEFINE_DEVICE_OP (ramdrv_write) {
|
|
if (a1 == NULL || a2 == NULL || a3 == NULL)
|
|
return -ST_BAD_ADDRESS_SPACE;
|
|
|
|
size_t sector = *(size_t*)a1;
|
|
size_t sector_count = *(size_t*)a2;
|
|
uint8_t* buffer = a3;
|
|
|
|
struct ramdrv* ramdrv = device->udata;
|
|
size_t pos = sector * ramdrv->sector_size;
|
|
size_t size = sector_count * ramdrv->sector_size;
|
|
|
|
memcpy ((void*)(((uintptr_t)ramdrv->buffer) + pos), buffer, size);
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
DEFINE_DEVICE_OP (ramdrv_partition_rescan) {
|
|
uint64_t fsd;
|
|
|
|
struct list_node_link *subdevice_link, *tmp_subdevice_link;
|
|
list_foreach (device->subdevices, subdevice_link, tmp_subdevice_link) {
|
|
struct device* subdevice = list_entry (subdevice_link, struct device, subdevices_link);
|
|
|
|
spin_lock (&subdevice->lock, &fsd);
|
|
list_remove (device->subdevices, &subdevice->subdevices_link);
|
|
spin_unlock (&subdevice->lock, fsd);
|
|
|
|
device_delete (subdevice->key, proc, rctx);
|
|
}
|
|
|
|
spin_unlock (&device->lock, *lockflags);
|
|
|
|
int r = device_probe_partitions (proc, rctx, device);
|
|
|
|
spin_lock (&device->lock, lockflags);
|
|
|
|
return r;
|
|
}
|