WebSVN – HelenOS – Path Comparison – / – /branches/dynload/uspace/lib/ Rev 4344 and /branches/dynload/uspace/lib/ Rev 4345

Ignore whitespace Rev 4344 → Rev 4345

 /branches/dynload/uspace/lib/libblock/libblock.c
 ,15 → 27,15
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup libblock
+/** @addtogroup libblock
  * @{
- */
+ */
 /**
  * @file
  * @brief
  */
-#include "libblock.h"
+#include "libblock.h"
 #include "../../srv/vfs/vfs.h"
 #include "../../srv/rd/rd.h"
 #include <ipc/devmap.h>
 ,7 → 146,7
     if (!com_area) {
         return ENOMEM;
     }
-    dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
+    dev_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
         DEVMAP_CONNECT_TO_DEVICE, dev_handle);
     if (dev_phone < 0) {

 /branches/dynload/uspace/lib/libc/include/vfs/vfs.h
 ,7 → 39,8
 extern char *absolutize(const char *, size_t *);
-extern int mount(const char *, const char *, const char *);
+extern int mount(const char *, const char *, const char *,
+    const unsigned int flags);
 #endif

 /branches/dynload/uspace/lib/libc/include/async.h
 ,7 → 76,7
 #define async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, dataptr) \
     async_send_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
         (arg5), (dataptr))
 extern aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr);
 extern aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
 ,8 → 86,8
 extern int async_wait_timeout(aid_t amsgid, ipcarg_t *retval,
     suseconds_t timeout);
-fid_t async_new_connection(ipcarg_t in_phone_hash,ipc_callid_t callid,
-    ipc_call_t *call, void (*cthread)(ipc_callid_t,ipc_call_t *));
+fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
+    ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *));
 void async_usleep(suseconds_t timeout);
 void async_create_manager(void);
 void async_destroy_manager(void);

 /branches/dynload/uspace/lib/libc/include/io/stream.h
 ,7 → 47,8
 extern ssize_t write_stdout(const void *, size_t);
 extern ssize_t write_stderr(const void *, size_t);
-extern int get_cons_phone(void);
+extern int get_console_phone(void);
+extern void console_wait(void);
 #endif

 /branches/dynload/uspace/lib/libc/include/ipc/ipc.h
 ,8 → 246,11
 extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
     ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int);
+#define IPC_FLAG_BLOCKING  0x01
 extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *);
 extern int ipc_connect_me_to(int, int, int, int);
+extern int ipc_connect_me_to_blocking(int, int, int, int);
 extern int ipc_hangup(int);
 extern int ipc_register_irq(int, int, int, irq_code_t *);
 extern int ipc_unregister_irq(int, int);

 /branches/dynload/uspace/lib/libc/include/ipc/services.h
 ,8 → 30,8
  * @{
  */
 /**
- * @file    services.h
- * @brief   List of all known services and their codes.
+ * @file  services.h
+ * @brief List of all known services and their codes.
  */
 #ifndef LIBIPC_SERVICES_H_

 /branches/dynload/uspace/lib/libc/include/sys/types.h
 ,6 → 42,10
 typedef long off_t;
 typedef int mode_t;
+typedef volatile uint8_t ioport8_t;
+typedef volatile uint16_t ioport16_t;
+typedef volatile uint32_t ioport32_t;
 #endif
 /** @}

/branches/dynload/uspace/lib/libc/generic/ddi.c
33,6 → 33,7
*/

#include <ddi.h>
#include <libarch/ddi.h>
#include <libc.h>
#include <task.h>
#include <as.h>

 /branches/dynload/uspace/lib/libc/generic/kbd.c
 ,7 → 41,7
 int kbd_get_event(kbd_event_t *ev)
 {
-    int console_phone = get_cons_phone();
+    int console_phone = get_console_phone();
     ipcarg_t r0, r1, r2, r3;
     int rc;

 /branches/dynload/uspace/lib/libc/generic/console.c
 ,25 → 39,25
 void console_clear(void)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     async_msg_0(cons_phone, CONSOLE_CLEAR);
 }
 void console_goto(int row, int col)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     async_msg_2(cons_phone, CONSOLE_GOTO, row, col);
 }
 void console_flush(void)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     async_msg_0(cons_phone, CONSOLE_FLUSH);
 }
 int console_get_size(int *rows, int *cols)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     ipcarg_t r, c;
     int rc;
 ,25 → 71,25
 void console_set_style(int style)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     async_msg_1(cons_phone, CONSOLE_SET_STYLE, style);
 }
 void console_set_color(int fg_color, int bg_color, int flags)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     async_msg_3(cons_phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
 }
 void console_set_rgb_color(int fg_color, int bg_color)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     async_msg_2(cons_phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
 }
 void console_cursor_visibility(int show)
 {
-    int cons_phone = get_cons_phone();
+    int cons_phone = get_console_phone();
     async_msg_1(cons_phone, CONSOLE_CURSOR_VISIBILITY, show != 0);
 }

 /branches/dynload/uspace/lib/libc/generic/loader.c
 ,7 → 62,7
     loader_t *ldr;
     int phone_id;
