Changeset 1f1fa64 in mainline for uspace/drv


Ignore:
Timestamp:
2014-07-28T21:53:11Z (12 years ago)
Author:
Agnieszka Tabaka <nufcia@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c3b25985, f2f4c00
Parents:
cbfece7 (diff), 7eb6c96 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Make MAC address change possible on ethip side. Merge mainline changes.

Location:
uspace/drv
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/usb/ohci/hc.c

    rcbfece7 r1f1fa64  
    193193        instance->rh.address = 1;
    194194        rc = usb_device_manager_request_address(
    195             &instance->generic.dev_manager, &instance->rh.address, false,
     195            &instance->generic->dev_manager, &instance->rh.address, false,
    196196            USB_SPEED_FULL);
    197197        if (rc != EOK) {
    … …  
    204204
    205205        rc = usb_endpoint_manager_add_ep(
    206             &instance->generic.ep_manager, instance->rh.address, 0,
     206            &instance->generic->ep_manager, instance->rh.address, 0,
    207207            USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64,
    208208            0, NULL, NULL);
    … …  
    231231        fun_bound = true;
    232232
    233         rc = usb_device_manager_bind_address(&instance->generic.dev_manager,
     233        rc = usb_device_manager_bind_address(&instance->generic->dev_manager,
    234234            instance->rh.address, ddf_fun_get_handle(hub_fun));
    235235        if (rc != EOK) {
    … …  
    244244        if (ep_added) {
    245245                usb_endpoint_manager_remove_ep(
    246                     &instance->generic.ep_manager, instance->rh.address, 0,
     246                    &instance->generic->ep_manager, instance->rh.address, 0,
    247247                    USB_DIRECTION_BOTH, NULL, NULL);
    248248        }
    249249        if (addr_reqd) {
    250250                usb_device_manager_release_address(
    251                     &instance->generic.dev_manager, instance->rh.address);
     251                    &instance->generic->dev_manager, instance->rh.address);
    252252        }
    253253        return rc;
    … …  
    257257 *
    258258 * @param[in] instance Memory place for the structure.
     259 * @param[in] HC function node
    259260 * @param[in] regs Device's I/O registers range.
    260261 * @param[in] interrupts True if w interrupts should be used
    261262 * @return Error code
    262263 */
    263 int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
     264int hc_init(hc_t *instance, ddf_fun_t *fun, addr_range_t *regs, bool interrupts)
    264265{
    265266        assert(instance);
    … …  
    274275        list_initialize(&instance->pending_batches);
    275276
    276         hcd_init(&instance->generic, USB_SPEED_FULL,
     277        instance->generic = ddf_fun_data_alloc(fun, sizeof(hcd_t));
     278        if (instance->generic == NULL) {
     279                usb_log_error("Out of memory.\n");
     280                return ENOMEM;
     281        }
     282
     283        hcd_init(instance->generic, USB_SPEED_FULL,
    277284            BANDWIDTH_AVAILABLE_USB11, bandwidth_count_usb11);
    278         instance->generic.private_data = instance;
    279         instance->generic.schedule = hc_schedule;
    280         instance->generic.ep_add_hook = ohci_endpoint_init;
    281         instance->generic.ep_remove_hook = ohci_endpoint_fini;
     285        instance->generic->private_data = instance;
     286        instance->generic->schedule = hc_schedule;
     287        instance->generic->ep_add_hook = ohci_endpoint_init;
     288        instance->generic->ep_remove_hook = ohci_endpoint_fini;
    282289
    283290        rc = hc_init_memory(instance);

  • uspace/drv/bus/usb/ohci/hc.h

    rcbfece7 r1f1fa64  
    3535#define DRV_OHCI_HC_H
    3636
     37#include <ddf/driver.h>
    3738#include <ddf/interrupt.h>
    3839#include <fibril.h>
    … …  
    5354typedef struct hc {
    5455        /** Generic USB hc driver */
    55         hcd_t generic;
     56        hcd_t *generic;
    5657
    5758        /** Memory mapped I/O registers area */
    … …  
    7980int hc_register_irq_handler(ddf_dev_t *, addr_range_t *, int,
    8081    interrupt_handler_t);
    81 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
    82 int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts);
     82int hc_register_hub(hc_t *, ddf_fun_t *);
     83int hc_init(hc_t *, ddf_fun_t *, addr_range_t *, bool);
    8384
    8485/** Safely dispose host controller internal structures

  • uspace/drv/bus/usb/ohci/ohci.c

    rcbfece7 r1f1fa64  
    3434 */
    3535
    36 /* XXX Fix this */
    37 #define _DDF_DATA_IMPLANT
    38 
    3936#include <errno.h>
    4037#include <str_error.h>
    … …  
    165162
    166163        ddf_fun_set_ops(instance->hc_fun, &hc_ops);
    167         ddf_fun_data_implant(instance->hc_fun, &instance->hc);
    168164
    169165        instance->rh_fun = ddf_fun_create(device, fun_inner, "ohci_rh");
    … …  
    214210        }
    215211
    216         rc = hc_init(&instance->hc, &regs, interrupts);
     212        rc = hc_init(&instance->hc, instance->hc_fun, &regs, interrupts);
    217213        if (rc != EOK) {
    218214                usb_log_error("Failed to init ohci_hcd: %s.\n", str_error(rc));

  • uspace/drv/bus/usb/uhci/hc.c

    rcbfece7 r1f1fa64  
    230230 *
    231231 * @param[in] instance Memory place to initialize.
     232 * @param[in] HC function node
    232233 * @param[in] regs Range of device's I/O control registers.
    233234 * @param[in] interrupts True if hw interrupts should be used.
    … …  
    238239 * interrupt fibrils.
    239240 */
    240 int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
     241int hc_init(hc_t *instance, ddf_fun_t *fun, addr_range_t *regs, bool interrupts)
    241242{
    242243        assert(regs->size >= sizeof(uhci_regs_t));
    … …  
    266267        }
    267268
    268         hcd_init(&instance->generic, USB_SPEED_FULL,
     269        instance->generic = ddf_fun_data_alloc(fun, sizeof(hcd_t));
     270        if (instance->generic == NULL) {
     271                usb_log_error("Out of memory.\n");
     272                return ENOMEM;
     273        }
     274
     275        hcd_init(instance->generic, USB_SPEED_FULL,
    269276            BANDWIDTH_AVAILABLE_USB11, bandwidth_count_usb11);
    270277
    271         instance->generic.private_data = instance;
    272         instance->generic.schedule = hc_schedule;
    273         instance->generic.ep_add_hook = NULL;
     278        instance->generic->private_data = instance;
     279        instance->generic->schedule = hc_schedule;
     280        instance->generic->ep_add_hook = NULL;
    274281
    275282        hc_init_hw(instance);

  • uspace/drv/bus/usb/uhci/hc.h

    rcbfece7 r1f1fa64  
    3636#define DRV_UHCI_HC_H
    3737
     38#include <ddf/driver.h>
    3839#include <ddf/interrupt.h>
    3940#include <device/hw_res_parsed.h>
    … …  
    9394typedef struct hc {
    9495        /** Generic HCD driver structure */
    95         hcd_t generic;
     96        hcd_t *generic;
    9697
    9798        /** Addresses of I/O registers */
    … …  
    126127    addr_range_t *);
    127128void hc_interrupt(hc_t *instance, uint16_t status);
    128 int hc_init(hc_t *instance, addr_range_t *regs, bool interupts);
     129int hc_init(hc_t *, ddf_fun_t *, addr_range_t *, bool);
    129130
    130131/** Safely dispose host controller internal structures

  • uspace/drv/bus/usb/uhci/uhci.c

    rcbfece7 r1f1fa64  
    3434 */
    3535
    36 /* XXX Fix this */
    37 #define _DDF_DATA_IMPLANT
    38 
    3936#include <errno.h>
    4037#include <stdbool.h>
    … …  
    6259        hc_t hc;
    6360        /** Internal driver's representation of UHCI root hub */
    64         rh_t rh;
     61        rh_t *rh;
    6562} uhci_t;
    6663
    … …  
    186183
    187184        ddf_fun_set_ops(instance->hc_fun, &hc_ops);
    188         ddf_fun_data_implant(instance->hc_fun, &instance->hc.generic);
    189185
    190186        instance->rh_fun = ddf_fun_create(device, fun_inner, "uhci_rh");
    … …  
    196192
    197193        ddf_fun_set_ops(instance->rh_fun, &rh_ops);
    198         ddf_fun_data_implant(instance->rh_fun, &instance->rh);
     194        instance->rh = ddf_fun_data_alloc(instance->rh_fun, sizeof(rh_t));
    199195
    200196        addr_range_t regs;
    … …  
    236232        }
    237233
    238         rc = hc_init(&instance->hc, &regs, interrupts);
     234        rc = hc_init(&instance->hc, instance->hc_fun, &regs, interrupts);
    239235        if (rc != EOK) {
    240236                usb_log_error("Failed to init uhci_hcd: %s.\n", str_error(rc));
    … …  
    260256        }
    261257
    262         rc = rh_init(&instance->rh, instance->rh_fun, &regs, 0x10, 4);
     258        rc = rh_init(instance->rh, instance->rh_fun, &regs, 0x10, 4);
    263259        if (rc != EOK) {
    264260                usb_log_error("Failed to setup UHCI root hub: %s.\n",

  • uspace/drv/bus/usb/uhcirh/port.c

    rcbfece7 r1f1fa64  
    269269        int ret, count = MAX_ERROR_COUNT;
    270270        do {
    271                 ret = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
     271                port->attached_device.fun = ddf_fun_create(port->rh, fun_inner,
     272                    NULL);
     273                if (port->attached_device.fun == NULL) {
     274                        ret = ENOMEM;
     275                        continue;
     276                }
     277
     278                ret = usb_hc_new_device_wrapper(port->rh,
     279                    port->attached_device.fun,
     280                    &port->hc_connection,
    272281                    speed, uhci_port_reset_enable, port,
    273                     &port->attached_device.address, NULL, NULL,
    274                     &port->attached_device.fun);
     282                    &port->attached_device.address, NULL);
     283
     284                if (ret != EOK) {
     285                        ddf_fun_destroy(port->attached_device.fun);
     286                        port->attached_device.fun = NULL;
     287                }
     288
    275289        } while (ret != EOK && count-- > 0);
    276290

  • uspace/drv/bus/usb/usbhid/usbhid.c

    rcbfece7 r1f1fa64  
    415415        }
    416416
    417         /*
    418          * 1) subdriver vytvori vlastnu ddf_fun, vlastne ddf_dev_ops, ktore da
    419          *    do nej.
    420          * 2) do tych ops do .interfaces[DEV_IFACE_USBHID (asi)] priradi
    421          *    vyplnenu strukturu usbhid_iface_t.
    422          * 3) klientska aplikacia - musi si rucne vytvorit telefon
    423          *    (devman_device_connect() - cesta k zariadeniu (/hw/pci0/...) az
    424          *    k tej fcii.
    425          *    pouzit usb/classes/hid/iface.h - prvy int je telefon
    426          */
     417        /* Initialize subdrivers */
    427418        bool ok = false;
    428419        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {

  • uspace/drv/bus/usb/usbhub/port.c

    rcbfece7 r1f1fa64  
    424424        ddf_fun_t *child_fun;
    425425
     426        child_fun = ddf_fun_create(data->hub->usb_device->ddf_dev,
     427            fun_inner, NULL);
     428        if (child_fun == NULL)
     429                return ENOMEM;
     430
    426431        const int rc = usb_hc_new_device_wrapper(data->hub->usb_device->ddf_dev,
    427             &data->hub->usb_device->hc_conn, data->speed, enable_port_callback,
    428             data->port, &new_address, NULL, NULL, &child_fun);
     432            child_fun, &data->hub->usb_device->hc_conn, data->speed,
     433            enable_port_callback, data->port, &new_address, NULL);
    429434
    430435        if (rc == EOK) {
    … …  
    440445                    ddf_fun_get_handle(child_fun));
    441446        } else {
     447                ddf_fun_destroy(child_fun);
    442448                usb_log_error("Failed registering device on port %zu: %s.\n",
    443449                    data->port->port_number, str_error(rc));

  • uspace/drv/bus/usb/usbmid/explore.c

    rcbfece7 r1f1fa64  
    3434 * Exploration of available interfaces in the USB device.
    3535 */
     36#include <ddf/driver.h>
    3637#include <errno.h>
    3738#include <str_error.h>
    … …  
    7071 * @param config_descriptor_size Size of configuration descriptor in bytes.
    7172 * @param list List where to add the interfaces.
    72  */
    73 static void create_interfaces(const uint8_t *config_descriptor,
    74     size_t config_descriptor_size, list_t *list)
     73 * @return EOK on success, ENOMEM if out of memory.
     74 */
     75static int create_interfaces(usb_mid_t *mid, const uint8_t *config_descriptor,
     76    size_t config_descriptor_size)
    7577{
    7678        const usb_dp_parser_data_t data = {
    … …  
    101103
    102104                /* Skip alternate interfaces. */
    103                 if (interface_in_list(list, interface->interface_number)) {
     105                if (interface_in_list(&mid->interface_list,
     106                    interface->interface_number)) {
    104107                        /* TODO: add the alternatives and create match ids
    105108                         * for them. */
    106109                        continue;
    107110                }
    108                 usbmid_interface_t *iface = malloc(sizeof(usbmid_interface_t));
    109                 if (iface == NULL) {
    110                         //TODO: Do something about that failure.
    111                         break;
    112                 }
     111
     112                /* Create the function */
     113                ddf_fun_t *fun = ddf_fun_create(mid->dev, fun_inner, NULL);
     114                if (fun == NULL)
     115                        goto error;
     116
     117                usbmid_interface_t *iface = ddf_fun_data_alloc(fun,
     118                    sizeof(usbmid_interface_t));
     119                if (iface == NULL)
     120                        goto error;
    113121
    114122                link_initialize(&iface->link);
    115                 iface->fun = NULL;
     123                iface->fun = fun;
    116124                iface->interface_no = interface->interface_number;
    117125                iface->interface = interface;
    118126
    119                 list_append(&iface->link, list);
    120         }
     127                list_append(&iface->link, &mid->interface_list);
     128        }
     129
     130        return EOK;
     131error:
     132        while (!list_empty(&mid->interface_list)) {
     133                link_t *link = list_first(&mid->interface_list);
     134                usbmid_interface_t *iface = list_get_instance(link,
     135                    usbmid_interface_t, link);
     136
     137                ddf_fun_destroy(iface->fun);
     138        }
     139
     140        return ENOMEM;
    121141}
    122142
    … …  
    165185        }
    166186
     187        usb_mid->dev = dev->ddf_dev;
     188
    167189        /* Create control function. */
    168190        usb_mid->ctl_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, "ctl");
    … …  
    182204        }
    183205
    184 
    185206        /* Create interface children. */
    186207        list_initialize(&usb_mid->interface_list);
    187         create_interfaces(config_descriptor_raw, config_descriptor_size,
    188             &usb_mid->interface_list);
     208        create_interfaces(usb_mid, config_descriptor_raw, config_descriptor_size);
    189209
    190210        /* Start child function for every interface. */

  • uspace/drv/bus/usb/usbmid/usbmid.c

    rcbfece7 r1f1fa64  
    3030 * @{
    3131 */
    32 
    33 /* XXX Fix this */
    34 #define _DDF_DATA_IMPLANT
    3532
    3633/**
    … …  
    10299    const usb_standard_interface_descriptor_t *interface_descriptor)
    103100{
    104         ddf_fun_t *child = NULL;
    105101        char *child_name = NULL;
    106102        int rc;
    … …  
    114110            usb_str_class(interface_descriptor->interface_class),
    115111            interface_descriptor->interface_number);
    116         if (rc < 0) {
     112        if (rc < 0)
    117113                return ENOMEM;
    118         }
    119114
    120         /* Create the device. */
    121         child = ddf_fun_create(parent->ddf_dev, fun_inner, child_name);
     115        rc = ddf_fun_set_name(iface->fun, child_name);
    122116        free(child_name);
    123         if (child == NULL) {
     117        if (rc != EOK)
    124118                return ENOMEM;
    125         }
    126119
    127120        match_id_list_t match_ids;
    … …  
    130123        rc = usb_device_create_match_ids_from_interface(device_descriptor,
    131124            interface_descriptor, &match_ids);
    132         if (rc != EOK) {
    133                 ddf_fun_destroy(child);
     125        if (rc != EOK)
    134126                return rc;
    135         }
    136127
    137128        list_foreach(match_ids.ids, link, match_id_t, match_id) {
    138                 rc = ddf_fun_add_match_id(child, match_id->id, match_id->score);
     129                rc = ddf_fun_add_match_id(iface->fun, match_id->id, match_id->score);
    139130                if (rc != EOK) {
    140131                        clean_match_ids(&match_ids);
    141                         ddf_fun_destroy(child);
    142132                        return rc;
    143133                }
    … …  
    145135        clean_match_ids(&match_ids);
    146136
    147         rc = ddf_fun_bind(child);
    148         if (rc != EOK) {
    149                 /* This takes care of match_id deallocation as well. */
    150                 ddf_fun_destroy(child);
     137        ddf_fun_set_ops(iface->fun, &child_device_ops);
     138
     139        rc = ddf_fun_bind(iface->fun);
     140        if (rc != EOK)
    151141                return rc;
    152         }
    153 
    154         iface->fun = child;
    155         ddf_fun_data_implant(child, iface);
    156         ddf_fun_set_ops(child, &child_device_ops);
    157142
    158143        return EOK;

  • uspace/drv/bus/usb/usbmid/usbmid.h

    rcbfece7 r1f1fa64  
    6060/** Container to hold all the function pointers */
    6161typedef struct usb_mid {
     62        ddf_dev_t *dev;
    6263        ddf_fun_t *ctl_fun;
    6364        list_t interface_list;

  • uspace/drv/bus/usb/vhc/hub.c

    rcbfece7 r1f1fa64  
    9494{
    9595        ddf_fun_t *hc_dev = (ddf_fun_t *) arg;
    96 
    97         /*
    98          * Wait until parent device is properly initialized.
    99          */
    100         async_sess_t *sess;
    101         do {
    102                 sess = devman_device_connect(EXCHANGE_SERIALIZE,
    103                     ddf_fun_get_handle(hc_dev), 0);
    104         } while (!sess);
    105         async_hangup(sess);
    106 
    10796        int rc;
    10897
    … …  
    114103
    115104        ddf_fun_t *hub_dev;
    116         rc = usb_hc_new_device_wrapper(ddf_fun_get_dev(hc_dev), &hc_conn, USB_SPEED_FULL,
    117             pretend_port_rest, NULL, NULL, &rh_ops, hc_dev, &hub_dev);
     105
     106        hub_dev = ddf_fun_create(ddf_fun_get_dev(hc_dev), fun_inner, NULL);
     107        if (hub_dev == NULL) {
     108                rc = ENOMEM;
     109                usb_log_fatal("Failed to create root hub: %s.\n",
     110                    str_error(rc));
     111                return rc;
     112        }
     113
     114        rc = usb_hc_new_device_wrapper(ddf_fun_get_dev(hc_dev), hub_dev,
     115            &hc_conn, USB_SPEED_FULL, pretend_port_rest, NULL, NULL, &rh_ops);
    118116        if (rc != EOK) {
    119117                usb_log_fatal("Failed to create root hub: %s.\n",
    120118                    str_error(rc));
     119                ddf_fun_destroy(hub_dev);
    121120        }
    122121

  • uspace/drv/nic/e1k/e1k.c

    rcbfece7 r1f1fa64  
    7171/** ddf_fun_t * -> nic_driver_data_t* cast */
    7272#define NIC_DATA_FUN(fun) \
    73         ((nic_t *) ddf_fun_data_get(fun))
     73        ((nic_t *) ddf_dev_data_get(ddf_fun_get_dev(fun)))
    7474
    7575/** ddf_dev_t * -> nic_driver_data_t* cast */

  • uspace/drv/nic/rtl8169/driver.c

    rcbfece7 r1f1fa64  
    439439        nic_set_ddf_fun(nic_data, fun);
    440440        ddf_fun_set_ops(fun, &rtl8169_dev_ops);
    441         ddf_fun_data_implant(fun, nic_data);
     441//      ddf_fun_data_implant(fun, nic_data);
    442442
    443443        rc = ddf_fun_bind(fun);
Note: See TracChangeset for help on using the changeset viewer.