Changeset 5944244 in mainline


Ignore:
Timestamp:
2011-02-01T23:25:48Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1f5c1e61
Parents:
c56dbe0
Message:

Refactoring uhci_ functions are called on uhci_t not device_t

Location:
uspace/drv
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    rc56dbe0 r5944244  
    4444{
    4545        assert(dev);
    46         uhci_t *hc = (uhci_t *)dev->driver_data;
     46        uhci_t *hc = dev_to_uhci(dev);
    4747        assert(hc);
    4848        *address = usb_address_keeping_find(&hc->address_manager, handle);
    … …  
    5555{
    5656        assert(dev);
    57         uhci_t *hc = (uhci_t *)dev->driver_data;
     57        uhci_t *hc = dev_to_uhci(dev);
    5858        assert(hc);
    5959        usb_address_keeping_reserve_default(&hc->address_manager);
    … …  
    6464{
    6565        assert(dev);
    66         uhci_t *hc = (uhci_t *)dev->driver_data;
     66        uhci_t *hc = dev_to_uhci(dev);
    6767        assert(hc);
    6868        usb_address_keeping_release_default(&hc->address_manager);
    … …  
    7373{
    7474        assert(dev);
    75         uhci_t *hc = (uhci_t *)dev->driver_data;
     75        uhci_t *hc = dev_to_uhci(dev);
    7676        assert(hc);
    7777        *address = usb_address_keeping_request(&hc->address_manager);
    … …  
    8585{
    8686        assert(dev);
    87         uhci_t *hc = (uhci_t *)dev->driver_data;
     87        uhci_t *hc = dev_to_uhci(dev);
    8888        assert(hc);
    8989        usb_address_keeping_devman_bind(&hc->address_manager, address, handle);
    … …  
    9494{
    9595        assert(dev);
    96         uhci_t *hc = (uhci_t *)dev->driver_data;
     96        uhci_t *hc = dev_to_uhci(dev);
    9797        assert(hc);
    9898        usb_address_keeping_release_default(&hc->address_manager);
    … …  
    104104    usbhc_iface_transfer_out_callback_t callback, void *arg)
    105105{
    106         return uhci_transfer(dev, target, USB_TRANSFER_INTERRUPT, 0, USB_PID_OUT,
     106        assert(dev);
     107        uhci_t *hc = dev_to_uhci(dev);
     108        assert(hc);
     109        return uhci_transfer(hc, dev, target, USB_TRANSFER_INTERRUPT, 0, USB_PID_OUT,
    107110                data, size, callback, NULL, arg);
    108111}
    … …  
    112115    usbhc_iface_transfer_in_callback_t callback, void *arg)
    113116{
    114         return uhci_transfer(dev, target, USB_TRANSFER_INTERRUPT, 0, USB_PID_IN,
     117        assert(dev);
     118        uhci_t *hc = dev_to_uhci(dev);
     119        assert(hc);
     120        return uhci_transfer(hc, dev, target, USB_TRANSFER_INTERRUPT, 0, USB_PID_IN,
    115121                data, size, NULL, callback, arg);
    116122}
    … …  
    120126    usbhc_iface_transfer_out_callback_t callback, void *arg)
    121127{
    122         return uhci_transfer(dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_SETUP,
     128        assert(dev);
     129        uhci_t *hc = dev_to_uhci(dev);
     130        assert(hc);
     131        return uhci_transfer(hc, dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_SETUP,
    123132                data, size, callback, NULL, arg);
    124133}
    … …  
    128137    usbhc_iface_transfer_out_callback_t callback, void *arg)
    129138{
    130         return uhci_transfer(dev, target, USB_TRANSFER_CONTROL, 1, USB_PID_OUT,
     139        assert(dev);
     140        uhci_t *hc = dev_to_uhci(dev);
     141        assert(hc);
     142        return uhci_transfer(hc, dev, target, USB_TRANSFER_CONTROL, 1, USB_PID_OUT,
    131143                data, size, callback, NULL, arg);
    132144}
    … …  
    135147    usbhc_iface_transfer_in_callback_t callback, void *arg)
    136148{
    137         return uhci_transfer(dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_IN,
     149        assert(dev);
     150        uhci_t *hc = dev_to_uhci(dev);
     151        assert(hc);
     152        return uhci_transfer(hc, dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_IN,
    138153                NULL, 0, NULL, callback, arg);
    139154}
    … …  
    143158    usbhc_iface_transfer_out_callback_t callback, void *arg)
    144159{
    145         return uhci_transfer(dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_SETUP,
     160        assert(dev);
     161        uhci_t *hc = dev_to_uhci(dev);
     162        assert(hc);
     163        return uhci_transfer(hc, dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_SETUP,
    146164                data, size, callback, NULL, arg);
    147165}
    … …  
    151169    usbhc_iface_transfer_in_callback_t callback, void *arg)
    152170{
    153         return uhci_transfer(dev, target, USB_TRANSFER_CONTROL, 1, USB_PID_IN,
     171        assert(dev);
     172        uhci_t *hc = dev_to_uhci(dev);
     173        assert(hc);
     174        return uhci_transfer(hc, dev, target, USB_TRANSFER_CONTROL, 1, USB_PID_IN,
    154175                data, size, NULL, callback, arg);
    155176}
    … …  
    158179    usbhc_iface_transfer_out_callback_t callback, void *arg)
    159180{
    160         return uhci_transfer(dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_OUT,
     181        assert(dev);
     182        uhci_t *hc = dev_to_uhci(dev);
     183        assert(hc);
     184        return uhci_transfer(hc, dev, target, USB_TRANSFER_CONTROL, 0, USB_PID_OUT,
    161185                NULL, 0, callback, NULL, arg);
    162186}

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

    rc56dbe0 r5944244  
    8787            io_reg_base, io_reg_size, irq);
    8888
    89         int ret = uhci_init(device, (void*)io_reg_base, io_reg_size);
     89        uhci_t *uhci_hc = malloc(sizeof(uhci_t));
     90        if (!uhci_hc) {
     91                usb_log_error("Failed to allocaete memory for uhci hcd driver.\n");
     92                return ENOMEM;
     93        }
    9094
     95        int ret = uhci_init(uhci_hc, (void*)io_reg_base, io_reg_size);
    9196        if (ret != EOK) {
    9297                usb_log_error("Failed to init uhci-hcd.\n");
    … …  
    108113                return ret;
    109114        }
     115
     116        device->driver_data = uhci_hc;
    110117
    111118        return EOK;

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

    rc56dbe0 r5944244  
    4343        instance->first = NULL;
    4444        instance->last = NULL;
    45         instance->queue_head = malloc32(sizeof(queue_head_t));
     45        instance->queue_head = queue_head_get();
    4646        if (!instance->queue_head) {
    4747                usb_log_error("Failed to allocate queue head.\n");

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

    rc56dbe0 r5944244  
    3737#include "uhci_struct/queue_head.h"
    3838#include "uhci_struct/transfer_descriptor.h"
    39 #include "utils/malloc32.h"
    4039
    4140typedef struct transfer_list
    … …  
    5251{
    5352        assert(instance);
    54         if (instance->queue_head)
    55                 free32(instance->queue_head);
     53        queue_head_dispose(instance->queue_head);
    5654}
    5755

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

    rc56dbe0 r5944244  
    3737#include <usb/usb.h>
    3838
    39 #include "utils/malloc32.h"
    4039#include "uhci.h"
    4140
    … …  
    4443static int uhci_debug_checker(void *arg);
    4544
    46 int uhci_init(device_t *device, void *regs, size_t reg_size)
    47 {
    48         assert(device);
    49         usb_log_info("Initializing device at address %p.\n", device);
    50 
    51 #define CHECK_RET_FREE_INSTANCE(message...) \
     45int uhci_init(uhci_t *instance, void *regs, size_t reg_size)
     46{
     47#define CHECK_RET_RETURN(message...) \
    5248        if (ret != EOK) { \
    5349                usb_log_error(message); \
    54                 if (instance) { \
    55                         free(instance); \
    56                 } \
    5750                return ret; \
    5851        } else (void) 0
    59 
    60         /* create instance */
    61         uhci_t *instance = malloc(sizeof(uhci_t));
    62         int ret = instance ? EOK : ENOMEM;
    63         CHECK_RET_FREE_INSTANCE("Failed to allocate uhci driver instance.\n");
    64 
    65         bzero(instance, sizeof(uhci_t));
    6652
    6753        /* init address keeper(libusb) */
    … …  
    7258        regs_t *io;
    7359        assert(reg_size >= sizeof(regs_t));
    74         ret = pio_enable(regs, reg_size, (void**)&io);
    75         CHECK_RET_FREE_INSTANCE("Failed to gain access to registers at %p.\n", io);
     60        int ret = pio_enable(regs, reg_size, (void**)&io);
     61        CHECK_RET_RETURN("Failed to gain access to registers at %p.\n", io);
    7662        instance->registers = io;
    7763        usb_log_debug("Device registers accessible.\n");
    … …  
    7965        /* init transfer lists */
    8066        ret = uhci_init_transfer_lists(instance->transfers);
    81         CHECK_RET_FREE_INSTANCE("Failed to initialize transfer lists.\n");
     67        CHECK_RET_RETURN("Failed to initialize transfer lists.\n");
    8268        usb_log_debug("Transfer lists initialized.\n");
    8369
    … …  
    8672        instance->frame_list = get_page();
    8773        ret = instance ? EOK : ENOMEM;
    88         CHECK_RET_FREE_INSTANCE("Failed to get frame list page.\n");
     74        CHECK_RET_RETURN("Failed to get frame list page.\n");
    8975
    9076        /* initialize all frames to point to the first queue head */
    91         unsigned i = 0;
    9277        const uint32_t queue =
    9378          instance->transfers[USB_TRANSFER_INTERRUPT].queue_head_pa
    9479          | LINK_POINTER_QUEUE_HEAD_FLAG;
     80        unsigned i = 0;
    9581        for(; i < UHCI_FRAME_LIST_COUNT; ++i) {
    9682                instance->frame_list[i] = queue;
    … …  
    10793        fibril_add_ready(instance->debug_checker);
    10894
    109         usb_log_debug("Starting UHCI HC.\n");
    110         pio_write_16(&instance->registers->usbcmd, UHCI_CMD_RUN_STOP);
     95        /* Start the hc with large(64b) packet FSBR */
     96        pio_write_16(&instance->registers->usbcmd,
     97            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET);
     98        usb_log_debug("Started UHCI HC.\n");
    11199/*
    112100        uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
    … …  
    114102        pio_write_16(&instance->registers->usbcmd, cmd);
    115103*/
    116         device->driver_data = instance;
    117104        return EOK;
    118105}
    … …  
    152139/*----------------------------------------------------------------------------*/
    153140int uhci_transfer(
     141  uhci_t *instance,
    154142  device_t *dev,
    155143  usb_target_t target,
    … …  
    172160        callback_t *job = NULL;
    173161        int ret = EOK;
     162        assert(dev);
    174163
    175164#define CHECK_RET_TRANS_FREE_JOB_TD(message) \
    … …  
    183172        } else (void) 0
    184173
    185 
    186174        job = callback_get(dev, buffer, size, callback_in, callback_out, arg);
    187175        ret = job ? EOK : ENOMEM;
    … …  
    193181
    194182        td->callback = job;
    195 
    196         assert(dev);
    197         uhci_t *instance = (uhci_t*)dev->driver_data;
    198         assert(instance);
    199183
    200184        usb_log_debug("Appending a new transfer to queue.\n");

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

    rc56dbe0 r5944244  
    8585
    8686/* init uhci specifics in device.driver_data */
    87 int uhci_init(device_t *device, void *regs, size_t reg_size);
     87int uhci_init(uhci_t *instance, void *regs, size_t reg_size);
    8888
    89 int uhci_destroy(device_t *device);
     89int uhci_fini(uhci_t *device);
    9090
    9191int uhci_transfer(
     92  uhci_t *instance,
    9293  device_t *dev,
    9394  usb_target_t target,
    … …  
    100101  void *arg );
    101102
     103static inline uhci_t * dev_to_uhci(device_t *dev)
     104        { return (uhci_t*)dev->driver_data; }
     105
    102106#endif
    103107/**

  • uspace/drv/uhci-hcd/uhci_struct/queue_head.h

    rc56dbe0 r5944244  
    3636#define DRV_UHCI_QH_H
    3737
     38/* libc */
    3839#include <assert.h>
    3940
    4041#include "link_pointer.h"
     42#include "utils/malloc32.h"
    4143
    4244typedef struct queue_head {
    … …  
    5961}
    6062
     63static inline queue_head_t * queue_head_get()
     64        { return malloc32(sizeof(queue_head_t)); }
     65
     66static inline void queue_head_dispose(queue_head_t *head)
     67        { free32(head); }
     68
     69
    6170#endif
    6271/**

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

    rc56dbe0 r5944244  
    7474        { return memalign(alignment, size); }
    7575
    76 static inline void free32(void * addr)
    77         { free(addr); }
     76static inline void free32(void *addr)
     77        { if (addr) free(addr); }
    7878
    7979#endif

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

    rc56dbe0 r5944244  
    8686
    8787        device->driver_data = rh;
    88         usb_log_info("Sucessfully initialized driver isntance for device:%d.\n",
     88        usb_log_info("Sucessfully initialized driver instance for device:%d.\n",
    8989            device->handle);
    9090        return EOK;
Note: See TracChangeset for help on using the changeset viewer.