Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4537 → Rev 4668

/branches/dd/uspace/srv/bd/file_bd/file_bd.c
44,11 → 44,12
#include <ipc/bd.h>
#include <async.h>
#include <as.h>
#include <futex.h>
#include <fibril_sync.h>
#include <devmap.h>
#include <sys/types.h>
#include <errno.h>
#include <bool.h>
#include <task.h>
 
#define NAME "file_bd"
 
56,12 → 57,12
static FILE *img;
 
static dev_handle_t dev_handle;
static atomic_t dev_futex = FUTEX_INITIALIZER;
static fibril_mutex_t dev_lock;
 
static int file_bd_init(const char *fname);
static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
static int file_bd_read(off_t blk_idx, off_t size, void *buf);
static int file_bd_write(off_t blk_idx, off_t size, void *buf);
static int file_bd_read(off_t blk_idx, size_t size, void *buf);
static int file_bd_write(off_t blk_idx, size_t size, void *buf);
 
int main(int argc, char **argv)
{
86,6 → 87,7
}
 
printf(NAME ": Accepting connections\n");
task_retval(0);
async_manager();
 
/* Not reached */
106,6 → 108,8
if (img == NULL)
return EINVAL;
 
fibril_mutex_initialize(&dev_lock);
 
return EOK;
}
 
118,7 → 122,7
int flags;
int retval;
off_t idx;
off_t size;
size_t size;
 
/* Answer the IPC_M_CONNECT_ME_TO call. */
ipc_answer_0(iid, EOK);
165,27 → 169,21
}
}
 
static int file_bd_read(off_t blk_idx, off_t size, void *buf)
static int file_bd_read(off_t blk_idx, size_t size, void *buf)
{
size_t n_rd;
 
printf("file_bd_read\n");
futex_down(&dev_futex);
fibril_mutex_lock(&dev_lock);
 
printf("seek\n");
fseek(img, blk_idx * size, SEEK_SET);
printf("read\n");
n_rd = fread(buf, 1, size, img);
printf("done\n");
 
printf("done\n");
 
if (ferror(img)) {
futex_up(&dev_futex);
fibril_mutex_unlock(&dev_lock);
return EIO; /* Read error */
}
 
futex_up(&dev_futex);
fibril_mutex_unlock(&dev_lock);
 
if (n_rd < size)
return EINVAL; /* Read beyond end of disk */
193,21 → 191,21
return EOK;
}
 
static int file_bd_write(off_t blk_idx, off_t size, void *buf)
static int file_bd_write(off_t blk_idx, size_t size, void *buf)
{
size_t n_wr;
 
futex_down(&dev_futex);
fibril_mutex_lock(&dev_lock);
 
fseek(img, blk_idx * size, SEEK_SET);
n_wr = fread(buf, 1, size, img);
 
if (ferror(img) || n_wr < size) {
futex_up(&dev_futex);
fibril_mutex_unlock(&dev_lock);
return EIO; /* Write error */
}
 
futex_up(&dev_futex);
fibril_mutex_unlock(&dev_lock);
 
return EOK;
}
/branches/dd/uspace/srv/bd/rd/rd.c
50,7 → 50,7
#include <async.h>
#include <align.h>
#include <async.h>
#include <futex.h>
#include <fibril_sync.h>
#include <stdio.h>
#include <devmap.h>
#include <ipc/bd.h>
63,12 → 63,12
static size_t rd_size;
 
/**
* This futex protects the ramdisk's data.
* This rwlock protects the ramdisk's data.
* If we were to serve multiple requests (read + write or several writes)
* concurrently (i.e. from two or more threads), each read and write needs to be
* protected by this futex.
* protected by this rwlock.
*/
atomic_t rd_futex = FUTEX_INITIALIZER;
fibril_rwlock_t rd_lock;
 
