Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b8100da in mainline


Ignore:
Timestamp:
2010-10-10T17:01:40Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
6c1315b
Parents:
b371844
Message:

Virtual USB device in separate library

The `usbvirt' library is intended to be a framework for creating
virtual USB devices.

So far, only the skeleton is ready.

Location:
uspace
Files:
7 added
9 edited
2 moved

Legend:

Unmodified
Added
Removed
  • uspace/Makefile

    rb371844 rb8100da  
    142142        LIBS += lib/pci
    143143        LIBS += lib/usb
     144        LIBS += lib/usbvirt
    144145endif
    145146
     
    147148        LIBS += lib/pci
    148149        LIBS += lib/usb
     150        LIBS += lib/usbvirt
    149151endif
    150152
  • uspace/Makefile.common

    rb371844 rb8100da  
    8888LIBPCI_PREFIX = $(LIB_PREFIX)/pci
    8989LIBUSB_PREFIX = $(LIB_PREFIX)/usb
     90LIBUSBVIRT_PREFIX = $(LIB_PREFIX)/usbvirt
    9091
    9192LIBSOCKET_PREFIX = $(LIB_PREFIX)/socket
  • uspace/app/virtusbkbd/Makefile

    rb371844 rb8100da  
    3131# (it is really annoying to write long names)
    3232BINARY = vuk
    33 LIBS = $(LIBUSB_PREFIX)/libusb.a
     33
     34LIBS = $(LIBUSB_PREFIX)/libusb.a $(LIBUSBVIRT_PREFIX)/libusbvirt.a
    3435EXTRA_CFLAGS = -I$(LIB_PREFIX)
     36
    3537SOURCES = \
    3638        virtusbkbd.c
  • uspace/app/virtusbkbd/virtusbkbd.c

    rb371844 rb8100da  
    4646
    4747#include <usb/hcd.h>
    48 #include <usb/virtdev.h>
     48#include <usbvirt/device.h>
     49#include <usbvirt/hub.h>
     50#include <usbvirt/ids.h>
    4951
    5052#define LOOPS 5
     
    5961        (printf("%s: %s" fmt "\n", NAME, _QUOTEME(cmd), __VA_ARGS__), cmd(__VA_ARGS__))
    6062
     63static int on_incoming_data(struct usbvirt_device *dev,
     64    usb_endpoint_t endpoint, void *buffer, size_t size)
     65{
     66        printf("%s: ignoring incomming data to endpoint %d\n", NAME, endpoint);
     67       
     68        return EOK;
     69}
     70
     71/** Keyboard callbacks.
     72 * We abuse the fact that static variables are zero-filled.
     73 */
     74static usbvirt_device_ops_t keyboard_ops = {
     75        .on_data = on_incoming_data
     76};
     77
     78/** Keyboard device.
     79 * Rest of the items will be initialized later.
     80 */
     81static usbvirt_device_t keyboard_dev = {
     82        .ops = &keyboard_ops,
     83        .device_id_ = USBVIRT_DEV_KEYBOARD_ID
     84};
     85
     86
    6187static void fibril_sleep(size_t sec)
    6288{
     
    6692}
    6793
    68 static void on_data_from_host(usb_endpoint_t endpoint, void *buffer, size_t len)
    69 {
    70         printf("%s: ignoring incomming data to endpoint %d\n", NAME, endpoint);
    71 }
    7294
    7395int main(int argc, char * argv[])
    7496{
    75         int vhcd_phone = usb_virtdev_connect(DEV_HCD_NAME,
    76             USB_VIRTDEV_KEYBOARD_ID, on_data_from_host);
    77        
    78         if (vhcd_phone < 0) {
     97        int rc = usbvirt_connect(&keyboard_dev, DEV_HCD_NAME);
     98        if (rc != EOK) {
    7999                printf("%s: Unable to start comunication with VHCD at usb://%s (%s).\n",
    80                     NAME, DEV_HCD_NAME, str_error(vhcd_phone));
    81                 return vhcd_phone;
     100                    NAME, DEV_HCD_NAME, str_error(rc));
     101                return rc;
    82102        }
    83        
    84        
    85103       
    86104        size_t i;
     
    94112               
    95113                printf("%s: Will send data to VHCD...\n", NAME);
    96                 int rc = usb_virtdev_data_to_host(vhcd_phone, 0, data, size);
     114                int rc = keyboard_dev.send_data(&keyboard_dev, 0, data, size);
    97115                printf("%s:   ...data sent (%s).\n", NAME, str_error(rc));
    98116        }
     
    101119        printf("%s: Terminating...\n", NAME);
    102120       
    103         ipc_hangup(vhcd_phone);
     121        usbvirt_disconnect();
    104122       
    105123        return 0;
  • uspace/lib/usb/Makefile

    rb371844 rb8100da  
    3131
    3232SOURCES = \
    33         hcd.c \
    34         virtdev.c
     33        hcd.c
    3534
    3635include $(USPACE_PREFIX)/Makefile.common
  • uspace/lib/usb/devreq.h

    rb371844 rb8100da  
    3131 */
    3232/** @file
    33  * @brief Virtual USB device.
     33 * @brief Standard USB device requests.
    3434 */
    35 #ifndef LIBUSB_VIRTDEV_H_
    36 #define LIBUSB_VIRTDEV_H_
     35#ifndef LIBUSB_DEVREQ_H_
     36#define LIBUSB_DEVREQ_H_
    3737
    3838#include <ipc/ipc.h>
    3939#include <async.h>
    40 #include "hcd.h"
    4140
    42 #define USB_VIRTDEV_KEYBOARD_ID 1
    43 #define USB_VIRTDEV_KEYBOARD_ADDRESS 1
     41/** Standard device request. */
     42typedef enum {
     43        USB_DEVREQ_GET_STATUS = 0,
     44        USB_DEVREQ_CLEAR_FEATURE = 1,
     45        USB_DEVREQ_SET_FEATURE = 3,
     46        USB_DEVREQ_SET_ADDRESS = 5,
     47        USB_DEVREQ_GET_DESCRIPTOR = 6,
     48        USB_DEVREQ_SET_DESCRIPTOR = 7,
     49        USB_DEVREQ_GET_CONFIGURATION = 8,
     50        USB_DEVREQ_SET_CONFIGURATION = 9,
     51        USB_DEVREQ_GET_INTERFACE = 10,
     52        USB_DEVREQ_SET_INTERFACE = 11,
     53        USB_DEVREQ_SYNCH_FRAME = 12
     54} usb_stddevreq_t;
    4455
    45 typedef void (*usb_virtdev_on_data_from_host_t)(usb_endpoint_t, void *, size_t);
    4656
    47 int usb_virtdev_connect(const char *, int, usb_virtdev_on_data_from_host_t);
    48 int usb_virtdev_data_to_host(int, usb_endpoint_t,
    49     void *, size_t);
    50 
    51 typedef enum {
    52         IPC_M_USB_VIRTDEV_DATA_TO_DEVICE = IPC_FIRST_USER_METHOD,
    53         IPC_M_USB_VIRTDEV_DATA_FROM_DEVICE
    54 } usb_virtdev_method_t;
    5557
    5658#endif
  • uspace/lib/usbvirt/main.c

    rb371844 rb8100da  
    2727 */
    2828
    29 /** @addtogroup libusb usb
     29/** @addtogroup libusbvirt usb
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief Virtual USB device (implementation).
     33 * @brief Main handler for virtual USB device.
    3434 */
    35 #include "virtdev.h"
    3635#include <devmap.h>
    3736#include <fcntl.h>
     
    4039#include <stdlib.h>
    4140
     41#include "hub.h"
     42#include "device.h"
     43#include "private.h"
     44
    4245#define NAMESPACE "usb"
    4346
    44 static usb_virtdev_on_data_from_host_t on_data_from_host = NULL;
     47usbvirt_device_t *device = NULL;
     48
    4549
    4650static void handle_data_to_device(ipc_callid_t iid, ipc_call_t icall)
     
    5963        }
    6064       
    61         on_data_from_host(endpoint, buffer, len);
     65        handle_incoming_data(endpoint, buffer, len);
    6266       
    6367        free(buffer);
     
    8084                                return;
    8185                       
    82                         case IPC_M_USB_VIRTDEV_DATA_TO_DEVICE:
     86                        case IPC_M_USBVIRT_DATA_TO_DEVICE:
    8387                                handle_data_to_device(callid, call);
    8488                                break;
     
    8993                }
    9094        }
     95}
     96
     97int usbvirt_data_to_host(struct usbvirt_device *dev,
     98    usb_endpoint_t endpoint, void *buffer, size_t size)
     99{
     100        int phone = dev->vhcd_phone_;
     101       
     102        if (phone < 0) {
     103                return EINVAL;
     104        }
     105        if ((buffer == NULL) || (size == 0)) {
     106                return EINVAL;
     107        }
     108
     109        ipc_call_t answer_data;
     110        ipcarg_t answer_rc;
     111        aid_t req;
     112        int rc;
     113       
     114        req = async_send_1(phone,
     115            IPC_M_USBVIRT_DATA_FROM_DEVICE,
     116            endpoint,
     117            &answer_data);
     118       
     119        rc = async_data_write_start(phone, buffer, size);
     120        if (rc != EOK) {
     121                async_wait_for(req, NULL);
     122                return rc;
     123        }
     124       
     125        async_wait_for(req, &answer_rc);
     126        rc = (int)answer_rc;
     127        if (rc != EOK) {
     128                return rc;
     129        }
     130       
     131        return EOK;
    91132}
    92133
     
    107148 * @param device_id Internal device identification (used by HCD).
    108149 * @param callback Handler for callbacks from HCD.
    109  * @return Phone for comunicating with HCD or error code from errno.h.
     150 * @return EOK on success or error code from errno.h.
    110151 */
    111 int usb_virtdev_connect(const char *hcd_path, int device_id,
    112     usb_virtdev_on_data_from_host_t callback)
     152int usbvirt_connect(usbvirt_device_t *dev, const char *hcd_path)
    113153{
    114154        char dev_path[DEVMAP_NAME_MAXLEN + 1];
     
    128168       
    129169        ipcarg_t phonehash;
    130         int rc = ipc_connect_to_me(hcd_phone, 1, device_id, 0, &phonehash);
    131         if (rc != EOK) {
    132                 return rc;
    133         }
    134         on_data_from_host = callback;
    135         async_new_connection(phonehash, 0, NULL, callback_connection);
    136        
    137         return hcd_phone;
    138 }
    139 
    140 int usb_virtdev_data_to_host(int phone,
    141     usb_endpoint_t endpoint,
    142     void * buffer, size_t size)
    143 {
    144         if (phone < 0) {
    145                 return EINVAL;
    146         }
    147         if ((buffer == NULL) || (size == 0)) {
    148                 return EINVAL;
    149         }
    150 
    151         ipc_call_t answer_data;
    152         ipcarg_t answer_rc;
    153         aid_t req;
    154         int rc;
    155        
    156         req = async_send_1(phone,
    157             IPC_M_USB_VIRTDEV_DATA_FROM_DEVICE,
    158             endpoint,
    159             &answer_data);
    160        
    161         rc = async_data_write_start(phone, buffer, size);
    162         if (rc != EOK) {
    163                 async_wait_for(req, NULL);
    164                 return rc;
    165         }
    166        
    167         async_wait_for(req, &answer_rc);
    168         rc = (int)answer_rc;
     170        int rc = ipc_connect_to_me(hcd_phone, 1, dev->device_id_, 0, &phonehash);
    169171        if (rc != EOK) {
    170172                return rc;
    171173        }
    172174       
     175        dev->vhcd_phone_ = hcd_phone;
     176        dev->send_data = usbvirt_data_to_host;
     177       
     178        device = dev;
     179       
     180        async_new_connection(phonehash, 0, NULL, callback_connection);
     181       
    173182        return EOK;
    174183}
     184
     185
     186int usbvirt_disconnect(void)
     187{
     188        ipc_hangup(device->vhcd_phone_);
     189       
     190        device = NULL;
     191       
     192        return EOK;
     193}
     194
    175195
    176196/**
  • uspace/srv/hw/bus/usb/hcd/virtual/conndev.c

    rb371844 rb8100da  
    3636#include <assert.h>
    3737#include <errno.h>
    38 #include <usb/virtdev.h>
     38#include <usbvirt/hub.h>
    3939
    4040#include "conn.h"
     
    101101                                break;
    102102                       
    103                         case IPC_M_USB_VIRTDEV_DATA_FROM_DEVICE:
     103                        case IPC_M_USBVIRT_DATA_FROM_DEVICE:
    104104                                handle_data_from_device(callid, call, dev);
    105105                                break;
  • uspace/srv/hw/bus/usb/hcd/virtual/devices.c

    rb371844 rb8100da  
    4343#include <str_error.h>
    4444
    45 #include <usb/virtdev.h>
     45#include <usbvirt/ids.h>
    4646
    4747#include "devices.h"
     
    6262        virtdev_connection_t * dev = NULL;
    6363        switch (id) {
    64                 case USB_VIRTDEV_KEYBOARD_ID:
     64                case USBVIRT_DEV_KEYBOARD_ID:
    6565                        dev = virtdev_add_device(
    66                             USB_VIRTDEV_KEYBOARD_ADDRESS, phone);
     66                            USBVIRT_DEV_KEYBOARD_ADDRESS, phone);
    6767                        break;
    6868                default:
  • uspace/srv/hw/bus/usb/hcd/virtual/hc.c

    rb371844 rb8100da  
    4343#include <str_error.h>
    4444
    45 #include <usb/virtdev.h>
     45#include <usbvirt/hub.h>
    4646
    4747#include "vhcd.h"
     
    155155                       
    156156                        req = async_send_2(dev->phone,
    157                             IPC_M_USB_VIRTDEV_DATA_TO_DEVICE,
     157                            IPC_M_USBVIRT_DATA_TO_DEVICE,
    158158                            transaction->target.endpoint,
    159159                            transaction->type,
  • uspace/srv/hw/bus/usb/hcd/virtual/hcd.c

    rb371844 rb8100da  
    4545
    4646#include <usb/hcd.h>
    47 #include <usb/virtdev.h>
    4847#include "vhcd.h"
    4948#include "hc.h"
Note: See TracChangeset for help on using the changeset viewer.