Changeset 48fe0c9 in mainline for uspace/drv/ohci/iface.c


Ignore:
Timestamp:
2011-03-21T13:43:27Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
361e61b, 5971dd3, 8a951ca
Parents:
0e45e7f (diff), 925e099 (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:

OHCI hc driver software side implementation

File:
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/iface.c

    r0e45e7f r48fe0c9  
    4343
    4444#include "iface.h"
     45#include "hc.h"
    4546
    4647#define UNSUPPORTED(methodname) \
    … …  
    5960static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
    6061{
    61         UNSUPPORTED("reserve_default_address");
    62 
    63         return ENOTSUP;
    64 }
    65 
     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  device_keeper_reserve_default(&hc->manager, speed);
     67  return EOK;
     68}
     69/*----------------------------------------------------------------------------*/
    6670/** Release default address.
    6771 *
    … …  
    7175static int release_default_address(ddf_fun_t *fun)
    7276{
    73         UNSUPPORTED("release_default_address");
    74 
    75         return ENOTSUP;
    76 }
    77 
     77  assert(fun);
     78  hc_t *hc = fun_to_hc(fun);
     79  assert(hc);
     80  usb_log_debug("Default address release.\n");
     81  device_keeper_release_default(&hc->manager);
     82  return EOK;
     83}
     84/*----------------------------------------------------------------------------*/
    7885/** Found free USB address.
    7986 *
    … …  
    8693    usb_address_t *address)
    8794{
    88         UNSUPPORTED("request_address");
    89 
    90         return ENOTSUP;
    91 }
    92 
     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_request(&hc->manager, speed);
     102  usb_log_debug("Address request with result: %d.\n", *address);
     103  if (*address <= 0)
     104    return *address;
     105  return EOK;
     106}
     107/*----------------------------------------------------------------------------*/
    93108/** Bind USB address with device devman handle.
    94109 *
    … …  
    101116    usb_address_t address, devman_handle_t handle)
    102117{
    103         UNSUPPORTED("bind_address");
    104 
    105         return ENOTSUP;
    106 }
    107 
     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  device_keeper_bind(&hc->manager, address, handle);
     123  return EOK;
     124}
     125/*----------------------------------------------------------------------------*/
    108126/** Release previously requested address.
    109127 *
    … …  
    114132static int release_address(ddf_fun_t *fun, usb_address_t address)
    115133{
    116         UNSUPPORTED("release_address");
    117 
    118         return ENOTSUP;
     134  assert(fun);
     135  hc_t *hc = fun_to_hc(fun);
     136  assert(hc);
     137  usb_log_debug("Address release %d.\n", address);
     138  device_keeper_release(&hc->manager, address);
     139  return EOK;
    119140}
    120141
    … …  
    155176        return ENOTSUP;
    156177}
    157 
     178/*----------------------------------------------------------------------------*/
    158179/** Schedule interrupt out transfer.
    159180 *
    … …  
    177198    usbhc_iface_transfer_out_callback_t callback, void *arg)
    178199{
    179         UNSUPPORTED("interrupt_out");
    180 
    181         return ENOTSUP;
    182 }
    183 
     200  hc_t *hc = fun_to_hc(fun);
     201  assert(hc);
     202  usb_speed_t speed = device_keeper_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  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;
     219}
     220/*----------------------------------------------------------------------------*/
    184221/** Schedule interrupt in transfer.
    185222 *
    … …  
    203240    usbhc_iface_transfer_in_callback_t callback, void *arg)
    204241{
    205         UNSUPPORTED("interrupt_in");
    206 
    207         return ENOTSUP;
    208 }
    209 
     242  assert(fun);
     243  hc_t *hc = fun_to_hc(fun);
     244  assert(hc);
     245  usb_speed_t speed = device_keeper_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  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;
     261}
     262/*----------------------------------------------------------------------------*/
    210263/** Schedule bulk out transfer.
    211264 *
    … …  
    229282    usbhc_iface_transfer_out_callback_t callback, void *arg)
    230283{
    231         UNSUPPORTED("bulk_out");
    232 
    233         return ENOTSUP;
    234 }
    235 
     284  assert(fun);
     285  hc_t *hc = fun_to_hc(fun);
     286  assert(hc);
     287  usb_speed_t speed = device_keeper_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  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
     305}
     306/*----------------------------------------------------------------------------*/
    236307/** Schedule bulk in transfer.
    237308 *
    … …  
    255326    usbhc_iface_transfer_in_callback_t callback, void *arg)
    256327{
    257         UNSUPPORTED("bulk_in");
    258 
    259         return ENOTSUP;
    260 }
    261 
     328  assert(fun);
     329  hc_t *hc = fun_to_hc(fun);
     330  assert(hc);
     331  usb_speed_t speed = device_keeper_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  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;
     347}
     348/*----------------------------------------------------------------------------*/
    262349/** Schedule control write transfer.
    263350 *
    … …  
    282369static int control_write(ddf_fun_t *fun, usb_target_t target,
    283370    size_t max_packet_size,
    284     void *setup_packet, size_t setup_packet_size,
    285     void *data_buffer, size_t data_buffer_size,
     371    void *setup_data, size_t setup_size,
     372    void *data, size_t size,
    286373    usbhc_iface_transfer_out_callback_t callback, void *arg)
    287374{
    288         UNSUPPORTED("control_write");
    289 
    290         return ENOTSUP;
    291 }
    292 
     375  assert(fun);
     376  hc_t *hc = fun_to_hc(fun);
     377  assert(hc);
     378  usb_speed_t speed = device_keeper_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  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  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;
     398}
     399/*----------------------------------------------------------------------------*/
    293400/** Schedule control read transfer.
    294401 *
    … …  
    313420static int control_read(ddf_fun_t *fun, usb_target_t target,
    314421    size_t max_packet_size,
    315     void *setup_packet, size_t setup_packet_size,
    316     void *data_buffer, size_t data_buffer_size,
     422    void *setup_data, size_t setup_size,
     423    void *data, size_t size,
    317424    usbhc_iface_transfer_in_callback_t callback, void *arg)
    318425{
    319         UNSUPPORTED("control_read");
    320 
    321         return ENOTSUP;
    322 }
    323 
     426  assert(fun);
     427  hc_t *hc = fun_to_hc(fun);
     428  assert(hc);
     429  usb_speed_t speed = device_keeper_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  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;
     445}
     446/*----------------------------------------------------------------------------*/
    324447/** Host controller interface implementation for OHCI. */
    325 usbhc_iface_t ohci_hc_iface = {
     448usbhc_iface_t hc_iface = {
    326449        .reserve_default_address = reserve_default_address,
    327450        .release_default_address = release_default_address,
Note: See TracChangeset for help on using the changeset viewer.