/** Handle one connection to ramdisk.
*
139,9 → 139,9
retval = ELIMIT;
break;
}
futex_down(&rd_futex);
fibril_rwlock_read_lock(&rd_lock);
memcpy(fs_va, rd_addr + offset * block_size, block_size);
futex_up(&rd_futex);
fibril_rwlock_read_unlock(&rd_lock);
retval = EOK;
break;
case BD_WRITE_BLOCK:
161,9 → 161,9
retval = ELIMIT;
break;
}
futex_up(&rd_futex);
fibril_rwlock_write_lock(&rd_lock);
memcpy(rd_addr + offset * block_size, fs_va, block_size);
futex_down(&rd_futex);
fibril_rwlock_write_unlock(&rd_lock);
retval = EOK;
break;
default:
216,6 → 216,8
printf(NAME ": Unable to register device\n");
return false;
}
 
fibril_rwlock_initialize(&rd_lock);
return true;
}
/branches/dd/uspace/srv/bd/gxe_bd/gxe_bd.c
42,10 → 42,11
#include <ipc/bd.h>
#include <async.h>
#include <as.h>
#include <futex.h>
#include <fibril_sync.h>
#include <devmap.h>
#include <sys/types.h>
#include <errno.h>
#include <task.h>
 
#define NAME "gxe_bd"
 
91,11 → 92,11
 
static dev_handle_t dev_handle[MAX_DISKS];
 
static atomic_t dev_futex = FUTEX_INITIALIZER;
static fibril_mutex_t dev_lock[MAX_DISKS];
 
static int gxe_bd_init(void);
static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, off_t size,
static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
void *buf);
static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,
void *buf);
110,6 → 111,7
return -1;
 
printf(NAME ": Accepting connections\n");
task_retval(0);
async_manager();
 
/* Not reached */
145,6 → 147,7
name);
return rc;
}
fibril_mutex_initialize(&dev_lock[i]);
}
 
return EOK;
160,7 → 163,7
int flags;
int retval;
off_t idx;
off_t size;
size_t size;
int disk_id, i;
 
/* Get the device handle. */
220,7 → 223,7
}
}
 
static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, off_t size,
static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
void *buf)
{
int rc;
256,7 → 259,7
size_t i;
uint32_t w;
 
futex_down(&dev_futex);
fibril_mutex_lock(&dev_lock[disk_id]);
pio_write_32(&dev->offset_lo, (uint32_t) offset);
pio_write_32(&dev->offset_hi, offset >> 32);
pio_write_32(&dev->disk_id, disk_id);
264,6 → 267,7
 
status = pio_read_32(&dev->status);
if (status == STATUS_FAILURE) {
fibril_mutex_unlock(&dev_lock[disk_id]);
return EIO;
}
 
271,7 → 275,7
((uint8_t *) buf)[i] = w = pio_read_8(&dev->buffer[i]);
}
 
futex_up(&dev_futex);
fibril_mutex_unlock(&dev_lock[disk_id]);
return EOK;
}
 
285,7 → 289,7
pio_write_8(&dev->buffer[i], ((const uint8_t *) buf)[i]);
}
 
futex_down(&dev_futex);
fibril_mutex_lock(&dev_lock[disk_id]);
pio_write_32(&dev->offset_lo, (uint32_t) offset);
pio_write_32(&dev->offset_hi, offset >> 32);
pio_write_32(&dev->disk_id, disk_id);
293,10 → 297,11
 
status = pio_read_32(&dev->status);
if (status == STATUS_FAILURE) {
fibril_mutex_unlock(&dev_lock[disk_id]);
return EIO;
}
 
futex_up(&dev_futex);
fibril_mutex_unlock(&dev_lock[disk_id]);
return EOK;
}
 
/branches/dd/uspace/srv/bd/ata_bd/ata_bd.h
36,6 → 36,7
#define __ATA_BD_H__
 
#include <sys/types.h>
#include <fibril_sync.h>
 
enum {
CTL_READ_START = 0,
50,22 → 51,32
MAX_DISKS = 2
};
 
/** ATA Command Register Block. */
typedef union {
/* Read */
/* Read/Write */
struct {
uint8_t data_port;
uint8_t error;
uint16_t data_port;
uint8_t sector_count;
uint8_t sector_number;
uint8_t cylinder_low;
uint8_t cylinder_high;
uint8_t drive_head;
uint8_t pad_rw0;
};
 
/* Read Only */
struct {
uint8_t pad_ro0;
uint8_t error;
uint8_t pad_ro1[5];
uint8_t status;
};
 
/* Write */
/* Write Only */
struct {
uint8_t pad0[7];
uint8_t pad_wo0;
uint8_t features;
uint8_t pad_wo1[5];
uint8_t command;
};
} ata_cmd_t;
129,6 → 140,9
unsigned cylinders;
unsigned sectors;
uint64_t blocks;
 
fibril_mutex_t lock;
dev_handle_t dev_handle;
} disk_t;
 
#endif
/branches/dd/uspace/srv/bd/ata_bd/ata_bd.c
37,6 → 37,9
* This driver currently works only with CHS addressing and uses PIO.
* Currently based on the (now obsolete) ANSI X3.221-1994 (ATA-1) standard.
* At this point only reading is possible, not writing.
*
* The driver services a single controller which can have up to two disks
* attached.
*/
 
