Changeset 50ba203 in mainline for uspace/drv/uhci-hcd/iface.c


Ignore:
Timestamp:
2011-02-20T15:46:48Z (14 years ago)
Author:
Matus Dekanek <smekideki@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6bb83c7
Parents:
d81ef61c (diff), 0c00dac (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 usb/development

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rd81ef61c r50ba203  
    5454}
    5555/*----------------------------------------------------------------------------*/
    56 static int reserve_default_address(device_t *dev)
     56static int reserve_default_address(device_t *dev, bool full_speed)
    5757{
    5858        assert(dev);
    … …  
    7272}
    7373/*----------------------------------------------------------------------------*/
    74 static int request_address(device_t *dev, usb_address_t *address)
     74static int request_address(device_t *dev, bool full_speed,
     75    usb_address_t *address)
    7576{
    7677        assert(dev);
    … …  
    103104/*----------------------------------------------------------------------------*/
    104105static int interrupt_out(device_t *dev, usb_target_t target,
    105     void *data, size_t size,
    106     usbhc_iface_transfer_out_callback_t callback, void *arg)
     106    size_t max_packet_size,
     107    void *data, size_t size,
     108    usbhc_iface_transfer_out_callback_t callback, void *arg)
     109{
     110        dev_speed_t speed = FULL_SPEED;
     111
     112        batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
     113            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
     114        if (!batch)
     115                return ENOMEM;
     116        batch_interrupt_out(batch);
     117        return EOK;
     118}
     119/*----------------------------------------------------------------------------*/
     120static int interrupt_in(device_t *dev, usb_target_t target,
     121    size_t max_packet_size,
     122    void *data, size_t size,
     123    usbhc_iface_transfer_in_callback_t callback, void *arg)
     124{
     125        dev_speed_t speed = FULL_SPEED;
     126
     127        batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
     128            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
     129        if (!batch)
     130                return ENOMEM;
     131        batch_interrupt_in(batch);
     132        return EOK;
     133}
     134/*----------------------------------------------------------------------------*/
     135static int control_write(device_t *dev, usb_target_t target,
     136    size_t max_packet_size,
     137    void *setup_data, size_t setup_size, void *data, size_t size,
     138    usbhc_iface_transfer_out_callback_t callback, void *arg)
     139{
     140        dev_speed_t speed = FULL_SPEED;
     141
     142        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     143            max_packet_size, speed, data, size, setup_data, setup_size,
     144            NULL, callback, arg);
     145        if (!batch)
     146                return ENOMEM;
     147        batch_control_write(batch);
     148        return EOK;
     149}
     150/*----------------------------------------------------------------------------*/
     151static int control_read(device_t *dev, usb_target_t target,
     152    size_t max_packet_size,
     153    void *setup_data, size_t setup_size, void *data, size_t size,
     154    usbhc_iface_transfer_in_callback_t callback, void *arg)
     155{
     156        dev_speed_t speed = FULL_SPEED;
     157
     158        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     159            max_packet_size, speed, data, size, setup_data, setup_size, callback,
     160            NULL, arg);
     161        if (!batch)
     162                return ENOMEM;
     163        batch_control_read(batch);
     164        return EOK;
     165}
     166/*----------------------------------------------------------------------------*/
     167static int control_write_setup(device_t *dev, usb_target_t target,
     168    size_t max_packet_size,
     169    void *data, size_t size,
     170    usbhc_iface_transfer_out_callback_t callback, void *arg)
     171{
     172        dev_speed_t speed = FULL_SPEED;
     173
     174        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     175        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     176            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
     177        if (!batch)
     178                return ENOMEM;
     179        batch_control_setup_old(batch);
     180        return EOK;
     181}
     182/*----------------------------------------------------------------------------*/
     183static int control_write_data(device_t *dev, usb_target_t target,
     184    size_t max_packet_size,
     185    void *data, size_t size,
     186    usbhc_iface_transfer_out_callback_t callback, void *arg)
     187{
     188        dev_speed_t speed = FULL_SPEED;
     189
     190        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     191        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     192            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
     193        if (!batch)
     194                return ENOMEM;
     195        batch_control_write_data_old(batch);
     196        return EOK;
     197}
     198/*----------------------------------------------------------------------------*/
     199static int control_write_status(device_t *dev, usb_target_t target,
     200    usbhc_iface_transfer_in_callback_t callback, void *arg)
    107201{
    108202        size_t max_packet_size = 8;
    109203        dev_speed_t speed = FULL_SPEED;
    110204
    111         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,
    112             max_packet_size, speed, data, size, NULL, callback, arg);
    113         if (!tracker)
    114                 return ENOMEM;
    115         tracker_interrupt_out(tracker);
    116         return EOK;
    117 }
    118 /*----------------------------------------------------------------------------*/
    119 static int interrupt_in(device_t *dev, usb_target_t target,
    120     void *data, size_t size,
    121     usbhc_iface_transfer_in_callback_t callback, void *arg)
    122 {
    123         size_t max_packet_size = 4;
    124         dev_speed_t speed = FULL_SPEED;
    125 
    126         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,
    127             max_packet_size, speed, data, size, callback, NULL, arg);
    128         if (!tracker)
    129                 return ENOMEM;
    130         tracker_interrupt_in(tracker);
    131         return EOK;
    132 }
    133 /*----------------------------------------------------------------------------*/
    134 static int control_write(device_t *dev, usb_target_t target,
    135     void *setup_data, size_t setup_size, void *data, size_t size,
     205        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     206        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     207            max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);
     208        if (!batch)
     209                return ENOMEM;
     210        batch_control_write_status_old(batch);
     211        return EOK;
     212}
     213/*----------------------------------------------------------------------------*/
     214static int control_read_setup(device_t *dev, usb_target_t target,
     215    size_t max_packet_size,
     216    void *data, size_t size,
     217    usbhc_iface_transfer_out_callback_t callback, void *arg)
     218{
     219        dev_speed_t speed = FULL_SPEED;
     220
     221        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     222        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     223            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
     224        if (!batch)
     225                return ENOMEM;
     226        batch_control_setup_old(batch);
     227        return EOK;
     228}
     229/*----------------------------------------------------------------------------*/
     230static int control_read_data(device_t *dev, usb_target_t target,
     231    size_t max_packet_size,
     232    void *data, size_t size,
     233    usbhc_iface_transfer_in_callback_t callback, void *arg)
     234{
     235        dev_speed_t speed = FULL_SPEED;
     236
     237        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     238        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     239            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
     240        if (!batch)
     241                return ENOMEM;
     242        batch_control_read_data_old(batch);
     243        return EOK;
     244}
     245/*----------------------------------------------------------------------------*/
     246static int control_read_status(device_t *dev, usb_target_t target,
    136247    usbhc_iface_transfer_out_callback_t callback, void *arg)
    137248{
    … …  
    139250        dev_speed_t speed = FULL_SPEED;
    140251
    141         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    142             max_packet_size, speed, data, size, NULL, callback, arg);
    143         if (!tracker)
    144                 return ENOMEM;
    145         tracker_control_write(tracker, setup_data, setup_size);
    146         return EOK;
    147 }
    148 /*----------------------------------------------------------------------------*/
    149 static int control_read(device_t *dev, usb_target_t target,
    150     void *setup_data, size_t setup_size, void *data, size_t size,
    151     usbhc_iface_transfer_in_callback_t callback, void *arg)
    152 {
    153         size_t max_packet_size = 8;
    154         dev_speed_t speed = FULL_SPEED;
    155 
    156         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    157             max_packet_size, speed, data, size, callback, NULL, arg);
    158         if (!tracker)
    159                 return ENOMEM;
    160         tracker_control_read(tracker, setup_data, setup_size);
    161         return EOK;
    162 }
    163 /*----------------------------------------------------------------------------*/
    164 static int control_write_setup(device_t *dev, usb_target_t target,
    165     void *data, size_t size,
    166     usbhc_iface_transfer_out_callback_t callback, void *arg)
    167 {
    168         usb_log_warning("Using deprecated API control write setup.\n");
    169         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    170             8, FULL_SPEED, data, size, NULL, callback, arg);
    171         if (!tracker)
    172                 return ENOMEM;
    173         tracker_control_setup_old(tracker);
    174         return EOK;
    175 }
    176 /*----------------------------------------------------------------------------*/
    177 static 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         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    182             size, FULL_SPEED, data, size, NULL, callback, arg);
    183         if (!tracker)
    184                 return ENOMEM;
    185         tracker_control_write_data_old(tracker);
    186         return EOK;
    187 }
    188 /*----------------------------------------------------------------------------*/
    189 static int control_write_status(device_t *dev, usb_target_t target,
    190     usbhc_iface_transfer_in_callback_t callback, void *arg)
    191 {
    192         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    193             0, FULL_SPEED, NULL, 0, callback, NULL, arg);
    194         if (!tracker)
    195                 return ENOMEM;
    196         tracker_control_write_status_old(tracker);
    197         return EOK;
    198 }
    199 /*----------------------------------------------------------------------------*/
    200 static int control_read_setup(device_t *dev, usb_target_t target,
    201     void *data, size_t size,
    202     usbhc_iface_transfer_out_callback_t callback, void *arg)
    203 {
    204         usb_log_warning("Using deprecated API control read setup.\n");
    205         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    206             8, FULL_SPEED, data, size, NULL, callback, arg);
    207         if (!tracker)
    208                 return ENOMEM;
    209         tracker_control_setup_old(tracker);
    210         return EOK;
    211 }
    212 /*----------------------------------------------------------------------------*/
    213 static int control_read_data(device_t *dev, usb_target_t target,
    214     void *data, size_t size,
    215     usbhc_iface_transfer_in_callback_t callback, void *arg)
    216 {
    217         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    218             size, FULL_SPEED, data, size, callback, NULL, arg);
    219         if (!tracker)
    220                 return ENOMEM;
    221         tracker_control_read_data_old(tracker);
    222         return EOK;
    223 }
    224 /*----------------------------------------------------------------------------*/
    225 static int control_read_status(device_t *dev, usb_target_t target,
    226     usbhc_iface_transfer_out_callback_t callback, void *arg)
    227 {
    228         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    229             0, FULL_SPEED, NULL, 0, NULL, callback, arg);
    230         if (!tracker)
    231                 return ENOMEM;
    232         tracker_control_read_status_old(tracker);
     252        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     253        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     254            max_packet_size, speed, NULL, 0, NULL, 0, NULL, callback, arg);
     255        if (!batch)
     256                return ENOMEM;
     257        batch_control_read_status_old(batch);
    233258        return EOK;
    234259}
Note: See TracChangeset for help on using the changeset viewer.