Changes in / [aee6c73:f3da9b2] in mainline


Ignore:
Files:
4 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    raee6c73 rf3da9b2  
    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 

  • kernel/generic/src/console/console.c

    raee6c73 rf3da9b2  
    5353#include <str.h>
    5454
    55 /*
    56  * devman produces a lot of output and by giving so many pages
    57  * we to allow /app/klog to catch-up.
    58  */
    59 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH
    60 #define KLOG_PAGES    64
    61 #else
    6255#define KLOG_PAGES    4
    63 #endif
    64 
    6556#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
    6657#define KLOG_LATENCY  8

  • kernel/generic/src/mm/as.c

    raee6c73 rf3da9b2  
    19491949sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
    19501950{
    1951         if (as_area_create(AS, flags, size, address,
     1951        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
    19521952            AS_AREA_ATTR_NONE, &anon_backend, NULL))
    19531953                return (sysarg_t) address;

  • uspace/app/init/init.c

    raee6c73 rf3da9b2  
    313313        getterm("term/vc5", "/app/bdsh", false);
    314314        getterm("term/vc6", "/app/klog", false);
    315 
    316 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH
    317         spawn("/srv/devman");
    318 #else
    319315        getterm("term/vc7", "/srv/devman", false);
    320 #endif
    321 
     316       
    322317        return 0;
    323318}

  • uspace/app/klog/klog.c

    raee6c73 rf3da9b2  
    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/ohci/Makefile

    raee6c73 rf3da9b2  
    3737        main.c \
    3838        hc.c \
    39         ohci.c \
    4039        root_hub.c \
    4140        pci.c

  • uspace/drv/ohci/hc.c

    raee6c73 rf3da9b2  
    3939#include <usb/debug.h>
    4040#include <usb/usb.h>
     41#include <usb/hub.h>
    4142#include <usb/ddfiface.h>
    4243#include <usb/usbdevice.h>
    … …  
    4445#include "hc.h"
    4546
     47static int dummy_reset(int foo, void *arg);
    4648static int interrupt_emulator(hc_t *instance);
    47 /*----------------------------------------------------------------------------*/
    48 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
    49 {
    50         assert(instance);
    51         assert(hub_fun);
    52 
    53         usb_address_t hub_address =
    54             device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
    55         instance->rh.address = hub_address;
    56         usb_device_keeper_bind(
    57             &instance->manager, hub_address, hub_fun->handle);
    58 
    59         char *match_str = NULL;
    60         int ret = asprintf(&match_str, "usb&mid");
    61         ret = (match_str == NULL) ? ret : EOK;
    62         if (ret < 0) {
    63                 usb_log_error("Failed to create root hub match-id string.\n");
    64                 return ret;
    65         }
    66 
    67         ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
    68         if (ret != EOK) {
    69                 usb_log_error("Failed add create root hub match-id.\n");
    70         }
    71         return ret;
    72 }
    7349/*----------------------------------------------------------------------------*/
    7450int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
    … …  
    9268        }
    9369
     70
    9471        rh_init(&instance->rh, dev, instance->registers);
     72        /* TODO: implement */
     73        return EOK;
     74}
     75/*----------------------------------------------------------------------------*/
     76int hc_register_hub(hc_t *instance)
     77{
     78        async_usleep(1000000);
     79#define CHECK_RET_RETURN(ret, msg...) \
     80        if (ret != EOK) { \
     81                usb_log_error(msg); \
     82                return ret; \
     83        } else (void)0
     84        assert(instance);
     85        assert(instance->ddf_instance);
     86        assert(instance->ddf_instance->handle);
     87        ddf_dev_t *dev = instance->rh.device;
     88        int ret = EOK;
    9589
    96         /* TODO: implement */
     90        usb_hc_connection_t conn;
     91        ret =
     92            usb_hc_connection_initialize(&conn, instance->ddf_instance->handle);
     93        CHECK_RET_RETURN(ret, "Failed to initialize hc connection.\n");
     94
     95        ret = usb_hc_connection_open(&conn);
     96        CHECK_RET_RETURN(ret, "Failed to open hc connection.\n");
     97
     98        usb_address_t address;
     99        devman_handle_t handle;
     100        ret = usb_hc_new_device_wrapper(dev, &conn, USB_SPEED_FULL, dummy_reset,
     101            0, instance, &address, &handle, NULL, NULL, NULL);
     102        if (ret != EOK) {
     103                usb_log_error("Failed to add rh device.\n");
     104                instance->rh.address = -1;
     105                return ret;
     106        }
     107
     108        ret = usb_hc_connection_close(&conn);
     109        CHECK_RET_RETURN(ret, "Failed to close hc connection.\n");
    97110        return EOK;
    98111}
    … …  
    121134}
    122135/*----------------------------------------------------------------------------*/
    123 int interrupt_emulator(hc_t *instance)
     136static int dummy_reset(int foo, void *arg)
     137{
     138        hc_t *hc = (hc_t*)arg;
     139        assert(hc);
     140        hc->rh.address = 0;
     141        return EOK;
     142}
     143/*----------------------------------------------------------------------------*/
     144static int interrupt_emulator(hc_t *instance)
    124145{
    125146        assert(instance);

  • uspace/drv/ohci/hc.h

    raee6c73 rf3da9b2  
    5757} hc_t;
    5858
    59 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
    60 
    6159int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
    6260     uintptr_t regs, size_t reg_size, bool interrupts);
     61
     62int hc_register_hub(hc_t *instance);
    6363
    6464int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);

  • uspace/drv/ohci/iface.h

    raee6c73 rf3da9b2  
    3333 * Common OHCI definitions.
    3434 */
    35 #ifndef DRV_OHCI_IFACE_H
    36 #define DRV_OHCI_IFACE_H
     35#ifndef DRV_OHCI_OHCI_H
     36#define DRV_OHCI_OHCI_H
    3737
    3838#include <usbhc_iface.h>
     39
     40#define NAME "ohci"
    3941
    4042extern usbhc_iface_t hc_iface;

  • uspace/drv/ohci/main.c

    raee6c73 rf3da9b2  
    3434 */
    3535#include <ddf/driver.h>
     36#include <ddf/interrupt.h>
     37#include <device/hw_res.h>
    3638#include <errno.h>
    3739#include <str_error.h>
    3840
     41#include <usb_iface.h>
     42#include <usb/ddfiface.h>
    3943#include <usb/debug.h>
    4044
    41 #include "ohci.h"
    42 
    43 #define NAME "ohci"
     45#include "pci.h"
     46#include "iface.h"
     47#include "hc.h"
    4448
    4549static int ohci_add_device(ddf_dev_t *device);
     50static int get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
     51{
     52        assert(handle);
     53  assert(fun != NULL);
     54
     55  *handle = fun->handle;
     56  return EOK;
     57}
     58/*----------------------------------------------------------------------------*/
     59static int get_address(
     60    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
     61{
     62        assert(fun);
     63        usb_device_keeper_t *manager = &fun_to_hc(fun)->manager;
     64  usb_address_t addr = usb_device_keeper_find(manager, handle);
     65  if (addr < 0) {
     66    return addr;
     67  }
     68
     69  if (address != NULL) {
     70    *address = addr;
     71  }
     72
     73  return EOK;
     74}
     75/*----------------------------------------------------------------------------*/
     76/** IRQ handling callback, identifies device
     77 *
     78 * @param[in] dev DDF instance of the device to use.
     79 * @param[in] iid (Unused).
     80 * @param[in] call Pointer to the call that represents interrupt.
     81 */
     82static void irq_handler(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *call)
     83{
     84        assert(dev);
     85        hc_t *hc = (hc_t*)dev->driver_data;
     86        assert(hc);
     87        hc_interrupt(hc, 0);
     88}
    4689/*----------------------------------------------------------------------------*/
    4790static driver_ops_t ohci_driver_ops = {
    … …  
    5497};
    5598/*----------------------------------------------------------------------------*/
     99static usb_iface_t hc_usb_iface = {
     100        .get_address = get_address,
     101        .get_hc_handle = get_hc_handle,
     102};
     103/*----------------------------------------------------------------------------*/
     104static ddf_dev_ops_t hc_ops = {
     105        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
     106        .interfaces[USBHC_DEV_IFACE] = &hc_iface,
     107};
     108/*----------------------------------------------------------------------------*/
    56109/** Initializes a new ddf driver instance of OHCI hcd.
    57110 *
    … …  
    59112 * @return Error code.
    60113 */
    61 int ohci_add_device(ddf_dev_t *device)
    62 {
    63         usb_log_debug("ohci_add_device() called\n");
     114static int ohci_add_device(ddf_dev_t *device)
     115{
    64116        assert(device);
    65         ohci_t *ohci = malloc(sizeof(ohci_t));
    66         if (ohci == NULL) {
     117#define CHECK_RET_RETURN(ret, message...) \
     118if (ret != EOK) { \
     119        usb_log_error(message); \
     120        return ret; \
     121}
     122
     123        uintptr_t mem_reg_base = 0;
     124        size_t mem_reg_size = 0;
     125        int irq = 0;
     126
     127        int ret =
     128            pci_get_my_registers(device, &mem_reg_base, &mem_reg_size, &irq);
     129        CHECK_RET_RETURN(ret,
     130            "Failed(%d) to get memory addresses:.\n", ret, device->handle);
     131        usb_log_info("Memory mapped regs at 0x%X (size %zu), IRQ %d.\n",
     132            mem_reg_base, mem_reg_size, irq);
     133
     134        ret = pci_disable_legacy(device);
     135        CHECK_RET_RETURN(ret,
     136            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
     137
     138        hc_t *hcd = malloc(sizeof(hc_t));
     139        if (hcd == NULL) {
    67140                usb_log_error("Failed to allocate OHCI driver.\n");
    68141                return ENOMEM;
    69142        }
    70143
    71         int ret = ohci_init(ohci, device);
     144        ddf_fun_t *hc_fun = ddf_fun_create(device, fun_exposed, "ohci-hc");
     145        if (hc_fun == NULL) {
     146                usb_log_error("Failed to create OHCI function.\n");
     147                free(hcd);
     148                return ENOMEM;
     149        }
     150
     151
     152        bool interrupts = false;
     153#ifdef CONFIG_USBHC_NO_INTERRUPTS
     154        usb_log_warning("Interrupts disabled in OS config, " \
     155            "falling back to polling.\n");
     156#else
     157        ret = pci_enable_interrupts(device);
    72158        if (ret != EOK) {
    73                 usb_log_error("Failed to initialize OHCI driver: %s.\n",
     159                usb_log_warning("Failed to enable interrupts: %s.\n",
    74160                    str_error(ret));
     161                usb_log_info("HW interrupts not available, " \
     162                    "falling back to polling.\n");
     163        } else {
     164                usb_log_debug("Hw interrupts enabled.\n");
     165                interrupts = true;
     166        }
     167#endif
     168
     169        ret = hc_init(hcd, hc_fun, device, mem_reg_base, mem_reg_size, interrupts);
     170        if (ret != EOK) {
     171                usb_log_error("Failed to initialize OHCI driver.\n");
     172                free(hcd);
    75173                return ret;
    76174        }
    77         device->driver_data = ohci;
    78 
    79         usb_log_info("Controlling new OHCI device `%s'.\n", device->name);
     175
     176        ret = register_interrupt_handler(device, irq, irq_handler, NULL);
     177
     178        hc_fun->ops = &hc_ops;
     179        ret = ddf_fun_bind(hc_fun);
     180        if (ret != EOK) {
     181                usb_log_error("Failed to bind OHCI function.\n");
     182                ddf_fun_destroy(hc_fun);
     183                free(hcd);
     184                return ret;
     185        }
     186        hc_fun->driver_data = hcd;
     187
     188        fid_t later = fibril_create((int(*)(void*))hc_register_hub, hcd);
     189        fibril_add_ready(later);
     190
     191        usb_log_info("Controlling new OHCI device `%s' (handle %llu).\n",
     192            device->name, device->handle);
    80193
    81194        return EOK;
     195#undef CHECK_RET_RETURN
    82196}
    83197/*----------------------------------------------------------------------------*/

  • uspace/drv/ohci/root_hub.c

    raee6c73 rf3da9b2  
    4343#include <usb/classes/hub.h>
    4444
    45 static const usb_standard_device_descriptor_t ohci_rh_device_descriptor =
    46 {
    47                 .configuration_count = 1,
    48                 .descriptor_type = USB_DESCTYPE_DEVICE,
    49                 .device_class = USB_CLASS_HUB,
    50                 .device_protocol = 0,
    51                 .device_subclass = 0,
    52                 .device_version = 0,
    53                 .length = sizeof(usb_standard_device_descriptor_t),
    54                 /// \TODO this value is guessed
    55                 .max_packet_size = 8,
    56                 .vendor_id = 0x16db,
    57                 .product_id = 0x0001,
    58                 /// \TODO these values migt be different
    59                 .str_serial_number = 0,
    60                 .usb_spec_version = 0,
    61 };
    62 
    63 static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor =
    64 {
    65         /// \TODO some values are default or guessed
    66         .attributes = 1<<7,
    67         .configuration_number = 1,
    68         .descriptor_type = USB_DESCTYPE_CONFIGURATION,
    69         .interface_count = 1,
    70         .length = sizeof(usb_standard_configuration_descriptor_t),
    71         .max_power = 100,
    72         .str_configuration = 0,
    73 };
    74 
    75 static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor =
    76 {
    77         .alternate_setting = 0,
    78         .descriptor_type = USB_DESCTYPE_INTERFACE,
    79         .endpoint_count = 1,
    80         .interface_class = USB_CLASS_HUB,
    81         /// \TODO is this correct?
    82         .interface_number = 1,
    83         .interface_protocol = 0,
    84         .interface_subclass = 0,
    85         .length = sizeof(usb_standard_interface_descriptor_t),
    86         .str_interface = 0,
    87 };
    88 
    89 static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor =
    90 {
    91         .attributes = USB_TRANSFER_INTERRUPT,
    92         .descriptor_type = USB_DESCTYPE_ENDPOINT,
    93         .endpoint_address = 1 + (1<<7),
    94         .length = sizeof(usb_standard_endpoint_descriptor_t),
    95         .max_packet_size = 8,
    96         .poll_interval = 255,
    97 };
    9845
    9946/** Root hub initialization
    … …  
    383330                        (usb_device_request_setup_packet_t*)request->setup_buffer;
    384331        size_t size;
    385         const void * result_descriptor = NULL;
    386         const uint16_t setup_request_value = setup_request->value_high;
     332        void * result_descriptor;
     333        uint16_t setup_request_value = setup_request->value_high;
    387334                        //(setup_request->value_low << 8);
    388 #if 0
    389         bool del = false;
    390         //this code was merged from development and has to be reviewed
    391         switch (setup_request_value)
    392         {
    393         case USB_DESCTYPE_HUB: {
    394                 uint8_t * descriptor;
    395                 usb_create_serialized_hub_descriptor(
    396                     instance, &descriptor, &size);
    397                 result_descriptor = descriptor;
    398                 break;
    399         }
    400         case USB_DESCTYPE_DEVICE: {
    401                 usb_log_debug("USB_DESCTYPE_DEVICE\n");
    402                 result_descriptor = &ohci_rh_device_descriptor;
    403                 size = sizeof(ohci_rh_device_descriptor);
    404                 break;
    405         }
    406         case USB_DESCTYPE_CONFIGURATION: {
    407                 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
    408                 usb_standard_configuration_descriptor_t * descriptor =
    409                                 malloc(sizeof(usb_standard_configuration_descriptor_t));
    410                 memcpy(descriptor, &ohci_rh_conf_descriptor,
    411                     sizeof(usb_standard_configuration_descriptor_t));
    412                 /// \TODO should this include device descriptor?
    413                 const size_t hub_descriptor_size = 7 +
    414                                 2* (instance->port_count / 8 +
    415                                 ((instance->port_count % 8 > 0) ? 1 : 0));
    416                 descriptor->total_length =
    417                                 sizeof(usb_standard_configuration_descriptor_t)+
    418                                 sizeof(usb_standard_endpoint_descriptor_t)+
    419                                 sizeof(usb_standard_interface_descriptor_t)+
    420                                 hub_descriptor_size;
    421                 result_descriptor = descriptor;
    422                 size = sizeof(usb_standard_configuration_descriptor_t);
    423                 del = true;
    424                 break;
    425         }
    426         case USB_DESCTYPE_INTERFACE: {
    427                 usb_log_debug("USB_DESCTYPE_INTERFACE\n");
    428                 result_descriptor = &ohci_rh_iface_descriptor;
    429                 size = sizeof(ohci_rh_iface_descriptor);
    430                 break;
    431         }
    432         case USB_DESCTYPE_ENDPOINT: {
    433                 usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
    434                 result_descriptor = &ohci_rh_ep_descriptor;
    435                 size = sizeof(ohci_rh_ep_descriptor);
    436                 break;
    437         }
    438         default: {
    439                 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
    440                 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
    441                                 setup_request->request_type,
    442                                 setup_request->request,
    443                                 setup_request_value,
    444                                 setup_request->index,
    445                                 setup_request->length
    446                                 );
    447                 return EINVAL;
    448         }
    449         }
    450 #endif
    451335        if(setup_request_value == USB_DESCTYPE_HUB){
    452336                usb_log_debug("USB_DESCTYPE_HUB\n");
    … …  
    494378        request->transfered_size = size;
    495379        memcpy(request->buffer,result_descriptor,size);
    496         if (result_descriptor)
    497                 free(result_descriptor);
     380        free(result_descriptor);
    498381        return EOK;
    499382}

  • uspace/drv/uhci-hcd/Makefile

    raee6c73 rf3da9b2  
    4040        root_hub.c \
    4141        hw_struct/transfer_descriptor.c \
    42         utils/slab.c \
    4342        pci.c \
    4443        batch.c

  • uspace/drv/uhci-hcd/hc.c

    raee6c73 rf3da9b2  
    223223        ret = instance ? EOK : ENOMEM;
    224224        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
    225         usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
     225        usb_log_debug("Initialized frame list.\n");
    226226
    227227        /* Set all frames to point to the first queue head */
    … …  
    336336            instance->transfers[batch->speed][batch->transfer_type];
    337337        assert(list);
    338         if (batch->transfer_type == USB_TRANSFER_CONTROL) {
    339                 usb_device_keeper_use_control(
    340                     &instance->manager, batch->target.address);
    341         }
    342338        transfer_list_add_batch(list, batch);
    343339
    … …  
    361357        /* Lower 2 bits are transaction error and transaction complete */
    362358        if (status & 0x3) {
    363                 LIST_INITIALIZE(done);
    364                 transfer_list_remove_finished(
    365                     &instance->transfers_interrupt, &done);
    366                 transfer_list_remove_finished(
    367                     &instance->transfers_control_slow, &done);
    368                 transfer_list_remove_finished(
    369                     &instance->transfers_control_full, &done);
    370                 transfer_list_remove_finished(
    371                     &instance->transfers_bulk_full, &done);
    372 
    373                 while (!list_empty(&done)) {
    374                         link_t *item = done.next;
    375                         list_remove(item);
    376                         usb_transfer_batch_t *batch =
    377                             list_get_instance(item, usb_transfer_batch_t, link);
    378                         if (batch->transfer_type == USB_TRANSFER_CONTROL) {
    379                                 usb_device_keeper_release_control(
    380                                     &instance->manager, batch->target.address);
    381                         }
    382                         batch->next_step(batch);
    383                 }
     359                transfer_list_remove_finished(&instance->transfers_interrupt);
     360                transfer_list_remove_finished(&instance->transfers_control_slow);
     361                transfer_list_remove_finished(&instance->transfers_control_full);
     362                transfer_list_remove_finished(&instance->transfers_bulk_full);
    384363        }
    385364        /* bits 4 and 5 indicate hc error */

  • uspace/drv/uhci-hcd/root_hub.c

    raee6c73 rf3da9b2  
    4848 * @return Error code.
    4949 */
    50 int rh_init(rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
     50int rh_init(
     51    rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
    5152{
    5253        assert(fun);

  • uspace/drv/uhci-hcd/transfer_list.c

    raee6c73 rf3da9b2  
    5858        }
    5959        instance->queue_head_pa = addr_to_phys(instance->queue_head);
    60         usb_log_debug2("Transfer list %s setup with QH: %p(%p).\n",
    61             name, instance->queue_head, instance->queue_head_pa);
    6260
    6361        qh_init(instance->queue_head);
    … …  
    120118        qh_set_next_qh(last_qh, pa);
    121119
    122         asm volatile ("": : :"memory");
    123 
    124120        /* Add to the driver list */
    125121        list_append(&batch->link, &instance->batch_list);
    … …  
    141137 * this transfer list leading to the deadlock if its done inline.
    142138 */
    143 void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
    144 {
    145         assert(instance);
    146         assert(done);
     139void transfer_list_remove_finished(transfer_list_t *instance)
     140{
     141        assert(instance);
     142
     143        LIST_INITIALIZE(done);
    147144
    148145        fibril_mutex_lock(&instance->guard);
    … …  
    156153                        /* Save for post-processing */
    157154                        transfer_list_remove_batch(instance, batch);
    158                         list_append(current, done);
     155                        list_append(current, &done);
    159156                }
    160157                current = next;
    … …  
    162159        fibril_mutex_unlock(&instance->guard);
    163160
     161        while (!list_empty(&done)) {
     162                link_t *item = done.next;
     163                list_remove(item);
     164                usb_transfer_batch_t *batch =
     165                    list_get_instance(item, usb_transfer_batch_t, link);
     166                batch->next_step(batch);
     167        }
    164168}
    165169/*----------------------------------------------------------------------------*/
    … …  
    218222                qpos = "NOT FIRST";
    219223        }
    220         asm volatile ("": : :"memory");
    221224        /* Remove from the batch list */
    222225        list_remove(&batch->link);

  • uspace/drv/uhci-hcd/transfer_list.h

    raee6c73 rf3da9b2  
    6767void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
    6868
    69 void transfer_list_remove_finished(transfer_list_t *instance, link_t *done);
     69void transfer_list_remove_finished(transfer_list_t *instance);
    7070
    7171void transfer_list_abort_all(transfer_list_t *instance);

  • uspace/drv/uhci-hcd/uhci.c

    raee6c73 rf3da9b2  
    4444#include "pci.h"
    4545
     46
    4647/** IRQ handling callback, identifies device
    4748 *
    … …  
    107108/*----------------------------------------------------------------------------*/
    108109static ddf_dev_ops_t hc_ops = {
    109 //      .interfaces[USB_DEV_IFACE] = &usb_iface,
     110        .interfaces[USB_DEV_IFACE] = &usb_iface,
    110111        .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
    111112};

  • uspace/drv/uhci-hcd/utils/malloc32.h

    raee6c73 rf3da9b2  
    4040#include <as.h>
    4141
    42 #include "slab.h"
    43 
    4442#define UHCI_STRCUTURES_ALIGNMENT 16
    4543#define UHCI_REQUIRED_PAGE_SIZE 4096
    46 
    4744
    4845/** Get physical address translation
    … …  
    5754
    5855        uintptr_t result;
    59         const int ret = as_get_physical_mapping(addr, &result);
    60         assert(ret == EOK);
     56        int ret = as_get_physical_mapping(addr, &result);
    6157
    6258        if (ret != EOK)
    … …  
    7066 * @return Address of the alligned and big enough memory place, NULL on failure.
    7167 */
    72 static inline void * malloc32(size_t size) {
    73         if (size <= SLAB_ELEMENT_SIZE)
    74                 return slab_malloc_g();
    75         assert(false);
    76         return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
    77 }
     68static inline void * malloc32(size_t size)
     69        { return memalign(UHCI_STRCUTURES_ALIGNMENT, size); }
    7870/*----------------------------------------------------------------------------*/
    7971/** Physical mallocator simulator
    … …  
    8173 * @param[in] addr Address of the place allocated by malloc32
    8274 */
    83 static inline void free32(void *addr) {
    84         if (!addr)
    85                 return;
    86         if (slab_in_range_g(addr))
    87                 return slab_free_g(addr);
    88         free(addr);
    89 }
     75static inline void free32(void *addr)
     76        { if (addr) free(addr); }
    9077/*----------------------------------------------------------------------------*/
    9178/** Create 4KB page mapping
    … …  
    9582static inline void * get_page(void)
    9683{
    97         void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
    98         assert(free_address); /* TODO: remove this assert */
     84        void * free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
     85        assert(free_address);
    9986        if (free_address == 0)
    10087                return NULL;
    101         void *ret = as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
     88        void* ret =
     89          as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
    10290                  AS_AREA_READ | AS_AREA_WRITE);
    10391        if (ret != free_address)

  • uspace/drv/usbmid/explore.c

    raee6c73 rf3da9b2  
    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

    raee6c73 rf3da9b2  
    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

    raee6c73 rf3da9b2  
    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

    raee6c73 rf3da9b2  
    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 *);

  • uspace/lib/c/generic/malloc.c

    raee6c73 rf3da9b2  
    240240        size_t asize = ALIGN_UP(size, PAGE_SIZE);
    241241       
    242         astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
     242        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
    243243        if (astart == (void *) -1)
    244244                return false;

  • uspace/lib/usb/include/usb/host/device_keeper.h

    raee6c73 rf3da9b2  
    5151        usb_speed_t speed;
    5252        bool occupied;
    53         bool control_used;
    5453        uint16_t toggle_status[2];
    5554        devman_handle_t handle;
    … …  
    6261        struct usb_device_info devices[USB_ADDRESS_COUNT];
    6362        fibril_mutex_t guard;
    64         fibril_condvar_t change;
     63        fibril_condvar_t default_address_occupied;
    6564        usb_address_t last_address;
    6665} usb_device_keeper_t;
    … …  
    9897    usb_address_t address);
    9998
    100 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
    101     usb_address_t address);
    102 
    103 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
    104     usb_address_t address);
    105 
    10699#endif
    107100/**

  • uspace/lib/usb/src/host/device_keeper.c

    raee6c73 rf3da9b2  
    4949        assert(instance);
    5050        fibril_mutex_initialize(&instance->guard);
    51         fibril_condvar_initialize(&instance->change);
     51        fibril_condvar_initialize(&instance->default_address_occupied);
    5252        instance->last_address = 0;
    5353        unsigned i = 0;
    5454        for (; i < USB_ADDRESS_COUNT; ++i) {
    5555                instance->devices[i].occupied = false;
    56                 instance->devices[i].control_used = false;
    5756                instance->devices[i].handle = 0;
    5857                instance->devices[i].toggle_status[0] = 0;
    … …  
    7271        fibril_mutex_lock(&instance->guard);
    7372        while (instance->devices[USB_ADDRESS_DEFAULT].occupied) {
    74                 fibril_condvar_wait(&instance->change, &instance->guard);
     73                fibril_condvar_wait(&instance->default_address_occupied,
     74                    &instance->guard);
    7575        }
    7676        instance->devices[USB_ADDRESS_DEFAULT].occupied = true;
    … …  
    9090        instance->devices[USB_ADDRESS_DEFAULT].occupied = false;
    9191        fibril_mutex_unlock(&instance->guard);
    92         fibril_condvar_signal(&instance->change);
     92        fibril_condvar_signal(&instance->default_address_occupied);
    9393}
    9494/*----------------------------------------------------------------------------*/
    … …  
    309309        return instance->devices[address].speed;
    310310}
    311 /*----------------------------------------------------------------------------*/
    312 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
    313     usb_address_t address)
    314 {
    315         assert(instance);
    316         fibril_mutex_lock(&instance->guard);
    317         while (instance->devices[address].control_used) {
    318                 fibril_condvar_wait(&instance->change, &instance->guard);
    319         }
    320         instance->devices[address].control_used = true;
    321         fibril_mutex_unlock(&instance->guard);
    322 }
    323 /*----------------------------------------------------------------------------*/
    324 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
    325     usb_address_t address)
    326 {
    327         assert(instance);
    328         fibril_mutex_lock(&instance->guard);
    329         instance->devices[address].control_used = false;
    330         fibril_mutex_unlock(&instance->guard);
    331         fibril_condvar_signal(&instance->change);
    332 }
     311
    333312/**
    334313 * @}
Note: See TracChangeset for help on using the changeset viewer.