-    phone_id = ipc_connect_me_to(PHONE_NS, SERVICE_LOAD, 0, 0);
+    phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0);
     if (phone_id < 0)
         return NULL;

 /branches/dynload/uspace/lib/libc/generic/ipc.c
 ,7 → 598,7
     ipcarg_t newphid;
     int res;
-    res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+    res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
         NULL, NULL, NULL, NULL, &newphid);
     if (res)
         return res;
 ,6 → 605,30
     return newphid;
 }
+/** Ask through phone for a new connection to some service.
+ *
+ * If the connection is not available at the moment, the
+ * call will block.
+ *
+ * @param phoneid   Phone handle used for contacting the other side.
+ * @param arg1      User defined argument.
+ * @param arg2      User defined argument.
+ * @param arg3      User defined argument.
+ *
+ * @return      New phone handle on success or a negative error code.
+ */
+int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3)
+{
+    ipcarg_t newphid;
+    int res;
+    res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+        IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
+    if (res)
+        return res;
+    return newphid;
+}
 /** Hang up a phone.
  *
  * @param phoneid   Handle of the phone to be hung up.

 /branches/dynload/uspace/lib/libc/generic/vfs/vfs.c
 ,7 → 31,7
  */
 /** @file
  */
 #include <vfs/vfs.h>
 #include <vfs/canonify.h>
 #include <stdlib.h>
 ,7 → 57,7
 futex_t cwd_futex = FUTEX_INITIALIZER;
 DIR *cwd_dir = NULL;
 char *cwd_path = NULL;
-size_t cwd_len = 0;
+size_t cwd_len = 0;
 char *absolutize(const char *path, size_t *retlen)
 {
 ,34 → 109,39
     return ncwd_path;
 }
-static int vfs_connect(void)
+static void vfs_connect(void)
 {
-    if (vfs_phone < 0)
-        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
-    return vfs_phone;
+    while (vfs_phone < 0)
+        vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
 }
-static int device_get_handle(const char *name, dev_handle_t *handle)
+static int device_get_handle(const char *name, dev_handle_t *handle,
+    const unsigned int flags)
 {
-    int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
-);
+    int phone;
+    if (flags & IPC_FLAG_BLOCKING)
+        phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+    else
+        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
     if (phone < 0)
         return phone;
     ipc_call_t answer;
-    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
+    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
         &answer);
     ipcarg_t retval = ipc_data_write_start(phone, name, strlen(name) + 1);
     if (retval != EOK) {
         async_wait_for(req, NULL);
         ipc_hangup(phone);
         return retval;
     }
     async_wait_for(req, &retval);
     if (handle != NULL)
         *handle = -1;
 ,7 → 154,8
     return retval;
 }
-int mount(const char *fs_name, const char *mp, const char *dev)
+int mount(const char *fs_name, const char *mp, const char *dev,
+    const unsigned int flags)
 {
     int res;
     ipcarg_t rc;
 ,7 → 162,7
     aid_t req;
     dev_handle_t dev_handle;
-    res = device_get_handle(dev, &dev_handle);
+    res = device_get_handle(dev, &dev_handle, flags);
     if (res != EOK)
         return res;
 ,20 → 170,13
     char *mpa = absolutize(mp, &mpa_len);
     if (!mpa)
         return ENOMEM;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(mpa);
-            return res;
-        }
-    }
-    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
-    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
+    vfs_connect();
+    req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
+    rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_len);
     if (rc != EOK) {
         async_wait_for(req, NULL);
         async_serialize_end();
 ,8 → 184,8
         free(mpa);
         return (int) rc;
     }
