Changeset ca62f86 in mainline for uspace/lib/c

Timestamp:

2013-09-09T17:52:40Z (12 years ago)

Author:

Jakub Klama <jakub.klama@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f7bb6d1

Parents:

6ad185d (diff), a1ecb88 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace/lib/c

Files:

• arch/sparc64/Makefile.common (modified) (1 diff)
• generic/async.c (modified) (2 diffs)
• generic/device/hw_res.c (modified) (3 diffs)
• generic/device/hw_res_parsed.c (modified) (6 diffs)
• generic/futex.c (modified) (4 diffs)
• include/adt/list.h (modified) (3 diffs)
• include/async.h (modified) (2 diffs)
• include/device/hw_res.h (modified) (2 diffs)
• include/device/hw_res_parsed.h (modified) (1 diff)
• include/ipc/dev_iface.h (modified) (3 diffs)
• include/macros.h (modified) (1 diff)

uspace/lib/c/arch/sparc64/Makefile.common

@@ -27 +27 @@
 #
 
-GCC_CFLAGS += -mcpu=ultrasparc -m64 -mcmodel=medlow
+ifeq ($(PROCESSOR),sun4v)
+GCC_CFLAGS += -mcpu=niagara -mno-vis
+else
+GCC_CFLAGS += -mcpu=ultrasparc
+endif
+
+GCC_CFLAGS += -m64 -mcmodel=medlow
+
 LFLAGS = -no-check-sections
 

uspace/lib/c/generic/async.c

@@ -2281 +2281 @@
 bool async_data_read_receive(ipc_callid_t *callid, size_t *size)
 {
+        ipc_call_t data;
+        return async_data_read_receive_call(callid, &data, size);
+}
+
+/** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ
+ * calls so that the user doesn't have to remember the meaning of each IPC
+ * argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid Storage for the hash of the IPC_M_DATA_READ.
+ * @param size   Storage for the maximum size. Can be NULL.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_data_read_receive_call(ipc_callid_t *callid, ipc_call_t *data,
+    size_t *size)
+{
         assert(callid);
-        
-        ipc_call_t data;
-        *callid = async_get_call(&data);
-        
-        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
+        assert(data);
+        
+        *callid = async_get_call(data);
+        
+        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_READ)
                 return false;
         
         if (size)
-                *size = (size_t) IPC_GET_ARG2(data);
+                *size = (size_t) IPC_GET_ARG2(*data);
         
         return true;
@@ -2385 +2406 @@
 bool async_data_write_receive(ipc_callid_t *callid, size_t *size)
 {
+        ipc_call_t data;
+        return async_data_write_receive_call(callid, &data, size);
+}
+
+/** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE
+ * calls so that the user doesn't have to remember the meaning of each IPC
+ * argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
+ * @param data   Storage for the ipc call data.
+ * @param size   Storage for the suggested size. May be NULL.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_data_write_receive_call(ipc_callid_t *callid, ipc_call_t *data,
+    size_t *size)
+{
         assert(callid);
-        
-        ipc_call_t data;
-        *callid = async_get_call(&data);
-        
-        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
+        assert(data);
+        
+        *callid = async_get_call(data);
+        
+        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_WRITE)
                 return false;
         
         if (size)
-                *size = (size_t) IPC_GET_ARG2(data);
+                *size = (size_t) IPC_GET_ARG2(*data);
         
         return true;

uspace/lib/c/generic/device/hw_res.c

@@ -44 +44 @@
         
         async_exch_t *exch = async_exchange_begin(sess);
+        if (exch == NULL)
+                return ENOMEM;
         int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
             HW_RES_GET_RESOURCE_LIST, &count);
@@ -77 +79 @@
 {
         async_exch_t *exch = async_exchange_begin(sess);
+        if (exch == NULL)
+                return false;
         int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
             HW_RES_ENABLE_INTERRUPT);
@@ -84 +88 @@
 }
 
+/**
+ * Setup DMA channel to specified place and mode.
+ * @param channel DMA Channel 1,2,3 for 8 bit transfers, 5,6,7 for 16 bit.
+ * @param pa Physical address of the buffer. Must be < 16MB for 16 bit and < 1MB
+ *           for 8 bit transfers.
+ * @param size DMA buffer size, limited to 64K.
+ * @param mode Mode of the DMA channel:
+ *              - Read or Write
+ *              - Allow automatic reset
+ *              - Use address decrement instead of increment
+ *              - Use SINGLE/BLOCK/ON DEMAND transfer mode
+ * @return Error code.
+ */
+int hw_res_dma_channel_setup(async_sess_t *sess,
+    unsigned channel, uint32_t pa, uint32_t size, uint8_t mode)
+{
+        async_exch_t *exch = async_exchange_begin(sess);
+        if (exch == NULL)
+                return ENOMEM;
+        const uint32_t packed = (channel & 0xffff) | (mode << 16);
+        const int ret = async_req_4_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
+            HW_RES_DMA_CHANNEL_SETUP, packed, pa, size);
+        async_exchange_end(exch);
+
+        return ret;
+}
+
+/**
+ * Query remaining bytes in the buffer.
+ * @param channel DMA Channel 1,2,3 for 8 bit transfers, 5,6,7 for 16 bit.
+ * @return Number of bytes remaining in the buffer(>=0) or error code(<0).
+ */
+int hw_res_dma_channel_remain(async_sess_t *sess, unsigned channel)
+{
+        async_exch_t *exch = async_exchange_begin(sess);
+        if (exch == NULL)
+                return ENOMEM;
+        sysarg_t remain;
+        const int ret = async_req_2_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
+            HW_RES_DMA_CHANNEL_REMAIN, channel, &remain);
+        async_exchange_end(exch);
+        if (ret == EOK)
+                return remain;
+        return ret;
+}
+
 /** @}
  */

