Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/bus/usb/ehci/main.c

    r7de1988c r58563585  
    2727 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828 */
     29
    2930/** @addtogroup drvusbehci
    3031 * @{
     
    3839#include <device/hw_res.h>
    3940#include <errno.h>
    40 #include <stdbool.h>
    4141#include <str_error.h>
     42#include <io/logctl.h>
    4243
    4344#include <usb_iface.h>
    44 #include <usb/ddfiface.h>
    4545#include <usb/debug.h>
    46 #include <usb/host/hcd.h>
     46#include <usb/host/ddf_helpers.h>
    4747
    4848#include "res.h"
     49#include "hc.h"
     50#include "ehci_endpoint.h"
    4951
    5052#define NAME "ehci"
    5153
    52 static int ehci_dev_add(ddf_dev_t *device);
     54static int ehci_driver_init(hcd_t *, const hw_res_list_parsed_t *, bool);
     55static void ehci_driver_fini(hcd_t *);
    5356
    54 static driver_ops_t ehci_driver_ops = {
    55         .dev_add = ehci_dev_add,
     57static const ddf_hc_driver_t ehci_hc_driver = {
     58        .claim = disable_legacy,
     59        .hc_speed = USB_SPEED_HIGH,
     60        .irq_code_gen = ehci_hc_gen_irq_code,
     61        .init = ehci_driver_init,
     62        .fini = ehci_driver_fini,
     63        .name = "EHCI-PCI",
     64        .ops = {
     65                .schedule       = ehci_hc_schedule,
     66                .ep_add_hook    = ehci_endpoint_init,
     67                .ep_remove_hook = ehci_endpoint_fini,
     68                .irq_hook       = ehci_hc_interrupt,
     69                .status_hook    = ehci_hc_status,
     70        }
    5671};
    5772
    58 static driver_t ehci_driver = {
    59         .name = NAME,
    60         .driver_ops = &ehci_driver_ops
    61 };
    62 static ddf_dev_ops_t hc_ops = {
    63         .interfaces[USBHC_DEV_IFACE] = &hcd_iface,
    64 };
    6573
     74static int ehci_driver_init(hcd_t *hcd, const hw_res_list_parsed_t *res,
     75    bool irq)
     76{
     77        assert(hcd);
     78        assert(hcd_get_driver_data(hcd) == NULL);
     79
     80        hc_t *instance = malloc(sizeof(hc_t));
     81        if (!instance)
     82                return ENOMEM;
     83
     84        const int ret = hc_init(instance, res, irq);
     85        if (ret == EOK) {
     86                hcd_set_implementation(hcd, instance, &ehci_hc_driver.ops);
     87        } else {
     88                free(instance);
     89        }
     90        return ret;
     91}
     92
     93static void ehci_driver_fini(hcd_t *hcd)
     94{
     95        assert(hcd);
     96        hc_t *hc = hcd_get_driver_data(hcd);
     97        if (hc)
     98                hc_fini(hc);
     99
     100        free(hc);
     101        hcd_set_implementation(hcd, NULL, NULL);
     102}
    66103
    67104/** Initializes a new ddf driver instance of EHCI hcd.
     
    72109static int ehci_dev_add(ddf_dev_t *device)
    73110{
    74         ddf_fun_t *hc_fun = NULL;
    75         bool fun_bound = false;
    76 
     111        usb_log_debug("ehci_dev_add() called\n");
    77112        assert(device);
    78113
    79         addr_range_t reg_range;
    80         int irq = 0;
     114        return hcd_ddf_add_hc(device, &ehci_hc_driver);
    81115
    82         int rc = get_my_registers(device, &reg_range, &irq);
    83         if (rc != EOK) {
    84                 usb_log_error("Failed to get memory addresses for %" PRIun
    85                     ": %s.\n", ddf_dev_get_handle(device), str_error(rc));
    86                 goto error;
    87         }
     116}
    88117
    89         usb_log_info("Memory mapped regs at %p (size %zu), IRQ %d.\n",
    90             RNGABSPTR(reg_range), RNGSZ(reg_range), irq);
    91118
    92         rc = disable_legacy(device, &reg_range);
    93         if (rc != EOK) {
    94                 usb_log_error("Failed to disable legacy USB: %s.\n",
    95                     str_error(rc));
    96                 goto error;
    97         }
     119static const driver_ops_t ehci_driver_ops = {
     120        .dev_add = ehci_dev_add,
     121};
    98122
    99         hc_fun = ddf_fun_create(device, fun_exposed, "ehci_hc");
    100         if (hc_fun == NULL) {
    101                 usb_log_error("Failed to create EHCI function.\n");
    102                 rc = ENOMEM;
    103                 goto error;
    104         }
     123static const driver_t ehci_driver = {
     124        .name = NAME,
     125        .driver_ops = &ehci_driver_ops
     126};
    105127
    106         hcd_t *ehci_hc = ddf_fun_data_alloc(hc_fun, sizeof(hcd_t));
    107         if (ehci_hc == NULL) {
    108                 usb_log_error("Failed to alloc generic HC driver.\n");
    109                 rc = ENOMEM;
    110                 goto error;
    111         }
    112 
    113         /* High Speed, no bandwidth */
    114         hcd_init(ehci_hc, USB_SPEED_HIGH, 0, NULL);
    115         ddf_fun_set_ops(hc_fun,  &hc_ops);
    116 
    117         rc = ddf_fun_bind(hc_fun);
    118         if (rc != EOK) {
    119                 usb_log_error("Failed to bind EHCI function: %s.\n",
    120                     str_error(rc));
    121                 goto error;
    122         }
    123 
    124         fun_bound = true;
    125 
    126         rc = ddf_fun_add_to_category(hc_fun, USB_HC_CATEGORY);
    127         if (rc != EOK) {
    128                 usb_log_error("Failed to add EHCI to HC class: %s.\n",
    129                     str_error(rc));
    130                 goto error;
    131         }
    132 
    133         usb_log_info("Controlling new EHCI device `%s' (handle %" PRIun ").\n",
    134             ddf_dev_get_name(device), ddf_dev_get_handle(device));
    135 
    136         return EOK;
    137 error:
    138         if (fun_bound)
    139                 ddf_fun_unbind(hc_fun);
    140         if (hc_fun != NULL)
    141                 ddf_fun_destroy(hc_fun);
    142         return rc;
    143 }
    144128
    145129/** Initializes global driver structures (NONE).
     
    154138{
    155139        log_init(NAME);
     140        logctl_set_log_level(NAME, LVL_NOTE);
    156141        return ddf_driver_main(&ehci_driver);
    157142}
     143
    158144/**
    159145 * @}
Note: See TracChangeset for help on using the changeset viewer.