-    /* Ask VFS whether it likes fs_name. */
-    rc = async_req_0_0(vfs_phone, IPC_M_PING);
+    rc = ipc_data_write_start(vfs_phone, (void *) fs_name, strlen(fs_name));
     if (rc != EOK) {
         async_wait_for(req, NULL);
         async_serialize_end();
 ,24 → 193,17
         free(mpa);
         return (int) rc;
     }
-    rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
-    if (rc != EOK) {
-        async_wait_for(req, NULL);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        free(mpa);
-        return (int) rc;
-    }
     async_wait_for(req, &rc);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
     free(mpa);
     return (int) rc;
 }
 static int _open(const char *path, int lflag, int oflag, ...)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,15 → 215,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,22 → 243,14
 int close(int fildes)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 259,6
 ssize_t read(int fildes, void *buf, size_t nbyte)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,14 → 265,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
     rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
     if (rc != EOK) {
 ,7 → 286,6
 ssize_t write(int fildes, const void *buf, size_t nbyte)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,14 → 292,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
     rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
     if (rc != EOK) {
 ,20 → 313,12
 off_t lseek(int fildes, off_t offset, int whence)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     ipcarg_t newoffs;
     rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
         &newoffs);
 ,19 → 334,12
 int ftruncate(int fildes, off_t length)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 381,6
 int mkdir(const char *path, mode_t mode)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,18 → 388,11
     char *pa = absolutize(path, &pa_len);
     if (!pa)
         return ENOMEM;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,7 → 411,6
 static int _unlink(const char *path, int lflag)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,15 → 421,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,7 → 451,6
 int rename(const char *old, const char *new)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,16 → 468,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(olda);
-            free(newa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_0(vfs_phone, VFS_RENAME, NULL);
     rc = ipc_data_write_start(vfs_phone, olda, olda_len);
     if (rc != EOK) {

 /branches/dynload/uspace/lib/libc/generic/io/stream.c
 ,11 → 115,19
     (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
 }
-int get_cons_phone(void)
+int get_console_phone(void)
 {
-    open_console();
+    if (console_phone < 0)
+        console_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_CONSOLE, 0, 0);
     return console_phone;
 }
+void console_wait(void)
+{
+    while (console_phone < 0)
+        get_console_phone();
+}
 /** @}
  */

 /branches/dynload/uspace/lib/libc/arch/sparc64/include/ddi.h
 ,0 → 1,92
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libsparc64
+ */
+#ifndef LIBC_sparc64_DDI_H_
+#define LIBC_sparc64_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline memory_barrier(void)
+{
+    asm volatile ("membar #LoadLoad | #StoreStore\n" ::: "memory");
+}
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    uint8_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    uint16_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    uint32_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+#endif

 /branches/dynload/uspace/lib/libc/arch/ia64/include/ddi.h
 ,5 → 1,5
 /*
- * Copyright (c) 2005 Jakub Jermar, Jakub Vana
+ * Copyright (c) 2005 Jakub Vana
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup ia64
+/** @addtogroup libcia64
  * @{
  */
 /** @file
 ,63 → 35,80
 #ifndef LIBC_ia64_DDI_H_
 #define LIBC_ia64_DDI_H_
+#include <sys/types.h>
 #include <libarch/types.h>
-typedef uint64_t ioport_t;
+#define IO_SPACE_BOUNDARY   (64 * 1024)
 uint64_t get_ia64_iospace_address(void);
 extern uint64_t ia64_iospace_address;
-#define IA64_IOSPACE_ADDRESS (ia64_iospace_address?ia64_iospace_address:(ia64_iospace_address=get_ia64_iospace_address()))
+#define IA64_IOSPACE_ADDRESS \
+    (ia64_iospace_address ? \
+        ia64_iospace_address : \
+        (ia64_iospace_address = get_ia64_iospace_address()))
-static inline void  outb(ioport_t port,uint8_t v)
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
 {
-    *((uint8_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 )))) = v;
+    uintptr_t prt = (uintptr_t) port;
+    *((uint8_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
     asm volatile ("mf\n" ::: "memory");
 }
-static inline void  outw(ioport_t port,uint16_t v)
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
 {
-    *((uint16_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 )))) = v;
+    uintptr_t prt = (uintptr_t) port;
+    *((uint16_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
     asm volatile ("mf\n" ::: "memory");
 }
-static inline void  outl(ioport_t port,uint32_t v)
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
 {
-    *((uint32_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 )))) = v;
+    uintptr_t prt = (uintptr_t) port;
+    *((uint32_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
     asm volatile ("mf\n" ::: "memory");
 }
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    uintptr_t prt = (uintptr_t) port;
-static inline uint8_t inb(ioport_t port)
-{
     asm volatile ("mf\n" ::: "memory");
-    return *((uint8_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 ))));
+    return *((uint8_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
 }
-static inline uint16_t inw(ioport_t port)
+static inline uint16_t pio_read_16(ioport16_t *port)
 {
+    uintptr_t prt = (uintptr_t) port;
     asm volatile ("mf\n" ::: "memory");
-    return *((uint16_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xffE) | ( (port >> 2) << 12 ))));
+    return *((uint16_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
 }
-static inline uint32_t inl(ioport_t port)
+static inline uint32_t pio_read_32(ioport32_t *port)
 {
+    uintptr_t prt = (uintptr_t) port;
     asm volatile ("mf\n" ::: "memory");
-    return *((uint32_t *)(IA64_IOSPACE_ADDRESS + ( (port & 0xfff) | ( (port >> 2) << 12 ))));
+    return *((uint32_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
 }
 #endif
 /** @}

 /branches/dynload/uspace/lib/libc/arch/arm32/include/ddi.h
 ,0 → 1,69
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libcarm32
+ */
+#ifndef LIBC_arm32_DDI_H_
+#define LIBC_arm32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/dynload/uspace/lib/libc/arch/ppc32/include/ddi.h
 ,0 → 1,69
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libcppc32
+ */
+#ifndef LIBC_ppc32_DDI_H_
+#define LIBC_ppc32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/dynload/uspace/lib/libc/arch/mips32/include/ddi.h
 ,0 → 1,69
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libcmips32
+ */
+#ifndef LIBC_mips32_DDI_H_
+#define LIBC_mips32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/dynload/uspace/lib/libc/arch/ia32/include/ddi.h
 ,45 → 33,72
 #ifndef LIBC_ia32_DDI_H_
 #define LIBC_ia32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
 #define IO_SPACE_BOUNDARY   ((void *) (64 * 1024))
-static inline void outb(int16_t port, uint8_t b)
+static inline uint8_t pio_read_8(ioport8_t *port)
 {
-    asm volatile ("outb %0, %1\n" :: "a" (b), "d" (port));
+    uint8_t val;
+    asm volatile (
+        "inb %w[port], %b[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline void outw(int16_t port, int16_t w)
+static inline uint16_t pio_read_16(ioport16_t *port)
 {
-    asm volatile ("outw %0, %1\n" :: "a" (w), "d" (port));
+    uint16_t val;
+    asm volatile (
+        "inw %w[port], %w[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline void outl(int16_t port, uint32_t l)
+static inline uint32_t pio_read_32(ioport32_t *port)
 {
-    asm volatile ("outl %0, %1\n" :: "a" (l), "d" (port));
+    uint32_t val;
+    asm volatile (
+        "inl %w[port], %[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline uint8_t inb(int16_t port)
+static inline void pio_write_8(ioport8_t *port, uint8_t val)
 {
-    uint8_t val;
-    asm volatile ("inb %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outb %b[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
-static inline int16_t inw(int16_t port)
+static inline void pio_write_16(ioport16_t *port, uint16_t val)
 {
-    int16_t val;
-    asm volatile ("inw %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outw %w[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
-static inline uint32_t inl(int16_t port)
+static inline void pio_write_32(ioport32_t *port, uint32_t val)
 {
-    uint32_t val;
-    asm volatile ("inl %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outl %[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
 #endif

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4344 → Rev 4345