Atmel xmega USB, Interrupt disabled / enabled / Latenz

[Wolfgang K. (opendcc)]

Hallo,

ich wühle mich gerade durch das Keyboard-Bespiel aus dem ASF und rätsle 
über die Notwendigkeit des Verriegels des Interruptsystems. Hintergrund: 
ich kann aus anderen Gründe keine allzu lange Zeit im Disabled-Zustand 
zulassen.


Atmel hat da Zugriffsroutinen auf den Keyboardreport definiert, hier mal 
als Beispiel der Modifiereintrag:

bool udi_hid_kbd_modifier_up(uint8_t modifier_id)
{
  irqflags_t flags = cpu_irq_save();

  // Fill report
  udi_hid_kbd_report[0] &= ~(unsigned)modifier_id;
  udi_hid_kbd_b_report_valid = true;

  // Send report
  udi_hid_kbd_send_report();

  cpu_irq_restore(flags);
  return true;
}

Hier machen sie also cli(), dann das Bit eintragen, dann kommt 
udi_hid_kbd_send_report():

static bool udi_hid_kbd_send_report(void)    // runs in disabled int
{
  if (udi_hid_kbd_b_report_trans_ongoing)
    return false;
  memcpy(udi_hid_kbd_report_trans, udi_hid_kbd_report,
      UDI_HID_KBD_REPORT_SIZE);
  udi_hid_kbd_b_report_valid = false;
  udi_hid_kbd_b_report_trans_ongoing =
      udd_ep_run(  UDI_HID_KBD_EP_IN,
              false,
              udi_hid_kbd_report_trans,
              UDI_HID_KBD_REPORT_SIZE,
              udi_hid_kbd_report_sent);
  return udi_hid_kbd_b_report_trans_ongoing;
}

Hier geht es, wenn möglich, nach udd_ep_run() = Endpoint run. Endpoint 
run ist dann eine länger Geschichte:

bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t * buf,
    iram_size_t buf_size, udd_callback_trans_t callback)
{
  udd_ep_job_t *ptr_job;
  irqflags_t flags;
  UDD_EP_t *ep_ctrl;

  Assert(udd_ep_is_valid(ep));

  // Get control & job about this endpoint
  ptr_job = udd_ep_get_job(ep);
  ep_ctrl = udd_ep_get_ctrl(ep);

  if (!udd_endpoint_is_enable(ep_ctrl)) {
    return false; // Endpoint not allocated
  }
  if (udd_endpoint_get_type(ep_ctrl)!=USB_EP_TYPE_ISOCHRONOUS_gc
    && udd_endpoint_is_stall(ep_ctrl)) {
    return false; // Endpoint is halted
  }
  flags = cpu_irq_save();          // endpoint run
  if (ptr_job->busy == true) {
    cpu_irq_restore(flags);
    return false; // Job already on going
  }
  ptr_job->busy = true;
  cpu_irq_restore(flags);


  // Update Job information
  ptr_job->buf = buf;
  ptr_job->buf_size = buf_size;
  ptr_job->nb_trans = 0;
  ptr_job->call_trans = callback;
  // Need to enable shortpacket to send a ZLP (buf_size==0)
  ptr_job->b_shortpacket = b_shortpacket || (buf_size==0);
  ptr_job->b_use_out_cache_buffer = false;

  // Initialize value to simulate a empty transfer
  if (USB_EP_DIR_IN == (ep & USB_EP_DIR_IN)) {
    udd_endpoint_in_reset_nb_sent(ep_ctrl);
  }
  else
  {
    if ((USB_EP_TYPE_ISOCHRONOUS_gc == udd_endpoint_get_type(ep_ctrl))
    && (0 != (buf_size % udd_ep_get_size(ep_ctrl)))) {
      // The user must use a buffer size modulo endpoint size
      ptr_job->busy = false;
      return false;
    }
    udd_endpoint_out_reset_nb_received(ep_ctrl);
    udd_endpoint_out_set_nbbyte(ep_ctrl, 0);
  }
  // Request next transfer
  udd_ep_trans_complet(ep);
  return true;
}

Hier ist die eigentlich kritische Geschichte, nämlich kontrollieren ob 
ptr_job->busy == true ist, nochmals mit cli()-restore geklammert. 
Brauche ich dann die äußere Verriegelung bei udi_hid_kbd_modifier_up? 
Oder soll die nur reentry verhindern?

Gruß Wolfgang