WebSVN – HelenOS – Diff – /branches/dd/uspace/srv/bd/gxe_bd/gxe_bd.c



#include <ddi.h>
#include <ipc/ipc.h>
#include <ipc/bd.h>
#include <async.h>
#include <as.h>
#include <fibril_sync.h>
#include <devmap.h>
#include <sys/types.h>
#include <errno.h>
#include <task.h>
 
#define NAME "gxe_bd"
 
enum {
    CTL_READ_START  = 0,

static uintptr_t dev_physical = 0x13000000;
static gxe_bd_t *dev;
 
static dev_handle_t dev_handle[MAX_DISKS];
 
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, size_t size,
    void *buf);
static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,
    void *buf);
static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
    const void *buf);

 
    if (gxe_bd_init() != EOK)
        return -1;
 
    printf(NAME ": Accepting connections\n");
    task_retval(0);
    async_manager();
 
    /* Not reached */
    return 0;
}

            devmap_hangup_phone(DEVMAP_DRIVER);
            printf(NAME ": Unable to register device %s.\n",
                name);
            return rc;
        }
        fibril_mutex_initialize(&dev_lock[i]);
    }
 
    return EOK;
}
 

    ipcarg_t method;
    dev_handle_t dh;
    int flags;
    int retval;
    off_t idx;
    size_t size;
    int disk_id, i;
 
    /* Get the device handle. */
    dh = IPC_GET_ARG1(*icall);
 

        }
        ipc_answer_0(callid, retval);
    }
}
 
static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
    void *buf)
{
    int rc;
    size_t now;
 

{
    uint32_t status;
    size_t i;
    uint32_t w;
 
    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);
    pio_write_32(&dev->control, CTL_READ_START);
 
    status = pio_read_32(&dev->status);
    if (status == STATUS_FAILURE) {
        fibril_mutex_unlock(&dev_lock[disk_id]);
        return EIO;
    }
 
    for (i = 0; i < size; i++) {
        ((uint8_t *) buf)[i] = w = pio_read_8(&dev->buffer[i]);
    }
 
    fibril_mutex_unlock(&dev_lock[disk_id]);
    return EOK;
}
 
static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
    const void *buf)

 
    for (i = 0; i < size; i++) {
        pio_write_8(&dev->buffer[i], ((const uint8_t *) buf)[i]);
    }
 
    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);
    pio_write_32(&dev->control, CTL_WRITE_START);
 
    status = pio_read_32(&dev->status);
    if (status == STATUS_FAILURE) {
        fibril_mutex_unlock(&dev_lock[disk_id]);
        return EIO;
    }
 
    fibril_mutex_unlock(&dev_lock[disk_id]);
    return EOK;
}
 
