Changeset c280d7e in mainline


Ignore:
Timestamp:
2018-01-20T03:02:36Z (7 years ago)
Author:
Ondřej Hlavatý <aearsis@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
60d3f35
Parents:
3cdaa7f
git-author:
Ondřej Hlavatý <aearsis@…> (2018-01-20 03:02:32)
git-committer:
Ondřej Hlavatý <aearsis@…> (2018-01-20 03:02:36)
Message:

libdrv: usb iface callbacks joined

In addition to handle and current interface, it is good for the device
to know its address and speed. Also, it is expected to add some other
fields (stats, info tied to devices of specific speed and so on) in the
future. Instead of adding yet another call, join those two and let HC
fill a description structure.

Location:
uspace
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/usb/usbmid/usbmid.c

    r3cdaa7f rc280d7e  
    4545#include "usbmid.h"
    4646
    47 /** Get USB device handle by calling the parent usb_device_t.
     47/**
     48 * Get USB device description by calling HC and altering the interface field.
    4849 *
    4950 * @param[in] fun Device function the operation is running on.
    50  * @param[out] handle Device handle.
     51 * @param[out] desc Device descriptor.
    5152 * @return Error code.
    5253 */
    53 static int usb_iface_device_handle(ddf_fun_t *fun, devman_handle_t *handle)
    54 {
    55         assert(fun);
    56         assert(handle);
    57         usb_device_t *usb_dev = usb_device_get(ddf_fun_get_dev(fun));
    58         *handle = usb_device_get_devman_handle(usb_dev);
    59         return EOK;
    60 }
    61 
    62 /** Callback for DDF USB get interface. */
    63 static int usb_iface_iface_no(ddf_fun_t *fun, int *iface_no)
     54static int usb_iface_description(ddf_fun_t *fun, usb_device_desc_t *desc)
    6455{
    6556        usbmid_interface_t *iface = ddf_fun_data_get(fun);
    6657        assert(iface);
     58        usb_device_t *usb_dev = ddf_dev_data_get(ddf_fun_get_dev(fun));
     59        assert(usb_dev);
    6760
    68         if (iface_no)
    69                 *iface_no = iface->interface_no;
     61        async_exch_t *exch = usb_device_bus_exchange_begin(usb_dev);
     62        if (!exch)
     63                return EPARTY;
     64
     65        usb_device_desc_t tmp_desc;
     66        const int ret = usb_get_my_description(exch, &tmp_desc);
     67
     68        if (ret == EOK && desc) {
     69                *desc = tmp_desc;
     70                desc->iface = iface->interface_no;
     71        }
    7072
    7173        return EOK;
    … …  
    7476/** DDF interface of the child - USB functions. */
    7577static usb_iface_t child_usb_iface = {
    76         .get_my_device_handle = usb_iface_device_handle,
    77         .get_my_interface = usb_iface_iface_no,
     78        .get_my_description = usb_iface_description,
    7879};
    7980

  • uspace/lib/drv/generic/remote_usb.c

    r3cdaa7f rc280d7e  
    6161
    6262typedef enum {
    63         IPC_M_USB_GET_MY_INTERFACE,
    64         IPC_M_USB_GET_MY_DEVICE_HANDLE,
     63        IPC_M_USB_GET_MY_DESCRIPTION,
    6564} usb_iface_funcs_t;
    6665
    … …  
    7170 * @return Error code.
    7271 */
    73 int usb_get_my_interface(async_exch_t *exch, int *usb_iface)
     72int usb_get_my_description(async_exch_t *exch, usb_device_desc_t *desc)
    7473{
    7574        if (!exch)
    7675                return EBADMEM;
    77         sysarg_t iface_no;
    78         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    79             IPC_M_USB_GET_MY_INTERFACE, &iface_no);
    80         if (ret == EOK && usb_iface)
    81                 *usb_iface = (int)iface_no;
     76
     77        usb_device_desc_t tmp_desc;
     78
     79        const int ret = async_req_1_4(exch, DEV_IFACE_ID(USB_DEV_IFACE),
     80            IPC_M_USB_GET_MY_DESCRIPTION,
     81            (sysarg_t *) &tmp_desc.address,
     82            (sysarg_t *) &tmp_desc.speed,
     83            &tmp_desc.handle,
     84            (sysarg_t *) &tmp_desc.iface);
     85        if (ret == EOK && desc)
     86                *desc = tmp_desc;
    8287        return ret;
    8388}
    8489
    85 /** Tell devman handle of the usb device function.
    86  *
    87  * @param[in]  exch   IPC communication exchange
    88  * @param[out] handle devman handle of the HC used by the target device.
    89  *
    90  * @return Error code.
    91  *
    92  */
    93 int usb_get_my_device_handle(async_exch_t *exch, devman_handle_t *handle)
    94 {
    95         devman_handle_t h = 0;
    96         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    97             IPC_M_USB_GET_MY_DEVICE_HANDLE, &h);
    98         if (ret == EOK && handle)
    99                 *handle = (devman_handle_t)h;
    100         return ret;
    101 }
    102 
    103 static void remote_usb_get_my_interface(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    104 static void remote_usb_get_my_device_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     90static void remote_usb_get_my_description(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    10591
    10692/** Remote USB interface operations. */
    10793static const remote_iface_func_ptr_t remote_usb_iface_ops [] = {
    108         [IPC_M_USB_GET_MY_INTERFACE] = remote_usb_get_my_interface,
    109         [IPC_M_USB_GET_MY_DEVICE_HANDLE] = remote_usb_get_my_device_handle,
     94        [IPC_M_USB_GET_MY_DESCRIPTION] = remote_usb_get_my_description,
    11095};
    11196
    … …  
    117102};
    118103
    119 void remote_usb_get_my_interface(ddf_fun_t *fun, void *iface,
     104void remote_usb_get_my_description(ddf_fun_t *fun, void *iface,
    120105    ipc_callid_t callid, ipc_call_t *call)
    121106{
    122107        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
    123108
    124         if (usb_iface->get_my_interface == NULL) {
     109        if (usb_iface->get_my_description == NULL) {
    125110                async_answer_0(callid, ENOTSUP);
    126111                return;
    127112        }
    128113
    129         int iface_no;
    130         const int ret = usb_iface->get_my_interface(fun, &iface_no);
     114        usb_device_desc_t desc;
     115        const int ret = usb_iface->get_my_description(fun, &desc);
    131116        if (ret != EOK) {
    132117                async_answer_0(callid, ret);
    133118        } else {
    134                 async_answer_1(callid, EOK, iface_no);
     119                async_answer_4(callid, EOK,
     120                    (sysarg_t) desc.address,
     121                    (sysarg_t) desc.speed,
     122                    desc.handle,
     123                    desc.iface);
    135124        }
    136 }
    137 
    138 void remote_usb_get_my_device_handle(ddf_fun_t *fun, void *iface,
    139     ipc_callid_t callid, ipc_call_t *call)
    140 {
    141         const usb_iface_t *usb_iface = (usb_iface_t *) iface;
    142 
    143         if (usb_iface->get_my_device_handle == NULL) {
    144                 async_answer_0(callid, ENOTSUP);
    145                 return;
    146         }
    147 
    148         devman_handle_t handle;
    149         const int ret = usb_iface->get_my_device_handle(fun, &handle);
    150         if (ret != EOK) {
    151                 async_answer_0(callid, ret);
    152         }
    153 
    154         async_answer_1(callid, EOK, (sysarg_t) handle);
    155125}
    156126

  • uspace/lib/drv/include/usb_iface.h

    r3cdaa7f rc280d7e  
    4040#include "ddf/driver.h"
    4141#include <async.h>
     42#include <usbhc_iface.h>
    4243
    4344typedef async_sess_t usb_dev_session_t;
     45
     46typedef struct {
     47        usb_address_t address;
     48        usb_speed_t speed;
     49        devman_handle_t handle;
     50        int iface;
     51} usb_device_desc_t;
    4452
    4553extern usb_dev_session_t *usb_dev_connect(devman_handle_t);
    … …  
    4755extern void usb_dev_disconnect(usb_dev_session_t *);
    4856
    49 extern int usb_get_my_interface(async_exch_t *, int *);
    50 extern int usb_get_my_device_handle(async_exch_t *, devman_handle_t *);
     57extern int usb_get_my_description(async_exch_t *, usb_device_desc_t *);
    5158
    5259/** USB device communication interface. */
    5360typedef struct {
    54         int (*get_my_interface)(ddf_fun_t *, int *);
    55         int (*get_my_device_handle)(ddf_fun_t *, devman_handle_t *);
     61        int (*get_my_description)(ddf_fun_t *, usb_device_desc_t *);
    5662} usb_iface_t;
    5763

  • uspace/lib/usbdev/src/devdrv.c

    r3cdaa7f rc280d7e  
    7373        /** Number of other endpoint pipes. */
    7474        size_t pipes_count;
     75
     76        /** USB address of this device */
     77        usb_address_t address;
     78
     79        /** USB speed of this device */
     80        usb_speed_t speed;
    7581
    7682        /** Current interface.
    … …  
    414420 */
    415421static int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
    416     const usb_endpoint_description_t **endpoints, const char **errstr_ptr,
    417     devman_handle_t handle, int interface_no)
     422    const usb_endpoint_description_t **endpoints, const char **errstr_ptr)
    418423{
    419424        assert(usb_dev != NULL);
    … …  
    423428
    424429        usb_dev->ddf_dev = ddf_dev;
    425         usb_dev->handle = handle;
    426         usb_dev->interface_no = interface_no;
    427430        usb_dev->driver_data = NULL;
    428431        usb_dev->descriptors.full_config = NULL;
    … …  
    431434        usb_dev->pipes = NULL;
    432435
    433         usb_dev->bus_session = usb_dev_connect(handle);
     436        usb_dev->bus_session = usb_dev_connect(usb_dev->handle);
    434437
    435438        if (!usb_dev->bus_session) {
    … …  
    476479}
    477480
    478 static int usb_device_get_info(async_sess_t *sess, devman_handle_t *handle,
    479         int *iface_no)
    480 {
    481         assert(handle);
    482         assert(iface_no);
     481static int usb_device_get_info(async_sess_t *sess, usb_device_t *dev)
     482{
     483        assert(dev);
    483484
    484485        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    486487                return EPARTY;
    487488
    488         int ret = usb_get_my_device_handle(exch, handle);
     489        usb_device_desc_t dev_desc;
     490        const int ret = usb_get_my_description(exch, &dev_desc);
     491
    489492        if (ret == EOK) {
    490                 ret = usb_get_my_interface(exch, iface_no);
    491                 if (ret == ENOTSUP) {
    492                         *iface_no = -1;
    493                         ret = EOK;
    494                 }
     493                dev->address = dev_desc.address;
     494                dev->speed = dev_desc.speed;
     495                dev->handle = dev_desc.handle;
     496                dev->interface_no = dev_desc.iface;
    495497        }
    496498
    … …  
    504506        assert(ddf_dev);
    505507        assert(err);
    506 
    507         devman_handle_t h = 0;
    508         int iface_no = -1;
    509508
    510509        async_sess_t *sess = ddf_dev_parent_sess_get(ddf_dev);
    511510        if (sess == NULL)
    512511                return ENOMEM;
    513         const int ret = usb_device_get_info(sess, &h, &iface_no);
    514         if (ret != EOK)
    515                 return ret;
    516512
    517513        usb_device_t *usb_dev =
    … …  
    522518        }
    523519
    524         return usb_device_init(usb_dev, ddf_dev, desc, err, h, iface_no);
     520        const int ret = usb_device_get_info(sess, usb_dev);
     521        if (ret != EOK)
     522                return ret;
     523
     524        return usb_device_init(usb_dev, ddf_dev, desc, err);
    525525}
    526526
    … …  
    536536usb_device_t * usb_device_create(devman_handle_t handle)
    537537{
    538         devman_handle_t h = 0;
    539         int iface_no = -1;
     538        usb_device_t *usb_dev = malloc(sizeof(usb_device_t));
     539        if (!usb_dev)
     540                return NULL;
    540541
    541542        async_sess_t *sess = devman_device_connect(handle, IPC_FLAG_BLOCKING);
    542         int ret = usb_device_get_info(sess, &h, &iface_no);
     543        int ret = usb_device_get_info(sess, usb_dev);
    543544        if (sess)
    544545                async_hangup(sess);
    … …  
    546547                return NULL;
    547548
    548         usb_device_t *usb_dev = malloc(sizeof(usb_device_t));
    549         if (!usb_dev)
    550                 return NULL;
    551 
    552549        const char* dummy = NULL;
    553         ret = usb_device_init(usb_dev, NULL, NULL, &dummy, handle, iface_no);
     550        ret = usb_device_init(usb_dev, NULL, NULL, &dummy);
    554551        if (ret != EOK) {
    555552                free(usb_dev);

  • uspace/lib/usbdev/src/pipes.c

    r3cdaa7f rc280d7e  
    248248 */
    249249static int usb_isoch_session_initialize(usb_pipe_t *pipe) {
    250         devman_handle_t handle;
    251 
    252         async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    253         if (!exch)
    254                 return EPARTY;
    255 
    256         int ret = usb_get_my_device_handle(exch, &handle);
    257 
    258         async_exchange_end(exch);
    259         if (ret != EOK)
    260                 return ret;
    261 
    262         pipe->isoch_session = usb_dev_connect(handle);
    263         if (!pipe->isoch_session)
    264                 return ENAK;
    265 
     250
     251        /*
     252         * XXX: As parallel exhanges are implemented by using parallel sessions,
     253         * it is safe to just take the same session. Once this won't be true,
     254         * just use session cloning to clone the bus session.
     255         */
     256        pipe->isoch_session = pipe->bus_session;
    266257        return EOK;
    267258}

  • uspace/lib/usbhost/src/ddf_helpers.c

    r3cdaa7f rc280d7e  
    224224}
    225225
    226 /** Gets handle of the respective device.
     226/**
     227 * Gets description of the device that is calling.
    227228 *
    228229 * @param[in] fun Device function.
    229  * @param[out] handle Place to write the handle.
     230 * @param[out] desc Device descriptor to be filled.
    230231 * @return Error code.
    231232 */
    232 static int get_my_device_handle(ddf_fun_t *fun, devman_handle_t *handle)
    233 {
    234         assert(fun);
    235         if (handle)
    236                 *handle = ddf_fun_get_handle(fun);
     233static int get_device_description(ddf_fun_t *fun, usb_device_desc_t *desc)
     234{
     235        assert(fun);
     236        device_t *dev = ddf_fun_data_get(fun);
     237        assert(dev);
     238
     239        if (!desc)
     240                return EOK;
     241
     242        *desc = (usb_device_desc_t) {
     243                .address = dev->address,
     244                .speed = dev->speed,
     245                .handle = ddf_fun_get_handle(fun),
     246                .iface = -1,
     247        };
    237248        return EOK;
    238249}
    … …  
    290301/** USB device interface */
    291302static usb_iface_t usb_iface = {
    292         .get_my_device_handle = get_my_device_handle,
     303        .get_my_description = get_device_description,
    293304};
    294305
Note: See TracChangeset for help on using the changeset viewer.