WebSVN – HelenOS – Diff – /trunk/uspace/app/tester/devmap/devmap1.c

 #include <async.h>
 #include <errno.h>
 #include <../../../srv/devmap/devmap.h>
 #include "../tester.h"
+#include <time.h>
+#define TEST_DEVICE1 "TestDevice1"
+#define TEST_DEVICE2 "TestDevice2"
-static int driver_register(char *name)
+/** Handle requests from clients
+ *
+ */
+static void driver_client_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    ipc_callid_t callid;
+    ipc_call_t call;
     int retval;
+    printf("connected: method=%u arg1=%u, arg2=%u arg3=%u.\n", IPC_GET_METHOD(*icall),
+        IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall), IPC_GET_ARG3(*icall));
+    printf("driver_client_connection.\n");
+    ipc_answer_0(iid, EOK);
+    /* Ignore parameters, the connection is already opened */
+    while (1) {
+        callid = async_get_call(&call);
+        retval = EOK;
+        printf("method=%u arg1=%u, arg2=%u arg3=%u.\n", IPC_GET_METHOD(call),
+            IPC_GET_ARG1(call), IPC_GET_ARG2(call), IPC_GET_ARG3(call));
+        switch (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            /* TODO: Handle hangup */
+            return;
+        default:
+            printf("Unknown device method %u.\n", IPC_GET_METHOD(call));
+            retval = ENOENT;
+        }
+        ipc_answer_0(callid, retval);
+    }
+    return;
+}
+static int device_client_fibril(void *arg)
+{
+    int handle;
+    int device_phone;
+    handle = (int)arg;
+    device_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, \
+        DEVMAP_CONNECT_TO_DEVICE, handle);
+    if (device_phone < 0) {
+        printf("Failed to connect to devmap as client (handle = %u).\n",
+            handle);
+        return -1;
+    }
+/*
+ *  device_phone = (int) IPC_GET_ARG3(answer);
+ */
+    printf("Connected to device.\n");
+    ipc_call_sync_1_0(device_phone, 1024, 1025);
+/*
+ * ipc_hangup(device_phone);
+ */
+    ipc_hangup(device_phone);
+    return EOK;
+}
+/** Communication test with device.
+ * @param handle handle to tested instance.
+ */
+static int device_client(int handle)
+{
+/*  fid_t fid;
+    ipc_call_t call;
+    ipc_callid_t callid;
+    fid = fibril_create(device_client_fibril, (void *)handle);
+    fibril_add_ready(fid);
+*/
+    return EOK;
+}
+/**
+ *
+ */
+static int driver_register(char *name)
+{
+    ipcarg_t retval;
     aid_t req;
     ipc_call_t answer;
     int phone;
     ipcarg_t callback_phonehash;
-    phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER);
+    phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
+        DEVMAP_DRIVER, 0);
     while (phone < 0) {
         usleep(100000);
-        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER);
+        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
+            DEVMAP_DRIVER, 0);
+    }
     req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
-    retval = ipc_data_send(phone, (char *)name, strlen(name));
+    retval = ipc_data_send(phone, (char *)name, strlen(name) + 1);
     if (retval != EOK) {
         async_wait_for(req, NULL);
         return -1;
+    }
-    ipc_connect_to_me(phone, 0, 0, &callback_phonehash);
+    async_set_client_connection(driver_client_connection);
+    ipc_connect_to_me(phone, 0, 0, &callback_phonehash);
+/*
+    if (NULL == async_new_connection(callback_phonehash, 0, NULL,
+            driver_client_connection)) {
+        printf("Failed to create new fibril.\n");
-    async_wait_for(req, NULL);
+        async_wait_for(req, NULL);
+        return -1;
+    }
+*/
+    async_wait_for(req, &retval);
     printf("Driver '%s' registered.\n", name);
     return phone;
