Changes in uspace/lib/drv/generic/driver.c [5fdd7c3:2a770a35] in mainline
- File:
-
- 1 edited
-
uspace/lib/drv/generic/driver.c (modified) (23 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/drv/generic/driver.c
r5fdd7c3 r2a770a35 1 1 /* 2 2 * Copyright (c) 2010 Lenka Trochtova 3 * Copyright (c) 2011 Jiri Svoboda 3 4 * All rights reserved. 4 5 * … … 49 50 #include <errno.h> 50 51 #include <inttypes.h> 52 #include <devman.h> 51 53 52 54 #include <ipc/driver.h> 53 55 54 56 #include "dev_iface.h" 55 #include "driver.h" 57 #include "ddf/driver.h" 58 #include "ddf/interrupt.h" 56 59 57 60 /** Driver structure */ … … 59 62 60 63 /** Devices */ 61 LIST_INITIALIZE( devices);62 FIBRIL_MUTEX_INITIALIZE( devices_mutex);64 LIST_INITIALIZE(functions); 65 FIBRIL_MUTEX_INITIALIZE(functions_mutex); 63 66 64 67 /** Interrupts */ … … 76 79 }; 77 80 81 static ddf_dev_t *create_device(void); 82 static void delete_device(ddf_dev_t *); 83 static remote_handler_t *function_get_default_handler(ddf_fun_t *); 84 static void *function_get_ops(ddf_fun_t *, dev_inferface_idx_t); 78 85 79 86 static void driver_irq_handler(ipc_callid_t iid, ipc_call_t *icall) … … 150 157 151 158 interrupt_context_t * 152 find_interrupt_context(interrupt_context_list_t *list, d evice_t *dev, int irq)159 find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq) 153 160 { 154 161 fibril_mutex_lock(&list->mutex); … … 172 179 173 180 int 174 register_interrupt_handler(d evice_t *dev, int irq, interrupt_handler_t *handler,181 register_interrupt_handler(ddf_dev_t *dev, int irq, interrupt_handler_t *handler, 175 182 irq_code_t *pseudocode) 176 183 { … … 186 193 pseudocode = &default_pseudocode; 187 194 188 int res = ipc_register_irq(irq, dev->handle, ctx->id, pseudocode);195 int res = register_irq(irq, dev->handle, ctx->id, pseudocode); 189 196 if (res != EOK) { 190 197 remove_interrupt_context(&interrupt_contexts, ctx); … … 195 202 } 196 203 197 int unregister_interrupt_handler(d evice_t *dev, int irq)204 int unregister_interrupt_handler(ddf_dev_t *dev, int irq) 198 205 { 199 206 interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts, 200 207 dev, irq); 201 int res = ipc_unregister_irq(irq, dev->handle);208 int res = unregister_irq(irq, dev->handle); 202 209 203 210 if (ctx != NULL) { … … 209 216 } 210 217 211 static void add_to_ devices_list(device_t *dev)212 { 213 fibril_mutex_lock(& devices_mutex);214 list_append(& dev->link, &devices);215 fibril_mutex_unlock(& devices_mutex);216 } 217 218 static void remove_from_ devices_list(device_t *dev)219 { 220 fibril_mutex_lock(& devices_mutex);221 list_remove(& dev->link);222 fibril_mutex_unlock(& devices_mutex);223 } 224 225 static d evice_t *driver_get_device(link_t *devices, devman_handle_t handle)226 { 227 d evice_t *dev= NULL;228 229 fibril_mutex_lock(& devices_mutex);230 link_t *link = devices->next;231 232 while (link != devices) {233 dev = list_get_instance(link, device_t, link);234 if ( dev->handle == handle) {235 fibril_mutex_unlock(& devices_mutex);236 return dev;218 static void add_to_functions_list(ddf_fun_t *fun) 219 { 220 fibril_mutex_lock(&functions_mutex); 221 list_append(&fun->link, &functions); 222 fibril_mutex_unlock(&functions_mutex); 223 } 224 225 static void remove_from_functions_list(ddf_fun_t *fun) 226 { 227 fibril_mutex_lock(&functions_mutex); 228 list_remove(&fun->link); 229 fibril_mutex_unlock(&functions_mutex); 230 } 231 232 static ddf_fun_t *driver_get_function(link_t *functions, devman_handle_t handle) 233 { 234 ddf_fun_t *fun = NULL; 235 236 fibril_mutex_lock(&functions_mutex); 237 link_t *link = functions->next; 238 239 while (link != functions) { 240 fun = list_get_instance(link, ddf_fun_t, link); 241 if (fun->handle == handle) { 242 fibril_mutex_unlock(&functions_mutex); 243 return fun; 237 244 } 245 238 246 link = link->next; 239 247 } 240 248 241 fibril_mutex_unlock(& devices_mutex);249 fibril_mutex_unlock(&functions_mutex); 242 250 243 251 return NULL; … … 250 258 251 259 devman_handle_t dev_handle = IPC_GET_ARG1(*icall); 252 devman_handle_t parent_ dev_handle = IPC_GET_ARG2(*icall);253 254 d evice_t *dev = create_device();260 devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall); 261 262 ddf_dev_t *dev = create_device(); 255 263 dev->handle = dev_handle; 256 264 257 265 async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0); 258 266 dev->name = dev_name; 259 260 add_to_devices_list(dev); 261 dev->parent = driver_get_device(&devices, parent_dev_handle); 267 268 /* 269 * Currently not used, parent fun handle is stored in context 270 * of the connection to the parent device driver. 271 */ 272 (void) parent_fun_handle; 262 273 263 274 res = driver->driver_ops->add_device(dev); … … 268 279 printf("%s: failed to add a new device with handle = %" PRIun ".\n", 269 280 driver->name, dev_handle); 270 remove_from_devices_list(dev);271 281 delete_device(dev); 272 282 } 273 283 274 ipc_answer_0(iid, res);284 async_answer_0(iid, res); 275 285 } 276 286 … … 278 288 { 279 289 /* Accept connection */ 280 ipc_answer_0(iid, EOK);290 async_answer_0(iid, EOK); 281 291 282 292 bool cont = true; … … 293 303 break; 294 304 default: 295 ipc_answer_0(callid, ENOENT);305 async_answer_0(callid, ENOENT); 296 306 } 297 307 } … … 311 321 */ 312 322 devman_handle_t handle = IPC_GET_ARG2(*icall); 313 d evice_t *dev = driver_get_device(&devices, handle);314 315 if ( dev== NULL) {316 printf("%s: driver_connection_gen error - no devicewith handle"323 ddf_fun_t *fun = driver_get_function(&functions, handle); 324 325 if (fun == NULL) { 326 printf("%s: driver_connection_gen error - no function with handle" 317 327 " %" PRIun " was found.\n", driver->name, handle); 318 ipc_answer_0(iid, ENOENT);328 async_answer_0(iid, ENOENT); 319 329 return; 320 330 } … … 327 337 328 338 int ret = EOK; 329 /* open the device*/330 if ( dev->ops != NULL && dev->ops->open != NULL)331 ret = (* dev->ops->open)(dev);332 333 ipc_answer_0(iid, ret);339 /* Open device function */ 340 if (fun->ops != NULL && fun->ops->open != NULL) 341 ret = (*fun->ops->open)(fun); 342 343 async_answer_0(iid, ret); 334 344 if (ret != EOK) 335 345 return; … … 344 354 switch (method) { 345 355 case IPC_M_PHONE_HUNGUP: 346 /* close the device*/347 if ( dev->ops != NULL && dev->ops->close != NULL)348 (* dev->ops->close)(dev);349 ipc_answer_0(callid, EOK);356 /* Close device function */ 357 if (fun->ops != NULL && fun->ops->close != NULL) 358 (*fun->ops->close)(fun); 359 async_answer_0(callid, EOK); 350 360 return; 351 361 default: … … 356 366 if (!is_valid_iface_idx(iface_idx)) { 357 367 remote_handler_t *default_handler = 358 device_get_default_handler(dev);368 function_get_default_handler(fun); 359 369 if (default_handler != NULL) { 360 (*default_handler)( dev, callid, &call);370 (*default_handler)(fun, callid, &call); 361 371 break; 362 372 } 373 363 374 /* 364 * This is not device's interface and the375 * Function has no such interface and 365 376 * default handler is not provided. 366 377 */ … … 368 379 "invalid interface id %d.", 369 380 driver->name, iface_idx); 370 ipc_answer_0(callid, ENOTSUP);381 async_answer_0(callid, ENOTSUP); 371 382 break; 372 383 } 373 384 374 /* calling one of the device's interfaces */385 /* calling one of the function's interfaces */ 375 386 376 387 /* Get the interface ops structure. */ 377 void *ops = device_get_ops(dev, iface_idx);388 void *ops = function_get_ops(fun, iface_idx); 378 389 if (ops == NULL) { 379 390 printf("%s: driver_connection_gen error - ", 380 391 driver->name); 381 printf(" devicewith handle %" PRIun " has no interface "392 printf("Function with handle %" PRIun " has no interface " 382 393 "with id %d.\n", handle, iface_idx); 383 ipc_answer_0(callid, ENOTSUP);394 async_answer_0(callid, ENOTSUP); 384 395 break; 385 396 } … … 400 411 printf("%s: driver_connection_gen error - " 401 412 "invalid interface method.", driver->name); 402 ipc_answer_0(callid, ENOTSUP);413 async_answer_0(callid, ENOTSUP); 403 414 break; 404 415 } … … 408 419 * receive parameters from the remote client and it will 409 420 * pass it to the corresponding local interface method 410 * associated with the deviceby its driver.421 * associated with the function by its driver. 411 422 */ 412 (*iface_method_ptr)( dev, ops, callid, &call);423 (*iface_method_ptr)(fun, ops, callid, &call); 413 424 break; 414 425 } … … 425 436 driver_connection_gen(iid, icall, false); 426 437 } 427 428 438 429 439 /** Function for handling connections to device driver. */ … … 446 456 default: 447 457 /* No such interface */ 448 ipc_answer_0(iid, ENOENT);458 async_answer_0(iid, ENOENT); 449 459 } 450 460 } … … 454 464 * @return The device structure. 455 465 */ 456 device_t *create_device(void)457 { 458 d evice_t *dev = malloc(sizeof(device_t));459 460 if (dev != NULL) {461 memset(dev, 0, sizeof(device_t));462 init_match_ids(&dev->match_ids);463 } 464 466 static ddf_dev_t *create_device(void) 467 { 468 ddf_dev_t *dev; 469 470 dev = malloc(sizeof(ddf_dev_t)); 471 if (dev == NULL) 472 return NULL; 473 474 memset(dev, 0, sizeof(ddf_dev_t)); 465 475 return dev; 466 476 } 467 477 478 /** Create new function structure. 479 * 480 * @return The device structure. 481 */ 482 static ddf_fun_t *create_function(void) 483 { 484 ddf_fun_t *fun; 485 486 fun = calloc(1, sizeof(ddf_fun_t)); 487 if (fun == NULL) 488 return NULL; 489 490 init_match_ids(&fun->match_ids); 491 link_initialize(&fun->link); 492 493 return fun; 494 } 495 468 496 /** Delete device structure. 469 497 * 470 498 * @param dev The device structure. 471 499 */ 472 void delete_device(device_t *dev) 473 { 474 clean_match_ids(&dev->match_ids); 475 if (dev->name != NULL) 476 free(dev->name); 500 static void delete_device(ddf_dev_t *dev) 501 { 477 502 free(dev); 478 503 } 479 504 480 void *device_get_ops(device_t *dev, dev_inferface_idx_t idx) 505 /** Delete device structure. 506 * 507 * @param dev The device structure. 508 */ 509 static void delete_function(ddf_fun_t *fun) 510 { 511 clean_match_ids(&fun->match_ids); 512 if (fun->name != NULL) 513 free(fun->name); 514 free(fun); 515 } 516 517 /** Create a DDF function node. 518 * 519 * Create a DDF function (in memory). Both child devices and external clients 520 * communicate with a device via its functions. 521 * 522 * The created function node is fully formed, but only exists in the memory 523 * of the client task. In order to be visible to the system, the function 524 * must be bound using ddf_fun_bind(). 525 * 526 * This function should only fail if there is not enough free memory. 527 * Specifically, this function succeeds even if @a dev already has 528 * a (bound) function with the same name. 529 * 530 * Type: A function of type fun_inner indicates that DDF should attempt 531 * to attach child devices to the function. fun_exposed means that 532 * the function should be exported to external clients (applications). 533 * 534 * @param dev Device to which we are adding function 535 * @param ftype Type of function (fun_inner or fun_exposed) 536 * @param name Name of function 537 * 538 * @return New function or @c NULL if memory is not available 539 */ 540 ddf_fun_t *ddf_fun_create(ddf_dev_t *dev, fun_type_t ftype, const char *name) 541 { 542 ddf_fun_t *fun; 543 544 fun = create_function(); 545 if (fun == NULL) 546 return NULL; 547 548 fun->bound = false; 549 fun->dev = dev; 550 fun->ftype = ftype; 551 552 fun->name = str_dup(name); 553 if (fun->name == NULL) { 554 delete_function(fun); 555 return NULL; 556 } 557 558 return fun; 559 } 560 561 /** Destroy DDF function node. 562 * 563 * Destroy a function previously created with ddf_fun_create(). The function 564 * must not be bound. 565 * 566 * @param fun Function to destroy 567 */ 568 void ddf_fun_destroy(ddf_fun_t *fun) 569 { 570 assert(fun->bound == false); 571 delete_function(fun); 572 } 573 574 static void *function_get_ops(ddf_fun_t *fun, dev_inferface_idx_t idx) 481 575 { 482 576 assert(is_valid_iface_idx(idx)); 483 if ( dev->ops == NULL)577 if (fun->ops == NULL) 484 578 return NULL; 485 return dev->ops->interfaces[idx]; 486 } 487 488 int child_device_register(device_t *child, device_t *parent) 489 { 490 assert(child->name != NULL); 579 return fun->ops->interfaces[idx]; 580 } 581 582 /** Bind a function node. 583 * 584 * Bind the specified function to the system. This effectively makes 585 * the function visible to the system (uploads it to the server). 586 * 587 * This function can fail for several reasons. Specifically, 588 * it will fail if the device already has a bound function of 589 * the same name. 590 * 591 * @param fun Function to bind 592 * @return EOK on success or negative error code 593 */ 594 int ddf_fun_bind(ddf_fun_t *fun) 595 { 596 assert(fun->name != NULL); 491 597 492 598 int res; 493 599 494 add_to_ devices_list(child);495 res = devman_ child_device_register(child->name, &child->match_ids,496 parent->handle, &child->handle);600 add_to_functions_list(fun); 601 res = devman_add_function(fun->name, fun->ftype, &fun->match_ids, 602 fun->dev->handle, &fun->handle); 497 603 if (res != EOK) { 498 remove_from_ devices_list(child);604 remove_from_functions_list(fun); 499 605 return res; 500 606 } 501 607 608 fun->bound = true; 502 609 return res; 503 610 } 504 611 505 /** Wrapper for child_device_register for devices with single match id. 506 * 507 * @param parent Parent device. 508 * @param child_name Child device name. 509 * @param child_match_id Child device match id. 510 * @param child_match_score Child device match score. 511 * @return Error code. 512 */ 513 int child_device_register_wrapper(device_t *parent, const char *child_name, 514 const char *child_match_id, int child_match_score) 515 { 516 device_t *child = NULL; 517 match_id_t *match_id = NULL; 518 int rc; 519 520 child = create_device(); 521 if (child == NULL) { 522 rc = ENOMEM; 523 goto failure; 524 } 525 526 child->name = child_name; 612 /** Add single match ID to inner function. 613 * 614 * Construct and add a single match ID to the specified function. 615 * Cannot be called when the function node is bound. 616 * 617 * @param fun Function 618 * @param match_id_str Match string 619 * @param match_score Match score 620 * @return EOK on success, ENOMEM if out of memory. 621 */ 622 int ddf_fun_add_match_id(ddf_fun_t *fun, const char *match_id_str, 623 int match_score) 624 { 625 match_id_t *match_id; 626 627 assert(fun->bound == false); 628 assert(fun->ftype == fun_inner); 527 629 528 630 match_id = create_match_id(); 529 if (match_id == NULL) { 530 rc = ENOMEM; 531 goto failure; 532 } 533 534 match_id->id = child_match_id; 535 match_id->score = child_match_score; 536 add_match_id(&child->match_ids, match_id); 537 538 rc = child_device_register(child, parent); 539 if (rc != EOK) 540 goto failure; 541 631 if (match_id == NULL) 632 return ENOMEM; 633 634 match_id->id = match_id_str; 635 match_id->score = 90; 636 637 add_match_id(&fun->match_ids, match_id); 542 638 return EOK; 543 544 failure:545 if (match_id != NULL) {546 match_id->id = NULL;547 delete_match_id(match_id);548 }549 550 if (child != NULL) {551 child->name = NULL;552 delete_device(child);553 }554 555 return rc;556 639 } 557 640 558 641 /** Get default handler for client requests */ 559 remote_handler_t *device_get_default_handler(device_t *dev)560 { 561 if ( dev->ops == NULL)642 static remote_handler_t *function_get_default_handler(ddf_fun_t *fun) 643 { 644 if (fun->ops == NULL) 562 645 return NULL; 563 return dev->ops->default_handler; 564 } 565 566 int add_device_to_class(device_t *dev, const char *class_name) 567 { 568 return devman_add_device_to_class(dev->handle, class_name); 569 } 570 571 int driver_main(driver_t *drv) 646 return fun->ops->default_handler; 647 } 648 649 /** Add exposed function to class. 650 * 651 * Must only be called when the function is bound. 652 */ 653 int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name) 654 { 655 assert(fun->bound == true); 656 assert(fun->ftype == fun_exposed); 657 658 return devman_add_device_to_class(fun->handle, class_name); 659 } 660 661 int ddf_driver_main(driver_t *drv) 572 662 { 573 663 /*
Note:
See TracChangeset
for help on using the changeset viewer.