uspace/lib/c/generic/device/hw_res_parsed.c

@@ -38 +38 @@
 #include <errno.h>
 
-static void hw_res_parse_add_irq(hw_res_list_parsed_t *out, hw_resource_t *res,
-    int flags)
+static void hw_res_parse_add_dma_channel(hw_res_list_parsed_t *out,
+    const hw_resource_t *res, int flags)
+{
+        assert(res);
+        assert((res->type == DMA_CHANNEL_8) || (res->type == DMA_CHANNEL_16));
+        
+        const unsigned channel = (res->type == DMA_CHANNEL_8) ?
+            res->res.dma_channel.dma8 : res->res.dma_channel.dma16;
+        const size_t count = out->dma_channels.count;
+        const int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
+        
+        if (!keep_duplicit) {
+                for (size_t i = 0; i < count; ++i) {
+                        if (out->dma_channels.channels[i] == channel)
+                                return;
+                }
+        }
+        
+        out->dma_channels.channels[count] = channel;
+        ++out->dma_channels.count;
+}
+
+static void hw_res_parse_add_irq(hw_res_list_parsed_t *out,
+    const hw_resource_t *res, int flags)
 {
         assert(res && (res->type == INTERRUPT));
@@ -59 +81 @@
 
 static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
-    hw_resource_t *res, int flags)
+    const hw_resource_t *res, int flags)
 {
         assert(res && (res->type == IO_RANGE));
@@ -90 +112 @@
 
 static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
-    hw_resource_t *res, int flags)
+    const hw_resource_t *res, int flags)
 {
         assert(res && (res->type == MEM_RANGE));
@@ -132 +154 @@
  *
  */
-int hw_res_list_parse(hw_resource_list_t *hw_resources,
+int hw_res_list_parse(const hw_resource_list_t *hw_resources,
     hw_res_list_parsed_t *out, int flags)
 {
@@ -141 +163 @@
         hw_res_list_parsed_clean(out);
         
-        out->irqs.irqs = malloc(res_count * sizeof(int));
-        out->io_ranges.ranges = malloc(res_count * sizeof(io_range_t));
-        out->mem_ranges.ranges = malloc(res_count * sizeof(mem_range_t));
+        out->irqs.irqs = calloc(res_count, sizeof(int));
+        out->dma_channels.channels = calloc(res_count, sizeof(int));
+        out->io_ranges.ranges = calloc(res_count, sizeof(io_range_t));
+        out->mem_ranges.ranges = calloc(res_count, sizeof(mem_range_t));
+        if (!out->irqs.irqs || !out->dma_channels.channels ||
+            !out->io_ranges.ranges || !out->mem_ranges.ranges) {
+                hw_res_list_parsed_clean(out);
+                return ENOMEM;
+        }
         
         for (size_t i = 0; i < res_count; ++i) {
-                hw_resource_t *resource = &(hw_resources->resources[i]);
+                const hw_resource_t *resource = &(hw_resources->resources[i]);
                 
                 switch (resource->type) {
@@ -158 +186 @@
                         hw_res_parse_add_mem_range(out, resource, flags);
                         break;
+                case DMA_CHANNEL_8:
+                case DMA_CHANNEL_16:
+                        hw_res_parse_add_dma_channel(out, resource, flags);
+                        break;
                 default:
+                        hw_res_list_parsed_clean(out);
                         return EINVAL;
                 }

uspace/lib/c/generic/futex.c

@@ -35 +35 @@
 #include <futex.h>
 #include <atomic.h>
+#include <libarch/barrier.h>
 #include <libc.h>
 #include <sys/types.h>
@@ -59 +60 @@
 int futex_trydown(futex_t *futex)
 {
-        return cas(futex, 1, 0);
+        int rc;
+
+        rc = cas(futex, 1, 0);
+        CS_ENTER_BARRIER();
+
+        return rc;
 }
 
@@ -73 +79 @@
 int futex_down(futex_t *futex)
 {
-        if ((atomic_signed_t) atomic_predec(futex) < 0)
+        atomic_signed_t nv;
+
+        nv = (atomic_signed_t) atomic_predec(futex);
+        CS_ENTER_BARRIER();
+        if (nv < 0)
                 return __SYSCALL1(SYS_FUTEX_SLEEP, (sysarg_t) &futex->count);
         
@@ -89 +99 @@
 int futex_up(futex_t *futex)
 {
+        CS_LEAVE_BARRIER();
+
         if ((atomic_signed_t) atomic_postinc(futex) < 0)
                 return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) &futex->count);

uspace/lib/c/include/adt/list.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2013 Jiri Svoboda
  * All rights reserved.
  *
@@ -65 +65 @@
 
 #define list_get_instance(link, type, member) \
-        ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
+        ((type *) (((void *)(link)) - list_link_to_void(&(((type *) NULL)->member))))
 
 #define list_foreach(list, iterator) \
@@ -318 +318 @@
 }
 
+/** Verify that argument type is a pointer to link_t (at compile time).
+ *
+ * This can be used to check argument type in a macro.
+ */
+static inline const void *list_link_to_void(const link_t *link)
+{
+        return link;
+}
+
 extern int list_member(const link_t *, const list_t *);
 extern void list_concat(list_t *, list_t *);

uspace/lib/c/include/async.h

@@ -399 +399 @@
 extern int async_data_read_start(async_exch_t *, void *, size_t);
 extern bool async_data_read_receive(ipc_callid_t *, size_t *);
+extern bool async_data_read_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
 extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
 
@@ -437 +438 @@
 extern int async_data_write_start(async_exch_t *, const void *, size_t);
 extern bool async_data_write_receive(ipc_callid_t *, size_t *);
+extern bool async_data_write_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
 extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
 

uspace/lib/c/include/device/hw_res.h

@@ -53 +53 @@
         HW_RES_ENABLE_INTERRUPT,
         HW_RES_DMA_CHANNEL_SETUP,
+        HW_RES_DMA_CHANNEL_REMAIN,
 } hw_res_method_t;
 
@@ -115 +116 @@
 
 extern int hw_res_dma_channel_setup(async_sess_t *, unsigned int, uint32_t,
-    uint16_t, uint8_t);
+    uint32_t, uint8_t);
+extern int hw_res_dma_channel_remain(async_sess_t *, unsigned);
 
 #endif

uspace/lib/c/include/device/hw_res_parsed.h

@@ -139 +139 @@
 }
 
