Changes in / [d70765d:9a2923d] in mainline


Ignore:
Location:
uspace/drv
Files:
1 added
2 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/Makefile

    rd70765d r9a2923d  
    3737        main.c \
    3838        hc.c \
    39         ohci.c \
    4039        root_hub.c \
    4140        pci.c

  • uspace/drv/ohci/hc.c

    rd70765d r9a2923d  
    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

    rd70765d r9a2923d  
    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

    rd70765d r9a2923d  
    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

    rd70765d r9a2923d  
    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

    rd70765d r9a2923d  
    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
    … …  
    231178                        (usb_device_request_setup_packet_t*)request->setup_buffer;
    232179        size_t size;
    233         const void * result_descriptor;
    234         const uint16_t setup_request_value = setup_request->value_high;
     180        void * result_descriptor;
     181        uint16_t setup_request_value = setup_request->value_high;
    235182                        //(setup_request->value_low << 8);
    236         bool del = false;
    237 
    238         switch (setup_request_value)
    239         {
    240         case USB_DESCTYPE_HUB: {
    241                 uint8_t * descriptor;
    242                 usb_create_serialized_hub_descriptor(
    243                     instance, &descriptor, &size);
    244                 result_descriptor = descriptor;
    245                 break;
    246         }
    247         case USB_DESCTYPE_DEVICE: {
    248                 usb_log_debug("USB_DESCTYPE_DEVICE\n");
    249                 result_descriptor = &ohci_rh_device_descriptor;
    250                 size = sizeof(ohci_rh_device_descriptor);
    251                 break;
    252         }
    253         case USB_DESCTYPE_CONFIGURATION: {
    254                 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
    255                 usb_standard_configuration_descriptor_t * descriptor =
    256                                 malloc(sizeof(usb_standard_configuration_descriptor_t));
    257                 memcpy(descriptor, &ohci_rh_conf_descriptor,
    258                     sizeof(usb_standard_configuration_descriptor_t));
    259                 /// \TODO should this include device descriptor?
    260                 const size_t hub_descriptor_size = 7 +
    261                                 2* (instance->port_count / 8 +
    262                                 ((instance->port_count % 8 > 0) ? 1 : 0));
    263                 descriptor->total_length =
    264                                 sizeof(usb_standard_configuration_descriptor_t)+
    265                                 sizeof(usb_standard_endpoint_descriptor_t)+
    266                                 sizeof(usb_standard_interface_descriptor_t)+
    267                                 hub_descriptor_size;
    268                 result_descriptor = descriptor;
    269                 size = sizeof(usb_standard_configuration_descriptor_t);
    270                 del = true;
    271                 break;
    272         }
    273         case USB_DESCTYPE_INTERFACE: {
    274                 usb_log_debug("USB_DESCTYPE_INTERFACE\n");
    275                 result_descriptor = &ohci_rh_iface_descriptor;
    276                 size = sizeof(ohci_rh_iface_descriptor);
    277                 break;
    278         }
    279         case USB_DESCTYPE_ENDPOINT: {
    280                 usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
    281                 result_descriptor = &ohci_rh_ep_descriptor;
    282                 size = sizeof(ohci_rh_ep_descriptor);
    283                 break;
    284         }
    285         default: {
    286                 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
    287                 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
    288                                 setup_request->request_type,
    289                                 setup_request->request,
    290                                 setup_request_value,
    291                                 setup_request->index,
    292                                 setup_request->length
    293                                 );
    294                 return EINVAL;
    295         }
    296         }
    297 #if 0
    298183        if(setup_request_value == USB_DESCTYPE_HUB){
    299184                usb_log_debug("USB_DESCTYPE_HUB\n");
    … …  
    392277                return EINVAL;
    393278        }
    394 #endif
    395279        if(request->buffer_size < size){
    396280                size = request->buffer_size;
    … …  
    398282        request->transfered_size = size;
    399283        memcpy(request->buffer,result_descriptor,size);
    400         if (del)
    401                 free(result_descriptor);
     284        free(result_descriptor);
    402285        return EOK;
    403286}

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

    rd70765d r9a2923d  
    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/uhci.c

    rd70765d r9a2923d  
    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};
Note: See TracChangeset for help on using the changeset viewer.