minix/lib/libddekit/src/usb_server.c

   1 #include "common.h"
   2
   3 #include <ddekit/minix/msg_queue.h>
   4 #include <ddekit/panic.h>
   5 #include <ddekit/printf.h>
   6 #include <ddekit/usb.h>
   7 #include <minix/safecopies.h>
   8 #include <minix/usb.h>
   9 #include <minix/usb_ch9.h>
  10 #include <minix/devman.h>
  11
  12 #define MAX_URBS    10
  13
  14 #define DRIVER_UNUSED 0
  15 #define DRIVER_ACTIVE 1
  16 #define DRIVER_BOUND  2
  17
  18 #if 0
  19 #define DEBUG_MSG(fmt, ...) ddekit_printf("%s : "fmt"\n", __func__, ##__VA_ARGS__ )
  20 #else
  21 #define DEBUG_MSG(fmt, ...)
  22 #endif
  23
  24 #undef DDEBUG
  25 #define DDEBUG 0
  26 #include "debug.h"
  27
  28 #define MAX_DEVS 256
  29 #define MAX_DRIVERS 256
  30 #define OK 0
  31
  32 #define INVAL_DEV (-1)
  33
  34 struct my_context {
  35         unsigned urb_id;
  36         struct ddekit_usb_urb *d_urb;
  37         struct usb_urb *mx_urb;
  38         struct minix_usb_driver *drv;
  39         gid_t gid;
  40 };
  41
  42 struct minix_usb_driver {
  43         endpoint_t ep;                       /* address of the client */
  44
  45         int status;                          /* In what state is the client? */
  46
  47         int dev;                          /* which device is this driver handling */
  48         unsigned interfaces;                 /* which interfaces of the device the
  49                                                 driver is handling */
  50
  51         struct ddekit_usb_urb *urbs[MAX_URBS]; /* pending urbs */
  52
  53         unsigned long urb_id;                        /* generation of driver_local urb_ids */
  54 };
  55
  56 struct minix_usb_device {
  57         struct ddekit_usb_dev *dev;
  58         unsigned int interfaces;
  59 };
  60
  61 static struct minix_usb_driver *find_driver(endpoint_t ep);
  62 static struct minix_usb_driver *find_unused_driver(void);
  63 static int add_to_pending_urbs(struct minix_usb_driver *drv, struct
  64         ddekit_usb_urb *urb);
  65 static int remove_from_pending_urbs(struct minix_usb_driver *drv,
  66         struct ddekit_usb_urb *urb);
  67 static struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver
  68         *drv, unsigned urb_id);
  69 static void register_driver(message *msg);
  70 static struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb
  71         *mx_urb);
  72 static void submit_urb(message *msg);
  73 static void cancle_urb(message *msg);
  74 static void get_info(message *msg);
  75 static void completion_callback(void *priv);
  76
  77 static void prepare_devman_usbdev(struct ddekit_usb_dev * dev, int
  78         dev_id, unsigned int interfaces, struct devman_usb_dev *dudev);
  79 static void device_disconnect_callback(struct ddekit_usb_dev * dev);
  80 static int add_acl(int dev_id, unsigned interfaces, endpoint_t ep);
  81 static int del_acl(int dev_id, unsigned interaces, endpoint_t ep);
  82 static int handle_msg(message *msg);
  83 static void _ddekit_usb_thread();
  84 static void device_connect_callback(struct ddekit_usb_dev * dev,
  85         unsigned int interfaces);
  86
  87 char *_ddekit_usb_get_manufacturer(struct ddekit_usb_dev *ddev);
  88 char *_ddekit_usb_get_product(struct ddekit_usb_dev *ddev);
  89 char *_ddekit_usb_get_serial(struct ddekit_usb_dev *ddev);
  90 usb_device_descriptor_t *_ddekit_usb_get_device_desc(struct
  91         ddekit_usb_dev *ddev);
  92 usb_interface_descriptor_t *_ddekit_usb_get_interface_desc(struct
  93         ddekit_usb_dev *ddev, int inum);
  94
  95
  96 static ddekit_usb_malloc_fn my_malloc;
  97 static ddekit_usb_free_fn my_free;
  98 static struct minix_usb_driver gbl_drivers[MAX_DRIVERS];
  99 static struct minix_usb_device _devices[MAX_DEVS];
 100
 101 static struct ddekit_usb_driver my_driver = {
 102         .completion = completion_callback,
 103         .connect    = device_connect_callback,
 104         .disconnect = device_disconnect_callback,
 105 };
 106
 107
 108 /*****************************************************************************
 109  *         find_driver                                                       *
 110  ****************************************************************************/
 111 static struct minix_usb_driver *find_driver(endpoint_t ep)
 112 {
 113         int i;
 114         for (i = 0; i < MAX_DRIVERS; i++ ){
 115                 if (gbl_drivers[i].ep == ep) {
 116                         return &gbl_drivers[i];
 117                 }
 118         }
 119         return NULL;
 120 }
 121
 122 /*****************************************************************************
 123  *         find_unused_driver                                                *
 124  ****************************************************************************/
 125 static struct minix_usb_driver *find_unused_driver()
 126 {
 127         int i;
 128         for (i = 0; i < MAX_DRIVERS; i++ ){
 129                 if (gbl_drivers[i].status == DRIVER_UNUSED) {
 130                         return &gbl_drivers[i];
 131                 }
 132         }
 133         return NULL;
 134 }
 135
 136 /*****************************************************************************
 137  *         add_to_pending_urbs                                               *
 138  ****************************************************************************/
 139 static int add_to_pending_urbs(struct minix_usb_driver *drv,
 140                                struct ddekit_usb_urb *urb)
 141 {
 142         int i;
 143
 144         for (i = 0; i < MAX_URBS; i++) {
 145                 if (drv->urbs[i] == NULL) {
 146                         drv->urbs[i] = urb;
 147                         return 0;
 148                 }
 149         }
 150
 151         return -1;
 152 }
 153
 154 /*****************************************************************************
 155  *         remove_from_pending_urbs                                          *
 156  ****************************************************************************/
 157 static int remove_from_pending_urbs(struct minix_usb_driver *drv,
 158                                struct ddekit_usb_urb *urb)
 159 {
 160         int i;
 161
 162         for (i = 0; i < MAX_URBS; i++) {
 163                 if (drv->urbs[i] == urb) {
 164                         drv->urbs[i] = NULL;
 165                         return 0;
 166                 }
 167         }
 168
 169         return -1;
 170 }
 171
 172 /*****************************************************************************
 173  *         find_pending_urb                                                  *
 174  ****************************************************************************/
 175 static struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver *drv,
 176                                                 unsigned urb_id)
 177 {
 178         int i;
 179
 180         for (i = 0; i < MAX_URBS; i++) {
 181                 if (((struct my_context*)drv->urbs[i]->priv)->urb_id == urb_id) {
 182                                 return drv->urbs[i];
 183                 }
 184         }
 185
 186         return NULL;
 187 }
 188
 189 /*****************************************************************************
 190  *         register_driver                                                   *
 191  ****************************************************************************/
 192 static void register_driver(message *msg)
 193 {
 194         endpoint_t ep = msg->m_source;
 195         struct minix_usb_driver *drv;
 196
 197         msg->m_type=USB_REPLY;
 198
 199         if ( (drv = find_driver(ep)) != NULL) {
 200                 msg->m_type = USB_REPLY;
 201                 msg->USB_RESULT = OK;
 202                 ipc_send(ep,msg);
 203         } else {
 204                 msg->m_type = USB_REPLY;
 205                 msg->USB_RESULT = EPERM;
 206                 ipc_send(ep,msg);
 207                 return;
 208         }
 209
 210         DEBUG_MSG("DRIVER %d registered \n"
 211                       "Announcing device %d, interfaces 0x%x\n",
 212                                   ep,
 213                                   drv->dev,
 214                                   drv->interfaces);
 215
 216         /* hand out the device */
 217         msg->m_type = USB_ANNOUCE_DEV;
 218         msg->USB_DEV_ID     = drv->dev;
 219         msg->USB_INTERFACES = drv->interfaces;
 220         ipc_send(ep, msg);
 221 }
 222
 223 /*****************************************************************************
 224  *         deregister_driver                                                 *
 225  ****************************************************************************/
 226 static void deregister_driver(message *msg)
 227 {
 228         endpoint_t ep = msg->m_source;
 229
 230         struct minix_usb_driver *drv;
 231
 232         msg->m_type=USB_REPLY;
 233
 234         if ( (drv = find_driver(ep)) == NULL) {
 235                 DEBUG_MSG("Non-registered driver tries to unregister.");
 236                 return;
 237         } else {
 238                 /* do not accept requests for this client anymore! */
 239                 drv->status = DRIVER_UNUSED;
 240
 241                 msg->USB_RESULT = 0;
 242                 asynsend3(ep, msg, AMF_NOREPLY);
 243         }
 244 }
 245
 246 /*****************************************************************************
 247  *         ddekit_usb_urb_from_mx_urb                                        *
 248  ****************************************************************************/
 249 static struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb *mx_urb)
 250 {
 251         /*
 252          * A helper function that generates (allocates and initializes)
 253          * a ddekit_usb_urb.
 254          */
 255
 256         struct ddekit_usb_urb *d_urb = (struct ddekit_usb_urb *)
 257                 my_malloc(sizeof(struct ddekit_usb_urb));
 258
 259         if (d_urb == NULL) {
 260                 return NULL;
 261         }
 262
 263         d_urb->type           = mx_urb->type;
 264         d_urb->direction      = mx_urb->direction;
 265         d_urb->transfer_flags = mx_urb->transfer_flags;
 266         d_urb->size           = mx_urb->size;
 267         d_urb->data           = mx_urb->buffer;
 268         d_urb->interval       = mx_urb->interval;
 269         d_urb->endpoint       = mx_urb->endpoint;
 270
 271         if (d_urb->type == USB_TRANSFER_CTL) {
 272                 d_urb->setup_packet = mx_urb->setup_packet;
 273         }
 274         DEBUG_MSG("setup_package at %p", d_urb->setup_packet);
 275
 276         if (d_urb->type == USB_TRANSFER_ISO) {
 277                 d_urb->iso_desc  = (struct ddekit_usb_iso_packet_desc *)
 278                     mx_urb->buffer + mx_urb->iso_desc_offset;
 279                 d_urb->number_of_packets = mx_urb->number_of_packets;
 280         }
 281
 282         return d_urb;
 283 }
 284
 285 /*****************************************************************************
 286  *         submit_urb                                                        *
 287  ****************************************************************************/
 288 static void submit_urb(message *msg)
 289 {
 290         /*
 291          * submit_urb
 292          *
 293          * Handles a submit_urb from a minix USB device driver. It copies the
 294          * usb_urb structure containing the buffers and generates and tries to
 295          * submit a ddekit_usb_urb. The reference to the ddekit_usb_urb is stored
 296          * in the driver structure in order to be able to cancle the URB on the
 297          * clients request.
 298          */
 299         endpoint_t ep = msg->m_source;
 300         struct minix_usb_driver *drv;
 301
 302         /* find driver */
 303         if ( (drv = find_driver(ep)) == NULL) {
 304                 DEBUG_MSG("Non-registered driver tries to send URB.");
 305                 return;
 306         } else {
 307
 308                 int res;
 309                 struct my_context *ctx = NULL;
 310                 struct ddekit_usb_urb *d_urb = NULL;
 311
 312                 struct usb_urb *mx_urb  = (struct usb_urb*)
 313                     my_malloc(msg->USB_GRANT_SIZE+sizeof(void *));
 314
 315                 if (mx_urb == NULL) {
 316                         DEBUG_MSG("Can't allocat mem for mx_urb.");
 317                         res = ENOMEM;
 318                         goto out;
 319                 }
 320
 321                 /* copy in URB */
 322                 res = sys_safecopyfrom(ep, msg->USB_GRANT_ID, 0,
 323                     (vir_bytes) &mx_urb->dev_id, msg->USB_GRANT_SIZE);
 324
 325                 if (res != 0) {
 326                         DEBUG_MSG("sys_safecopyfrom failed ");
 327                         my_free(mx_urb);
 328                         res = EINVAL;
 329                         goto out;
 330                 }
 331
 332                 DEBUG_MSG("URB type: %d", mx_urb->type);
 333                 /* check if urb is valid */
 334                 if (mx_urb->dev_id >= MAX_DEVS || mx_urb->dev_id < 0) {
 335                         DEBUG_MSG("Bogus device ID.");
 336                         res = EINVAL;
 337                         goto out;
 338                 }
 339
 340                 /* create ddekit_usb_urb */
 341                 d_urb = ddekit_usb_urb_from_mx_urb(mx_urb);
 342                 d_urb->dev = _devices[drv->dev].dev;
 343                 /* submit urb */
 344
 345                 if (!d_urb) {
 346                         res = ENOMEM;
 347                         goto out;
 348                 }
 349
 350                 ctx = my_malloc(sizeof(struct my_context));
 351
 352                 if(!ctx) {
 353                         res = ENOMEM;
 354                         goto out;
 355                 }
 356
 357                 ctx->drv       = drv;
 358                 ctx->urb_id    = drv->urb_id++;
 359                 mx_urb->urb_id = ctx->urb_id;
 360                 ctx->mx_urb    = mx_urb;
 361                 ctx->d_urb     = d_urb;
 362                 ctx->gid       = msg->USB_GRANT_ID;
 363
 364                 DEBUG_MSG("ctx: %p, urb_id: %d, d_urb: %p, mx_urb: %p, drv: %d, gid: %d ",
 365                     ctx, ctx->urb_id, ctx->d_urb, ctx->mx_urb, ctx->drv, ctx->gid);
 366
 367                 d_urb->priv = ctx;
 368
 369                 res = add_to_pending_urbs(drv, d_urb);
 370
 371                 if (res == 0) {
 372                         DEBUG_MSG("submitting urb...");
 373                         res = ddekit_usb_submit_urb(d_urb);
 374                         if(res) {
 375                                 DEBUG_MSG("submitting urb failed (err: %d)", res);
 376                                 remove_from_pending_urbs(drv, d_urb);
 377                         }
 378                 }
 379
 380 out:
 381                 /* reply */
 382                 msg->m_type     = USB_REPLY;
 383                 msg->USB_URB_ID = mx_urb->urb_id;
 384                 msg->USB_RESULT = res;
 385
 386                 if(res != 0) {
 387
 388                         if (mx_urb != NULL) {
 389                                 my_free(mx_urb);
 390                         }
 391                         if (ctx != NULL) {
 392                                 my_free(ctx);
 393                         }
 394
 395                         if (d_urb != NULL) {
 396                                 my_free(d_urb);
 397                         }
 398
 399                 }
 400
 401                 /* send reply */
 402                 ipc_send(ep, msg);
 403         }
 404 }
 405
 406
 407 /*
 408  * cancle_urb
 409  *
 410  * Cancels the submission of an URB identified by a URB_id
 411  */
 412 /*****************************************************************************
 413  *         cancle_urb                                                        *
 414  ****************************************************************************/
 415 static void cancle_urb(message *msg)
 416 {
 417         endpoint_t ep = msg->m_source;
 418
 419         struct minix_usb_driver *drv;
 420
 421         msg->USB_RESULT = -1;
 422         msg->m_type = USB_REPLY;
 423
 424         /* find driver */
 425         if ( (drv = find_driver(ep)) == NULL) {
 426                 DEBUG_MSG("Non-registered driver tries to cancel URB.");
 427                 return;
 428         } else {
 429                 struct ddekit_usb_urb *d_urb = NULL;
 430
 431                 d_urb = find_pending_urb(drv, msg->USB_URB_ID);
 432
 433                 if (d_urb != NULL) {
 434                         ddekit_usb_cancle_urb(d_urb);
 435                         msg->USB_RESULT = 0;
 436                 } else {
 437                         DEBUG_MSG("No URB to cancle");
 438                         msg->USB_RESULT = ENODEV;
 439                 }
 440         }
 441
 442         ipc_send(ep, msg);
 443 }
 444
 445
 446 /*****************************************************************************
 447  *         get_info                                                          *
 448  *****************************************************************************/
 449 static void
 450 get_info(message * msg)
 451 {
 452         struct minix_usb_driver * drv;
 453         endpoint_t ep;
 454         long info_type;
 455         long info_value;
 456
 457         /* Read */
 458         ep              = msg->m_source;
 459         info_type       = msg->USB_INFO_TYPE;
 460         info_value      = msg->USB_INFO_VALUE;
 461
 462         /* Reuse as reply */
 463         msg->m_type     = USB_REPLY;
 464         msg->USB_RESULT = -1;
 465
 466         /* Try and find driver first */
 467         if (NULL == (drv = find_driver(ep)))
 468                 ddekit_printf("Non-registered driver tries to send info");
 469         else
 470                 /* Route info to device */
 471                 msg->USB_RESULT = ddekit_usb_info(_devices[drv->dev].dev,
 472                                                 info_type, info_value);
 473
 474         /* Reply */
 475         ipc_send(ep, msg);
 476 }
 477
 478
 479 /*****************************************************************************
 480  *         completion_callback                                               *
 481  ****************************************************************************/
 482 static void completion_callback(void *priv)
 483 {
 484         /*
 485          * completion_callback
 486          *
 487          * This is called by the DDE side. Here the data is copied back to
 488          * the driver and a message is send to inform the driver about the
 489          * completion.
 490          */
 491         message msg;
 492         int res;
 493         struct my_context *ctx       = (struct my_context *)priv;
 494         struct usb_urb *mx_urb       = ctx->mx_urb;
 495         struct ddekit_usb_urb *d_urb = ctx->d_urb;
 496         struct minix_usb_driver *drv = ctx->drv;
 497
 498         DEBUG_MSG("ctx: %p, urb_id: %d, d_urb: %p, mx_urb: %p, drv: %d, gid: %d ",
 499                     ctx, ctx->urb_id, ctx->d_urb, ctx->mx_urb, ctx->drv, ctx->gid);
 500
 501         /* update data in minix URB */
 502         mx_urb->status          = d_urb->status;
 503         mx_urb->actual_length   = d_urb->actual_length;
 504         mx_urb->error_count     = d_urb->error_count;
 505         mx_urb->transfer_flags  = d_urb->transfer_flags;
 506
 507         remove_from_pending_urbs(drv, d_urb);
 508
 509         /* copy out URB */
 510         res = sys_safecopyto(drv->ep, ctx->gid, 0,
 511             (vir_bytes) ((char*)mx_urb) + sizeof(void*),
 512                 mx_urb->urb_size - sizeof(void*));
 513
 514         if (res != 0) {
 515                 DEBUG_MSG("Copy out failed: %d", res);
 516                 DEBUG_MSG(" URB ID: %d, Grant-ID: %d, Grant-size: %d", ctx->urb_id,
 517                             ctx->gid, mx_urb->urb_size);
 518         }
 519
 520         /* send message to client */
 521         msg.m_type     = USB_COMPLETE_URB;
 522         msg.USB_URB_ID = ctx->urb_id;
 523         asynsend3(drv->ep, &msg, AMF_NOREPLY);
 524
 525         /* free stuff */
 526         my_free(ctx);
 527         my_free(mx_urb);
 528         my_free(d_urb);
 529 }
 530
 531
 532 /*****************************************************************************
 533  *         prepare_devman_usbdev                                             *
 534  ****************************************************************************/
 535 static void prepare_devman_usbdev
 536 (struct ddekit_usb_dev * dev, int dev_id, unsigned int interfaces,
 537  struct devman_usb_dev *dudev)
 538 {
 539         int j;
 540         int intf_count;
 541         /*
 542          * currently this is only implemented by stub driver
 543          */
 544
 545         usb_device_descriptor_t *desc = _ddekit_usb_get_device_desc(dev);
 546
 547         dudev->manufacturer = _ddekit_usb_get_manufacturer(dev);
 548         dudev->product = _ddekit_usb_get_product(dev);
 549         dudev->serial = _ddekit_usb_get_serial(dev);
 550
 551         dudev->desc = desc;
 552
 553         intf_count = 0;
 554
 555         for (j=0; j < 32; j++) {
 556                 if (interfaces & (1 << j)) {
 557                                 dudev->interfaces[intf_count++].desc =
 558                                    _ddekit_usb_get_interface_desc(dev, j);
 559                 }
 560         }
 561
 562         dudev->intf_count = intf_count;
 563         dudev->dev_id     = dev_id;
 564 }
 565
 566 /*****************************************************************************
 567  *         device_connect_callback                                           *
 568  ****************************************************************************/
 569 static void
 570 device_connect_callback
 571 (struct ddekit_usb_dev * dev, unsigned int interfaces) {
 572
 573         int i, res;
 574
 575         /* add to device list */
 576         for (i=0; i < MAX_DEVS; i++) {
 577                 if (_devices[i].dev == NULL)
 578                         break;
 579         }
 580
 581         if (i >= MAX_DEVS) {
 582                 DEBUG_MSG("Too much devices...");
 583         } else {
 584                 _devices[i].dev = dev;
 585                 _devices[i].interfaces = (1 << interfaces);
 586         }
 587
 588         struct devman_usb_dev *dudev;
 589
 590         dudev = devman_usb_device_new(i);
 591
 592         prepare_devman_usbdev(dev, i, interfaces, dudev);
 593
 594         if (dudev == NULL) {
 595                 /* TODO: ERROR */
 596                 printf("ERROR: !");
 597         }
 598
 599         ddekit_usb_dev_set_data(dev, dudev);
 600
 601         res = devman_usb_device_add(dudev);
 602
 603         if (res != 0) {
 604                 /* TODO: Error*/
 605                 printf("ERROR!");
 606         }
 607 }
 608
 609 /*****************************************************************************
 610  *         device_disconnect_callback                                        *
 611  ****************************************************************************/
 612 static void device_disconnect_callback(struct ddekit_usb_dev * dev)
 613 {
 614         int i;
 615
 616         /* remove ACL entry */
 617         for (i = 0; i< MAX_DRIVERS; i++) {
 618                 if (gbl_drivers[i].dev != INVAL_DEV
 619                         && _devices[gbl_drivers[i].dev].dev == dev) {
 620                         struct minix_usb_driver *drv = &gbl_drivers[i];
 621                         drv->ep     = 0;
 622                         drv->status = DRIVER_UNUSED;
 623                         drv->dev    = INVAL_DEV;
 624                 }
 625         }
 626
 627         for (i=0; i < MAX_DEVS; i++) {
 628                 if (_devices[i].dev == dev) {
 629                         _devices[i].dev = NULL;
 630                         _devices[i].interfaces = 0;
 631                 }
 632         }
 633
 634
 635         /* get the devman device */
 636         struct devman_usb_dev * dudev = NULL;
 637
 638         dudev = ddekit_usb_dev_get_data(dev);
 639
 640         if (dudev == NULL) {
 641                 /* TODO: error */
 642         }
 643
 644         devman_usb_device_remove(dudev);
 645
 646         /* free the devman dev */
 647         devman_usb_device_delete(dudev);
 648 }
 649
 650
 651 /*****************************************************************************
 652  *         add_acl                                                           *
 653  ****************************************************************************/
 654 static int add_acl(int dev_id, unsigned interfaces, endpoint_t ep)
 655 {
 656         /*
 657          * This functions binds a specific USB interface to a client.
 658          */
 659         int i;
 660         struct minix_usb_driver *drv;
 661
 662         if (_devices[dev_id].dev == NULL) {
 663                 /* if no device with that ID */
 664                 return  ENODEV;
 665         }
 666
 667         /* is the device allready given to a client*/
 668         for (i = 0; i< MAX_DRIVERS; i++) {
 669                 if (gbl_drivers[i].status != DRIVER_UNUSED &&
 670                         gbl_drivers[i].dev == dev_id) {
 671                         printf("devid: %d\n", dev_id);
 672                         return EBUSY;
 673                 }
 674         }
 675
 676         /* bind device to client */
 677         drv = find_unused_driver();
 678
 679         if (drv == NULL) {
 680                 return ENOMEM;
 681         }
 682
 683         drv->status     = DRIVER_BOUND;
 684         drv->dev        = dev_id;
 685         drv->interfaces = 1 << interfaces;
 686         drv->ep         = ep;
 687         drv->urb_id     = 0;
 688
 689         return OK;
 690 }
 691
 692 /*****************************************************************************
 693  *         del_acl                                                           *
 694  ****************************************************************************/
 695 static int del_acl(int dev_id, unsigned interfaces, endpoint_t ep)
 696 {
 697         struct minix_usb_driver *drv;
 698         int dev, withdraw = 0;
 699         message msg;
 700
 701         /* find driver */
 702         drv = find_driver(ep);
 703
 704         if (drv == NULL) {
 705                 return  ENOENT;
 706         }
 707
 708         dev = drv->dev;
 709
 710         if (drv->status == DRIVER_ACTIVE) {
 711                 withdraw = 1;
 712         }
 713
 714         drv->ep    = 0;
 715         drv->status = DRIVER_UNUSED;
 716         drv->dev   = INVAL_DEV;
 717
 718         if (withdraw) {
 719                 msg.m_type     = USB_WITHDRAW_DEV;
 720                 msg.USB_DEV_ID = dev;
 721                 asynsend3(ep, &msg, AMF_NOREPLY);
 722         }
 723
 724         return 0;
 725 }
 726
 727 /*****************************************************************************
 728  *         handle_msg                                                        *
 729  ****************************************************************************/
 730 static int handle_msg(message *msg)
 731 {
 732         /*
 733          * handle_msg
 734          *
 735          * The dispatcher for USB related messages.
 736          */
 737
 738         switch(msg->m_type) {
 739                 case USB_RQ_INIT:
 740                         register_driver(msg);
 741                         return 1;
 742                 case USB_RQ_DEINIT:
 743                         deregister_driver(msg);
 744                         return 1;
 745                 case USB_RQ_SEND_URB:
 746                         submit_urb(msg);
 747                         return 1;
 748                 case USB_RQ_CANCEL_URB:
 749                         cancle_urb(msg);
 750                         return 1;
 751                 case USB_RQ_SEND_INFO:
 752                         get_info(msg);
 753                         return 1;
 754                 default:
 755                         return 0;
 756         }
 757 }
 758
 759 /*****************************************************************************
 760  *         devman_tread                                                      *
 761  ****************************************************************************/
 762 static void devman_thread(void *unused)
 763 {
 764         struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(DEVMAN_BASE,
 765             DEVMAN_BASE + 0xff);
 766         int ipc_status;
 767         message m;
 768         while (1) {
 769                 ddekit_minix_rcv(mq, &m, &ipc_status);
 770                 devman_handle_msg(&m);
 771         }
 772 }
 773
 774 /*****************************************************************************
 775  *         _ddekit_usb_thread                                                *
 776  ****************************************************************************/
 777 static void _ddekit_usb_thread(void * unused)
 778 {
 779         struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(USB_BASE,
 780             USB_BASE + 0xff);
 781
 782         message m;
 783         int ipc_status;
 784
 785         /* create devman thread */
 786         ddekit_thread_t * __unused dmth;
 787
 788         dmth = ddekit_thread_create(devman_thread, NULL, "devman_thread");
 789
 790         while (1) {
 791                 ddekit_minix_rcv(mq, &m, &ipc_status);
 792                 handle_msg(&m);
 793         }
 794 }
 795
 796
 797 /*****************************************************************************
 798  *         bind_cb                                                           *
 799  ****************************************************************************/
 800 static int bind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
 801 {
 802         if(data) {
 803                 return add_acl(data->dev_id, data->interface, ep);
 804         } else {
 805                 printf("warning: missing cb_data!\n");
 806                 return EINVAL;
 807         }
 808 }
 809
 810 /*****************************************************************************
 811  *         unbind_cb                                                         *
 812  ****************************************************************************/
 813 static int unbind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
 814 {
 815         if(data) {
 816                 return del_acl(data->dev_id, data->interface, ep);
 817         } else {
 818                 printf("warning: missing cb_data!\n");
 819                 return EINVAL;
 820         }
 821 }
 822
 823 /*****************************************************************************
 824  *         ddekit_usb_server_init                                            *
 825  ****************************************************************************/
 826 void ddekit_usb_server_init()
 827 {
 828         int i;
 829         /*
 830          * this function has to be called inside the context of an dedicated
 831          * DDELinux thread
 832          */
 833         devman_usb_init(bind_cb, unbind_cb);
 834         ddekit_usb_init(&my_driver, &my_malloc, &my_free);
 835         for (i = 0; i< MAX_DRIVERS; i++) {
 836                 gbl_drivers[i].dev = DRIVER_UNUSED;
 837                 gbl_drivers[i].dev = INVAL_DEV;
 838         }
 839         _ddekit_usb_thread(NULL);
 840
 841 }