char *svga_rcall(uint64_t source, struct vfs_obj *file, const char *args) {
char *rets = NULL;
int x, y, d, w, h;
int mode;
if (!strcmp(args, "getmode")) {
rets = malloc(16);
sprintf(rets, "%d %d %d", svga.w, svga.h, svga.d);
return rets;
}
if (!strcmp(args, "listmodes")) {
return strdup(modesstr);
}
if (!strcmp(args, "unshare")) {
mutex_spin(&file->mutex);
page_free(buffer, msize(buffer));
free(buffer);
buffer = valloc(svga.w * svga.h * 4);
mutex_free(&file->mutex);
return strdup("T");
}
if (!strncmp(args, "setmode ", 8)) {
if (sscanf(args + 8, "%i %i %i", &x, &y, &d) != 3) {
return strdup("");
}
mutex_spin(&file->mutex);
mode = svga_find_mode(x, y, d);
if (svga_set_mode(mode)) {
return strdup("");
}
page_free(buffer, msize(buffer));
free(buffer);
buffer = valloc(svga.w * svga.h * 4);
mutex_free(&file->mutex);
return strdup("T");
}
if (!strncmp(args, "syncrect ", 9)) {
if (sscanf(args + 9, "%i %i %i %i", &x, &y, &w, &h) != 4) {
return strdup("");
}
mutex_spin(&file->mutex);
svga_fliprect(buffer, x, y, w, h);
mutex_free(&file->mutex);
return strdup("T");
}
return NULL;
}
int fb_setbmp(struct fb *fb, uint32_t *bitmap) {
if (!fb) {
return 1;
}
mutex_spin(&fb->mutex);
// unshare old bitmap
if (fb->flags & FB_SHARED) {
rp_share(fb->rp, fd_getkey(fb->fd, AC_WRITE), NULL, 0, 0, 0);
fb->flags &= ~FB_SHARED;
}
// free old bitmap
if (fb->bitmap && !(fb->flags & FB_USRBMP)) {
free(fb->bitmap);
}
// set bitmap
fb->bitmap = bitmap;
fb->flags |= FB_USRBMP;
// check for shared memory interface
if (!rp_share(fb->rp, fd_getkey(fb->fd, AC_WRITE), fb->bitmap,
fb->xdim * fb->ydim * sizeof(uint32_t), 0, PROT_READ)) {
// successful
fb->flags |= FB_SHARED;
}
mutex_free(&fb->mutex);
return 0;
}
int mqueue_push(struct msg *msg) {
struct mqueue_msg *node;
uint8_t port;
if (!msg) {
return 1;
}
port = msg->port;
mutex_spin(&mqueue[port].mutex);
node = malloc(sizeof(struct mqueue_msg));
if (!node) {
return 1;
}
node->next = NULL;
node->prev = mqueue[port].back;
node->msg = msg;
if (!mqueue[port].front) mqueue[port].front = node;
if (mqueue[port].back) mqueue[port].back->next = node;
mqueue[port].back = node;
mutex_free(&mqueue[port].mutex);
return 0;
}
struct msg *mqueue_pull(uint8_t port, uint64_t source) {
struct mqueue_msg *node;
struct msg *msg;
mutex_spin(&mqueue[port].mutex);
if (source) {
for (node = mqueue[port].front; node; node = node->next) {
if (node->msg->source == source) {
break;
}
}
}
else {
node = mqueue[port].front;
}
if (!node) {
mutex_free(&mqueue[port].mutex);
return NULL;
}
if (node->prev) node->prev->next = node->next;
else mqueue[port].front = node->next;
if (node->next) node->next->prev = node->prev;
else mqueue[port].back = node->prev;
mutex_free(&mqueue[port].mutex);
msg = node->msg;
free(node);
return msg;
}
size_t tmpfs_read(struct robject *self, rp_t source, uint8_t *buffer, size_t size, off_t offset) {
uint8_t *file_data;
off_t *file_size;
mutex_spin(&self->driver_mutex);
file_data = robject_data(self, "data");
file_size = robject_data(self, "size");
if (!file_data || !file_size) {
mutex_free(&self->driver_mutex);
return 0;
}
if (offset > *file_size) {
mutex_free(&self->driver_mutex);
return 0;
}
if (offset + size >= *file_size) {
size = *file_size - offset;
}
memcpy(buffer, &file_data[offset], size);
mutex_free(&self->driver_mutex);
return size;
}
size_t tmpfs_write(struct robject *self, rp_t source, uint8_t *buffer, size_t size, off_t offset) {
uint8_t *file_data;
off_t _file_size = 0;
off_t *file_size;
mutex_spin(&self->driver_mutex);
file_data = robject_data(self, "data");
file_size = robject_data(self, "size");
if (!file_size) {
file_size = &_file_size;
}
if (offset + size >= *file_size) {
file_data = realloc(file_data, offset + size);
robject_set_data(self, "data", file_data);
if (file_size == &_file_size) {
file_size = malloc(sizeof(off_t));
}
*file_size = offset + size;
robject_set_data(self, "size", file_size);
}
memcpy(&file_data[offset], buffer, size);
mutex_free(&self->driver_mutex);
return size;
}
void rewind(FILE *stream) {
fflush(stream);
mutex_spin(&stream->mutex);
stream->position = 0;
mutex_free(&stream->mutex);
}
int fgetpos(FILE *stream, fpos_t *pos) {
int ret;
mutex_spin(&stream->mutex);
if (pos && stream) {
*pos = stream->position;
*pos += stream->buffpos;
ret = 0;
}
else {
errno = EINVAL;
ret = -1;
}
mutex_spin(&stream->mutex);
return ret;
}
char *svga_rcall_unshare(struct robject *self, rp_t source, int argc, char **argv) {
mutex_spin(&self->driver_mutex);
page_free(buffer, msize(buffer));
free(buffer);
buffer = valloc(svga.w * svga.h * 4);
mutex_free(&self->driver_mutex);
return strdup("T");
}
int svga_sync(uint64_t source, struct vfs_obj *file) {
if (!buffer) {
return -1;
}
mutex_spin(&file->mutex);
svga_flip(buffer);
mutex_free(&file->mutex);
return 0;
}
fpos_t ftell(FILE *stream) {
fpos_t pos;
mutex_spin(&stream->mutex);
pos = stream->position;
pos += stream->buffpos;
mutex_free(&stream->mutex);
return pos;
}
void __sig_init(void) {
size_t i;
mutex_spin(&__sigmutex);
for (i = 0; i < SIGMAX; i++) {
__sighandlerv[i] = SIG_DFL;
when(i, _sigwrap);
}
mutex_free(&__sigmutex);
}
int fflush(FILE *stream) {
mutex_spin(&stream->mutex);
if (stream->buffer && stream->buffpos) {
write(stream->fd, stream->buffer, stream->buffpos, stream->position);
stream->position += stream->buffpos;
stream->buffpos = 0;
}
mutex_free(&stream->mutex);
return 0;
}
char *svga_rcall_syncrect(struct robject *self, rp_t source, int argc, char **argv) {
int x, y, w, h;
if (argc != 5) return NULL;
x = atoi(argv[1]);
y = atoi(argv[2]);
w = atoi(argv[3]);
h = atoi(argv[4]);
mutex_spin(&self->driver_mutex);
svga_fliprect(buffer, x, y, w, h);
mutex_free(&self->driver_mutex);
return strdup("T");
}
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) {
const uint8_t *data = ptr;
size_t i, ret;
if (!stream) {
return 0;
}
if (!(size * nmemb)) {
return 0;
}
mutex_spin(&stream->mutex);
if (stream->flags & FILE_NBF) {
ret = write(stream->fd, (void*) ptr, size * nmemb, stream->position);
stream->position += ret;
if (size == 0) {
size = 1;
}
mutex_free(&stream->mutex);
return (ret / size);
}
for (i = 0; i < size * nmemb; i++) {
stream->buffer[stream->buffpos++] = data[i];
if (stream->flags & FILE_LBF) {
if ((data[i] == '\n') || (stream->buffpos > stream->buffsize)) {
mutex_free(&stream->mutex);
fflush(stream);
}
}
else {
if (stream->buffpos >= stream->buffsize) {
mutex_free(&stream->mutex);
fflush(stream);
}
}
}
return nmemb;
}
size_t svga_write(uint64_t source, struct vfs_obj *file, uint8_t *_buffer, size_t size, uint64_t off) {
size_t i;
mutex_spin(&file->mutex);
if (size > svga.w * svga.h * 4 - off) {
size = svga.w * svga.h * 4 - off;
}
for (i = 0; i < size; i++) {
((uint8_t*) buffer)[i + off] = buffer[i];
}
mutex_free(&file->mutex);
return size;
}
int fclose(FILE *stream) {
fflush(stream);
mutex_spin(&stream->mutex);
if (stream->buffer) {
free(stream->buffer);
}
mutex_free(&stream->mutex);
close(stream->fd);
free(stream);
return 0;
}
static void pipe_putc(struct pipe *pipe, int datum) {
struct pipe_node *node;
node = malloc(sizeof(struct pipe_node));
node->datum = datum;
node->next = NULL;
mutex_spin(&pipe->mutex);
if (!pipe->back) {
pipe->back = node;
pipe->front = node;
}
else {
pipe->back->next = node;
pipe->back = node;
}
mutex_free(&pipe->mutex);
}
int fflush(FILE *stream) {
size_t size;
if (!stream) {
return -1;
}
mutex_spin(&stream->mutex);
if (stream->buffer && stream->buffpos) {
size = rp_write(fd_rp(stream->fd), stream->buffer, stream->buffpos, stream->position);
stream->position += size;
stream->buffpos -= size;
}
mutex_free(&stream->mutex);
return 0;
}
char *tmpfs_reset(struct robject *self, rp_t source, int argc, char **argv) {
uint8_t *file_data;
off_t *file_size;
mutex_spin(&self->driver_mutex);
file_data = robject_data(self, "data");
file_size = robject_data(self, "size");
free(file_data);
free(file_size);
robject_set_data(self, "data", NULL);
robject_set_data(self, "size", NULL);
mutex_free(&self->driver_mutex);
return strdup("T");
}
int fsetpos(FILE *stream, fpos_t *pos) {
int ret;
fflush(stream);
mutex_spin(&stream->mutex);
if (stream && pos) {
stream->position = *pos;
ret = 0;
}
else {
errno = EINVAL;
ret = -1;
}
mutex_free(&stream->mutex);
return ret;
}
char *svga_rcall_setmode(struct robject *self, rp_t source, int argc, char **argv) {
int x, y, d;
int mode;
if (argc != 4) return NULL;
x = atoi(argv[1]);
y = atoi(argv[2]);
d = atoi(argv[3]);
mutex_spin(&self->driver_mutex);
mode = svga_find_mode(x, y, d);
if (svga_set_mode(mode)) return NULL;
page_free(buffer, msize(buffer));
free(buffer);
buffer = valloc(svga.w * svga.h * 4);
mutex_free(&self->driver_mutex);
return strdup("T");
}
static int pipe_getc(struct pipe *pipe) {
struct pipe_node *node;
int datum;
mutex_spin(&pipe->mutex);
if (pipe->front) {
datum = pipe->front->datum;
node = pipe->front;
pipe->front = node->next;
if (pipe->back == node) {
pipe->back = NULL;
}
free(node);
}
else {
datum = ERR_EMPTY;
}
mutex_free(&pipe->mutex);
return datum;
}
int svga_share(uint64_t source, struct vfs_obj *file, uint8_t *_buffer, size_t size, uint64_t off) {
if (size != svga.w * svga.h * 4) {
return -1;
}
if (off != 0) {
return -1;
}
mutex_spin(&file->mutex);
if (buffer) {
page_free(buffer, msize(buffer));
free(buffer);
}
buffer = (uint32_t*) _buffer;
mutex_free(&file->mutex);
return 0;
}
void mouse_irq(struct msg *msg) {
mutex_spin(&mutex);
read_byte();
mutex_free(&mutex);
}
