Changeset 84439d7 in mainline for uspace/drv


Ignore:
Timestamp:
2010-12-05T09:34:46Z (15 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
75732da
Parents:
56b962d (diff), 35537a7 (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:

Merge with development/

Location:
uspace/drv
Files:
7 added
13 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/isa/isa.c

    r56b962d r84439d7  
    493493        /* Add child devices. */
    494494        add_legacy_children(dev);
    495         printf(NAME ": finished the enumeration of legacy devices\n",
    496             dev->handle);
     495        printf(NAME ": finished the enumeration of legacy devices\n");
    497496
    498497        return EOK;

  • uspace/drv/ns8250/ns8250.c

    r56b962d r84439d7  
    276276        if (pio_enable((void *) data->io_addr, REG_COUNT,
    277277            (void **) &data->port)) {
    278                 printf(NAME ": error - cannot gain the port %lx for device "
     278                printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
    279279                    "%s.\n", data->io_addr, dev->name);
    280280                return false;

  • uspace/drv/pciintel/pci.c

    r56b962d r84439d7  
    323323        if (range_addr != 0) {
    324324                printf(NAME ": device %s : ", dev->name);
    325                 printf("address = %x", range_addr);
     325                printf("address = %" PRIx64, range_addr);
    326326                printf(", size = %x\n", range_size);
    327327        }
    … …  
    479479        }       
    480480       
    481         printf(NAME ": conf_addr = %x.\n",
     481        printf(NAME ": conf_addr = %" PRIx64 ".\n",
    482482            hw_resources.resources[0].res.io_range.address);
    483483       

  • uspace/drv/root/root.c

    r56b962d r84439d7  
    4545#include <ctype.h>
    4646#include <macros.h>
     47#include <inttypes.h>
    4748
    4849#include <driver.h>
    … …  
    180181static int root_add_device(device_t *dev)
    181182{
    182         printf(NAME ": root_add_device, device handle = %d\n", dev->handle);
     183        printf(NAME ": root_add_device, device handle=%" PRIun "\n",
     184            dev->handle);
    183185       
    184186        /* Register root device's children. */

  • uspace/drv/uhci/Makefile

    r56b962d r84439d7  
    3333
    3434SOURCES = \
    35         main.c
     35        main.c \
     36        transfers.c
    3637
    3738include $(USPACE_PREFIX)/Makefile.common

  • uspace/drv/uhci/main.c

    r56b962d r84439d7  
    2828#include <usb/hcdhubd.h>
    2929#include <errno.h>
     30#include "uhci.h"
    3031
    31 static int enqueue_transfer_out(usb_hc_device_t *hc,
    32     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    33     void *buffer, size_t size,
    34     usb_hcd_transfer_callback_out_t callback, void *arg)
    35 {
    36         printf("UHCI: transfer OUT [%d.%d (%s); %u]\n",
    37             dev->address, endpoint->endpoint,
    38             usb_str_transfer_type(endpoint->transfer_type),
    39             size);
    40         return ENOTSUP;
    41 }
    42 
    43 static int enqueue_transfer_setup(usb_hc_device_t *hc,
    44     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    45     void *buffer, size_t size,
    46     usb_hcd_transfer_callback_out_t callback, void *arg)
    47 {
    48         printf("UHCI: transfer SETUP [%d.%d (%s); %u]\n",
    49             dev->address, endpoint->endpoint,
    50             usb_str_transfer_type(endpoint->transfer_type),
    51             size);
    52         return ENOTSUP;
    53 }
    54 
    55 static int enqueue_transfer_in(usb_hc_device_t *hc,
    56     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    57     void *buffer, size_t size,
    58     usb_hcd_transfer_callback_in_t callback, void *arg)
    59 {
    60         printf("UHCI: transfer IN [%d.%d (%s); %u]\n",
    61             dev->address, endpoint->endpoint,
    62             usb_str_transfer_type(endpoint->transfer_type),
    63             size);
    64         return ENOTSUP;
    65 }
    66 
    67 static usb_hcd_transfer_ops_t uhci_transfer_ops = {
    68         .transfer_out = enqueue_transfer_out,
    69         .transfer_in = enqueue_transfer_in,
    70         .transfer_setup = enqueue_transfer_setup
     32static device_ops_t uhci_ops = {
     33        .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
    7134};
    7235
    73 static int uhci_add_hc(usb_hc_device_t *device)
     36static int uhci_add_device(device_t *device)
    7437{
    75         device->transfer_ops = &uhci_transfer_ops;
     38        device->ops = &uhci_ops;
    7639
    7740        /*
    7841         * We need to announce the presence of our root hub.
    79          * Commented out until the problem which causes the whole task to
    80          * block is solved.
    8142         */
    82         //usb_hcd_add_root_hub(device);
     43        usb_hcd_add_root_hub(device);
    8344
    8445        return EOK;
    8546}
    8647
    87 usb_hc_driver_t uhci_driver = {
    88         .name = "uhci",
    89         .add_hc = uhci_add_hc
     48static driver_ops_t uhci_driver_ops = {
     49        .add_device = uhci_add_device,
     50};
     51
     52static driver_t uhci_driver = {
     53        .name = NAME,
     54        .driver_ops = &uhci_driver_ops
    9055};
    9156
    … …  
    9560         * Do some global initializations.
    9661         */
     62        sleep(5);
    9763
    98         return usb_hcd_main(&uhci_driver);
     64        return driver_main(&uhci_driver);
    9965}

  • uspace/drv/uhci/uhci.ma

    r56b962d r84439d7  
    1110 pci/ven=8086&dev=7020
    2 10 usb&hc=uhci
    3 10 usb&hc=uhci&hub
     2

  • uspace/drv/usbhub/Makefile

    r56b962d r84439d7  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2010 Vojtech Horky
    43# All rights reserved.
    54#
    … …  
    2928
    3029USPACE_PREFIX = ../..
    31 BINARY = test_serial
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include
     32BINARY = usbhub
    3233
    3334SOURCES = \
    34         test_serial.c
     35        main.c \
     36        utils.c
    3537
    3638include $(USPACE_PREFIX)/Makefile.common

  • uspace/drv/usbkbd/usbkbd.ma

    r56b962d r84439d7  
    1110 usb&class=hid
     210 usb&hid

  • uspace/drv/vhc/Makefile

    r56b962d r84439d7  
    3939
    4040SOURCES = \
     41        addrmgm.c \
    4142        conndev.c \
    4243        connhost.c \

  • uspace/drv/vhc/conn.h

    r56b962d r84439d7  
    3838#include <usb/usb.h>
    3939#include <usb/hcdhubd.h>
     40#include <usbhc_iface.h>
    4041#include "vhcd.h"
    4142#include "devices.h"
    … …  
    4445
    4546usb_hcd_transfer_ops_t vhc_transfer_ops;
     47usbhc_iface_t vhc_iface;
     48
     49void address_init(void);
     50int reserve_default_address(device_t *);
     51int release_default_address(device_t *);
     52int request_address(device_t *, usb_address_t *);
     53int release_address(device_t *, usb_address_t);
     54int bind_address(device_t *, usb_address_t, devman_handle_t);
     55
     56int tell_address(device_t *, devman_handle_t, usb_address_t *);
    4657
    4758void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);

  • uspace/drv/vhc/connhost.c

    r56b962d r84439d7  
    4343typedef struct {
    4444        usb_direction_t direction;
    45         usb_hcd_transfer_callback_out_t out_callback;
    46         usb_hcd_transfer_callback_in_t in_callback;
    47         usb_hc_device_t *hc;
     45        usbhc_iface_transfer_out_callback_t out_callback;
     46        usbhc_iface_transfer_in_callback_t in_callback;
     47        device_t *dev;
    4848        void *arg;
    4949} transfer_info_t;
    … …  
    5656        switch (transfer->direction) {
    5757                case USB_DIRECTION_IN:
    58                         transfer->in_callback(transfer->hc,
     58                        transfer->in_callback(transfer->dev,
    5959                            size, outcome,
    6060                            transfer->arg);
    6161                        break;
    6262                case USB_DIRECTION_OUT:
    63                         transfer->out_callback(transfer->hc,
     63                        transfer->out_callback(transfer->dev,
    6464                            outcome,
    6565                            transfer->arg);
    … …  
    7373}
    7474
    75 static transfer_info_t *create_transfer_info(usb_hc_device_t *hc,
     75static transfer_info_t *create_transfer_info(device_t *dev,
    7676    usb_direction_t direction, void *arg)
    7777{
    … …  
    8282        transfer->out_callback = NULL;
    8383        transfer->arg = arg;
    84         transfer->hc = hc;
     84        transfer->dev = dev;
    8585
    8686        return transfer;
    8787}
    8888
    89 static int enqueue_transfer_out(usb_hc_device_t *hc,
    90     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     89static int enqueue_transfer_out(device_t *dev,
     90    usb_target_t target, usb_transfer_type_t transfer_type,
    9191    void *buffer, size_t size,
    92     usb_hcd_transfer_callback_out_t callback, void *arg)
     92    usbhc_iface_transfer_out_callback_t callback, void *arg)
    9393{
    9494        printf(NAME ": transfer OUT [%d.%d (%s); %u]\n",
    95             dev->address, endpoint->endpoint,
    96             usb_str_transfer_type(endpoint->transfer_type),
     95            target.address, target.endpoint,
     96            usb_str_transfer_type(transfer_type),
    9797            size);
    9898
    9999        transfer_info_t *transfer
    100             = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
     100            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
    101101        transfer->out_callback = callback;
    102 
    103         usb_target_t target = {
    104                 .address = dev->address,
    105                 .endpoint = endpoint->endpoint
    106         };
    107102
    108103        hc_add_transaction_to_device(false, target, buffer, size,
    … …  
    112107}
    113108
    114 static int enqueue_transfer_setup(usb_hc_device_t *hc,
    115     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     109static int enqueue_transfer_setup(device_t *dev,
     110    usb_target_t target, usb_transfer_type_t transfer_type,
    116111    void *buffer, size_t size,
    117     usb_hcd_transfer_callback_out_t callback, void *arg)
     112    usbhc_iface_transfer_out_callback_t callback, void *arg)
    118113{
    119114        printf(NAME ": transfer SETUP [%d.%d (%s); %u]\n",
    120             dev->address, endpoint->endpoint,
    121             usb_str_transfer_type(endpoint->transfer_type),
     115            target.address, target.endpoint,
     116            usb_str_transfer_type(transfer_type),
    122117            size);
    123118
    124119        transfer_info_t *transfer
    125             = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
     120            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
    126121        transfer->out_callback = callback;
    127 
    128         usb_target_t target = {
    129                 .address = dev->address,
    130                 .endpoint = endpoint->endpoint
    131         };
    132122
    133123        hc_add_transaction_to_device(true, target, buffer, size,
    … …  
    137127}
    138128
    139 static int enqueue_transfer_in(usb_hc_device_t *hc,
    140     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     129static int enqueue_transfer_in(device_t *dev,
     130    usb_target_t target, usb_transfer_type_t transfer_type,
    141131    void *buffer, size_t size,
    142     usb_hcd_transfer_callback_in_t callback, void *arg)
     132    usbhc_iface_transfer_in_callback_t callback, void *arg)
    143133{
    144134        printf(NAME ": transfer IN [%d.%d (%s); %u]\n",
    145             dev->address, endpoint->endpoint,
    146             usb_str_transfer_type(endpoint->transfer_type),
     135            target.address, target.endpoint,
     136            usb_str_transfer_type(transfer_type),
    147137            size);
    148138
    149139        transfer_info_t *transfer
    150             = create_transfer_info(hc, USB_DIRECTION_IN, arg);
     140            = create_transfer_info(dev, USB_DIRECTION_IN, arg);
    151141        transfer->in_callback = callback;
    152 
    153         usb_target_t target = {
    154                 .address = dev->address,
    155                 .endpoint = endpoint->endpoint
    156         };
    157142
    158143        hc_add_transaction_from_device(target, buffer, size,
    … …  
    163148
    164149
    165 usb_hcd_transfer_ops_t vhc_transfer_ops = {
    166         .transfer_out = enqueue_transfer_out,
    167         .transfer_in = enqueue_transfer_in,
    168         .transfer_setup = enqueue_transfer_setup
     150static int interrupt_out(device_t *dev, usb_target_t target,
     151    void *data, size_t size,
     152    usbhc_iface_transfer_out_callback_t callback, void *arg)
     153{
     154        return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
     155            data, size,
     156            callback, arg);
     157}
     158
     159static int interrupt_in(device_t *dev, usb_target_t target,
     160    void *data, size_t size,
     161    usbhc_iface_transfer_in_callback_t callback, void *arg)
     162{
     163        return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
     164            data, size,
     165            callback, arg);
     166}
     167
     168static int control_write_setup(device_t *dev, usb_target_t target,
     169    void *data, size_t size,
     170    usbhc_iface_transfer_out_callback_t callback, void *arg)
     171{
     172        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
     173            data, size,
     174            callback, arg);
     175}
     176
     177static int control_write_data(device_t *dev, usb_target_t target,
     178    void *data, size_t size,
     179    usbhc_iface_transfer_out_callback_t callback, void *arg)
     180{
     181        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
     182            data, size,
     183            callback, arg);
     184}
     185
     186static int control_write_status(device_t *dev, usb_target_t target,
     187    usbhc_iface_transfer_in_callback_t callback, void *arg)
     188{
     189        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
     190            NULL, 0,
     191            callback, arg);
     192}
     193
     194static int control_read_setup(device_t *dev, usb_target_t target,
     195    void *data, size_t size,
     196    usbhc_iface_transfer_out_callback_t callback, void *arg)
     197{
     198        return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
     199            data, size,
     200            callback, arg);
     201}
     202
     203static int control_read_data(device_t *dev, usb_target_t target,
     204    void *data, size_t size,
     205    usbhc_iface_transfer_in_callback_t callback, void *arg)
     206{
     207        return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
     208            data, size,
     209            callback, arg);
     210}
     211
     212static int control_read_status(device_t *dev, usb_target_t target,
     213    usbhc_iface_transfer_out_callback_t callback, void *arg)
     214{
     215        return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
     216            NULL, 0,
     217            callback, arg);
     218}
     219
     220
     221usbhc_iface_t vhc_iface = {
     222        .tell_address = tell_address,
     223
     224        .reserve_default_address = reserve_default_address,
     225        .release_default_address = release_default_address,
     226        .request_address = request_address,
     227        .bind_address = bind_address,
     228        .release_address = release_address,
     229
     230        .interrupt_out = interrupt_out,
     231        .interrupt_in = interrupt_in,
     232
     233        .control_write_setup = control_write_setup,
     234        .control_write_data = control_write_data,
     235        .control_write_status = control_write_status,
     236
     237        .control_read_setup = control_read_setup,
     238        .control_read_data = control_read_data,
     239        .control_read_status = control_read_status
    169240};
    170241

  • uspace/drv/vhc/hcd.c

    r56b962d r84439d7  
    5252#include "conn.h"
    5353
     54static device_ops_t vhc_ops = {
     55        .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
     56        .default_handler = default_connection_handler
     57};
    5458
    5559static int vhc_count = 0;
    56 static int vhc_add_device(usb_hc_device_t *dev)
     60static int vhc_add_device(device_t *dev)
    5761{
    5862        /*
    … …  
    6569        vhc_count++;
    6670
    67         dev->transfer_ops = &vhc_transfer_ops;
    68         dev->generic->ops->default_handler = default_connection_handler;
     71        dev->ops = &vhc_ops;
     72
     73        /*
     74         * Initialize address management.
     75         */
     76        address_init();
    6977
    7078        /*
    … …  
    7987}
    8088
    81 static usb_hc_driver_t vhc_driver = {
     89static driver_ops_t vhc_driver_ops = {
     90        .add_device = vhc_add_device,
     91};
     92
     93static driver_t vhc_driver = {
    8294        .name = NAME,
    83         .add_hc = &vhc_add_device
     95        .driver_ops = &vhc_driver_ops
    8496};
    8597
    … …  
    114126        sleep(4);
    115127
    116         return usb_hcd_main(&vhc_driver);
     128        return driver_main(&vhc_driver);
    117129}
    118130

  • uspace/drv/vhc/vhc.ma

    r56b962d r84439d7  
    1110 usb&hc=vhc
    2 10 usb&hc=vhc&hub
     2
Note: See TracChangeset for help on using the changeset viewer.