uart_base.h

/* SPDX-License-Identifier: GPL-2.0-only OR License-Ref-kk-custom */
/*
 * Copyright (C) 2023 Kernkonzept GmbH.
 */
/*
 * (c) 2009-2012 Adam Lackorzynski <adam@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 */
#pragma once
 
#include <stddef.h>
#include <l4/drivers/io_regblock.h>
 
#include "poll_timeout_counter.h"
 
namespace L4
{
  class Uart
  {
  protected:
    unsigned _mode;
    unsigned _rate;
    Io_register_block const *_regs;
 
  public:
    void *operator new (size_t, void* a)
    { return a; }
 
  public:
    typedef unsigned Transfer_mode;
    typedef unsigned Baud_rate;
 
    Uart()
    : _mode(~0U), _rate(~0U)
    {}
 
    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 get_char(bool blocking = true) const = 0;
 
    virtual int char_avail() const = 0;
 
    virtual int write(char const *s, unsigned long count,
                      bool blocking = true) const = 0;
 
    virtual void irq_ack() {}
 
    virtual bool enable_rx_irq(bool = true) { return false; }
 
    Transfer_mode mode() const { return _mode; }
 
    Baud_rate rate() const { return _rate; }
 
  protected:
    template <typename Uart_driver>
    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;
 
          Poll_timeout_counter i(3000000);
          while (i.test(!self->tx_avail()))
            ;
 
          self->out_char(*s++);
        }
 
      if (blocking)
        self->wait_tx_done();
 
      return c;
    }
  };
}