Changeset 8d6c1f1 in mainline for uspace/lib/c/generic

Timestamp:

2011-06-07T21:31:35Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

75608143

Parents:

ff4f073 (diff), eb522e8 (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 USB support.

Changes from bzr://helenos-usb.bzr.sourceforge.net/bzrroot/helenos-usb/mainline:

• replaced '-' with '_' in new driver names
• USB libs are built for each architecture
• devman starts early
• sys_thread_udelay() uses generic delay()
• sys_as_create_area() now creates cacheable areas by default

Location:

uspace/lib/c/generic

Files:

• adt/hash_table.c (modified) (1 diff)
• as.c (modified) (2 diffs)
• async.c (modified) (1 diff)
• devman.c (modified) (1 diff)
• l18n/langs.c (added)
• str_error.c (modified) (2 diffs)
• time.c (modified) (1 diff)

uspace/lib/c/generic/adt/hash_table.c

@@ -54 +54 @@
  *
  */
-int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
 {

uspace/lib/c/generic/as.c

@@ -35 +35 @@
 #include <as.h>
 #include <libc.h>
+#include <errno.h>
 #include <unistd.h>
 #include <align.h>
@@ -114 +115 @@
 }
 
+/** Find mapping to physical address.
+ *
+ * @param address Virtual address in question (virtual).
+ * @param[out] frame Frame address (physical).
+ * @return Error code.
+ * @retval EOK No error, @p frame holds the translation.
+ * @retval ENOENT Mapping not found.
+ */
+int as_get_physical_mapping(void *address, uintptr_t *frame)
+{
+        uintptr_t tmp_frame;
+        uintptr_t virt = (uintptr_t) address;
+        
+        int rc = (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING,
+            (sysarg_t) virt, (sysarg_t) &tmp_frame);
+        if (rc != EOK) {
+                return rc;
+        }
+        
+        if (frame != NULL) {
+                *frame = tmp_frame;
+        }
+        
+        return EOK;
+}
+
 /** @}
  */

uspace/lib/c/generic/async.c

@@ -1569 +1569 @@
 }
 
+/** Start IPC_M_DATA_READ using the async framework.
+ *
+ * @param phoneid Phone that will be used to contact the receiving side.
+ * @param dst Address of the beginning of the destination buffer.
+ * @param size Size of the destination buffer (in bytes).
+ * @param dataptr Storage of call data (arg 2 holds actual data size).
+ * @return Hash of the sent message or 0 on error.
+ */
+aid_t async_data_read(int phoneid, void *dst, size_t size, ipc_call_t *dataptr)
+{
+        return async_send_2(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
+            (sysarg_t) size, dataptr);
+}
+
 /** Wrapper for IPC_M_DATA_READ calls using the async framework.
  *

uspace/lib/c/generic/devman.c

@@ -374 +374 @@
 }
 
+int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
+{
+        int phone = devman_get_phone(DEVMAN_CLIENT, 0);
+
+        if (phone < 0)
+                return phone;
+
+        async_serialize_start();
+
+        ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_DEVICE_PATH,
+            handle, &answer);
+
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(phone, path, path_size,
+            &data_request_call);
+        if (data_request == 0) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return ENOMEM;
+        }
+
+        sysarg_t data_request_rc;
+        sysarg_t opening_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        async_wait_for(req, &opening_request_rc);
+
+        async_serialize_end();
+
+        if (data_request_rc != EOK) {
+                /* Prefer the return code of the opening request. */
+                if (opening_request_rc != EOK) {
+                        return (int) opening_request_rc;
+                } else {
+                        return (int) data_request_rc;
+                }
+        }
+        if (opening_request_rc != EOK) {
+                return (int) opening_request_rc;
+        }
+
+        /* To be on the safe-side. */
+        path[path_size - 1] = 0;
+
+        size_t transferred_size = IPC_GET_ARG2(data_request_call);
+
+        if (transferred_size >= path_size) {
+                return ELIMIT;
+        }
+
+        /* Terminate the string (trailing 0 not send over IPC). */
+        path[transferred_size] = 0;
+
+        return EOK;
+}
+
 
 /** @}

uspace/lib/c/generic/str_error.c

@@ -33 +33 @@
  */
 
+#include <errno.h>
 #include <str_error.h>
 #include <stdio.h>
@@ -63 +64 @@
 static fibril_local char noerr[NOERR_LEN];
 
-const char *str_error(const int errno)
+const char *str_error(const int e)
 {
-        if ((errno <= 0) && (errno >= MIN_ERRNO))
-                return err_desc[-errno];
+        if ((e <= 0) && (e >= MIN_ERRNO))
+                return err_desc[-e];
         
-        snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
+        /* Ad hoc descriptions of error codes interesting for USB. */
+        switch (e) {
+                case EBADCHECKSUM:
+                        return "Bad checksum";
+                case ESTALL:
+                        return "Operation stalled";
+                case EAGAIN:
+                        return "Resource temporarily unavailable";
+                case EEMPTY:
+                        return "Resource is empty";
+                default:
+                        break;
+        }
+
+        snprintf(noerr, NOERR_LEN, "Unkown error code %d", e);
         return noerr;
 }

uspace/lib/c/generic/time.c

@@ -207 +207 @@
 }
 
+void udelay(useconds_t time)
+{
+        (void) __SYSCALL1(SYS_THREAD_UDELAY, (sysarg_t) time);
+}
+
+
 /** Wait unconditionally for specified number of seconds
  *