Changeset 26e7d6d in mainline for uspace/srv/hw/bus/cuda_adb/cuda_adb.c

Timestamp:

2011-09-19T16:31:00Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

a347a11

Parents:

3842a955 (diff), 086290d (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

File:

• uspace/srv/hw/bus/cuda_adb/cuda_adb.c (modified) (7 diffs)

uspace/srv/hw/bus/cuda_adb/cuda_adb.c

@@ -43 +43 @@
 #include <ddi.h>
 #include <libarch/ddi.h>
-#include <devmap.h>
+#include <loc.h>
 #include <sysinfo.h>
 #include <errno.h>
 #include <ipc/adb.h>
 #include <async.h>
-#include <async_obsolete.h>
 #include <assert.h>
 #include "cuda_adb.h"
 
-// FIXME: remove this header
-#include <kernel/ipc/ipc_methods.h>
-
-#define NAME "cuda_adb"
+#define NAME  "cuda_adb"
 
 static void cuda_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
@@ -147 +143 @@
 int main(int argc, char *argv[])
 {
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
         int rc;
         int i;
@@ -154 +150 @@
 
         for (i = 0; i < ADB_MAX_ADDR; ++i) {
-                adb_dev[i].client_phone = -1;
-                adb_dev[i].devmap_handle = 0;
-        }
-
-        rc = devmap_driver_register(NAME, cuda_connection);
+                adb_dev[i].client_sess = NULL;
+                adb_dev[i].service_id = 0;
+        }
+
+        rc = loc_server_register(NAME, cuda_connection);
         if (rc < 0) {
-                printf(NAME ": Unable to register driver.\n");
+                printf(NAME ": Unable to register server.\n");
                 return rc;
         }
 
-        rc = devmap_device_register("adb/kbd", &devmap_handle);
+        rc = loc_service_register("adb/kbd", &service_id);
         if (rc != EOK) {
-                printf(NAME ": Unable to register device %s.\n", "adb/kdb");
+                printf(NAME ": Unable to register service %s.\n", "adb/kdb");
                 return rc;
         }
 
-        adb_dev[2].devmap_handle = devmap_handle;
-        adb_dev[8].devmap_handle = devmap_handle;
-
-        rc = devmap_device_register("adb/mouse", &devmap_handle);
+        adb_dev[2].service_id = service_id;
+        adb_dev[8].service_id = service_id;
+
+        rc = loc_service_register("adb/mouse", &service_id);
         if (rc != EOK) {
-                printf(NAME ": Unable to register device %s.\n", "adb/mouse");
+                printf(NAME ": Unable to register servise %s.\n", "adb/mouse");
                 return rc;
         }
 
-        adb_dev[9].devmap_handle = devmap_handle;
+        adb_dev[9].service_id = service_id;
 
         if (cuda_init() < 0) {
@@ -198 +194 @@
         ipc_call_t call;
         sysarg_t method;
-        devmap_handle_t dh;
-        int retval;
+        service_id_t dsid;
         int dev_addr, i;
 
         /* Get the device handle. */
-        dh = IPC_GET_ARG1(*icall);
+        dsid = IPC_GET_ARG1(*icall);
 
         /* Determine which disk device is the client connecting to. */
         dev_addr = -1;
         for (i = 0; i < ADB_MAX_ADDR; i++) {
-                if (adb_dev[i].devmap_handle == dh)
+                if (adb_dev[i].service_id == dsid)
                         dev_addr = i;
         }
@@ -220 +215 @@
         async_answer_0(iid, EOK);
 
-        while (1) {
+        while (true) {
                 callid = async_get_call(&call);
                 method = IPC_GET_IMETHOD(call);
@@ -230 +225 @@
                 }
                 
-                switch (method) {
-                case IPC_M_CONNECT_TO_ME:
-                        if (adb_dev[dev_addr].client_phone != -1) {
-                                retval = ELIMIT;
-                                break;
-                        }
-                        adb_dev[dev_addr].client_phone = IPC_GET_ARG5(call);
-                        /*
-                         * A hack so that we send the data to the phone
-                         * regardless of which address the device is on.
-                         */
-                        for (i = 0; i < ADB_MAX_ADDR; ++i) {
-                                if (adb_dev[i].devmap_handle == dh) {
-                                        adb_dev[i].client_phone = IPC_GET_ARG5(call);
+                async_sess_t *sess =
+                    async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
+                if (sess != NULL) {
+                        if (adb_dev[dev_addr].client_sess == NULL) {
+                                adb_dev[dev_addr].client_sess = sess;
+                                
+                                /*
+                                 * A hack so that we send the data to the session
+                                 * regardless of which address the device is on.
+                                 */
+                                for (i = 0; i < ADB_MAX_ADDR; ++i) {
+                                        if (adb_dev[i].service_id == dsid)
+                                                adb_dev[i].client_sess = sess;
                                 }
-                        }
-                        retval = 0;
-                        break;
-                default:
-                        retval = EINVAL;
-                        break;
-                }
-                async_answer_0(callid, retval);
+                                
+                                async_answer_0(callid, EOK);
+                        } else
+                                async_answer_0(callid, ELIMIT);
+                } else
+                        async_answer_0(callid, EINVAL);
         }
 }
@@ -483 +475 @@
         reg_val = ((uint16_t) data[1] << 8) | (uint16_t) data[2];
 
-        if (adb_dev[dev_addr].client_phone == -1)
-                return;
-
-        async_obsolete_msg_1(adb_dev[dev_addr].client_phone, ADB_REG_NOTIF, reg_val);
+        if (adb_dev[dev_addr].client_sess == NULL)
+                return;
+
+        async_exch_t *exch =
+            async_exchange_begin(adb_dev[dev_addr].client_sess);
+        async_msg_1(exch, ADB_REG_NOTIF, reg_val);
+        async_exchange_end(exch);
 }