uart_base.h

/*
 * Copyright (C) 2009-2012 Technische Universität Dresden.
 * Copyright (C) 2023-2025 Kernkonzept GmbH.
 * Author(s): Adam Lackorzynski <adam@os.inf.tu-dresden.de>
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
#pragma once
 
#include <stddef.h>
#include <l4/drivers/io_regblock.h>
#include <l4/sys/types.h>
 
#include <l4/drivers/device.h>
#include "poll_timeout_counter.h"
 
namespace L4 {

class Uart : public Dev_obj
{
protected:
  unsigned _mode;
  unsigned _rate;
  Io_register_block const *_regs;
 
public:
  void *operator new (size_t, void *p) { return p; }
 
public:
  typedef unsigned Transfer_mode;
  typedef unsigned Baud_rate;
 
  Uart()
  : _mode(~0U), _rate(~0U)
  {}

  virtual bool reg_shift(unsigned char *shift __attribute__((unused))) const
  { return false; }

  virtual bool startup(Io_register_block const *regs) = 0;
 
  virtual ~Uart() {}

  virtual void shutdown() = 0;

  virtual bool change_mode(Transfer_mode m, Baud_rate r) = 0;

  virtual int write(char const *s, unsigned long count,
                    bool blocking = true) const = 0;

  Transfer_mode mode() const { return _mode; }

  Baud_rate rate() const { return _rate; }
 
#ifndef UART_WITHOUT_INPUT

  virtual bool enable_rx_irq(bool = true) { return false; }

  virtual void irq_ack() {}

  virtual int char_avail() const = 0;

  virtual int get_char(bool blocking = true) const = 0;
 
#endif // !UART_WITHOUT_INPUT
 
protected:
  template <typename Uart_driver, bool Timeout_guard = true>
  int generic_write(char const *s, unsigned long count,
                    bool blocking = true) const
  {
    auto *self = static_cast<Uart_driver const*>(this);
 
    unsigned long c;
    for (c = 0; c < count; ++c)
      {
        if (!blocking && !self->tx_avail())
          break;
 
        if constexpr (Timeout_guard)
          {
            Poll_timeout_counter i(3000000);
            while (i.test(!self->tx_avail()))
              ;
          }
        else
          {
            while (!self->tx_avail())
              ;
          }
 
        self->out_char(*s++);
      }
 
    if (blocking)
      self->wait_tx_done();
 
    return c;
  }
};
 
} // namespace L4
 
/*
 * Instantiate a UART, given the memory.
 */
static inline
L4::Uart *
l4re_dev_uart_create_by_dt_compatible(const char *dt_compatible,
                                      void *obj_buf, unsigned obj_buf_size,
                                      unsigned freq)
{
  L4::Dev_obj *dev = l4re_dev_create_by_dt_compatible(dt_compatible,
                                                      obj_buf, obj_buf_size,
                                                      freq);
  return static_cast<L4::Uart *>(dev);
}
 
/*
 * Instantiate a UART a single time, use an internal static buffer.
 */
static inline
L4::Uart *
l4re_dev_uart_create_by_dt_compatible_once(const char *dt_compatible, unsigned freq)
{
  static bool once_done = false;
 
  if (once_done)
    return nullptr;
 
  static char __attribute__((aligned(sizeof(long) * 2))) obj_buf[64];
  L4::Uart *uart
    = l4re_dev_uart_create_by_dt_compatible(dt_compatible,
                                            obj_buf, sizeof(obj_buf),
                                            freq);
  if (uart)
    once_done = true;
 
  return uart;
}
 
#define l4re_register_device_uart(Device_class, instance_name, \
                                  device_dt_ids, pci_ids) \
  static const struct l4re_device_ids __dev_spec_##instance_name \
    = { .dt = device_dt_ids, .pcidev = pci_ids }; \
  l4re_register_device(L4::Uart, Device_class, instance_name, \
                       __dev_spec_##instance_name)
 
#define l4re_register_device_uart_dt(Device_class, instance_name, dt_ids) \
  l4re_register_device_uart(Device_class, instance_name, dt_ids, nullptr)
 
#define l4re_register_device_uart_pci(Device_class, instance_name, pci_ids) \
  l4re_register_device_uart(Device_class, instance_name, nullptr, pci_ids)