Changes in / [b01995b:31b568e] in mainline


Ignore:
Location:
uspace
Files:
8 added
8 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/iface.c

    rb01995b r31b568e  
    3333 */
    3434#include <ddf/driver.h>
     35#include <ddf/interrupt.h>
     36#include <device/hw_res.h>
    3537#include <errno.h>
    36 
     38#include <str_error.h>
     39
     40#include <usb_iface.h>
     41#include <usb/ddfiface.h>
    3742#include <usb/debug.h>
    3843
    … …  
    5560static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
    5661{
    57         assert(fun);
    58         hc_t *hc = fun_to_hc(fun);
    59         assert(hc);
    60         usb_log_debug("Default address request with speed %d.\n", speed);
    61         usb_device_keeper_reserve_default_address(&hc->manager, speed);
    62         return EOK;
     62  assert(fun);
     63  hc_t *hc = fun_to_hc(fun);
     64  assert(hc);
     65  usb_log_debug("Default address request with speed %d.\n", speed);
     66  usb_device_keeper_reserve_default_address(&hc->manager, speed);
     67  return EOK;
    6368}
    6469/*----------------------------------------------------------------------------*/
    … …  
    7075static int release_default_address(ddf_fun_t *fun)
    7176{
    72         assert(fun);
    73         hc_t *hc = fun_to_hc(fun);
    74         assert(hc);
    75         usb_log_debug("Default address release.\n");
    76         usb_device_keeper_release_default_address(&hc->manager);
    77         return EOK;
     77  assert(fun);
     78  hc_t *hc = fun_to_hc(fun);
     79  assert(hc);
     80  usb_log_debug("Default address release.\n");
     81  usb_device_keeper_release_default_address(&hc->manager);
     82  return EOK;
    7883}
    7984/*----------------------------------------------------------------------------*/
    … …  
    8590 * @return Error code.
    8691 */
    87 static int request_address(
    88     ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
    89 {
    90         assert(fun);
    91         hc_t *hc = fun_to_hc(fun);
    92         assert(hc);
    93         assert(address);
    94 
    95         usb_log_debug("Address request with speed %d.\n", speed);
    96         *address = device_keeper_get_free_address(&hc->manager, speed);
    97         usb_log_debug("Address request with result: %d.\n", *address);
    98         if (*address <= 0)
    99                 return *address;
    100         return EOK;
     92static int request_address(ddf_fun_t *fun, usb_speed_t speed,
     93    usb_address_t *address)
     94{
     95  assert(fun);
     96  hc_t *hc = fun_to_hc(fun);
     97  assert(hc);
     98  assert(address);
     99
     100  usb_log_debug("Address request with speed %d.\n", speed);
     101  *address = device_keeper_get_free_address(&hc->manager, speed);
     102  usb_log_debug("Address request with result: %d.\n", *address);
     103  if (*address <= 0)
     104    return *address;
     105  return EOK;
    101106}
    102107/*----------------------------------------------------------------------------*/
    … …  
    108113 * @return Error code.
    109114 */
    110 static int bind_address(
    111     ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
    112 {
    113         assert(fun);
    114         hc_t *hc = fun_to_hc(fun);
    115         assert(hc);
    116         usb_log_debug("Address bind %d-%d.\n", address, handle);
    117         usb_device_keeper_bind(&hc->manager, address, handle);
    118         return EOK;
     115static int bind_address(ddf_fun_t *fun,
     116    usb_address_t address, devman_handle_t handle)
     117{
     118  assert(fun);
     119  hc_t *hc = fun_to_hc(fun);
     120  assert(hc);
     121  usb_log_debug("Address bind %d-%d.\n", address, handle);
     122  usb_device_keeper_bind(&hc->manager, address, handle);
     123  return EOK;
    119124}
    120125/*----------------------------------------------------------------------------*/
    … …  
    127132static int release_address(ddf_fun_t *fun, usb_address_t address)
    128133{
    129         assert(fun);
    130         hc_t *hc = fun_to_hc(fun);
    131         assert(hc);
    132         usb_log_debug("Address release %d.\n", address);
    133         usb_device_keeper_release(&hc->manager, address);
    134         return EOK;
    135 }
    136 /*----------------------------------------------------------------------------*/
     134  assert(fun);
     135  hc_t *hc = fun_to_hc(fun);
     136  assert(hc);
     137  usb_log_debug("Address release %d.\n", address);
     138  usb_device_keeper_release(&hc->manager, address);
     139  return EOK;
     140}
     141
    137142/** Register endpoint for bandwidth reservation.
    138143 *
    … …  
    146151 * @return Error code.
    147152 */
    148 static int register_endpoint(
    149     ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
     153static int register_endpoint(ddf_fun_t *fun,
     154    usb_address_t address, usb_endpoint_t endpoint,
    150155    usb_transfer_type_t transfer_type, usb_direction_t direction,
    151156    size_t max_packet_size, unsigned int interval)
    … …  
    155160        return ENOTSUP;
    156161}
    157 /*----------------------------------------------------------------------------*/
     162
    158163/** Unregister endpoint (free some bandwidth reservation).
    159164 *
    … …  
    164169 * @return Error code.
    165170 */
    166 static int unregister_endpoint(
    167     ddf_fun_t *fun, usb_address_t address,
     171static int unregister_endpoint(ddf_fun_t *fun, usb_address_t address,
    168172    usb_endpoint_t endpoint, usb_direction_t direction)
    169173{
    … …  
    190194 * @return Error code.
    191195 */
    192 static int interrupt_out(
    193     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    194     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    195 {
    196         assert(fun);
    197         hc_t *hc = fun_to_hc(fun);
    198         assert(hc);
    199         usb_speed_t speed =
    200             usb_device_keeper_get_speed(&hc->manager, target.address);
    201 
    202         usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    203             target.address, target.endpoint, size, max_packet_size);
    204 
    205         usb_transfer_batch_t *batch =
    206             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    207                 speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    208         if (!batch)
    209                 return ENOMEM;
    210         batch_interrupt_out(batch);
    211         const int ret = hc_schedule(hc, batch);
    212         if (ret != EOK) {
    213                 batch_dispose(batch);
    214         }
    215         return ret;
     196static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
     197    size_t max_packet_size, void *data, size_t size,
     198    usbhc_iface_transfer_out_callback_t callback, void *arg)
     199{
     200  hc_t *hc = fun_to_hc(fun);
     201  assert(hc);
     202  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     203
     204  usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
     205      target.address, target.endpoint, size, max_packet_size);
     206
     207  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     208      max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     209      &hc->manager);
     210  if (!batch)
     211    return ENOMEM;
     212  batch_interrupt_out(batch);
     213  const int ret = hc_schedule(hc, batch);
     214  if (ret != EOK) {
     215    batch_dispose(batch);
     216    return ret;
     217  }
     218  return EOK;
    216219}
    217220/*----------------------------------------------------------------------------*/
    … …  
    233236 * @return Error code.
    234237 */
    235 static int interrupt_in(
    236     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    237     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    238 {
    239         assert(fun);
    240         hc_t *hc = fun_to_hc(fun);
    241         assert(hc);
    242         usb_speed_t speed =
    243             usb_device_keeper_get_speed(&hc->manager, target.address);
    244         usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    245             target.address, target.endpoint, size, max_packet_size);
    246 
    247         usb_transfer_batch_t *batch =
    248             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    249                 speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    250         if (!batch)
    251                 return ENOMEM;
    252         batch_interrupt_in(batch);
    253         const int ret = hc_schedule(hc, batch);
    254         if (ret != EOK) {
    255                 batch_dispose(batch);
    256         }
    257         return ret;
     238static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
     239    size_t max_packet_size, void *data, size_t size,
     240    usbhc_iface_transfer_in_callback_t callback, void *arg)
     241{
     242  assert(fun);
     243  hc_t *hc = fun_to_hc(fun);
     244  assert(hc);
     245  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     246  usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
     247      target.address, target.endpoint, size, max_packet_size);
     248
     249  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     250      max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     251      &hc->manager);
     252  if (!batch)
     253    return ENOMEM;
     254  batch_interrupt_in(batch);
     255  const int ret = hc_schedule(hc, batch);
     256  if (ret != EOK) {
     257    batch_dispose(batch);
     258    return ret;
     259  }
     260  return EOK;
    258261}
    259262/*----------------------------------------------------------------------------*/
    … …  
    275278 * @return Error code.
    276279 */
    277 static int bulk_out(
    278     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    279     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    280 {
    281         assert(fun);
    282         hc_t *hc = fun_to_hc(fun);
    283         assert(hc);
    284         usb_speed_t speed =
    285             usb_device_keeper_get_speed(&hc->manager, target.address);
    286 
    287         usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    288             target.address, target.endpoint, size, max_packet_size);
    289 
    290         usb_transfer_batch_t *batch =
    291             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    292                 data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    293         if (!batch)
    294                 return ENOMEM;
    295         batch_bulk_out(batch);
    296         const int ret = hc_schedule(hc, batch);
    297         if (ret != EOK) {
    298                 batch_dispose(batch);
    299         }
    300         return ret;
     280static int bulk_out(ddf_fun_t *fun, usb_target_t target,
     281    size_t max_packet_size, void *data, size_t size,
     282    usbhc_iface_transfer_out_callback_t callback, void *arg)
     283{
     284  assert(fun);
     285  hc_t *hc = fun_to_hc(fun);
     286  assert(hc);
     287  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     288
     289  usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
     290      target.address, target.endpoint, size, max_packet_size);
     291
     292  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     293      max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     294      &hc->manager);
     295  if (!batch)
     296    return ENOMEM;
     297  batch_bulk_out(batch);
     298  const int ret = hc_schedule(hc, batch);
     299  if (ret != EOK) {
     300    batch_dispose(batch);
     301    return ret;
     302  }
     303  return EOK;
     304
    301305}
    302306/*----------------------------------------------------------------------------*/
    … …  
    318322 * @return Error code.
    319323 */
    320 static int bulk_in(
    321     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    322     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    323 {
    324         assert(fun);
    325         hc_t *hc = fun_to_hc(fun);
    326         assert(hc);
    327         usb_speed_t speed =
    328             usb_device_keeper_get_speed(&hc->manager, target.address);
    329         usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    330             target.address, target.endpoint, size, max_packet_size);
    331 
    332         usb_transfer_batch_t *batch =
    333             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    334                 data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    335         if (!batch)
    336                 return ENOMEM;
    337         batch_bulk_in(batch);
    338         const int ret = hc_schedule(hc, batch);
    339         if (ret != EOK) {
    340                 batch_dispose(batch);
    341         }
    342         return ret;
     324static int bulk_in(ddf_fun_t *fun, usb_target_t target,
     325    size_t max_packet_size, void *data, size_t size,
     326    usbhc_iface_transfer_in_callback_t callback, void *arg)
     327{
     328  assert(fun);
     329  hc_t *hc = fun_to_hc(fun);
     330  assert(hc);
     331  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     332  usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
     333      target.address, target.endpoint, size, max_packet_size);
     334
     335  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     336      max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     337      &hc->manager);
     338  if (!batch)
     339    return ENOMEM;
     340  batch_bulk_in(batch);
     341  const int ret = hc_schedule(hc, batch);
     342  if (ret != EOK) {
     343    batch_dispose(batch);
     344    return ret;
     345  }
     346  return EOK;
    343347}
    344348/*----------------------------------------------------------------------------*/
    … …  
    363367 * @return Error code.
    364368 */
    365 static int control_write(
    366     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    367     void *setup_data, size_t setup_size, void *data, size_t size,
     369static int control_write(ddf_fun_t *fun, usb_target_t target,
     370    size_t max_packet_size,
     371    void *setup_data, size_t setup_size,
     372    void *data, size_t size,
    368373    usbhc_iface_transfer_out_callback_t callback, void *arg)
    369374{
    370         assert(fun);
    371         hc_t *hc = fun_to_hc(fun);
    372         assert(hc);
    373         usb_speed_t speed =
    374             usb_device_keeper_get_speed(&hc->manager, target.address);
    375         usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    376             speed, target.address, target.endpoint, size, max_packet_size);
    377 
    378         if (setup_size != 8)
    379                 return EINVAL;
    380 
    381         usb_transfer_batch_t *batch =
    382             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
    383                 speed, data, size, setup_data, setup_size, NULL, callback, arg,
    384                 &hc->manager);
    385         if (!batch)
    386                 return ENOMEM;
    387         usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
    388         batch_control_write(batch);
    389         const int ret = hc_schedule(hc, batch);
    390         if (ret != EOK) {
    391                 batch_dispose(batch);
    392         }
    393         return ret;
     375  assert(fun);
     376  hc_t *hc = fun_to_hc(fun);
     377  assert(hc);
     378  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     379  usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
     380      speed, target.address, target.endpoint, size, max_packet_size);
     381
     382  if (setup_size != 8)
     383    return EINVAL;
     384
     385  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     386      max_packet_size, speed, data, size, setup_data, setup_size,
     387      NULL, callback, arg, &hc->manager);
     388  if (!batch)
     389    return ENOMEM;
     390  usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
     391  batch_control_write(batch);
     392  const int ret = hc_schedule(hc, batch);
     393  if (ret != EOK) {
     394    batch_dispose(batch);
     395    return ret;
     396  }
     397  return EOK;
    394398}
    395399/*----------------------------------------------------------------------------*/
    … …  
    414418 * @return Error code.
    415419 */
    416 static int control_read(
    417     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    418     void *setup_data, size_t setup_size, void *data, size_t size,
     420static int control_read(ddf_fun_t *fun, usb_target_t target,
     421    size_t max_packet_size,
     422    void *setup_data, size_t setup_size,
     423    void *data, size_t size,
    419424    usbhc_iface_transfer_in_callback_t callback, void *arg)
    420425{
    421         assert(fun);
    422         hc_t *hc = fun_to_hc(fun);
    423         assert(hc);
    424         usb_speed_t speed =
    425             usb_device_keeper_get_speed(&hc->manager, target.address);
    426 
    427         usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    428             speed, target.address, target.endpoint, size, max_packet_size);
    429         usb_transfer_batch_t *batch =
    430             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
    431                 speed, data, size, setup_data, setup_size, callback, NULL, arg,
    432                 &hc->manager);
    433         if (!batch)
    434                 return ENOMEM;
    435         batch_control_read(batch);
    436         const int ret = hc_schedule(hc, batch);
    437         if (ret != EOK) {
    438                 batch_dispose(batch);
    439         }
    440         return ret;
     426  assert(fun);
     427  hc_t *hc = fun_to_hc(fun);
     428  assert(hc);
     429  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     430
     431  usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
     432      speed, target.address, target.endpoint, size, max_packet_size);
     433  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     434      max_packet_size, speed, data, size, setup_data, setup_size, callback,
     435      NULL, arg, &hc->manager);
     436  if (!batch)
     437    return ENOMEM;
     438  batch_control_read(batch);
     439  const int ret = hc_schedule(hc, batch);
     440  if (ret != EOK) {
     441    batch_dispose(batch);
     442    return ret;
     443  }
     444  return EOK;
    441445}
    442446/*----------------------------------------------------------------------------*/
    … …  
    459463
    460464        .control_write = control_write,
    461         .control_read = control_read,
     465        .control_read = control_read
    462466};
    463467

  • uspace/drv/uhci-hcd/Makefile

    rb01995b r31b568e  
    3737        transfer_list.c \
    3838        uhci.c \
    39         hc.c \
    40         root_hub.c \
    41         hw_struct/transfer_descriptor.c \
     39        uhci_hc.c \
     40        uhci_rh.c \
     41        uhci_struct/transfer_descriptor.c \
    4242        pci.c \
    4343        batch.c

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

    rb01995b r31b568e  
    4040#include "batch.h"
    4141#include "transfer_list.h"
    42 #include "hw_struct/transfer_descriptor.h"
     42#include "uhci_hc.h"
    4343#include "utils/malloc32.h"
     44#include "uhci_struct/transfer_descriptor.h"
    4445
    4546#define DEFAULT_ERROR_COUNT 3

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

    rb01995b r31b568e  
    4242#include <usb/host/batch.h>
    4343
    44 #include "hw_struct/queue_head.h"
     44#include "uhci_struct/queue_head.h"
    4545
    4646usb_transfer_batch_t * batch_get(

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

    rb01995b r31b568e  
    3333 */
    3434#include <ddf/driver.h>
     35#include <remote_usbhc.h>
     36
     37#include <usb/debug.h>
     38
    3539#include <errno.h>
    3640
    37 #include <usb/debug.h>
    38 
    3941#include "iface.h"
    40 #include "hc.h"
     42#include "uhci_hc.h"
    4143
    4244/** Reserve default address interface function
    … …  
    4648 * @return Error code.
    4749 */
     50/*----------------------------------------------------------------------------*/
    4851static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
    4952{
    5053        assert(fun);
    51         hc_t *hc = fun_to_hc(fun);
     54        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    5255        assert(hc);
    5356        usb_log_debug("Default address request with speed %d.\n", speed);
    54         usb_device_keeper_reserve_default_address(&hc->manager, speed);
     57        usb_device_keeper_reserve_default_address(&hc->device_manager, speed);
    5558        return EOK;
    5659}
    … …  
    6467{
    6568        assert(fun);
    66         hc_t *hc = fun_to_hc(fun);
     69        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    6770        assert(hc);
    6871        usb_log_debug("Default address release.\n");
    69         usb_device_keeper_release_default_address(&hc->manager);
     72        usb_device_keeper_release_default_address(&hc->device_manager);
    7073        return EOK;
    7174}
    … …  
    7881 * @return Error code.
    7982 */
    80 static int request_address(
    81     ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
    82 {
    83         assert(fun);
    84         hc_t *hc = fun_to_hc(fun);
     83static int request_address(ddf_fun_t *fun, usb_speed_t speed,
     84    usb_address_t *address)
     85{
     86        assert(fun);
     87        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    8588        assert(hc);
    8689        assert(address);
    8790
    8891        usb_log_debug("Address request with speed %d.\n", speed);
    89         *address = device_keeper_get_free_address(&hc->manager, speed);
     92        *address = device_keeper_get_free_address(&hc->device_manager, speed);
    9093        usb_log_debug("Address request with result: %d.\n", *address);
    9194        if (*address <= 0)
    92                 return *address;
     95          return *address;
    9396        return EOK;
    9497}
    … …  
    105108{
    106109        assert(fun);
    107         hc_t *hc = fun_to_hc(fun);
     110        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    108111        assert(hc);
    109112        usb_log_debug("Address bind %d-%d.\n", address, handle);
    110         usb_device_keeper_bind(&hc->manager, address, handle);
     113        usb_device_keeper_bind(&hc->device_manager, address, handle);
    111114        return EOK;
    112115}
    … …  
    121124{
    122125        assert(fun);
    123         hc_t *hc = fun_to_hc(fun);
     126        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    124127        assert(hc);
    125128        usb_log_debug("Address release %d.\n", address);
    126         usb_device_keeper_release(&hc->manager, address);
     129        usb_device_keeper_release(&hc->device_manager, address);
    127130        return EOK;
    128131}
    … …  
    139142 * @return Error code.
    140143 */
    141 static int interrupt_out(
    142     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    143     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    144 {
    145         assert(fun);
    146         hc_t *hc = fun_to_hc(fun);
    147         assert(hc);
    148         usb_speed_t speed =
    149             usb_device_keeper_get_speed(&hc->manager, target.address);
     144static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
     145    size_t max_packet_size, void *data, size_t size,
     146    usbhc_iface_transfer_out_callback_t callback, void *arg)
     147{
     148        assert(fun);
     149        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     150        assert(hc);
     151        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    150152
    151153        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    152154            target.address, target.endpoint, size, max_packet_size);
    153155
    154         usb_transfer_batch_t *batch =
    155             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    156                 speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
     156        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     157            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     158            &hc->device_manager);
    157159        if (!batch)
    158160                return ENOMEM;
    159161        batch_interrupt_out(batch);
    160         const int ret = hc_schedule(hc, batch);
    161         if (ret != EOK) {
    162                 batch_dispose(batch);
    163         }
    164         return ret;
     162        const int ret = uhci_hc_schedule(hc, batch);
     163        if (ret != EOK) {
     164                batch_dispose(batch);
     165                return ret;
     166        }
     167        return EOK;
    165168}
    166169/*----------------------------------------------------------------------------*/
    … …  
    176179 * @return Error code.
    177180 */
    178 static int interrupt_in(
    179     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    180     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    181 {
    182         assert(fun);
    183         hc_t *hc = fun_to_hc(fun);
    184         assert(hc);
    185         usb_speed_t speed =
    186             usb_device_keeper_get_speed(&hc->manager, target.address);
     181static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
     182    size_t max_packet_size, void *data, size_t size,
     183    usbhc_iface_transfer_in_callback_t callback, void *arg)
     184{
     185        assert(fun);
     186        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     187        assert(hc);
     188        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    187189        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    188190            target.address, target.endpoint, size, max_packet_size);
    189191
    190         usb_transfer_batch_t *batch =
    191             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    192                 speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
     192        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     193            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     194                        &hc->device_manager);
    193195        if (!batch)
    194196                return ENOMEM;
    195197        batch_interrupt_in(batch);
    196         const int ret = hc_schedule(hc, batch);
    197         if (ret != EOK) {
    198                 batch_dispose(batch);
    199         }
    200         return ret;
     198        const int ret = uhci_hc_schedule(hc, batch);
     199        if (ret != EOK) {
     200                batch_dispose(batch);
     201                return ret;
     202        }
     203        return EOK;
    201204}
    202205/*----------------------------------------------------------------------------*/
    … …  
    212215 * @return Error code.
    213216 */
    214 static int bulk_out(
    215     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    216     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    217 {
    218         assert(fun);
    219         hc_t *hc = fun_to_hc(fun);
    220         assert(hc);
    221         usb_speed_t speed =
    222             usb_device_keeper_get_speed(&hc->manager, target.address);
     217static int bulk_out(ddf_fun_t *fun, usb_target_t target,
     218    size_t max_packet_size, void *data, size_t size,
     219    usbhc_iface_transfer_out_callback_t callback, void *arg)
     220{
     221        assert(fun);
     222        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     223        assert(hc);
     224        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    223225
    224226        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    225227            target.address, target.endpoint, size, max_packet_size);
    226228
    227         usb_transfer_batch_t *batch =
    228             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    229                 data, size, NULL, 0, NULL, callback, arg, &hc->manager);
     229        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     230            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     231            &hc->device_manager);
    230232        if (!batch)
    231233                return ENOMEM;
    232234        batch_bulk_out(batch);
    233         const int ret = hc_schedule(hc, batch);
    234         if (ret != EOK) {
    235                 batch_dispose(batch);
    236         }
    237         return ret;
     235        const int ret = uhci_hc_schedule(hc, batch);
     236        if (ret != EOK) {
     237                batch_dispose(batch);
     238                return ret;
     239        }
     240        return EOK;
    238241}
    239242/*----------------------------------------------------------------------------*/
    … …  
    249252 * @return Error code.
    250253 */
    251 static int bulk_in(
    252     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    253     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    254 {
    255         assert(fun);
    256         hc_t *hc = fun_to_hc(fun);
    257         assert(hc);
    258         usb_speed_t speed =
    259             usb_device_keeper_get_speed(&hc->manager, target.address);
     254static int bulk_in(ddf_fun_t *fun, usb_target_t target,
     255    size_t max_packet_size, void *data, size_t size,
     256    usbhc_iface_transfer_in_callback_t callback, void *arg)
     257{
     258        assert(fun);
     259        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     260        assert(hc);
     261        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    260262        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    261263            target.address, target.endpoint, size, max_packet_size);
    262264
    263         usb_transfer_batch_t *batch =
    264             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    265                 data, size, NULL, 0, callback, NULL, arg, &hc->manager);
     265        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     266            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     267            &hc->device_manager);
    266268        if (!batch)
    267269                return ENOMEM;
    268270        batch_bulk_in(batch);
    269         const int ret = hc_schedule(hc, batch);
    270         if (ret != EOK) {
    271                 batch_dispose(batch);
    272         }
    273         return ret;
     271        const int ret = uhci_hc_schedule(hc, batch);
     272        if (ret != EOK) {
     273                batch_dispose(batch);
     274                return ret;
     275        }
     276        return EOK;
    274277}
    275278/*----------------------------------------------------------------------------*/
    … …  
    287290 * @return Error code.
    288291 */
    289 static int control_write(
    290     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
     292static int control_write(ddf_fun_t *fun, usb_target_t target,
     293    size_t max_packet_size,
    291294    void *setup_data, size_t setup_size, void *data, size_t size,
    292295    usbhc_iface_transfer_out_callback_t callback, void *arg)
    293296{
    294297        assert(fun);
    295         hc_t *hc = fun_to_hc(fun);
    296         assert(hc);
    297         usb_speed_t speed =
    298             usb_device_keeper_get_speed(&hc->manager, target.address);
     298        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     299        assert(hc);
     300        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    299301        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    300302            speed, target.address, target.endpoint, size, max_packet_size);
    … …  
    303305                return EINVAL;
    304306
    305         usb_transfer_batch_t *batch =
    306             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    307                 data, size, setup_data, setup_size, NULL, callback, arg,
    308                 &hc->manager);
    309         if (!batch)
    310                 return ENOMEM;
    311         usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
     307        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     308            max_packet_size, speed, data, size, setup_data, setup_size,
     309            NULL, callback, arg, &hc->device_manager);
     310        if (!batch)
     311                return ENOMEM;
     312        usb_device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
    312313        batch_control_write(batch);
    313         const int ret = hc_schedule(hc, batch);
    314         if (ret != EOK) {
    315                 batch_dispose(batch);
    316         }
    317         return ret;
     314        const int ret = uhci_hc_schedule(hc, batch);
     315        if (ret != EOK) {
     316                batch_dispose(batch);
     317                return ret;
     318        }
     319        return EOK;
    318320}
    319321/*----------------------------------------------------------------------------*/
    … …  
    331333 * @return Error code.
    332334 */
    333 static int control_read(
    334     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
     335static int control_read(ddf_fun_t *fun, usb_target_t target,
     336    size_t max_packet_size,
    335337    void *setup_data, size_t setup_size, void *data, size_t size,
    336338    usbhc_iface_transfer_in_callback_t callback, void *arg)
    337339{
    338340        assert(fun);
    339         hc_t *hc = fun_to_hc(fun);
    340         assert(hc);
    341         usb_speed_t speed =
    342             usb_device_keeper_get_speed(&hc->manager, target.address);
     341        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     342        assert(hc);
     343        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    343344
    344345        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    345346            speed, target.address, target.endpoint, size, max_packet_size);
    346         usb_transfer_batch_t *batch =
    347             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    348                 data, size, setup_data, setup_size, callback, NULL, arg,
    349                 &hc->manager);
     347        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     348            max_packet_size, speed, data, size, setup_data, setup_size, callback,
     349            NULL, arg, &hc->device_manager);
    350350        if (!batch)
    351351                return ENOMEM;
    352352        batch_control_read(batch);
    353         const int ret = hc_schedule(hc, batch);
    354         if (ret != EOK) {
    355                 batch_dispose(batch);
    356         }
    357         return ret;
    358 }
    359 /*----------------------------------------------------------------------------*/
    360 usbhc_iface_t hc_iface = {
     353        const int ret = uhci_hc_schedule(hc, batch);
     354        if (ret != EOK) {
     355                batch_dispose(batch);
     356                return ret;
     357        }
     358        return EOK;
     359}
     360/*----------------------------------------------------------------------------*/
     361usbhc_iface_t uhci_hc_iface = {
    361362        .reserve_default_address = reserve_default_address,
    362363        .release_default_address = release_default_address,
    … …  
    368369        .interrupt_in = interrupt_in,
    369370
     371        .bulk_in = bulk_in,
    370372        .bulk_out = bulk_out,
    371         .bulk_in = bulk_in,
    372 
     373
     374        .control_read = control_read,
    373375        .control_write = control_write,
    374         .control_read = control_read,
    375376};
    376377/**

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

    rb01995b r31b568e  
    3838#include <usbhc_iface.h>
    3939
    40 extern usbhc_iface_t hc_iface;
     40extern usbhc_iface_t uhci_hc_iface;
    4141
    4242#endif

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

    rb01995b r31b568e  
    7979        if (!instance->queue_head)
    8080                return;
    81         /* Set both queue_head.next to point to the follower */
     81        /* Set both next and element to point to the same QH */
    8282        qh_set_next_qh(instance->queue_head, next->queue_head_pa);
     83        qh_set_element_qh(instance->queue_head, next->queue_head_pa);
    8384}
    8485/*----------------------------------------------------------------------------*/
    … …  
    9798        usb_log_debug2("Queue %s: Adding batch(%p).\n", instance->name, batch);
    9899
     100        const uint32_t pa = addr_to_phys(batch_qh(batch));
     101        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
     102
     103        /* New batch will be added to the end of the current list
     104         * so set the link accordingly */
     105        qh_set_next_qh(batch_qh(batch), instance->queue_head->next);
     106
    99107        fibril_mutex_lock(&instance->guard);
    100108
    101         qh_t *last_qh = NULL;
    102109        /* Add to the hardware queue. */
    103110        if (list_empty(&instance->batch_list)) {
    104111                /* There is nothing scheduled */
    105                 last_qh = instance->queue_head;
     112                qh_t *qh = instance->queue_head;
     113                assert(qh->element == qh->next);
     114                qh_set_element_qh(qh, pa);
    106115        } else {
    107116                /* There is something scheduled */
    108117                usb_transfer_batch_t *last = list_get_instance(
    109118                    instance->batch_list.prev, usb_transfer_batch_t, link);
    110                 last_qh = batch_qh(last);
    111         }
    112         const uint32_t pa = addr_to_phys(batch_qh(batch));
    113         assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
    114 
    115         /* keep link */
    116         batch_qh(batch)->next = last_qh->next;
    117         qh_set_next_qh(last_qh, pa);
    118 
     119                qh_set_next_qh(batch_qh(last), pa);
     120        }
    119121        /* Add to the driver list */
    120122        list_append(&batch->link, &instance->batch_list);
    … …  
    172174{
    173175        fibril_mutex_lock(&instance->guard);
    174         while (!list_empty(&instance->batch_list)) {
     176        while (list_empty(&instance->batch_list)) {
    175177                link_t *current = instance->batch_list.next;
    176178                usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link);
    … …  
    195197        assert(batch);
    196198        assert(batch_qh(batch));
    197         assert(fibril_mutex_is_locked(&instance->guard));
    198 
    199199        usb_log_debug2(
    200200            "Queue %s: removing batch(%p).\n", instance->name, batch);
    201201
    202         const char *qpos = NULL;
     202        const char * pos = NULL;
    203203        /* Remove from the hardware queue */
    204         if (instance->batch_list.next == &batch->link) {
     204        if (batch->link.prev == &instance->batch_list) {
    205205                /* I'm the first one here */
    206                 assert((instance->queue_head->next & LINK_POINTER_ADDRESS_MASK)
    207                     == addr_to_phys(batch_qh(batch)));
    208                 instance->queue_head->next = batch_qh(batch)->next;
    209                 qpos = "FIRST";
     206                qh_set_element_qh(instance->queue_head, batch_qh(batch)->next);
     207                pos = "FIRST";
    210208        } else {
    211209                usb_transfer_batch_t *prev =
    212210                    list_get_instance(batch->link.prev, usb_transfer_batch_t, link);
    213                 assert((batch_qh(prev)->next & LINK_POINTER_ADDRESS_MASK)
    214                     == addr_to_phys(batch_qh(batch)));
    215                 batch_qh(prev)->next = batch_qh(batch)->next;
    216                 qpos = "NOT FIRST";
    217         }
    218         /* Remove from the batch list */
     211                qh_set_next_qh(batch_qh(prev), batch_qh(batch)->next);
     212                pos = "NOT FIRST";
     213        }
     214        /* Remove from the driver list */
    219215        list_remove(&batch->link);
    220         usb_log_debug("Batch(%p) removed (%s) from %s, next %x.\n",
    221             batch, qpos, instance->name, batch_qh(batch)->next);
     216        usb_log_debug("Batch(%p) removed (%s) from %s, next element %x.\n",
     217            batch, pos, instance->name, batch_qh(batch)->next);
    222218}
    223219/**

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

    rb01995b r31b568e  
    3737#include <fibril_synch.h>
    3838
     39#include "uhci_struct/queue_head.h"
     40
    3941#include "batch.h"
    40 #include "hw_struct/queue_head.h"
    4142
    4243typedef struct transfer_list

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

    rb01995b r31b568e  
    5454{
    5555        assert(dev);
    56         hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
     56        uhci_hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
    5757        uint16_t status = IPC_GET_ARG1(*call);
    5858        assert(hc);
    59         hc_interrupt(hc, status);
     59        uhci_hc_interrupt(hc, status);
    6060}
    6161/*----------------------------------------------------------------------------*/
    … …  
    7070{
    7171        assert(fun);
    72         usb_device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.manager;
     72        usb_device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager;
    7373
    7474        usb_address_t addr = usb_device_keeper_find(manager, handle);
    … …  
    107107};
    108108/*----------------------------------------------------------------------------*/
    109 static ddf_dev_ops_t hc_ops = {
     109static ddf_dev_ops_t uhci_hc_ops = {
    110110        .interfaces[USB_DEV_IFACE] = &usb_iface,
    111         .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
     111        .interfaces[USBHC_DEV_IFACE] = &uhci_hc_iface, /* see iface.h/c */
    112112};
    113113/*----------------------------------------------------------------------------*/
    … …  
    120120{
    121121        assert(fun);
    122         return &((rh_t*)fun->driver_data)->resource_list;
     122        return &((uhci_rh_t*)fun->driver_data)->resource_list;
    123123}
    124124/*----------------------------------------------------------------------------*/
    … …  
    128128};
    129129/*----------------------------------------------------------------------------*/
    130 static ddf_dev_ops_t rh_ops = {
     130static ddf_dev_ops_t uhci_rh_ops = {
    131131        .interfaces[USB_DEV_IFACE] = &usb_iface,
    132132        .interfaces[HW_RES_DEV_IFACE] = &hw_res_iface
    … …  
    190190            "Failed(%d) to create HC function.\n", ret);
    191191
    192         ret = hc_init(&instance->hc, instance->hc_fun,
     192        ret = uhci_hc_init(&instance->hc, instance->hc_fun,
    193193            (void*)io_reg_base, io_reg_size, interrupts);
    194194        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to init uhci-hcd.\n", ret);
    195         instance->hc_fun->ops = &hc_ops;
     195        instance->hc_fun->ops = &uhci_hc_ops;
    196196        instance->hc_fun->driver_data = &instance->hc;
    197197        ret = ddf_fun_bind(instance->hc_fun);
    … …  
    208208        if (instance->rh_fun) \
    209209                ddf_fun_destroy(instance->rh_fun); \
    210         hc_fini(&instance->hc); \
     210        uhci_hc_fini(&instance->hc); \
    211211        return ret; \
    212212}
    … …  
    223223            "Failed(%d) to create root hub function.\n", ret);
    224224
    225         ret = rh_init(&instance->rh, instance->rh_fun,
     225        ret = uhci_rh_init(&instance->rh, instance->rh_fun,
    226226            (uintptr_t)instance->hc.registers + 0x10, 4);
    227227        CHECK_RET_FINI_RETURN(ret,
    228228            "Failed(%d) to setup UHCI root hub.\n", ret);
    229229
    230         instance->rh_fun->ops = &rh_ops;
     230        instance->rh_fun->ops = &uhci_rh_ops;
    231231        instance->rh_fun->driver_data = &instance->rh;
    232232        ret = ddf_fun_bind(instance->rh_fun);

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

    rb01995b r31b568e  
    3838#include <ddf/driver.h>
    3939
    40 #include "hc.h"
    41 #include "root_hub.h"
     40#include "uhci_hc.h"
     41#include "uhci_rh.h"
    4242
    4343typedef struct uhci {
    … …  
    4545        ddf_fun_t *rh_fun;
    4646
    47         hc_t hc;
    48         rh_t rh;
     47        uhci_hc_t hc;
     48        uhci_rh_t rh;
    4949} uhci_t;
    5050

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

    rb01995b r31b568e  
    5050static inline uintptr_t addr_to_phys(void *addr)
    5151{
    52         if (addr == NULL)
    53                 return 0;
    54 
    5552        uintptr_t result;
    5653        int ret = as_get_physical_mapping(addr, &result);

  • uspace/lib/usb/src/host/device_keeper.c

    rb01995b r31b568e  
    214214        fibril_mutex_lock(&instance->guard);
    215215
    216         usb_address_t new_address = instance->last_address;
    217         do {
    218                 ++new_address;
    219                 if (new_address > USB11_ADDRESS_MAX)
    220                         new_address = 1;
     216        usb_address_t new_address = instance->last_address + 1;
     217        while (instance->devices[new_address].occupied) {
    221218                if (new_address == instance->last_address) {
    222219                        fibril_mutex_unlock(&instance->guard);
    223220                        return ENOSPC;
    224221                }
    225         } while (instance->devices[new_address].occupied);
     222                if (new_address == USB11_ADDRESS_MAX)
     223                        new_address = 1;
     224                ++new_address;
     225        }
    226226
    227227        assert(new_address != USB_ADDRESS_DEFAULT);
Note: See TracChangeset for help on using the changeset viewer.