// SPDX-License-Identifier: GPL-2.0
/*
 * MIPI SyS-T framing protocol for STM devices.
 * Copyright (c) 2018, Intel Corporation.
 */

#include <linux/configfs.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/uuid.h>
#include <linux/stm.h>
#include "stm.h"

enum sys_t_message_type {
 MIPI_SYST_TYPE_BUILD = 0,
 MIPI_SYST_TYPE_SHORT32,
 MIPI_SYST_TYPE_STRING,
 MIPI_SYST_TYPE_CATALOG,
 MIPI_SYST_TYPE_RAW = 6,
 MIPI_SYST_TYPE_SHORT64,
 MIPI_SYST_TYPE_CLOCK,
 MIPI_SYST_TYPE_SBD,
};

enum sys_t_message_severity {
 MIPI_SYST_SEVERITY_MAX = 0,
 MIPI_SYST_SEVERITY_FATAL,
 MIPI_SYST_SEVERITY_ERROR,
 MIPI_SYST_SEVERITY_WARNING,
 MIPI_SYST_SEVERITY_INFO,
 MIPI_SYST_SEVERITY_USER1,
 MIPI_SYST_SEVERITY_USER2,
 MIPI_SYST_SEVERITY_DEBUG,
};

enum sys_t_message_build_subtype {
 MIPI_SYST_BUILD_ID_COMPACT32 = 0,
 MIPI_SYST_BUILD_ID_COMPACT64,
 MIPI_SYST_BUILD_ID_LONG,
};

enum sys_t_message_clock_subtype {
 MIPI_SYST_CLOCK_TRANSPORT_SYNC = 1,
};

enum sys_t_message_string_subtype {
 MIPI_SYST_STRING_GENERIC = 1,
 MIPI_SYST_STRING_FUNCTIONENTER,
 MIPI_SYST_STRING_FUNCTIONEXIT,
 MIPI_SYST_STRING_INVALIDPARAM = 5,
 MIPI_SYST_STRING_ASSERT  = 7,
 MIPI_SYST_STRING_PRINTF_32 = 11,
 MIPI_SYST_STRING_PRINTF_64 = 12,
};

/**
 * enum sys_t_message_sbd_subtype - SyS-T SBD message subtypes
 * @MIPI_SYST_SBD_ID32: SBD message with 32-bit message ID
 * @MIPI_SYST_SBD_ID64: SBD message with 64-bit message ID
 *
 * Structured Binary Data messages can send information of arbitrary length,
 * together with ID's that describe BLOB's content and layout.
 */
enum sys_t_message_sbd_subtype {
 MIPI_SYST_SBD_ID32 = 0,
 MIPI_SYST_SBD_ID64 = 1,
};

#define MIPI_SYST_TYPE(t)  ((u32)(MIPI_SYST_TYPE_ ## t))
#define MIPI_SYST_SEVERITY(s)  ((u32)(MIPI_SYST_SEVERITY_ ## s) << 4)
#define MIPI_SYST_OPT_LOC  BIT(8)
#define MIPI_SYST_OPT_LEN  BIT(9)
#define MIPI_SYST_OPT_CHK  BIT(10)
#define MIPI_SYST_OPT_TS  BIT(11)
#define MIPI_SYST_UNIT(u)  ((u32)(u) << 12)
#define MIPI_SYST_ORIGIN(o)  ((u32)(o) << 16)
#define MIPI_SYST_OPT_GUID  BIT(23)
#define MIPI_SYST_SUBTYPE(s)  ((u32)(MIPI_SYST_ ## s) << 24)
#define MIPI_SYST_UNITLARGE(u)  (MIPI_SYST_UNIT(u & 0xf) | \
      MIPI_SYST_ORIGIN(u >> 4))
#define MIPI_SYST_TYPES(t, s)  (MIPI_SYST_TYPE(t) | \
      MIPI_SYST_SUBTYPE(t ## _ ## s))

#define DATA_HEADER (MIPI_SYST_TYPES(STRING, GENERIC) | \
    MIPI_SYST_SEVERITY(INFO)  | \
    MIPI_SYST_OPT_GUID)

#define CLOCK_SYNC_HEADER (MIPI_SYST_TYPES(CLOCK, TRANSPORT_SYNC) | \
     MIPI_SYST_SEVERITY(MAX))

/*
 * SyS-T and ftrace headers are compatible to an extent that ftrace event ID
 * and args can be treated as SyS-T SBD message with 64-bit ID and arguments
 * BLOB right behind the header without modification. Bits [16:63] coming
 * together with message ID from ftrace aren't used by SBD and must be zeroed.
 *
 *         0       15  16   23  24     31  32   39  40  63
 * ftrace: <event_id>  <flags>  <preempt>  <-pid->  <----> <args>
 * SBD:    <------- msg_id ------------------------------> <BLOB>
 */
#define SBD_HEADER (MIPI_SYST_TYPES(SBD, ID64) | \
    MIPI_SYST_SEVERITY(INFO)  | \
    MIPI_SYST_OPT_GUID)

