Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbdev/src/devdrv.c

    rfb422312 r882580a  
    5454};
    5555
    56 static usb_driver_t *driver = NULL;
     56static const usb_driver_t *driver = NULL;
    5757
    5858
    … …  
    6464 * @return Task exit status.
    6565 */
    66 int usb_driver_main(usb_driver_t *drv)
     66int usb_driver_main(const usb_driver_t *drv)
    6767{
    6868        assert(drv != NULL);
    … …  
    8181 * @return Number of pipes (excluding default control pipe).
    8282 */
    83 static size_t count_other_pipes(usb_endpoint_description_t **endpoints)
     83static size_t count_other_pipes(const usb_endpoint_description_t **endpoints)
    8484{
    8585        size_t count = 0;
    … …  
    101101 * @return Error code.
    102102 */
    103 static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
     103static int initialize_other_pipes(const usb_endpoint_description_t **endpoints,
    104104    usb_device_t *dev, int alternate_setting)
    105105{
    … …  
    115115        int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints,
    116116            dev->descriptors.configuration, dev->descriptors.configuration_size,
    117             dev->interface_no, alternate_setting,
    118             &pipes, &pipes_count);
     117            dev->interface_no, alternate_setting, &pipes, &pipes_count);
    119118
    120119        if (rc != EOK) {
    … …  
    141140        assert(driver->ops->device_add);
    142141
    143         int rc;
    144 
    145         usb_device_t *dev = NULL;
     142        usb_device_t *dev = ddf_dev_data_alloc(gen_dev, sizeof(usb_device_t));
     143        if (dev == NULL) {
     144                usb_log_error("USB device `%s' structure allocation failed.\n",
     145                    gen_dev->name);
     146                return ENOMEM;
     147        }
    146148        const char *err_msg = NULL;
    147         rc = usb_device_create(gen_dev, driver->endpoints, &dev, &err_msg);
    148         if (rc != EOK) {
    149                 usb_log_error("USB device `%s' creation failed (%s): %s.\n",
     149        int rc = usb_device_init(dev, gen_dev, driver->endpoints, &err_msg);
     150        if (rc != EOK) {
     151                usb_log_error("USB device `%s' init failed (%s): %s.\n",
    150152                    gen_dev->name, err_msg, str_error(rc));
    151153                return rc;
    152154        }
    153         gen_dev->driver_data = dev;
    154 
    155         return driver->ops->device_add(dev);
     155
     156        rc = driver->ops->device_add(dev);
     157        if (rc != EOK)
     158                usb_device_deinit(dev);
     159        return rc;
    156160}
    157161/*----------------------------------------------------------------------------*/
    … …  
    186190        if (driver->ops->device_gone == NULL)
    187191                return ENOTSUP;
    188         const int ret = driver->ops->device_gone(gen_dev->driver_data);
     192        usb_device_t *usb_dev = gen_dev->driver_data;
     193        const int ret = driver->ops->device_gone(usb_dev);
    189194        if (ret == EOK)
    190                 usb_device_destroy(gen_dev->driver_data);
     195                usb_device_deinit(usb_dev);
    191196
    192197        return ret;
    … …  
    235240 */
    236241int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting,
    237     usb_endpoint_description_t **endpoints)
     242    const usb_endpoint_description_t **endpoints)
    238243{
    239244        if (dev->interface_no < 0) {
    … …  
    318323 */
    319324int usb_device_create_pipes(const ddf_dev_t *dev, usb_device_connection_t *wire,
    320     usb_endpoint_description_t **endpoints,
    321     uint8_t *config_descr, size_t config_descr_size,
     325    const usb_endpoint_description_t **endpoints,
     326    const uint8_t *config_descr, size_t config_descr_size,
    322327    int interface_no, int interface_setting,
    323328    usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr)
    … …  
    333338        int rc;
    334339
    335         size_t pipe_count = count_other_pipes(endpoints);
     340        const size_t pipe_count = count_other_pipes(endpoints);
    336341        if (pipe_count == 0) {
     342                *pipes_count_ptr = pipe_count;
    337343                *pipes_ptr = NULL;
    338344                return EOK;
    … …  
    445451{
    446452        assert(dev != NULL);
    447         assert(((pipes != NULL) && (pipes_count > 0))
    448             || ((pipes == NULL) && (pipes_count == 0)));
    449453
    450454        if (pipes_count == 0) {
     455                assert(pipes == NULL);
    451456                return EOK;
    452457        }
     458        assert(pipes != NULL);
    453459
    454460        int rc;
    … …  
    468474        size_t i;
    469475        for (i = 0; i < pipes_count; i++) {
    470                 usb_pipe_unregister(pipes[i].pipe, &hc_conn);
     476                usb_log_debug2("Unregistering pipe %zu (%spresent).\n",
     477                    i, pipes[i].present ? "" : "not ");
     478                if (pipes[i].present)
     479                        usb_pipe_unregister(pipes[i].pipe, &hc_conn);
    471480                free(pipes[i].pipe);
    472481        }
    … …  
    509518
    510519
    511 /** Create new instance of USB device.
    512  *
     520/** Initialize new instance of USB device.
     521 *
     522 * @param[in] usb_dev Pointer to the new device.
    513523 * @param[in] ddf_dev Generic DDF device backing the USB one.
    514524 * @param[in] endpoints NULL terminated array of endpoints (NULL for none).
    515  * @param[out] dev_ptr Where to store pointer to the new device.
    516525 * @param[out] errstr_ptr Where to store description of context
    517526 *      (in case error occurs).
    518527 * @return Error code.
    519528 */
    520 int usb_device_create(ddf_dev_t *ddf_dev,
    521     usb_endpoint_description_t **endpoints,
    522     usb_device_t **dev_ptr, const char **errstr_ptr)
    523 {
    524         assert(dev_ptr != NULL);
     529int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
     530    const usb_endpoint_description_t **endpoints, const char **errstr_ptr)
     531{
     532        assert(usb_dev != NULL);
    525533        assert(ddf_dev != NULL);
    526534
    527         int rc;
    528 
    529         usb_device_t *dev = malloc(sizeof(usb_device_t));
    530         if (dev == NULL) {
    531                 *errstr_ptr = "structure allocation";
    532                 return ENOMEM;
    533         }
    534 
    535         // FIXME: proper deallocation in case of errors
    536 
    537         dev->ddf_dev = ddf_dev;
    538         dev->driver_data = NULL;
    539         dev->descriptors.configuration = NULL;
    540         dev->alternate_interfaces = NULL;
    541 
    542         dev->pipes_count = 0;
    543         dev->pipes = NULL;
     535        usb_dev->ddf_dev = ddf_dev;
     536        usb_dev->driver_data = NULL;
     537        usb_dev->descriptors.configuration = NULL;
     538        usb_dev->alternate_interfaces = NULL;
     539        usb_dev->pipes_count = 0;
     540        usb_dev->pipes = NULL;
    544541
    545542        /* Initialize backing wire and control pipe. */
    546         rc = init_wire_and_ctrl_pipe(dev, errstr_ptr);
     543        int rc = init_wire_and_ctrl_pipe(usb_dev, errstr_ptr);
    547544        if (rc != EOK) {
    548545                return rc;
    … …  
    550547
    551548        /* Get our interface. */
    552         dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
     549        usb_dev->interface_no = usb_device_get_assigned_interface(ddf_dev);
    553550
    554551        /* Retrieve standard descriptors. */
    555         rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe,
    556             &dev->descriptors);
    557         if (rc != EOK) {
     552        rc = usb_device_retrieve_descriptors(&usb_dev->ctrl_pipe,
     553            &usb_dev->descriptors);
     554        if (rc != EOK) {
     555                /* Nothing allocated, nothing to free. */
    558556                *errstr_ptr = "descriptor retrieval";
    559557                return rc;
    560558        }
    561559
    562         /* Create alternate interfaces. */
    563         rc = usb_alternate_interfaces_create(dev->descriptors.configuration,
    564             dev->descriptors.configuration_size, dev->interface_no,
    565             &dev->alternate_interfaces);
    566         if (rc != EOK) {
    567                 /* We will try to silently ignore this. */
    568                 dev->alternate_interfaces = NULL;
    569         }
    570 
    571         rc = initialize_other_pipes(endpoints, dev, 0);
    572         if (rc != EOK) {
     560        /* Create alternate interfaces. We will silently ignore failure. */
     561        //TODO Why ignore?
     562        usb_alternate_interfaces_create(usb_dev->descriptors.configuration,
     563            usb_dev->descriptors.configuration_size, usb_dev->interface_no,
     564            &usb_dev->alternate_interfaces);
     565
     566        rc = initialize_other_pipes(endpoints, usb_dev, 0);
     567        if (rc != EOK) {
     568                /* Full configuration descriptor is allocated. */
     569                free(usb_dev->descriptors.configuration);
     570                /* Alternate interfaces may be allocated */
     571                usb_alternate_interfaces_destroy(usb_dev->alternate_interfaces);
    573572                *errstr_ptr = "pipes initialization";
    574573                return rc;
    … …  
    576575
    577576        *errstr_ptr = NULL;
    578         *dev_ptr = dev;
    579577
    580578        return EOK;
    581579}
    582580
    583 /** Destroy instance of a USB device.
    584  *
    585  * @param dev Device to be destroyed.
    586  */
    587 void usb_device_destroy(usb_device_t *dev)
    588 {
    589         if (dev == NULL) {
    590                 return;
    591         }
    592 
    593         /* Ignore errors and hope for the best. */
    594         usb_device_destroy_pipes(dev->ddf_dev, dev->pipes, dev->pipes_count);
    595         free(dev->descriptors.configuration);
    596 
    597         if (dev->alternate_interfaces != NULL) {
    598                 free(dev->alternate_interfaces->alternatives);
    599         }
    600         free(dev->alternate_interfaces);
    601 
    602         free(dev);
     581/** Clean instance of a USB device.
     582 *
     583 * @param dev Device to be de-initialized.
     584 *
     585 * Does not free/destroy supplied pointer.
     586 */
     587void usb_device_deinit(usb_device_t *dev)
     588{
     589        if (dev) {
     590                /* Ignore errors and hope for the best. */
     591                destroy_current_pipes(dev);
     592
     593                usb_alternate_interfaces_destroy(dev->alternate_interfaces);
     594                free(dev->descriptors.configuration);
     595                free(dev->driver_data);
     596        }
     597}
     598
     599void * usb_device_data_alloc(usb_device_t *usb_dev, size_t size)
     600{
     601        assert(usb_dev);
     602        assert(usb_dev->driver_data == NULL);
     603        return usb_dev->driver_data = calloc(1, size);
     604
    603605}
    604606
Note: See TracChangeset for help on using the changeset viewer.