-extern int hw_res_list_parse(hw_resource_list_t *, hw_res_list_parsed_t *, int);
+extern int hw_res_list_parse(const hw_resource_list_t *,
+    hw_res_list_parsed_t *, int);
 extern int hw_res_get_list_parsed(async_sess_t *, hw_res_list_parsed_t *, int);
 

uspace/lib/c/include/ipc/dev_iface.h

@@ -36 +36 @@
 typedef enum {
         HW_RES_DEV_IFACE = 0,
+
         /** Character device interface */
         CHAR_DEV_IFACE,
@@ -41 +42 @@
         /** Graphic device interface */
         GRAPH_DEV_IFACE,
+
+        /** Audio device mixer interface */
+        AUDIO_MIXER_IFACE,
+        /** Audio device pcm buffer interface */
+        AUDIO_PCM_BUFFER_IFACE,
         
         /** Network interface controller interface */
@@ -54 +60 @@
         /** Interface provided by USB HID devices. */
         USBHID_DEV_IFACE,
+
         /** Interface provided by Real Time Clock devices */
         CLOCK_DEV_IFACE,
+
         /** Interface provided by battery powered devices */
         BATTERY_DEV_IFACE,
+
         /** Interface provided by AHCI devices. */
         AHCI_DEV_IFACE,

uspace/lib/c/include/macros.h

@@ -40 +40 @@
 #define abs(a)     ((a) >= 0 ? (a) : -(a))
 
+#define ARRAY_SIZE(array)   (sizeof(array) / sizeof(array[0]))
 
 #define KiB2SIZE(kb)  ((kb) << 10)