struct sys_t_policy_node {
 uuid_t  uuid;
 bool  do_len;
 unsigned long ts_interval;
 unsigned long clocksync_interval;
};

struct sys_t_output {
 struct sys_t_policy_node node;
 unsigned long ts_jiffies;
 unsigned long clocksync_jiffies;
};

static void sys_t_policy_node_init(void *priv)
{
 struct sys_t_policy_node *pn = priv;

 uuid_gen(&pn->uuid);
}

static int sys_t_output_open(void *priv, struct stm_output *output)
{
 struct sys_t_policy_node *pn = priv;
 struct sys_t_output *opriv;

 opriv = kzalloc(sizeof(*opriv), GFP_ATOMIC);
 if (!opriv)
  return -ENOMEM;

 memcpy(&opriv->node, pn, sizeof(opriv->node));
 output->pdrv_private = opriv;

 return 0;
}

static void sys_t_output_close(struct stm_output *output)
{
 kfree(output->pdrv_private);
}

static ssize_t sys_t_policy_uuid_show(struct config_item *item,
          char *page)
{
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);

 return sprintf(page, "%pU\n", &pn->uuid);
}

static ssize_t
sys_t_policy_uuid_store(struct config_item *item, const char *page,
   size_t count)
{
 struct mutex *mutexp = &item->ci_group->cg_subsys->su_mutex;
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);
 int ret;

 mutex_lock(mutexp);
 ret = uuid_parse(page, &pn->uuid);
 mutex_unlock(mutexp);

 return ret < 0 ? ret : count;
}

CONFIGFS_ATTR(sys_t_policy_, uuid);

static ssize_t sys_t_policy_do_len_show(struct config_item *item,
          char *page)
{
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);

 return sprintf(page, "%d\n", pn->do_len);
}

static ssize_t
sys_t_policy_do_len_store(struct config_item *item, const char *page,
   size_t count)
{
 struct mutex *mutexp = &item->ci_group->cg_subsys->su_mutex;
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);
 int ret;

 mutex_lock(mutexp);
 ret = kstrtobool(page, &pn->do_len);
 mutex_unlock(mutexp);

 return ret ? ret : count;
}

CONFIGFS_ATTR(sys_t_policy_, do_len);

static ssize_t sys_t_policy_ts_interval_show(struct config_item *item,
          char *page)
{
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);

 return sprintf(page, "%u\n", jiffies_to_msecs(pn->ts_interval));
}

static ssize_t
sys_t_policy_ts_interval_store(struct config_item *item, const char *page,
          size_t count)
{
 struct mutex *mutexp = &item->ci_group->cg_subsys->su_mutex;
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);
 unsigned int ms;
 int ret;

 mutex_lock(mutexp);
 ret = kstrtouint(page, 10, &ms);
 mutex_unlock(mutexp);

 if (!ret) {
  pn->ts_interval = msecs_to_jiffies(ms);
  return count;
 }

 return ret;
}

CONFIGFS_ATTR(sys_t_policy_, ts_interval);

static ssize_t sys_t_policy_clocksync_interval_show(struct config_item *item,
          char *page)
{
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);

 return sprintf(page, "%u\n", jiffies_to_msecs(pn->clocksync_interval));
}

static ssize_t
sys_t_policy_clocksync_interval_store(struct config_item *item,
          const char *page, size_t count)
{
 struct mutex *mutexp = &item->ci_group->cg_subsys->su_mutex;
 struct sys_t_policy_node *pn = to_pdrv_policy_node(item);
 unsigned int ms;
 int ret;

 mutex_lock(mutexp);
 ret = kstrtouint(page, 10, &ms);
 mutex_unlock(mutexp);

 if (!ret) {
  pn->clocksync_interval = msecs_to_jiffies(ms);
  return count;
 }

 return ret;
}

CONFIGFS_ATTR(sys_t_policy_, clocksync_interval);

static struct configfs_attribute *sys_t_policy_attrs[] = {
 &sys_t_policy_attr_uuid,
 &sys_t_policy_attr_do_len,
 &sys_t_policy_attr_ts_interval,
 &sys_t_policy_attr_clocksync_interval,
 NULL,
};

static inline bool sys_t_need_ts(struct sys_t_output *op)
{
 if (op->node.ts_interval &&
     time_after(jiffies, op->ts_jiffies + op->node.ts_interval)) {
  op->ts_jiffies = jiffies;

  return true;
 }

 return false;
}

static bool sys_t_need_clock_sync(struct sys_t_output *op)
{
 if (op->node.clocksync_interval &&
     time_after(jiffies,
         op->clocksync_jiffies + op->node.clocksync_interval)) {
  op->clocksync_jiffies = jiffies;

  return true;
 }

 return false;
}