+}
+static int device_get_handle(int driver_phone, char *name, int *handle)
+{
+    ipcarg_t retval;
+    aid_t req;
+    ipc_call_t answer;
+    req = async_send_2(driver_phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0, &answer);
+    retval = ipc_data_send(driver_phone, name, strlen(name) + 1);
+    if (retval != EOK) {
+        printf("Failed to send device name '%s'.\n", name);
+        async_wait_for(req, NULL);
+        return retval;
+    }
+    async_wait_for(req, &retval);
+    if (NULL != handle) {
+        *handle = -1;
+    }
+    if (EOK == retval) {
+        if (NULL != handle) {
+            *handle = (int) IPC_GET_ARG1(answer);
+        }
+        printf("Device '%s' has handle %u.\n", name, (int) IPC_GET_ARG1(answer));
+    } else {
+        printf("Failed to get handle for device '%s'.\n", name);
+    }
+    return retval;
+}
+/** Register new device.
+ * @param driver_phone
+ * @param name Device name.
+ * @param handle Output variable. Handle to the created instance of device.
+ */
 static int device_register(int driver_phone, char *name, int *handle)
+{
     ipcarg_t retval;
     aid_t req;
     ipc_call_t answer;
     req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0, &answer);
-    retval = ipc_data_send(driver_phone, (char *)name, strlen(name));
+    retval = ipc_data_send(driver_phone, (char *)name, strlen(name) + 1);
     if (retval != EOK) {
         printf("Failed to send device name '%s'.\n", name);
         async_wait_for(req, NULL);
         return retval;
+{
     int driver_phone;
     int dev1_handle;
     int dev2_handle;
     int dev3_handle;
+    int handle;
     /* Register new driver */
     driver_phone = driver_register("TestDriver");
     if (driver_phone < 0) {
         return "Error: Cannot register driver.\n";
+    }
     /* Register new device dev1*/
-    if (EOK != device_register(driver_phone, "TestDevice1", &dev1_handle)) {
+    if (EOK != device_register(driver_phone, TEST_DEVICE1, &dev1_handle)) {
         ipc_hangup(driver_phone);
         return "Error: cannot register device.\n";
+    }
-    /* TODO: get handle for dev1*/
-    /* TODO: get handle for dev2 (Should fail unless device is already
+    /* Get handle for dev2 (Should fail unless device is already
      * registered by someone else)
      */
+    if (EOK == device_get_handle(driver_phone, TEST_DEVICE2, &handle)) {
+        ipc_hangup(driver_phone);
+        return "Error: got handle for dev2 before it was registered.\n";
+    }
     /* Register new device dev2*/
-    if (EOK != device_register(driver_phone, "TestDevice2", &dev2_handle)) {
+    if (EOK != device_register(driver_phone, TEST_DEVICE2, &dev2_handle)) {
         ipc_hangup(driver_phone);
         return "Error: cannot register device dev2.\n";
+    }
     /* Register again device dev1 */
-    if (EOK == device_register(driver_phone, "TestDevice1", &dev3_handle)) {
+    if (EOK == device_register(driver_phone, TEST_DEVICE1, &dev3_handle)) {
         return "Error: dev1 registered twice.\n";
+    }
-    /* TODO: get handle for dev2 */
+    /* Get handle for dev1*/
+    if (EOK != device_get_handle(driver_phone, TEST_DEVICE1, &handle)) {
+        ipc_hangup(driver_phone);
+        return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n";
+    }
+    if (handle != dev1_handle) {
+        ipc_hangup(driver_phone);
+        return "Error: cannot get handle for 'DEVMAP_DEVICE1'.\n";
+    }
+    if (EOK != device_client(dev1_handle)) {
+        ipc_hangup(driver_phone);
+        return "Error: failed client test for 'DEVMAP_DEVICE1'.\n";
+    }
-    /* TODO:  */
+    /* TODO: */
     ipc_hangup(driver_phone);
     return NULL;
+}

Subversion Repositories HelenOS

(root)/trunk/uspace/app/tester/devmap/devmap1.c – Rev 2594 → 2635