#include <stdio.h>
46,11 → 49,12
#include <ipc/bd.h>
#include <async.h>
#include <as.h>
#include <futex.h>
#include <fibril_sync.h>
#include <devmap.h>
#include <sys/types.h>
#include <errno.h>
#include <bool.h>
#include <task.h>
 
#include "ata_bd.h"
 
64,15 → 68,12
static ata_cmd_t *cmd;
static ata_ctl_t *ctl;
 
static dev_handle_t dev_handle[MAX_DISKS];
 
static atomic_t dev_futex = FUTEX_INITIALIZER;
 
/** Per-disk state. */
static disk_t disk[MAX_DISKS];
 
static int ata_bd_init(void);
static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, off_t size,
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
void *buf);
static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
void *buf);
89,14 → 90,15
 
printf(NAME ": ATA disk driver\n");
 
printf("cmd_physical = 0x%x\n", cmd_physical);
printf("ctl_physical = 0x%x\n", ctl_physical);
printf("I/O address 0x%x\n", cmd_physical);
 
if (ata_bd_init() != EOK)
return -1;
 
/* Put drives to reset, disable interrupts. */
printf("Reset drives...\n");
printf("Reset drives... ");
fflush(stdout);
 
pio_write_8(&ctl->device_control, DCR_SRST);
/* FIXME: Find out how to do this properly. */
async_usleep(100);
107,8 → 109,6
} while ((status & SR_BSY) != 0);
printf("Done\n");
 
printf("Status = 0x%x\n", pio_read_8(&cmd->status));
 
(void) drive_identify(0, &disk[0]);
(void) drive_identify(1, &disk[1]);
 
120,7 → 120,7
continue;
 
snprintf(name, 16, "disk%d", i);
rc = devmap_device_register(name, &dev_handle[i]);
rc = devmap_device_register(name, &disk[i].dev_handle);
if (rc != EOK) {
devmap_hangup_phone(DEVMAP_DRIVER);
printf(NAME ": Unable to register device %s.\n",
136,6 → 136,7
}
 
printf(NAME ": Accepting connections\n");
task_retval(0);
async_manager();
 
/* Not reached */
146,15 → 147,16
{
uint16_t data;
uint8_t status;
int i;
size_t i;
 
printf("Identify drive %d\n", disk_id);
printf("Identify drive %d... ", disk_id);
fflush(stdout);
 
pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
async_usleep(100);
pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
 
status = pio_read_8(&cmd->status);
printf("Status = 0x%x\n", status);
 
d->present = false;
 
181,8 → 183,6
}
}
 
printf("\n\nStatus = 0x%x\n", pio_read_8(&cmd->status));
 
d->blocks = d->cylinders * d->heads * d->sectors;
 
printf("Geometry: %u cylinders, %u heads, %u sectors\n",
189,6 → 189,7
d->cylinders, d->heads, d->sectors);
 
d->present = true;
fibril_mutex_initialize(&d->lock);
 
return EOK;
}
234,7 → 235,7
int flags;
int retval;
off_t idx;
off_t size;
size_t size;
int disk_id, i;
 
/* Get the device handle. */
243,7 → 244,7
/* Determine which disk device is the client connecting to. */
disk_id = -1;
for (i = 0; i < MAX_DISKS; i++)
if (dev_handle[i] == dh)
if (disk[i].dev_handle == dh)
disk_id = i;
 
if (disk_id < 0 || disk[disk_id].present == false) {
294,14 → 295,14
}
}
 
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, off_t size,
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
void *buf)
{
int rc;
off_t now;
size_t now;
 
while (size > 0) {
now = size < block_size ? size : (off_t) block_size;
now = size < block_size ? size : block_size;
if (now != block_size)
return EINVAL;
 
355,7 → 356,7
((disk_id != 0) ? DHR_DRV : 0) |
(h & 0x0f);
 
futex_down(&dev_futex);
fibril_mutex_lock(&d->lock);
 
/* Program a Read Sectors operation. */
 
377,7 → 378,7
((uint16_t *) buf)[i] = data;
}
 
futex_up(&dev_futex);
fibril_mutex_unlock(&d->lock);
return EOK;
}
 
409,7 → 410,7
((disk_id != 0) ? DHR_DRV : 0) |
(h & 0x0f);
 
futex_down(&dev_futex);
fibril_mutex_lock(&d->lock);
 
/* Program a Read Sectors operation. */
 
430,7 → 431,7
pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
}
 
futex_up(&dev_futex);
fibril_mutex_unlock(&d->lock);
return EOK;
}