static ssize_t
sys_t_clock_sync(struct stm_data *data, unsigned int m, unsigned int c)
{
 u32 header = CLOCK_SYNC_HEADER;
 const unsigned char nil = 0;
 u64 payload[2]; /* Clock value and frequency */
 ssize_t sz;

 sz = data->packet(data, m, c, STP_PACKET_DATA, STP_PACKET_TIMESTAMPED,
     4, (u8 *)&header);
 if (sz <= 0)
  return sz;

 payload[0] = ktime_get_real_ns();
 payload[1] = NSEC_PER_SEC;
 sz = stm_data_write(data, m, c, false, &payload, sizeof(payload));
 if (sz <= 0)
  return sz;

 data->packet(data, m, c, STP_PACKET_FLAG, 0, 0, &nil);

 return sizeof(header) + sizeof(payload);
}

static inline u32 sys_t_header(struct stm_source_data *source)
{
 if (source && source->type == STM_FTRACE)
  return SBD_HEADER;
 return DATA_HEADER;
}

static ssize_t sys_t_write_data(struct stm_data *data,
    struct stm_source_data *source,
    unsigned int master, unsigned int channel,
    bool ts_first, const void *buf, size_t count)
{
 ssize_t sz;
 const unsigned char nil = 0;

 /*
  * Ftrace is zero-copy compatible with SyS-T SBD, but requires
  * special handling of first 64 bits. Trim and send them separately
  * to avoid damage on original ftrace buffer.
 */
 if (source && source->type == STM_FTRACE) {
  u64 compat_ftrace_header;
  ssize_t header_sz;
  ssize_t buf_sz;

  if (count < sizeof(compat_ftrace_header))
   return -EINVAL;

  /* SBD only makes use of low 16 bits (event ID) from ftrace event */
  compat_ftrace_header = *(u64 *)buf & 0xffff;
  header_sz = stm_data_write(data, master, channel, false,
        &compat_ftrace_header,
        sizeof(compat_ftrace_header));
  if (header_sz != sizeof(compat_ftrace_header))
   return header_sz;

  buf_sz = stm_data_write(data, master, channel, false,
     buf + header_sz, count - header_sz);
  if (buf_sz != count - header_sz)
   return buf_sz;
  sz = header_sz + buf_sz;
 } else {
  sz = stm_data_write(data, master, channel, false, buf, count);
 }

 if (sz <= 0)
  return sz;

 data->packet(data, master, channel, STP_PACKET_FLAG, 0, 0, &nil);

 return sz;
}

static ssize_t sys_t_write(struct stm_data *data, struct stm_output *output,
      unsigned int chan, const char *buf, size_t count,
      struct stm_source_data *source)
{
 struct sys_t_output *op = output->pdrv_private;
 unsigned int c = output->channel + chan;
 unsigned int m = output->master;
 u32 header = sys_t_header(source);
 u8 uuid[UUID_SIZE];
 ssize_t sz;

 /* We require an existing policy node to proceed */
 if (!op)
  return -EINVAL;

 if (sys_t_need_clock_sync(op)) {
  sz = sys_t_clock_sync(data, m, c);
  if (sz <= 0)
   return sz;
 }

 if (op->node.do_len)
  header |= MIPI_SYST_OPT_LEN;
 if (sys_t_need_ts(op))
  header |= MIPI_SYST_OPT_TS;

 /*
  * STP framing rules for SyS-T frames:
  *   * the first packet of the SyS-T frame is timestamped;
  *   * the last packet is a FLAG.
 */
 /* Message layout: HEADER / GUID / [LENGTH /][TIMESTAMP /] DATA */
 /* HEADER */
 sz = data->packet(data, m, c, STP_PACKET_DATA, STP_PACKET_TIMESTAMPED,
     4, (u8 *)&header);
 if (sz <= 0)
  return sz;

 /* GUID */
 export_uuid(uuid, &op->node.uuid);
 sz = stm_data_write(data, m, c, false, uuid, sizeof(op->node.uuid));
 if (sz <= 0)
  return sz;

 /* [LENGTH] */
 if (op->node.do_len) {
  u16 length = count;

  sz = data->packet(data, m, c, STP_PACKET_DATA, 0, 2,
      (u8 *)&length);
  if (sz <= 0)
   return sz;
 }

 /* [TIMESTAMP] */
 if (header & MIPI_SYST_OPT_TS) {
  u64 ts = ktime_get_real_ns();

  sz = stm_data_write(data, m, c, false, &ts, sizeof(ts));
  if (sz <= 0)
   return sz;
 }

 /* DATA */
 return sys_t_write_data(data, source, m, c, false, buf, count);
}

static const struct stm_protocol_driver sys_t_pdrv = {
 .owner   = THIS_MODULE,
 .name   = "p_sys-t",
 .priv_sz  = sizeof(struct sys_t_policy_node),
 .write   = sys_t_write,
 .policy_attr  = sys_t_policy_attrs,
 .policy_node_init = sys_t_policy_node_init,
 .output_open  = sys_t_output_open,
 .output_close  = sys_t_output_close,
};

static int sys_t_stm_init(void)
{
 return stm_register_protocol(&sys_t_pdrv);
}

static void sys_t_stm_exit(void)
{
 stm_unregister_protocol(&sys_t_pdrv);
}

module_init(sys_t_stm_init);
module_exit(sys_t_stm_exit);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("MIPI SyS-T STM framing protocol driver");
MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>");