Changeset 1889786 in mainline for uspace/drv/uhci-hcd


Ignore:
Timestamp:
2011-05-25T18:05:51Z (14 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
14e7959, 9ca8539, b8cab5c
Parents:
c9256c5 (diff), fb2de0a (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:

Hopefully last quirks and fixes

Removed slab allocator used by UHCI hcd

Location:
uspace/drv/uhci-hcd
Files:
2 deleted
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/Makefile

    rc9256c5 r1889786  
    4848        root_hub.c \
    4949        hw_struct/transfer_descriptor.c \
    50         utils/slab.c \
    5150        pci.c \
    5251        batch.c

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

    rc9256c5 r1889786  
    3535#define DRV_UHCI_BATCH_H
    3636
    37 #include <usbhc_iface.h>
    38 #include <usb/usb.h>
    39 #include <usb/host/device_keeper.h>
    40 #include <usb/host/endpoint.h>
    4137#include <usb/host/batch.h>
    4238

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

    rc9256c5 r1889786  
    3939#include <usb/debug.h>
    4040#include <usb/usb.h>
    41 #include <usb/ddfiface.h>
    42 #include <usb_iface.h>
    4341
    4442#include "hc.h"
    … …  
    8583        /* allow access to hc control registers */
    8684        regs_t *io;
    87         ret = pio_enable(regs, reg_size, (void**)&io);
     85        ret = pio_enable(regs, reg_size, (void **)&io);
    8886        CHECK_RET_RETURN(ret,
    8987            "Failed(%d) to gain access to registers at %p: %s.\n",
    … …  
    143141        }
    144142
    145         uint16_t status = pio_read_16(&registers->usbcmd);
     143        const uint16_t status = pio_read_16(&registers->usbcmd);
    146144        if (status != 0)
    147145                usb_log_warning("Previous command value: %x.\n", status);
    … …  
    212210        /* Init USB frame list page*/
    213211        instance->frame_list = get_page();
    214         ret = instance ? EOK : ENOMEM;
     212        ret = instance->frame_list ? EOK : ENOMEM;
    215213        CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
    216214        usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
    … …  
    277275                &instance->transfers_control_slow);
    278276
    279         /*FSBR*/
     277        /*FSBR, This feature is not needed (adds no benefit) and is supposedly
     278         * buggy on certain hw, enable at your own risk. */
    280279#ifdef FSBR
    281280        transfer_list_set_next(&instance->transfers_bulk_full,
    … …  
    428427                }
    429428
    430                 uintptr_t frame_list =
     429                const uintptr_t frame_list =
    431430                    pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
    432431                if (frame_list != addr_to_phys(instance->frame_list)) {

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

    rc9256c5 r1889786  
    3737
    3838#include <fibril.h>
    39 #include <fibril_synch.h>
    40 #include <adt/list.h>
    4139#include <ddi.h>
    4240
    43 #include <usbhc_iface.h>
    4441#include <usb/host/device_keeper.h>
    4542#include <usb/host/usb_endpoint_manager.h>
     43#include <usb/host/batch.h>
    4644
    47 #include "batch.h"
    4845#include "transfer_list.h"
    4946
    … …  
    154151 */
    155152static inline hc_t * fun_to_hc(ddf_fun_t *fun)
    156         { return (hc_t*)fun->driver_data; }
     153{
     154        assert(fun);
     155        return fun->driver_data;
     156}
    157157#endif
    158158/**

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

    rc9256c5 r1889786  
    3939
    4040#include "iface.h"
     41#include "batch.h"
    4142#include "hc.h"
    4243
    … …  
    122123        return EOK;
    123124}
    124 
     125/*----------------------------------------------------------------------------*/
    125126/** Find device handle by address interface function.
    126127 *
    … …  
    136137        hc_t *hc = fun_to_hc(fun);
    137138        assert(hc);
    138         bool found =
     139        const bool found =
    139140            usb_device_keeper_find_by_address(&hc->manager, address, handle);
    140141        return found ? EOK : ENOENT;
    141142}
    142 
    143143/*----------------------------------------------------------------------------*/
    144144/** Release address interface function
    … …  
    164164    size_t max_packet_size, unsigned int interval)
    165165{
     166        assert(fun);
    166167        hc_t *hc = fun_to_hc(fun);
    167168        assert(hc);
    … …  
    183184    usb_endpoint_t endpoint, usb_direction_t direction)
    184185{
     186        assert(fun);
    185187        hc_t *hc = fun_to_hc(fun);
    186188        assert(hc);
    … …  
    211213        if (ret != EOK)
    212214                return ret;
     215        assert(batch);
     216        assert(hc);
    213217        batch_interrupt_out(batch);
    214218        ret = hc_schedule(hc, batch);
    … …  
    239243        if (ret != EOK)
    240244                return ret;
     245        assert(batch);
     246        assert(hc);
    241247        batch_interrupt_in(batch);
    242248        ret = hc_schedule(hc, batch);
    … …  
    267273        if (ret != EOK)
    268274                return ret;
     275        assert(batch);
     276        assert(hc);
    269277        batch_bulk_out(batch);
    270278        ret = hc_schedule(hc, batch);
    … …  
    295303        if (ret != EOK)
    296304                return ret;
     305        assert(batch);
     306        assert(hc);
    297307        batch_bulk_in(batch);
    298308        ret = hc_schedule(hc, batch);
    … …  
    327337        if (ret != EOK)
    328338                return ret;
     339        assert(batch);
     340        assert(hc);
    329341        usb_endpoint_manager_reset_if_need(&hc->ep_manager, target, setup_data);
    330342        batch_control_write(batch);
    … …  
    360372        if (ret != EOK)
    361373                return ret;
     374        assert(batch);
     375        assert(hc);
    362376        batch_control_read(batch);
    363377        ret = hc_schedule(hc, batch);

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

    rc9256c5 r1889786  
    5252 * @return Error code.
    5353 */
    54 int pci_get_my_registers(ddf_dev_t *dev,
     54int pci_get_my_registers(const ddf_dev_t *dev,
    5555    uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
    5656{
    57         assert(dev != NULL);
     57        assert(dev);
     58        assert(io_reg_address);
     59        assert(io_reg_size);
     60        assert(irq_no);
    5861
    5962        int parent_phone =
    … …  
    6669        int rc = hw_res_get_resource_list(parent_phone, &hw_resources);
    6770        if (rc != EOK) {
    68                 goto leave;
     71                async_hangup(parent_phone);
     72                return rc;
    6973        }
    7074
    … …  
    7882        size_t i;
    7983        for (i = 0; i < hw_resources.count; i++) {
    80                 hw_resource_t *res = &hw_resources.resources[i];
     84                const hw_resource_t *res = &hw_resources.resources[i];
    8185                switch (res->type)
    8286                {
    … …  
    99103                }
    100104        }
     105        async_hangup(parent_phone);
    101106
    102         if (!io_found || !irq_found) {
    103                 rc = ENOENT;
    104                 goto leave;
    105         }
     107        if (!io_found || !irq_found)
     108                return ENOENT;
    106109
    107110        *io_reg_address = io_address;
    … …  
    109112        *irq_no = irq;
    110113
    111         rc = EOK;
    112 leave:
    113         async_hangup(parent_phone);
    114         return rc;
     114        return EOK;
    115115}
    116116/*----------------------------------------------------------------------------*/
    … …  
    120120 * @return Error code.
    121121 */
    122 int pci_enable_interrupts(ddf_dev_t *device)
     122int pci_enable_interrupts(const ddf_dev_t *device)
    123123{
    124         int parent_phone = devman_parent_device_connect(device->handle,
    125             IPC_FLAG_BLOCKING);
    126         bool enabled = hw_res_enable_interrupt(parent_phone);
     124        const int parent_phone =
     125            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
     126        if (parent_phone < 0) {
     127                return parent_phone;
     128        }
     129        const bool enabled = hw_res_enable_interrupt(parent_phone);
    127130        async_hangup(parent_phone);
    128131        return enabled ? EOK : EIO;
    … …  
    134137 * @return Error code.
    135138 */
    136 int pci_disable_legacy(ddf_dev_t *device)
     139int pci_disable_legacy(const ddf_dev_t *device)
    137140{
    138141        assert(device);
    139         int parent_phone =
     142        const int parent_phone =
    140143            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
    141144        if (parent_phone < 0) {
    … …  
    145148        /* See UHCI design guide for these values p.45,
    146149         * write all WC bits in USB legacy register */
    147         sysarg_t address = 0xc0;
    148         sysarg_t value = 0xaf00;
     150        const sysarg_t address = 0xc0;
     151        const sysarg_t value = 0xaf00;
    149152
    150         int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
     153        const int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
    151154            IPC_M_CONFIG_SPACE_WRITE_16, address, value);
    152155        async_hangup(parent_phone);

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

    rc9256c5 r1889786  
    3838#include <ddf/driver.h>
    3939
    40 int pci_get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
    41 int pci_enable_interrupts(ddf_dev_t *);
    42 int pci_disable_legacy(ddf_dev_t *);
     40int pci_get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
     41int pci_enable_interrupts(const ddf_dev_t *);
     42int pci_disable_legacy(const ddf_dev_t *);
    4343
    4444#endif

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

    rc9256c5 r1889786  
    6060                return ret;
    6161        }
     62        assert(match_str);
    6263
    6364        ret = ddf_fun_add_match_id(fun, match_str, 100);

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

    rc9256c5 r1889786  
    4343        /** List of resources available to the root hub. */
    4444        hw_resource_list_t resource_list;
    45         /** The only resource in the above list */
     45        /** The only resource in the RH resource list */
    4646        hw_resource_t io_regs;
    4747} rh_t;

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

    rc9256c5 r1889786  
    3636#include <arch/barrier.h>
    3737
     38
    3839#include "transfer_list.h"
     40#include "batch.h"
    3941
    4042static void transfer_list_remove_batch(
    … …  
    5860                return ENOMEM;
    5961        }
    60         uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
     62        const uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
    6163        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).\n",
    6264            name, instance->queue_head, queue_head_pa);
    … …  
    9092{
    9193        assert(instance);
     94        assert(instance->queue_head);
    9295        assert(next);
    93         if (!instance->queue_head)
    94                 return;
    9596        /* Set queue_head.next to point to the follower */
    9697        qh_set_next_qh(instance->queue_head, next->queue_head);
    … …  
    137138        write_barrier();
    138139
    139         /* Add to the driver list */
     140        /* Add to the driver's list */
    140141        list_append(&batch->link, &instance->batch_list);
    141142
    … …  
    160161        link_t *current = instance->batch_list.next;
    161162        while (current != &instance->batch_list) {
    162                 link_t *next = current->next;
     163                link_t * const next = current->next;
    163164                usb_transfer_batch_t *batch =
    164165                    usb_transfer_batch_from_link(current);
    … …  
    182183        fibril_mutex_lock(&instance->guard);
    183184        while (!list_empty(&instance->batch_list)) {
    184                 link_t *current = instance->batch_list.next;
     185                link_t * const current = instance->batch_list.next;
    185186                usb_transfer_batch_t *batch =
    186187                    usb_transfer_batch_from_link(current);

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

    rc9256c5 r1889786  
    3636
    3737#include <fibril_synch.h>
     38#include <usb/host/batch.h>
    3839
    39 #include "batch.h"
    4040#include "hw_struct/queue_head.h"
    4141

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

    rc9256c5 r1889786  
    7777{
    7878        assert(dev);
    79         hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
     79        uhci_t *uhci = dev->driver_data;
     80        assert(uhci);
     81        hc_t *hc = &uhci->hc;
    8082        uint16_t status = IPC_GET_ARG1(*call);
    8183        assert(hc);
    … …  
    144146{
    145147        assert(fun);
    146         return &((rh_t*)fun->driver_data)->resource_list;
     148        rh_t *rh = fun->driver_data;
     149        assert(rh);
     150        return &rh->resource_list;
    147151}
    148152/*----------------------------------------------------------------------------*/

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

    rc9256c5 r1889786  
    3535#ifndef DRV_UHCI_UHCI_H
    3636#define DRV_UHCI_UHCI_H
    37 #include <ddi.h>
    3837#include <ddf/driver.h>
    3938

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

    rc9256c5 r1889786  
    4141#include <as.h>
    4242
    43 #include "slab.h"
    44 
    4543#define UHCI_STRCUTURES_ALIGNMENT 16
    4644#define UHCI_REQUIRED_PAGE_SIZE 4096
    … …  
    5957        uintptr_t result;
    6058        const int ret = as_get_physical_mapping(addr, &result);
    61         assert(ret == EOK);
    62 
    6359        if (ret != EOK)
    6460                return 0;
    … …  
    7268 */
    7369static inline void * malloc32(size_t size) {
    74         if (size <= SLAB_ELEMENT_SIZE)
    75                 return slab_malloc_g();
    76         usb_log_warning("Requested %zu bytes, current allocator can't handle "
    77             "that amount, pray that the standard malloc will suffice.", size);
    78         return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
     70        /* This works only when the host has less than 4GB of memory as
     71         * physical address needs to fit into 32 bits */
     72
     73        /* If we need more than one page there is no guarantee that the
     74         * memory will be continuous */
     75        if (size > PAGE_SIZE)
     76                return NULL;
     77        /* Calculate alignment to make sure the block won't cross page
     78         * boundary */
     79        size_t alignment = UHCI_STRCUTURES_ALIGNMENT;
     80        while (alignment < size)
     81                alignment *= 2;
     82        return memalign(alignment, size);
    7983}
    8084/*----------------------------------------------------------------------------*/
    … …  
    8690        if (!addr)
    8791                return;
    88         if (slab_in_range_g(addr))
    89                 return slab_free_g(addr);
    9092        free(addr);
    9193}
    … …  
    98100{
    99101        void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
    100         assert(free_address); /* TODO: remove this assert */
    101102        if (free_address == 0)
    102103                return NULL;
Note: See TracChangeset for help on using the changeset viewer.