Changes in / [063ead6f:c20da9f] in mainline


Ignore:
Location:
uspace/drv
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/pciintel/pci.c

    r063ead6f rc20da9f  
    4949#include <ipc/devman.h>
    5050#include <ipc/dev_iface.h>
    51 #include <ipc/irc.h>
    52 #include <ipc/ns.h>
    53 #include <ipc/services.h>
    54 #include <sysinfo.h>
    5551#include <ops/hw_res.h>
    5652#include <device/hw_res.h>
    … …  
    7672static bool pciintel_enable_child_interrupt(device_t *dev)
    7773{
    78         /* This is an old ugly way, copied from ne2000 driver */
    79         assert(dev);
    80         pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
    81 
    82   sysarg_t apic;
    83   sysarg_t i8259;
    84         int irc_phone = -1;
    85         int irc_service = 0;
    86 
    87   if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) {
    88     irc_service = SERVICE_APIC;
    89         } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) {
    90     irc_service = SERVICE_I8259;
    91         }
    92 
    93   if (irc_service) {
    94     while (irc_phone < 0)
    95       irc_phone = service_connect_blocking(irc_service, 0, 0);
    96   } else {
    97                 return false;
    98         }
    99 
    100         size_t i;
    101   for (i = 0; i < dev_data->hw_resources.count; i++) {
    102                 if (dev_data->hw_resources.resources[i].type == INTERRUPT) {
    103                         int irq = dev_data->hw_resources.resources[i].res.interrupt.irq;
    104                         async_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, irq);
    105                 }
    106         }
    107 
    108         async_hangup(irc_phone);
    109         return true;
     74        /* TODO */
     75       
     76        return false;
    11077}
    11178

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

    r063ead6f rc20da9f  
    141141        usb_log_debug("Checking(%p) %d packet for completion.\n",
    142142            instance, instance->packets);
     143        /* This is just an ugly trick to support the old API */
    143144        instance->transfered_size = 0;
    144145        size_t i = 0;
    … …  
    156157                    transfer_descriptor_actual_size(&instance->tds[i]);
    157158        }
    158         /* This is just an ugly trick to support the old API */
    159159        instance->transfered_size -= instance->setup_size;
    160160        return true;
    … …  
    191191            0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
    192192
    193         instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
    194 
    195193        instance->next_step = batch_call_out_and_dispose;
    196194        batch_schedule(instance);
    … …  
    223221        transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
    224222            0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
    225 
    226         instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
    227223
    228224        instance->next_step = batch_call_in_and_dispose;
    … …  
    248244        }
    249245
    250         instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
    251 
    252246        instance->next_step = batch_call_in_and_dispose;
    253247        batch_schedule(instance);
    … …  
    274268        }
    275269
    276         instance->tds[i - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
    277 
    278270        instance->next_step = batch_call_out_and_dispose;
    279271        batch_schedule(instance);

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

    r063ead6f rc20da9f  
    3434#include <driver.h>
    3535#include <usb_iface.h>
    36 #include <usb/ddfiface.h>
    37 #include <device/hw_res.h>
    3836
    3937#include <errno.h>
    … …  
    4846#define NAME "uhci-hcd"
    4947
    50 static int uhci_add_device(device_t *device);
     48static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
     49{
     50        /* This shall be called only for the UHCI itself. */
     51        assert(dev->parent == NULL);
     52
     53        *handle = dev->handle;
     54        return EOK;
     55}
    5156
    5257static int usb_iface_get_address(device_t *dev, devman_handle_t handle,
    … …  
    7075}
    7176
    72 
    7377static usb_iface_t hc_usb_iface = {
    74         .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
     78        .get_hc_handle = usb_iface_get_hc_handle,
    7579        .get_address = usb_iface_get_address
    7680};
    77 /*----------------------------------------------------------------------------*/
     81
    7882static device_ops_t uhci_ops = {
    7983        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
    8084        .interfaces[USBHC_DEV_IFACE] = &uhci_iface
    8185};
    82 /*----------------------------------------------------------------------------*/
    83 static driver_ops_t uhci_driver_ops = {
    84         .add_device = uhci_add_device,
    85 };
    86 /*----------------------------------------------------------------------------*/
    87 static driver_t uhci_driver = {
    88         .name = NAME,
    89         .driver_ops = &uhci_driver_ops
    90 };
    91 /*----------------------------------------------------------------------------*/
    92 static void irq_handler(device_t *device, ipc_callid_t iid, ipc_call_t *call)
    93 {
    94         assert(device);
    95         uhci_t *hc = dev_to_uhci(device);
    96         uint16_t status = IPC_GET_ARG1(*call);
    97         assert(hc);
    98         uhci_interrupt(hc, status);
    99 }
    100 /*----------------------------------------------------------------------------*/
    101 #define CHECK_RET_RETURN(ret, message...) \
    102 if (ret != EOK) { \
    103         usb_log_error(message); \
    104         return ret; \
    105 }
    10686
    10787static int uhci_add_device(device_t *device)
    … …  
    11696        int irq;
    11797
    118         int ret =
    119             pci_get_my_registers(device, &io_reg_base, &io_reg_size, &irq);
     98        int rc = pci_get_my_registers(device,
     99            &io_reg_base, &io_reg_size, &irq);
    120100
    121         CHECK_RET_RETURN(ret,
    122             "Failed(%d) to get I/O addresses:.\n", ret, device->handle);
     101        if (rc != EOK) {
     102                usb_log_error("Failed(%d) to get I/O registers addresses for device:.\n",
     103                    rc, device->handle);
     104                return rc;
     105        }
     106
    123107        usb_log_info("I/O regs at 0x%X (size %zu), IRQ %d.\n",
    124108            io_reg_base, io_reg_size, irq);
    125109
    126         ret = pci_enable_interrupts(device);
    127         CHECK_RET_RETURN(ret, "Failed(%d) to get enable interrupts:\n", ret);
     110        uhci_t *uhci_hc = malloc(sizeof(uhci_t));
     111        if (!uhci_hc) {
     112                usb_log_error("Failed to allocaete memory for uhci hcd driver.\n");
     113                return ENOMEM;
     114        }
    128115
    129         uhci_t *uhci_hc = malloc(sizeof(uhci_t));
    130         ret = (uhci_hc != NULL) ? EOK : ENOMEM;
    131         CHECK_RET_RETURN(ret, "Failed to allocate memory for uhci hcd driver.\n");
    132 
    133         ret = uhci_init(uhci_hc, (void*)io_reg_base, io_reg_size);
     116        int ret = uhci_init(uhci_hc, (void*)io_reg_base, io_reg_size);
    134117        if (ret != EOK) {
    135118                usb_log_error("Failed to init uhci-hcd.\n");
    136                 free(uhci_hc);
    137119                return ret;
    138120        }
    139 
    140         ret = register_interrupt_handler(device, irq, irq_handler,
    141             &uhci_hc->interrupt_code);
    142         if (ret != EOK) {
    143                 usb_log_error("Failed to register interrupt handler.\n");
    144                 uhci_fini(uhci_hc);
    145                 free(uhci_hc);
    146                 return ret;
    147         }
    148 
    149121        device_t *rh;
    150122        ret = setup_root_hub(&rh, device);
     123
    151124        if (ret != EOK) {
    152125                usb_log_error("Failed to setup uhci root hub.\n");
    153                 uhci_fini(uhci_hc);
    154                 free(uhci_hc);
     126                /* TODO: destroy uhci here */
    155127                return ret;
    156128        }
    … …  
    159131        if (ret != EOK) {
    160132                usb_log_error("Failed to register root hub.\n");
    161                 uhci_fini(uhci_hc);
    162                 free(uhci_hc);
    163                 free(rh);
     133                /* TODO: destroy uhci here */
    164134                return ret;
    165135        }
    166136
    167137        device->driver_data = uhci_hc;
     138
    168139        return EOK;
    169140}
    170 /*----------------------------------------------------------------------------*/
     141
     142static driver_ops_t uhci_driver_ops = {
     143        .add_device = uhci_add_device,
     144};
     145
     146static driver_t uhci_driver = {
     147        .name = NAME,
     148        .driver_ops = &uhci_driver_ops
     149};
     150
    171151int main(int argc, char *argv[])
    172152{
    173         sleep(3);
    174         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
     153        /*
     154         * Do some global initializations.
     155         */
     156        sleep(5);
     157        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
    175158
    176159        return driver_main(&uhci_driver);

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

    r063ead6f rc20da9f  
    121121        return rc;
    122122}
    123 /*----------------------------------------------------------------------------*/
    124 int pci_enable_interrupts(device_t *device)
    125 {
    126         int parent_phone = devman_parent_device_connect(device->handle,
    127             IPC_FLAG_BLOCKING);
    128         bool enabled = hw_res_enable_interrupt(parent_phone);
    129         return enabled ? EOK : EIO;
    130 }
     123
    131124/**
    132125 * @}

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

    r063ead6f rc20da9f  
    3939
    4040int pci_get_my_registers(device_t *, uintptr_t *, size_t *, int *);
    41 int pci_enable_interrupts(device_t *device);
    4241
    4342#endif

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

    r063ead6f rc20da9f  
    111111        /* I'm the first one here */
    112112        if (batch->link.prev == &instance->batch_list) {
    113                 usb_log_debug("Removing batch %p was first, next element %x.\n",
     113                usb_log_debug("Removing tracer %p was first, next element %x.\n",
    114114                        batch, batch->qh->next_queue);
    115115                instance->queue_head->element = batch->qh->next_queue;
    116116        } else {
    117                 usb_log_debug("Removing batch %p was NOT first, next element %x.\n",
     117                usb_log_debug("Removing tracer %p was NOT first, next element %x.\n",
    118118                        batch, batch->qh->next_queue);
    119119                batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);

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

    r063ead6f rc20da9f  
    1110 pci/ven=8086&dev=7020
    2 10 pci/ven=8086&dev=7112
     2

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

    r063ead6f rc20da9f  
    3939
    4040#include "uhci.h"
    41 static irq_cmd_t uhci_cmds[] = {
    42         {
    43                 .cmd = CMD_PIO_READ_16,
    44                 .addr = (void*)0xc022,
    45                 .dstarg = 1
    46         },
    47         {
    48                 .cmd = CMD_PIO_WRITE_16,
    49                 .addr = (void*)0xc022,
    50                 .value = 0x1f
    51         },
    52         {
    53                 .cmd = CMD_ACCEPT
    54         }
    55 };
    5641
    5742static int uhci_init_transfer_lists(uhci_t *instance);
    58 static int uhci_init_mem_structures(uhci_t *instance);
    59 static void uhci_init_hw(uhci_t *instance);
    60 
    61 static int uhci_interrupt_emulator(void *arg);
     43static int uhci_clean_finished(void *arg);
    6244static int uhci_debug_checker(void *arg);
    63 
    6445static bool allowed_usb_packet(
    6546        bool low_speed, usb_transfer_type_t, size_t size);
    6647
    67 #define CHECK_RET_RETURN(ret, message...) \
     48int uhci_init(uhci_t *instance, void *regs, size_t reg_size)
     49{
     50#define CHECK_RET_RETURN(message...) \
    6851        if (ret != EOK) { \
    6952                usb_log_error(message); \
    … …  
    7154        } else (void) 0
    7255
    73 int uhci_init(uhci_t *instance, void *regs, size_t reg_size)
    74 {
    75         assert(reg_size >= sizeof(regs_t));
     56        /* init address keeper(libusb) */
     57        usb_address_keeping_init(&instance->address_manager, USB11_ADDRESS_MAX);
     58        usb_log_debug("Initialized address manager.\n");
    7659
    7760        /* allow access to hc control registers */
    7861        regs_t *io;
     62        assert(reg_size >= sizeof(regs_t));
    7963        int ret = pio_enable(regs, reg_size, (void**)&io);
    80         CHECK_RET_RETURN(ret, "Failed to gain access to registers at %p.\n", io);
     64        CHECK_RET_RETURN("Failed to gain access to registers at %p.\n", io);
    8165        instance->registers = io;
    8266        usb_log_debug("Device registers accessible.\n");
    8367
    84         ret = uhci_init_mem_structures(instance);
    85         CHECK_RET_RETURN(ret, "Failed to initialize memory structures.\n");
    86 
    87         uhci_init_hw(instance);
    88 
    89         instance->cleaner = fibril_create(uhci_interrupt_emulator, instance);
    90 //      fibril_add_ready(instance->cleaner);
    91 
    92         instance->debug_checker = fibril_create(uhci_debug_checker, instance);
    93         fibril_add_ready(instance->debug_checker);
    94 
    95         return EOK;
    96 }
    97 /*----------------------------------------------------------------------------*/
    98 void uhci_init_hw(uhci_t *instance)
    99 {
    100 
    101         /* set framelist pointer */
    102         const uint32_t pa = addr_to_phys(instance->frame_list);
    103         pio_write_32(&instance->registers->flbaseadd, pa);
    104 
    105         /* enable all interrupts, but resume interrupt */
    106         pio_write_16(&instance->registers->usbintr,
    107                   UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
    108 
    109         /* Start the hc with large(64B) packet FSBR */
    110         pio_write_16(&instance->registers->usbcmd,
    111             UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
    112         usb_log_debug("Started UHCI HC.\n");
    113 }
    114 /*----------------------------------------------------------------------------*/
    115 int uhci_init_mem_structures(uhci_t *instance)
    116 {
    117         assert(instance);
    118 
    119         /* init interrupt code */
    120         irq_cmd_t *interrupt_commands = malloc(sizeof(uhci_cmds));
    121         if (interrupt_commands == NULL) {
    122                 return ENOMEM;
    123         }
    124         memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
    125         interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
    126         interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
    127         instance->interrupt_code.cmds = interrupt_commands;
    128         instance->interrupt_code.cmdcount =
    129             sizeof(uhci_cmds) / sizeof(irq_cmd_t);
    130 
    13168        /* init transfer lists */
    132         int ret = uhci_init_transfer_lists(instance);
    133         CHECK_RET_RETURN(ret, "Failed to initialize transfer lists.\n");
    134         usb_log_debug("Initialized transfer lists.\n");
    135 
    136         /* frame list initialization */
     69        ret = uhci_init_transfer_lists(instance);
     70        CHECK_RET_RETURN("Failed to initialize transfer lists.\n");
     71        usb_log_debug("Transfer lists initialized.\n");
     72
     73
     74        usb_log_debug("Initializing frame list.\n");
    13775        instance->frame_list = get_page();
    13876        ret = instance ? EOK : ENOMEM;
    139         CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
    140         usb_log_debug("Initialized frame list.\n");
     77        CHECK_RET_RETURN("Failed to get frame list page.\n");
    14178
    14279        /* initialize all frames to point to the first queue head */
    … …  
    14986        }
    15087
    151         /* init address keeper(libusb) */
    152         usb_address_keeping_init(&instance->address_manager, USB11_ADDRESS_MAX);
    153         usb_log_debug("Initialized address manager.\n");
     88        const uintptr_t pa = (uintptr_t)addr_to_phys(instance->frame_list);
     89        pio_write_32(&instance->registers->flbaseadd, (uint32_t)pa);
     90
     91        list_initialize(&instance->batch_list);
     92        fibril_mutex_initialize(&instance->batch_list_mutex);
     93
     94        instance->cleaner = fibril_create(uhci_clean_finished, instance);
     95        fibril_add_ready(instance->cleaner);
     96
     97        instance->debug_checker = fibril_create(uhci_debug_checker, instance);
     98        fibril_add_ready(instance->debug_checker);
     99
     100        /* Start the hc with large(64B) packet FSBR */
     101        pio_write_16(&instance->registers->usbcmd,
     102            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET);
     103        usb_log_debug("Started UHCI HC.\n");
     104
     105        uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
     106        cmd |= UHCI_CMD_DEBUG;
     107        pio_write_16(&instance->registers->usbcmd, cmd);
    154108
    155109        return EOK;
    … …  
    160114        assert(instance);
    161115
    162         /* initialize TODO: check errors */
     116        /* initialize */
    163117        int ret;
    164118        ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
    … …  
    192146        instance->transfers[1][USB_TRANSFER_CONTROL] =
    193147          &instance->transfers_control_slow;
    194         instance->transfers[0][USB_TRANSFER_BULK] =
    195           &instance->transfers_bulk_full;
     148        instance->transfers[0][USB_TRANSFER_CONTROL] =
     149          &instance->transfers_control_full;
    196150
    197151        return EOK;
    … …  
    220174}
    221175/*----------------------------------------------------------------------------*/
    222 void uhci_interrupt(uhci_t *instance, uint16_t status)
    223 {
    224         assert(instance);
    225         if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
    226                 return;
    227         usb_log_debug("UHCI interrupt: %X.\n", status);
    228         transfer_list_check(&instance->transfers_interrupt);
    229         transfer_list_check(&instance->transfers_control_slow);
    230         transfer_list_check(&instance->transfers_control_full);
    231         transfer_list_check(&instance->transfers_bulk_full);
    232 }
    233 /*----------------------------------------------------------------------------*/
    234 int uhci_interrupt_emulator(void* arg)
    235 {
    236         usb_log_debug("Started interrupt emulator.\n");
     176int uhci_clean_finished(void* arg)
     177{
     178        usb_log_debug("Started cleaning fibril.\n");
    237179        uhci_t *instance = (uhci_t*)arg;
    238180        assert(instance);
    239181
    240182        while(1) {
    241                 uint16_t status = pio_read_16(&instance->registers->usbsts);
    242                 uhci_interrupt(instance, status);
     183                transfer_list_check(&instance->transfers_interrupt);
     184                transfer_list_check(&instance->transfers_control_slow);
     185                transfer_list_check(&instance->transfers_control_full);
     186                transfer_list_check(&instance->transfers_bulk_full);
    243187                async_usleep(UHCI_CLEANER_TIMEOUT);
    244188        }
    … …  
    251195        assert(instance);
    252196        while (1) {
    253                 const uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
    254                 const uint16_t sts = pio_read_16(&instance->registers->usbsts);
    255                 const uint16_t intr = pio_read_16(&instance->registers->usbintr);
    256                 usb_log_debug("Command: %X Status: %X Interrupts: %x\n",
    257                     cmd, sts, intr);
     197                uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
     198                uint16_t sts = pio_read_16(&instance->registers->usbsts);
     199                usb_log_debug("Command register: %X Status register: %X\n", cmd, sts);
    258200
    259201                uintptr_t frame_list = pio_read_32(&instance->registers->flbaseadd);
    260                 if (frame_list != addr_to_phys(instance->frame_list)) {
     202                if (frame_list != (uintptr_t)addr_to_phys(instance->frame_list)) {
    261203                        usb_log_debug("Framelist address: %p vs. %p.\n",
    262204                                frame_list, addr_to_phys(instance->frame_list));

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

    r063ead6f rc20da9f  
    6666
    6767        uint16_t usbintr;
    68 #define UHCI_INTR_SHORT_PACKET (1 << 3)
    69 #define UHCI_INTR_COMPLETE (1 << 2)
    70 #define UHCI_INTR_RESUME (1 << 1)
    71 #define UHCI_INTR_CRC (1 << 0)
    72 
    7368        uint16_t frnum;
    7469        uint32_t flbaseadd;
    … …  
    8681        link_pointer_t *frame_list;
    8782
     83        link_t batch_list;
     84        fibril_mutex_t batch_list_mutex;
     85
    8886        transfer_list_t transfers_bulk_full;
    8987        transfer_list_t transfers_control_full;
    … …  
    9290
    9391        transfer_list_t *transfers[2][4];
    94 
    95         irq_code_t interrupt_code;
    9692
    9793        fid_t cleaner;
    … …  
    10298int uhci_init(uhci_t *instance, void *regs, size_t reg_size);
    10399
    104 static inline void uhci_fini(uhci_t *instance) {};
     100int uhci_fini(uhci_t *device);
     101
     102int uhci_transfer(
     103  uhci_t *instance,
     104  device_t *dev,
     105  usb_target_t target,
     106  usb_transfer_type_t transfer_type,
     107        bool toggle,
     108  usb_packet_id pid,
     109        bool low_speed,
     110  void *buffer, size_t size,
     111  usbhc_iface_transfer_out_callback_t callback_out,
     112  usbhc_iface_transfer_in_callback_t callback_in,
     113  void *arg );
    105114
    106115int uhci_schedule(uhci_t *instance, batch_t *batch);
    107116
    108 void uhci_interrupt(uhci_t *instance, uint16_t status);
    109 
    110117static inline uhci_t * dev_to_uhci(device_t *dev)
    111118        { return (uhci_t*)dev->driver_data; }
    112 
    113119
    114120#endif
Note: See TracChangeset for help on using the changeset viewer.