Changes in / [3094804b:0cec844] in mainline


Ignore:
Location:
uspace
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/pciintel/pci.c

    r3094804b r0cec844  
    107107        }
    108108
    109         size_t i = 0;
    110         hw_resource_list_t *res = &dev_data->hw_resources;
    111         for (; i < res->count; i++) {
    112                 if (res->resources[i].type == INTERRUPT) {
    113                         const int irq = res->resources[i].res.interrupt.irq;
    114                         const int rc =
    115                             async_req_1_0(irc_phone, IRC_ENABLE_INTERRUPT, irq);
     109        size_t i;
     110        for (i = 0; i < dev_data->hw_resources.count; i++) {
     111                if (dev_data->hw_resources.resources[i].type == INTERRUPT) {
     112                        int irq = dev_data->hw_resources.resources[i].res.interrupt.irq;
     113                        int rc = async_req_1_0(irc_phone, IRC_ENABLE_INTERRUPT, irq);
    116114                        if (rc != EOK) {
    117115                                async_hangup(irc_phone);

  • uspace/drv/uhci-rhd/main.c

    r3094804b r0cec844  
    4444
    4545#define NAME "uhci-rhd"
    46 
    4746static int hc_get_my_registers(ddf_dev_t *dev,
    4847    uintptr_t *io_reg_address, size_t *io_reg_size);
    49 /*----------------------------------------------------------------------------*/
    50 static int uhci_rh_add_device(ddf_dev_t *device);
     48#if 0
     49/*----------------------------------------------------------------------------*/
     50static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
     51{
     52        assert(fun);
     53        assert(fun->driver_data);
     54        assert(handle);
     55
     56        *handle = ((uhci_root_hub_t*)fun->driver_data)->hc_handle;
     57
     58        return EOK;
     59}
     60/*----------------------------------------------------------------------------*/
     61static usb_iface_t uhci_rh_usb_iface = {
     62        .get_hc_handle = usb_iface_get_hc_handle,
     63        .get_address = usb_iface_get_address_hub_impl
     64};
     65/*----------------------------------------------------------------------------*/
     66static ddf_dev_ops_t uhci_rh_ops = {
     67        .interfaces[USB_DEV_IFACE] = &uhci_rh_usb_iface,
     68};
     69#endif
     70/*----------------------------------------------------------------------------*/
     71/** Initialize a new ddf driver instance of UHCI root hub.
     72 *
     73 * @param[in] device DDF instance of the device to initialize.
     74 * @return Error code.
     75 */
     76static int uhci_rh_add_device(ddf_dev_t *device)
     77{
     78        if (!device)
     79                return ENOTSUP;
     80
     81        usb_log_debug2("%s called device %d\n", __FUNCTION__, device->handle);
     82
     83        //device->ops = &uhci_rh_ops;
     84        uintptr_t io_regs = 0;
     85        size_t io_size = 0;
     86
     87        int ret = hc_get_my_registers(device, &io_regs, &io_size);
     88        if (ret != EOK) {
     89                usb_log_error("Failed to get registers from parent HC: %s.\n",
     90                    str_error(ret));
     91        }
     92        usb_log_debug("I/O regs at %#X (size %zu).\n", io_regs, io_size);
     93
     94        uhci_root_hub_t *rh = malloc(sizeof(uhci_root_hub_t));
     95        if (!rh) {
     96                usb_log_error("Failed to allocate driver instance.\n");
     97                return ENOMEM;
     98        }
     99
     100        ret = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
     101        if (ret != EOK) {
     102                usb_log_error("Failed to initialize driver instance: %s.\n",
     103                    str_error(ret));
     104                free(rh);
     105                return ret;
     106        }
     107
     108        device->driver_data = rh;
     109        usb_log_info("Controlling root hub `%s' (%llu).\n",
     110            device->name, device->handle);
     111        return EOK;
     112}
    51113/*----------------------------------------------------------------------------*/
    52114static driver_ops_t uhci_rh_driver_ops = {
    … …  
    70132{
    71133        printf(NAME ": HelenOS UHCI root hub driver.\n");
     134
    72135        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
     136
    73137        return ddf_driver_main(&uhci_rh_driver);
    74 }
    75 /*----------------------------------------------------------------------------*/
    76 /** Initialize a new ddf driver instance of UHCI root hub.
    77  *
    78  * @param[in] device DDF instance of the device to initialize.
    79  * @return Error code.
    80  */
    81 static int uhci_rh_add_device(ddf_dev_t *device)
    82 {
    83         if (!device)
    84                 return EINVAL;
    85 
    86         usb_log_debug2("%s called device %d\n", __FUNCTION__, device->handle);
    87 
    88         uintptr_t io_regs = 0;
    89         size_t io_size = 0;
    90         uhci_root_hub_t *rh = NULL;
    91         int ret = EOK;
    92 
    93 #define CHECK_RET_FREE_RH_RETURN(ret, message...) \
    94 if (ret != EOK) { \
    95         usb_log_error(message); \
    96         if (rh) \
    97                 free(rh); \
    98         return ret; \
    99 } else (void)0
    100 
    101         ret = hc_get_my_registers(device, &io_regs, &io_size);
    102         CHECK_RET_FREE_RH_RETURN(ret,
    103             "Failed(%d) to get registers from HC: %s.\n", ret, str_error(ret));
    104         usb_log_debug("I/O regs at %#x (size %zu).\n", io_regs, io_size);
    105 
    106         rh = malloc(sizeof(uhci_root_hub_t));
    107         ret = (rh == NULL) ? ENOMEM : EOK;
    108         CHECK_RET_FREE_RH_RETURN(ret,
    109             "Failed to allocate rh driver instance.\n");
    110 
    111         ret = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
    112         CHECK_RET_FREE_RH_RETURN(ret,
    113             "Failed(%d) to initialize rh driver instance: %s.\n",
    114             ret, str_error(ret));
    115 
    116         device->driver_data = rh;
    117         usb_log_info("Controlling root hub '%s' (%llu).\n",
    118             device->name, device->handle);
    119         return EOK;
    120138}
    121139/*----------------------------------------------------------------------------*/
    … …  
    138156        }
    139157
     158        int rc;
     159
    140160        hw_resource_list_t hw_resources;
    141         int ret = hw_res_get_resource_list(parent_phone, &hw_resources);
    142         if (ret != EOK) {
    143                 async_hangup(parent_phone);
    144                 return ret;
     161        rc = hw_res_get_resource_list(parent_phone, &hw_resources);
     162        if (rc != EOK) {
     163                goto leave;
    145164        }
    146165
    … …  
    149168        bool io_found = false;
    150169
    151         size_t i = 0;
    152         for (; i < hw_resources.count; i++) {
     170        size_t i;
     171        for (i = 0; i < hw_resources.count; i++) {
    153172                hw_resource_t *res = &hw_resources.resources[i];
    154                 if (res->type == IO_RANGE) {
    155                         io_address = res->res.io_range.address;
     173                switch (res->type)
     174                {
     175                case IO_RANGE:
     176                        io_address = (uintptr_t) res->res.io_range.address;
    156177                        io_size = res->res.io_range.size;
    157178                        io_found = true;
     179
     180                default:
     181                        break;
    158182                }
    159183        }
    160         async_hangup(parent_phone);
    161184
    162185        if (!io_found) {
    163                 return ENOENT;
    164         }
     186                rc = ENOENT;
     187                goto leave;
     188        }
     189
    165190        if (io_reg_address != NULL) {
    166191                *io_reg_address = io_address;
    … …  
    169194                *io_reg_size = io_size;
    170195        }
    171         return EOK;
     196        rc = EOK;
     197
     198leave:
     199        async_hangup(parent_phone);
     200        return rc;
    172201}
    173202/**

  • uspace/drv/uhci-rhd/port.c

    r3094804b r0cec844  
    4343#include "port.h"
    4444
    45 static int uhci_port_check(void *port);
    46 static int uhci_port_reset_enable(int portno, void *arg);
    4745static int uhci_port_new_device(uhci_port_t *port, usb_speed_t speed);
    4846static int uhci_port_remove_device(uhci_port_t *port);
    4947static int uhci_port_set_enabled(uhci_port_t *port, bool enabled);
     48static int uhci_port_check(void *port);
     49static int uhci_port_reset_enable(int portno, void *arg);
    5050static void uhci_port_print_status(
    5151    uhci_port_t *port, const port_status_t value);
    … …  
    7474        pio_write_16(port->address, value);
    7575}
     76
    7677/*----------------------------------------------------------------------------*/
    7778/** Initialize UHCI root hub port instance.
    … …  
    258259
    259260        usb_address_t dev_addr;
    260         int ret = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
     261        int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
    261262            speed, uhci_port_reset_enable, port->number, port,
    262263            &dev_addr, &port->attached_device, NULL, NULL, NULL);
    263264
    264         if (ret != EOK) {
     265        if (rc != EOK) {
    265266                usb_log_error("%s: Failed(%d) to add device: %s.\n",
    266                     port->id_string, ret, str_error(ret));
     267                    port->id_string, rc, str_error(rc));
    267268                uhci_port_set_enabled(port, false);
    268                 return ret;
     269                return rc;
    269270        }
    270271
    … …  
    286287int uhci_port_remove_device(uhci_port_t *port)
    287288{
    288         usb_log_error("%s: Don't know how to remove device %llu.\n",
    289             port->id_string, port->attached_device);
    290         return ENOTSUP;
     289        usb_log_error("%s: Don't know how to remove device %d.\n",
     290            port->id_string, (unsigned int)port->attached_device);
     291        return EOK;
    291292}
    292293/*----------------------------------------------------------------------------*/
    … …  
    340341            (value & STATUS_CONNECTED_CHANGED) ? " CONNECTED-CHANGE," : "",
    341342            (value & STATUS_CONNECTED) ? " CONNECTED," : "",
    342             (value & STATUS_ALWAYS_ONE) ? " ALWAYS ONE" : " ERR: NO ALWAYS ONE"
     343            (value & STATUS_ALWAYS_ONE) ? " ALWAYS ONE" : " ERROR: NO ALWAYS ONE"
    343344        );
    344345}

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

    r3094804b r0cec844  
    5151        assert(instance);
    5252        assert(rh);
     53        int ret;
    5354
    5455        /* Allow access to root hub port registers */
    5556        assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT <= size);
    5657        port_status_t *regs;
    57         int ret = pio_enable(addr, size, (void**)&regs);
     58        ret = pio_enable(addr, size, (void**)&regs);
    5859        if (ret < 0) {
    5960                usb_log_error(
    … …  
    8384 *
    8485 * @param[in] instance Root hub structure to use.
     86 * @return Error code.
    8587 */
    86 void uhci_root_hub_fini(uhci_root_hub_t* instance)
     88int uhci_root_hub_fini(uhci_root_hub_t* instance)
    8789{
    8890        assert(instance);
    … …  
    9193                uhci_port_fini(&instance->ports[i]);
    9294        }
     95        return EOK;
    9396}
    9497/*----------------------------------------------------------------------------*/

  • uspace/drv/uhci-rhd/root_hub.h

    r3094804b r0cec844  
    5050  uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh);
    5151
    52 void uhci_root_hub_fini(uhci_root_hub_t *instance);
     52int uhci_root_hub_fini(uhci_root_hub_t *instance);
    5353#endif
    5454/**

  • uspace/srv/hw/irc/apic/apic.c

    r3094804b r0cec844  
    8787                        async_answer_0(callid, EOK);
    8888                        break;
    89                 case IPC_M_PHONE_HUNGUP:
    90                         /* The other side has hung up. */
    91                         async_answer_0(callid, EOK);
    92                         return;
    9389                default:
    9490                        async_answer_0(callid, EINVAL);

  • uspace/srv/hw/irc/i8259/i8259.c

    r3094804b r0cec844  
    121121                        async_answer_0(callid, EOK);
    122122                        break;
    123                 case IPC_M_PHONE_HUNGUP:
    124                         /* The other side has hung up. */
    125                         async_answer_0(callid, EOK);
    126                         return;
    127123                default:
    128124                        async_answer_0(callid, EINVAL);
Note: See TracChangeset for help on using the changeset viewer.