source: mainline/uspace/lib/drv/generic/driver.c@ 3a4b3ba

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 3a4b3ba was cb819f9, checked in by Jakub Jermar <jakub@…>, 15 years ago

When using async framework, we already know the call is not a notification,
so there is no need to test it explicitly.

  • Property mode set to 100644
File size: 10.1 KB
RevLine 
[c16cf62]1/*
2 * Copyright (c) 2010 Lenka Trochtova
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/**
30 * @defgroup libdrv generic device driver support.
31 * @brief HelenOS generic device driver support.
32 * @{
33 */
34
35/** @file
36 */
[52b7b1bb]37
[c16cf62]38#include <assert.h>
39#include <ipc/services.h>
40#include <ipc/ns.h>
41#include <async.h>
42#include <stdio.h>
43#include <errno.h>
44#include <bool.h>
45#include <fibril_synch.h>
46#include <stdlib.h>
[c47e1a8]47#include <str.h>
[c16cf62]48#include <ctype.h>
[66babbd]49#include <errno.h>
[c16cf62]50
[084ff99]51#include <ipc/driver.h>
[c16cf62]52
53#include "driver.h"
54
[7a252ec8]55/* driver structure */
[7f8b581]56
[c16cf62]57static driver_t *driver;
[7f8b581]58
[7a252ec8]59/* devices */
[7f8b581]60
[084ff99]61LIST_INITIALIZE(devices);
[9a66bc2e]62FIBRIL_MUTEX_INITIALIZE(devices_mutex);
[084ff99]63
[7a252ec8]64/* interrupts */
[7f8b581]65
66static interrupt_context_list_t interrupt_contexts;
67
68static irq_cmd_t default_cmds[] = {
69 {
70 .cmd = CMD_ACCEPT
71 }
72};
73
74static irq_code_t default_pseudocode = {
75 sizeof(default_cmds) / sizeof(irq_cmd_t),
76 default_cmds
77};
78
79
80static void driver_irq_handler(ipc_callid_t iid, ipc_call_t *icall)
[7a252ec8]81{
[7f8b581]82 int id = (int)IPC_GET_METHOD(*icall);
[7a252ec8]83 interrupt_context_t *ctx;
84
85 ctx = find_interrupt_context_by_id(&interrupt_contexts, id);
86 if (NULL != ctx && NULL != ctx->handler)
87 (*ctx->handler)(ctx->dev, iid, icall);
[7f8b581]88}
89
[7a252ec8]90int
91register_interrupt_handler(device_t *dev, int irq, interrupt_handler_t *handler,
92 irq_code_t *pseudocode)
[7f8b581]93{
94 interrupt_context_t *ctx = create_interrupt_context();
95
96 ctx->dev = dev;
97 ctx->irq = irq;
98 ctx->handler = handler;
99
100 add_interrupt_context(&interrupt_contexts, ctx);
101
[7a252ec8]102 if (NULL == pseudocode)
[7f8b581]103 pseudocode = &default_pseudocode;
104
105 int res = ipc_register_irq(irq, dev->handle, ctx->id, pseudocode);
106 if (0 != res) {
107 remove_interrupt_context(&interrupt_contexts, ctx);
108 delete_interrupt_context(ctx);
109 }
[7a252ec8]110
111 return res;
[7f8b581]112}
113
114int unregister_interrupt_handler(device_t *dev, int irq)
115{
[7a252ec8]116 interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts,
117 dev, irq);
[7f8b581]118 int res = ipc_unregister_irq(irq, dev->handle);
[7a252ec8]119
[7f8b581]120 if (NULL != ctx) {
121 remove_interrupt_context(&interrupt_contexts, ctx);
[7a252ec8]122 delete_interrupt_context(ctx);
[7f8b581]123 }
124 return res;
125}
126
[9a66bc2e]127static void add_to_devices_list(device_t *dev)
128{
129 fibril_mutex_lock(&devices_mutex);
130 list_append(&dev->link, &devices);
131 fibril_mutex_unlock(&devices_mutex);
132}
133
134static void remove_from_devices_list(device_t *dev)
135{
136 fibril_mutex_lock(&devices_mutex);
[5af21c5]137 list_remove(&dev->link);
[9a66bc2e]138 fibril_mutex_unlock(&devices_mutex);
139}
140
[0b5a4131]141static device_t * driver_get_device(link_t *devices, devman_handle_t handle)
[52b7b1bb]142{
[a1769ee]143 device_t *dev = NULL;
[9a66bc2e]144
[7a252ec8]145 fibril_mutex_lock(&devices_mutex);
[a1769ee]146 link_t *link = devices->next;
147 while (link != devices) {
148 dev = list_get_instance(link, device_t, link);
149 if (handle == dev->handle) {
[9a66bc2e]150 fibril_mutex_unlock(&devices_mutex);
[a1769ee]151 return dev;
152 }
[9a66bc2e]153 link = link->next;
[a1769ee]154 }
[9a66bc2e]155 fibril_mutex_unlock(&devices_mutex);
[52b7b1bb]156
[a1769ee]157 return NULL;
158}
159
[52b7b1bb]160static void driver_add_device(ipc_callid_t iid, ipc_call_t *icall)
[084ff99]161{
[df747b9c]162 char *dev_name = NULL;
163 int res = EOK;
[9a66bc2e]164
[0b5a4131]165 devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
[5af21c5]166 device_t *dev = create_device();
[084ff99]167 dev->handle = dev_handle;
[df747b9c]168
[7a252ec8]169 async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
[df747b9c]170 dev->name = dev_name;
171
[7a252ec8]172 add_to_devices_list(dev);
[df747b9c]173 res = driver->driver_ops->add_device(dev);
174 if (0 == res) {
[7a252ec8]175 printf("%s: new device with handle = %x was added.\n",
176 driver->name, dev_handle);
[9a66bc2e]177 } else {
[7a252ec8]178 printf("%s: failed to add a new device with handle = %d.\n",
179 driver->name, dev_handle);
[9a66bc2e]180 remove_from_devices_list(dev);
[7a252ec8]181 delete_device(dev);
[084ff99]182 }
[df747b9c]183
184 ipc_answer_0(iid, res);
[084ff99]185}
[c16cf62]186
187static void driver_connection_devman(ipc_callid_t iid, ipc_call_t *icall)
188{
189 /* Accept connection */
190 ipc_answer_0(iid, EOK);
[52b7b1bb]191
[c16cf62]192 bool cont = true;
193 while (cont) {
194 ipc_call_t call;
195 ipc_callid_t callid = async_get_call(&call);
[52b7b1bb]196
[c16cf62]197 switch (IPC_GET_METHOD(call)) {
198 case IPC_M_PHONE_HUNGUP:
199 cont = false;
200 continue;
201 case DRIVER_ADD_DEVICE:
[084ff99]202 driver_add_device(callid, &call);
[c16cf62]203 break;
204 default:
[cb819f9]205 ipc_answer_0(callid, ENOENT);
[c16cf62]206 }
[52b7b1bb]207 }
[c16cf62]208}
209
[52b7b1bb]210/**
[a1769ee]211 * Generic client connection handler both for applications and drivers.
[52b7b1bb]212 *
[7a252ec8]213 * @param drv True for driver client, false for other clients
214 * (applications, services etc.).
[a1769ee]215 */
[9a66bc2e]216static void driver_connection_gen(ipc_callid_t iid, ipc_call_t *icall, bool drv)
[52b7b1bb]217{
[7a252ec8]218 /*
219 * Answer the first IPC_M_CONNECT_ME_TO call and remember the handle of
220 * the device to which the client connected.
221 */
[0b5a4131]222 devman_handle_t handle = IPC_GET_ARG2(*icall);
[a1769ee]223 device_t *dev = driver_get_device(&devices, handle);
[52b7b1bb]224
[a1769ee]225 if (dev == NULL) {
[7a252ec8]226 printf("%s: driver_connection_gen error - no device with handle"
227 " %x was found.\n", driver->name, handle);
[a1769ee]228 ipc_answer_0(iid, ENOENT);
229 return;
230 }
[5cd136ab]231
232
[7a252ec8]233 /*
234 * TODO - if the client is not a driver, check whether it is allowed to
235 * use the device.
236 */
[a1769ee]237
[25a7e11d]238 int ret = EOK;
[7a252ec8]239 /* open the device */
240 if (NULL != dev->ops && NULL != dev->ops->open)
[5159ae9]241 ret = (*dev->ops->open)(dev);
[a1769ee]242
[25a7e11d]243 ipc_answer_0(iid, ret);
[7a252ec8]244 if (EOK != ret)
[a6e54c5d]245 return;
[52b7b1bb]246
[a1769ee]247 while (1) {
248 ipc_callid_t callid;
249 ipc_call_t call;
250 callid = async_get_call(&call);
251 ipcarg_t method = IPC_GET_METHOD(call);
[3843ecb]252 int iface_idx;
253
[a1769ee]254 switch (method) {
[25a7e11d]255 case IPC_M_PHONE_HUNGUP:
[7a252ec8]256 /* close the device */
257 if (NULL != dev->ops && NULL != dev->ops->close)
[5159ae9]258 (*dev->ops->close)(dev);
[a1769ee]259 ipc_answer_0(callid, EOK);
260 return;
[3843ecb]261 default:
[7a252ec8]262 /* convert ipc interface id to interface index */
[3843ecb]263
264 iface_idx = DEV_IFACE_IDX(method);
265
266 if (!is_valid_iface_idx(iface_idx)) {
[7a252ec8]267 remote_handler_t *default_handler =
268 device_get_default_handler(dev);
269 if (NULL != default_handler) {
[08d9525a]270 (*default_handler)(dev, callid, &call);
271 break;
272 }
[7a252ec8]273 /*
274 * This is not device's interface and the
275 * default handler is not provided.
276 */
277 printf("%s: driver_connection_gen error - "
278 "invalid interface id %d.",
279 driver->name, iface_idx);
[52b7b1bb]280 ipc_answer_0(callid, ENOTSUP);
281 break;
282 }
283
[7a252ec8]284 /* calling one of the device's interfaces */
[52b7b1bb]285
[7a252ec8]286 /* get the device interface structure */
[3843ecb]287 void *iface = device_get_iface(dev, iface_idx);
[52b7b1bb]288 if (NULL == iface) {
[7a252ec8]289 printf("%s: driver_connection_gen error - ",
290 driver->name);
291 printf("device with handle %d has no interface "
292 "with id %d.\n", handle, iface_idx);
[a1769ee]293 ipc_answer_0(callid, ENOTSUP);
[52b7b1bb]294 break;
[a1769ee]295 }
[52b7b1bb]296
[7a252ec8]297 /*
298 * Get the corresponding interface for remote request
299 * handling ("remote interface").
300 */
[3843ecb]301 remote_iface_t* rem_iface = get_remote_iface(iface_idx);
[52b7b1bb]302 assert(NULL != rem_iface);
303
[7a252ec8]304 /* get the method of the remote interface */
[52b7b1bb]305 ipcarg_t iface_method_idx = IPC_GET_ARG1(call);
[7a252ec8]306 remote_iface_func_ptr_t iface_method_ptr =
307 get_remote_method(rem_iface, iface_method_idx);
[52b7b1bb]308 if (NULL == iface_method_ptr) {
309 // the interface has not such method
[7a252ec8]310 printf("%s: driver_connection_gen error - "
311 "invalid interface method.", driver->name);
[52b7b1bb]312 ipc_answer_0(callid, ENOTSUP);
313 break;
314 }
315
[7a252ec8]316 /*
317 * Call the remote interface's method, which will
318 * receive parameters from the remote client and it will
319 * pass it to the corresponding local interface method
320 * associated with the device by its driver.
321 */
[52b7b1bb]322 (*iface_method_ptr)(dev, iface, callid, &call);
[a1769ee]323 break;
324 }
325 }
326}
327
[c16cf62]328static void driver_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
329{
[52b7b1bb]330 driver_connection_gen(iid, icall, true);
[c16cf62]331}
332
333static void driver_connection_client(ipc_callid_t iid, ipc_call_t *icall)
334{
[52b7b1bb]335 driver_connection_gen(iid, icall, false);
[c16cf62]336}
337
338
[7a252ec8]339/** Function for handling connections to device driver. */
[c16cf62]340static void driver_connection(ipc_callid_t iid, ipc_call_t *icall)
341{
342 /* Select interface */
343 switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
344 case DRIVER_DEVMAN:
[7a252ec8]345 /* handle PnP events from device manager */
[c16cf62]346 driver_connection_devman(iid, icall);
347 break;
348 case DRIVER_DRIVER:
[7a252ec8]349 /* handle request from drivers of child devices */
[c16cf62]350 driver_connection_driver(iid, icall);
351 break;
352 case DRIVER_CLIENT:
[7a252ec8]353 /* handle requests from client applications */
[c16cf62]354 driver_connection_client(iid, icall);
355 break;
356
357 default:
[52b7b1bb]358 /* No such interface */
[c16cf62]359 ipc_answer_0(iid, ENOENT);
360 }
361}
362
[df747b9c]363int child_device_register(device_t *child, device_t *parent)
[7707954]364{
[bda60d9]365 assert(NULL != child->name);
[52b7b1bb]366
[df747b9c]367 int res;
368
[9a66bc2e]369 add_to_devices_list(child);
[7a252ec8]370 res = devman_child_device_register(child->name, &child->match_ids,
371 parent->handle, &child->handle);
372 if (EOK == res)
[df747b9c]373 return res;
[9a66bc2e]374 remove_from_devices_list(child);
[df747b9c]375 return res;
[7707954]376}
377
[52b7b1bb]378int driver_main(driver_t *drv)
[c16cf62]379{
[7a252ec8]380 /*
381 * Remember the driver structure - driver_ops will be called by generic
382 * handler for incoming connections.
383 */
[c16cf62]384 driver = drv;
[52b7b1bb]385
[7a252ec8]386 /* Initialize the list of interrupt contexts. */
[7f8b581]387 init_interrupt_context_list(&interrupt_contexts);
388
[7a252ec8]389 /* Set generic interrupt handler. */
[7f8b581]390 async_set_interrupt_received(driver_irq_handler);
391
[7a252ec8]392 /*
393 * Register driver by device manager with generic handler for incoming
394 * connections.
395 */
[52b7b1bb]396 devman_driver_register(driver->name, driver_connection);
[c16cf62]397
398 async_manager();
399
[7a252ec8]400 /* Never reached. */
[52b7b1bb]401 return 0;
[c16cf62]402}
403
404/**
405 * @}
[52b7b1bb]406 */
Note: See TracBrowser for help on using the repository browser.