Changes in / [d70765d:b3f655f] in mainline


Ignore:
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    rd70765d rb3f655f  
    554554% Polling UHCI & OHCI (no interrupts)
    555555! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
    556 
    557 % Run devman in kconsole (not recommended)
    558 ! CONFIG_DEVMAN_EARLY_LAUNCH (n/y)
    559 

  • uspace/app/init/init.c

    rd70765d rb3f655f  
    288288       
    289289        spawn("/srv/clip");
    290 
    291 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH
    292         spawn("/srv/devman");
    293 #endif
    294290       
    295291        /*
    … …  
    317313        getterm("term/vc5", "/app/bdsh", false);
    318314        getterm("term/vc6", "/app/klog", false);
    319 
    320 #ifndef CONFIG_DEVMAN_EARLY_LAUNCH
    321315        getterm("term/vc7", "/srv/devman", false);
    322 #endif
    323 
     316       
    324317        return 0;
    325318}

  • uspace/app/klog/klog.c

    rd70765d rb3f655f  
    4444#include <io/klog.h>
    4545#include <sysinfo.h>
    46 #include <fibril_synch.h>
    4746
    4847#define NAME       "klog"
    … …  
    5554static FILE *log;
    5655
    57 /* Serialize the output a bit. This will not avoid messed-up log completely
    58    but chances for are pretty high (experimentally confirmed). */
    59 static FIBRIL_MUTEX_INITIALIZE(log_mutex);
    60 
    6156static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
    6257{
    63         fibril_mutex_lock(&log_mutex);
    64        
    6558        size_t klog_start = (size_t) IPC_GET_ARG1(*call);
    6659        size_t klog_len = (size_t) IPC_GET_ARG2(*call);
    … …  
    8174                fsync(fileno(log));
    8275        }
    83        
    84         fibril_mutex_unlock(&log_mutex);
    8576}
    8677

  • uspace/drv/usbmid/explore.c

    rd70765d rb3f655f  
    4040#include <usb/request.h>
    4141#include <usb/dp.h>
    42 #include <usb/ddfiface.h>
    4342#include "usbmid.h"
    44 
    45 /** Operations of the device itself. */
    46 static ddf_dev_ops_t mid_device_ops = {
    47         .interfaces[USB_DEV_IFACE] = &usb_iface_hub_impl
    48 };
    4943
    5044/** Find starting indexes of all interface descriptors in a configuration.
    … …  
    111105 * @return Whether to accept this device from devman.
    112106 */
    113 bool usbmid_explore_device(usb_device_t *dev)
     107bool usbmid_explore_device(usbmid_device_t *dev)
    114108{
    115         int rc;
    116 
    117         int dev_class = dev->descriptors.device.device_class;
    118         if (dev_class != USB_CLASS_USE_INTERFACE) {
     109        usb_standard_device_descriptor_t device_descriptor;
     110        int rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
     111            &device_descriptor);
     112        if (rc != EOK) {
     113                usb_log_error("Getting device descriptor failed: %s.\n",
     114                    str_error(rc));
     115                return false;
     116        }
     117
     118        if (device_descriptor.device_class != USB_CLASS_USE_INTERFACE) {
    119119                usb_log_warning(
    120120                    "Device class: %d (%s), but expected class 0.\n",
    121                     dev_class, usb_str_class(dev_class));
     121                    device_descriptor.device_class,
     122                    usb_str_class(device_descriptor.device_class));
    122123                usb_log_error("Not multi interface device, refusing.\n");
    123124                return false;
    124125        }
    125126
    126         /* Short cuts to save on typing ;-). */
    127         uint8_t *config_descriptor_raw = dev->descriptors.configuration;
    128         size_t config_descriptor_size = dev->descriptors.configuration_size;
    129         usb_standard_configuration_descriptor_t *config_descriptor =
    130             (usb_standard_configuration_descriptor_t *) config_descriptor_raw;
     127        size_t config_descriptor_size;
     128        uint8_t *config_descriptor_raw = NULL;
     129        rc = usb_request_get_full_configuration_descriptor_alloc(
     130            &dev->ctrl_pipe, 0,
     131            (void **) &config_descriptor_raw, &config_descriptor_size);
     132        if (rc != EOK) {
     133                usb_log_error("Failed getting full config descriptor: %s.\n",
     134                    str_error(rc));
     135                return false;
     136        }
     137
     138        usb_standard_configuration_descriptor_t *config_descriptor
     139            = (usb_standard_configuration_descriptor_t *) config_descriptor_raw;
    131140
    132141        size_t *interface_descriptors
    … …  
    145154        if (interface_descriptors_count == (size_t) -1) {
    146155                usb_log_error("Problem parsing configuration descriptor.\n");
     156                free(config_descriptor_raw);
    147157                free(interface_descriptors);
    148158                return false;
    … …  
    155165                usb_log_error("Failed to set device configuration: %s.\n",
    156166                    str_error(rc));
     167                free(config_descriptor_raw);
    157168                free(interface_descriptors);
    158169                return false;
    … …  
    161172
    162173        /* Create control function */
    163         ddf_fun_t *ctl_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, "ctl");
     174        ddf_fun_t *ctl_fun = ddf_fun_create(dev->dev, fun_exposed, "ctl");
    164175        if (ctl_fun == NULL) {
    165176                usb_log_error("Failed to create control function.\n");
    166                 free(interface_descriptors);
    167                 return false;
    168         }
    169 
    170         ctl_fun->ops = &mid_device_ops;
    171 
     177                free(config_descriptor_raw);
     178                free(interface_descriptors);
     179                return false;
     180        }
    172181        rc = ddf_fun_bind(ctl_fun);
    173182        if (rc != EOK) {
    174183                usb_log_error("Failed to bind control function: %s.\n",
    175184                    str_error(rc));
     185                free(config_descriptor_raw);
    176186                free(interface_descriptors);
    177187                return false;
    … …  
    189199                    (int) interface->interface_number,
    190200                    usb_str_class(interface->interface_class));
    191                 rc = usbmid_spawn_interface_child(dev, &dev->descriptors.device,
     201                rc = usbmid_spawn_interface_child(dev, &device_descriptor,
    192202                    interface);
    193203                if (rc != EOK) {
    … …  
    197207        }
    198208
     209        free(config_descriptor_raw);
     210
    199211        return true;
    200212}

  • uspace/drv/usbmid/main.c

    rd70765d rb3f655f  
    4949 * @return Error code.
    5050 */
    51 static int usbmid_add_device(usb_device_t *dev)
     51static int usbmid_add_device(ddf_dev_t *gen_dev)
    5252{
    53         usb_log_info("Taking care of new MID `%s'.\n", dev->ddf_dev->name);
     53        usbmid_device_t *dev = usbmid_device_create(gen_dev);
     54        if (dev == NULL) {
     55                return ENOMEM;
     56        }
     57
     58        usb_log_info("Taking care of new MID: addr %d (HC %zu)\n",
     59            dev->wire.address, dev->wire.hc_handle);
    5460
    5561        int rc;
    … …  
    5965                usb_log_error("Failed to start session on control pipe: %s.\n",
    6066                    str_error(rc));
    61                 return rc;
     67                goto error_leave;
    6268        }
    6369
    … …  
    7177
    7278        if (!accept) {
    73                 return ENOTSUP;
     79                rc = ENOTSUP;
     80                goto error_leave;
    7481        }
    7582
     83        gen_dev->driver_data = dev;
     84
    7685        return EOK;
     86
     87
     88error_leave:
     89        free(dev);
     90        return rc;
    7791}
    7892
    7993/** USB MID driver ops. */
    80 static usb_driver_ops_t mid_driver_ops = {
     94static driver_ops_t mid_driver_ops = {
    8195        .add_device = usbmid_add_device,
    8296};
    8397
    8498/** USB MID driver. */
    85 static usb_driver_t mid_driver = {
     99static driver_t mid_driver = {
    86100        .name = NAME,
    87         .ops = &mid_driver_ops,
    88         .endpoints = NULL
     101        .driver_ops = &mid_driver_ops
    89102};
    90103
    … …  
    94107
    95108        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
    96 
    97         return usb_driver_main(&mid_driver);
     109        return ddf_driver_main(&mid_driver);
    98110}
    99111

  • uspace/drv/usbmid/usbmid.c

    rd70765d rb3f655f  
    7979};
    8080
     81/** Operations of the device itself. */
     82static ddf_dev_ops_t mid_device_ops = {
     83        .interfaces[USB_DEV_IFACE] = &usb_iface_hub_impl
     84};
     85
     86/** Create new USB multi interface device.
     87 *
     88 * @param dev Backing generic DDF device.
     89 * @return New USB MID device.
     90 * @retval NULL Error occured.
     91 */
     92usbmid_device_t *usbmid_device_create(ddf_dev_t *dev)
     93{
     94        usbmid_device_t *mid = malloc(sizeof(usbmid_device_t));
     95        if (mid == NULL) {
     96                usb_log_error("Out of memory (wanted %zu bytes).\n",
     97                    sizeof(usbmid_device_t));
     98                return NULL;
     99        }
     100
     101        int rc;
     102        rc = usb_device_connection_initialize_from_device(&mid->wire, dev);
     103        if (rc != EOK) {
     104                usb_log_error("Failed to initialize `USB wire': %s.\n",
     105                    str_error(rc));
     106                free(mid);
     107                return NULL;
     108        }
     109
     110        rc = usb_pipe_initialize_default_control(&mid->ctrl_pipe,
     111            &mid->wire);
     112        if (rc != EOK) {
     113                usb_log_error("Failed to initialize control pipe: %s.\n",
     114                    str_error(rc));
     115                free(mid);
     116                return NULL;
     117        }
     118        rc = usb_pipe_probe_default_control(&mid->ctrl_pipe);
     119        if (rc != EOK) {
     120                usb_log_error("Probing default control pipe failed: %s.\n",
     121                    str_error(rc));
     122                free(mid);
     123                return NULL;
     124        }
     125
     126        mid->dev = dev;
     127        (void) &mid_device_ops;
     128
     129        return mid;
     130}
     131
    81132/** Create new interface for USB MID device.
    82133 *
    … …  
    109160 * @return Error code.
    110161 */
    111 int usbmid_spawn_interface_child(usb_device_t *parent,
     162int usbmid_spawn_interface_child(usbmid_device_t *parent,
    112163    const usb_standard_device_descriptor_t *device_descriptor,
    113164    const usb_standard_interface_descriptor_t *interface_descriptor)
    … …  
    131182
    132183        /* Create the device. */
    133         child = ddf_fun_create(parent->ddf_dev, fun_inner, child_name);
     184        child = ddf_fun_create(parent->dev, fun_inner, child_name);
    134185        if (child == NULL) {
    135186                rc = ENOMEM;

  • uspace/drv/usbmid/usbmid.h

    rd70765d rb3f655f  
    4141#include <usb/pipes.h>
    4242#include <usb/debug.h>
    43 #include <usb/devdrv.h>
    4443
    4544#define NAME "usbmid"
     45
     46/** USB MID device container. */
     47typedef struct {
     48        /** Device container. */
     49        ddf_dev_t *dev;
     50
     51        /** Representation of USB wire. */
     52        usb_device_connection_t wire;
     53        /** Default control pipe. */
     54        usb_pipe_t ctrl_pipe;
     55} usbmid_device_t;
     56
    4657
    4758/** Container for single interface in a MID device. */
    … …  
    5465} usbmid_interface_t;
    5566
     67usbmid_device_t *usbmid_device_create(ddf_dev_t *);
    5668usbmid_interface_t *usbmid_interface_create(ddf_fun_t *, int);
    57 bool usbmid_explore_device(usb_device_t *);
    58 int usbmid_spawn_interface_child(usb_device_t *,
     69bool usbmid_explore_device(usbmid_device_t *);
     70int usbmid_spawn_interface_child(usbmid_device_t *,
    5971    const usb_standard_device_descriptor_t *,
    6072    const usb_standard_interface_descriptor_t *);
Note: See TracChangeset for help on using the changeset viewer.