/**
 * @}

Rev 4537	Rev 4668
Line 40...	Line 40...
40	#include <ddi.h>	40	#include <ddi.h>
41	#include <ipc/ipc.h>	41	#include <ipc/ipc.h>
42	#include <ipc/bd.h>	42	#include <ipc/bd.h>
43	#include <async.h>	43	#include <async.h>
44	#include <as.h>	44	#include <as.h>
45	#include <futex.h>	45	#include <fibril_sync.h>
46	#include <devmap.h>	46	#include <devmap.h>
47	#include <sys/types.h>	47	#include <sys/types.h>
48	#include <errno.h>	48	#include <errno.h>
-		49	#include <task.h>
49		50
50	#define NAME "gxe_bd"	51	#define NAME "gxe_bd"
51		52
52	enum {	53	enum {
53	CTL_READ_START = 0,	54	CTL_READ_START = 0,
Line 89...	Line 90...
89	static uintptr_t dev_physical = 0x13000000;	90	static uintptr_t dev_physical = 0x13000000;
90	static gxe_bd_t *dev;	91	static gxe_bd_t *dev;
91		92
92	static dev_handle_t dev_handle[MAX_DISKS];	93	static dev_handle_t dev_handle[MAX_DISKS];
93		94
94	static atomic_t dev_futex = FUTEX_INITIALIZER;	95	static fibril_mutex_t dev_lock[MAX_DISKS];
95		96
96	static int gxe_bd_init(void);	97	static int gxe_bd_init(void);
97	static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall);	98	static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
98	static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, off_t size,	99	static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
99	void *buf);	100	void *buf);
100	static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,	101	static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,
101	void *buf);	102	void *buf);
102	static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,	103	static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
103	const void *buf);	104	const void *buf);
Line 108...	Line 109...
108		109
109	if (gxe_bd_init() != EOK)	110	if (gxe_bd_init() != EOK)
110	return -1;	111	return -1;
111		112
112	printf(NAME ": Accepting connections\n");	113	printf(NAME ": Accepting connections\n");
-		114	task_retval(0);
113	async_manager();	115	async_manager();
114		116
115	/* Not reached */	117	/* Not reached */
116	return 0;	118	return 0;
117	}	119	}
Line 143...	Line 145...
143	devmap_hangup_phone(DEVMAP_DRIVER);	145	devmap_hangup_phone(DEVMAP_DRIVER);
144	printf(NAME ": Unable to register device %s.\n",	146	printf(NAME ": Unable to register device %s.\n",
145	name);	147	name);
146	return rc;	148	return rc;
147	}	149	}
-		150	fibril_mutex_initialize(&dev_lock[i]);
148	}	151	}
149		152
150	return EOK;	153	return EOK;
151	}	154	}
152		155
Line 158...	Line 161...
158	ipcarg_t method;	161	ipcarg_t method;
159	dev_handle_t dh;	162	dev_handle_t dh;
160	int flags;	163	int flags;
161	int retval;	164	int retval;
162	off_t idx;	165	off_t idx;
163	off_t size;	166	size_t size;
164	int disk_id, i;	167	int disk_id, i;
165		168
166	/* Get the device handle. */	169	/* Get the device handle. */
167	dh = IPC_GET_ARG1(*icall);	170	dh = IPC_GET_ARG1(*icall);
168		171
Line 218...	Line 221...
218	}	221	}
219	ipc_answer_0(callid, retval);	222	ipc_answer_0(callid, retval);
220	}	223	}
221	}	224	}
222		225
223	static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, off_t size,	226	static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
224	void *buf)	227	void *buf)
225	{	228	{
226	int rc;	229	int rc;
227	size_t now;	230	size_t now;
228		231
Line 254...	Line 257...
254	{	257	{
255	uint32_t status;	258	uint32_t status;
256	size_t i;	259	size_t i;
257	uint32_t w;	260	uint32_t w;
258		261
259	futex_down(&dev_futex);	262	fibril_mutex_lock(&dev_lock[disk_id]);
260	pio_write_32(&dev->offset_lo, (uint32_t) offset);	263	pio_write_32(&dev->offset_lo, (uint32_t) offset);
261	pio_write_32(&dev->offset_hi, offset >> 32);	264	pio_write_32(&dev->offset_hi, offset >> 32);
262	pio_write_32(&dev->disk_id, disk_id);	265	pio_write_32(&dev->disk_id, disk_id);
263	pio_write_32(&dev->control, CTL_READ_START);	266	pio_write_32(&dev->control, CTL_READ_START);
264		267
265	status = pio_read_32(&dev->status);	268	status = pio_read_32(&dev->status);
266	if (status == STATUS_FAILURE) {	269	if (status == STATUS_FAILURE) {
-		270	fibril_mutex_unlock(&dev_lock[disk_id]);
267	return EIO;	271	return EIO;
268	}	272	}
269		273
270	for (i = 0; i < size; i++) {	274	for (i = 0; i < size; i++) {
271	((uint8_t *) buf)[i] = w = pio_read_8(&dev->buffer[i]);	275	((uint8_t *) buf)[i] = w = pio_read_8(&dev->buffer[i]);
272	}	276	}
273		277
274	futex_up(&dev_futex);	278	fibril_mutex_unlock(&dev_lock[disk_id]);
275	return EOK;	279	return EOK;
276	}	280	}
277		281
278	static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,	282	static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
279	const void *buf)	283	const void *buf)
Line 283...	Line 287...
283		287
284	for (i = 0; i < size; i++) {	288	for (i = 0; i < size; i++) {
285	pio_write_8(&dev->buffer[i], ((const uint8_t *) buf)[i]);	289	pio_write_8(&dev->buffer[i], ((const uint8_t *) buf)[i]);
286	}	290	}
287		291
288	futex_down(&dev_futex);	292	fibril_mutex_lock(&dev_lock[disk_id]);
289	pio_write_32(&dev->offset_lo, (uint32_t) offset);	293	pio_write_32(&dev->offset_lo, (uint32_t) offset);
290	pio_write_32(&dev->offset_hi, offset >> 32);	294	pio_write_32(&dev->offset_hi, offset >> 32);
291	pio_write_32(&dev->disk_id, disk_id);	295	pio_write_32(&dev->disk_id, disk_id);
292	pio_write_32(&dev->control, CTL_WRITE_START);	296	pio_write_32(&dev->control, CTL_WRITE_START);
293		297
294	status = pio_read_32(&dev->status);	298	status = pio_read_32(&dev->status);
295	if (status == STATUS_FAILURE) {	299	if (status == STATUS_FAILURE) {
-		300	fibril_mutex_unlock(&dev_lock[disk_id]);
296	return EIO;	301	return EIO;
297	}	302	}
298		303
299	futex_up(&dev_futex);	304	fibril_mutex_unlock(&dev_lock[disk_id]);
300	return EOK;	305	return EOK;
301	}	306	}
302		307
303	/**	308	/**
304	* @}	309	* @}

Subversion Repositories HelenOS

(root)/branches/dd/uspace/srv/bd/gxe_bd/gxe_bd.c – Rev 4537 → 4668