// SPDX-License-Identifier: GPL-2.0+

  /*
   * (C) Copyright 2007 Semihalf
   *
   * Written by: Rafal Jaworowski <raj@semihalf.com>

   */
  
  #include <config.h>

  #include <command.h>
  #include <common.h>

  #include <env.h>

  #include <malloc.h>

  #include <env_internal.h>

  #include <linux/types.h>
  #include <api_public.h>

  #include <u-boot/crc.h>

  
  #include "api_private.h"
  
  #define DEBUG
  #undef DEBUG

  /*****************************************************************************
   *
   * This is the API core.
   *
   * API_ functions are part of U-Boot code and constitute the lowest level
   * calls:
   *
   *  - they know what values they need as arguments
   *  - their direct return value pertains to the API_ "shell" itself (0 on
   *    success, some error code otherwise)
   *  - if the call returns a value it is buried within arguments
   *
   ****************************************************************************/
  
  #ifdef DEBUG
  #define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt, ##args); } while (0)
  #else
  #define debugf(fmt, args...)
  #endif
  
  typedef	int (*cfp_t)(va_list argp);
  
  static int calls_no;
  
  /*
   * pseudo signature:
   *
   * int API_getc(int *c)
   */
  static int API_getc(va_list ap)
  {
  	int *c;

  	if ((c = (int *)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;
  
  	*c = getc();
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_tstc(int *c)
   */
  static int API_tstc(va_list ap)
  {
  	int *t;

  	if ((t = (int *)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;
  
  	*t = tstc();
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_putc(char *ch)
   */
  static int API_putc(va_list ap)
  {
  	char *c;

  	if ((c = (char *)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;
  
  	putc(*c);
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_puts(char **s)
   */
  static int API_puts(va_list ap)
  {
  	char *s;

  	if ((s = (char *)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;
  
  	puts(s);
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_reset(void)
   */
  static int API_reset(va_list ap)
  {
  	do_reset(NULL, 0, 0, NULL);
  
  	/* NOT REACHED */
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_get_sys_info(struct sys_info *si)
   *
   * fill out the sys_info struct containing selected parameters about the
   * machine
   */
  static int API_get_sys_info(va_list ap)
  {
  	struct sys_info *si;

  	si = (struct sys_info *)va_arg(ap, uintptr_t);

  	if (si == NULL)
  		return API_ENOMEM;
  
  	return (platform_sys_info(si)) ? 0 : API_ENODEV;
  }
  
  /*
   * pseudo signature:
   *
   * int API_udelay(unsigned long *udelay)
   */
  static int API_udelay(va_list ap)
  {
  	unsigned long *d;

  	if ((d = (unsigned long *)va_arg(ap, unsigned long)) == NULL)

  		return API_EINVAL;
  
  	udelay(*d);
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_get_timer(unsigned long *current, unsigned long *base)
   */
  static int API_get_timer(va_list ap)
  {
  	unsigned long *base, *cur;

  	cur = (unsigned long *)va_arg(ap, unsigned long);

  	if (cur == NULL)
  		return API_EINVAL;

  	base = (unsigned long *)va_arg(ap, unsigned long);

  	if (base == NULL)
  		return API_EINVAL;
  
  	*cur = get_timer(*base);
  	return 0;
  }
  
  
  /*****************************************************************************
   *
   * pseudo signature:
   *
   * int API_dev_enum(struct device_info *)
   *
   *
   * cookies uniqely identify the previously enumerated device instance and
   * provide a hint for what to inspect in current enum iteration:
   *
   *   - net: &eth_device struct address from list pointed to by eth_devices
   *

   *   - storage: struct blk_desc struct address from &ide_dev_desc[n],

   *     &scsi_dev_desc[n] and similar tables
   *
   ****************************************************************************/
  
  static int API_dev_enum(va_list ap)
  {
  	struct device_info *di;
  
  	/* arg is ptr to the device_info struct we are going to fill out */

  	di = (struct device_info *)va_arg(ap, uintptr_t);

  	if (di == NULL)
  		return API_EINVAL;
  
  	if (di->cookie == NULL) {
  		/* start over - clean up enumeration */
  		dev_enum_reset();	/* XXX shouldn't the name contain 'stor'? */
  		debugf("RESTART ENUM
  ");

  		/* net device enumeration first */
  		if (dev_enum_net(di))
  			return 0;
  	}
  
  	/*
  	 * The hidden assumption is there can only be one active network
  	 * device and it is identified upon enumeration (re)start, so there's
  	 * no point in trying to find network devices in other cases than the
  	 * (re)start and hence the 'next' device can only be storage
  	 */
  	if (!dev_enum_storage(di))
  		/* make sure we mark there are no more devices */
  		di->cookie = NULL;
  
  	return 0;
  }
  
  
  static int API_dev_open(va_list ap)
  {
  	struct device_info *di;
  	int err = 0;
  
  	/* arg is ptr to the device_info struct */

  	di = (struct device_info *)va_arg(ap, uintptr_t);

  	if (di == NULL)
  		return API_EINVAL;
  
  	/* Allow only one consumer of the device at a time */
  	if (di->state == DEV_STA_OPEN)
  		return API_EBUSY;
  
  	if (di->cookie == NULL)
  		return API_ENODEV;
  
  	if (di->type & DEV_TYP_STOR)
  		err = dev_open_stor(di->cookie);
  
  	else if (di->type & DEV_TYP_NET)
  		err = dev_open_net(di->cookie);
  	else
  		err = API_ENODEV;
  
  	if (!err)
  		di->state = DEV_STA_OPEN;
  
  	return err;
  }
  
  
  static int API_dev_close(va_list ap)
  {
  	struct device_info *di;
  	int err = 0;
  
  	/* arg is ptr to the device_info struct */

  	di = (struct device_info *)va_arg(ap, uintptr_t);

  	if (di == NULL)
  		return API_EINVAL;
  
  	if (di->state == DEV_STA_CLOSED)
  		return 0;
  
  	if (di->cookie == NULL)
  		return API_ENODEV;
  
  	if (di->type & DEV_TYP_STOR)
  		err = dev_close_stor(di->cookie);
  
  	else if (di->type & DEV_TYP_NET)
  		err = dev_close_net(di->cookie);
  	else
  		/*
  		 * In case of unknown device we cannot change its state, so
  		 * only return error code
  		 */
  		err = API_ENODEV;
  
  	if (!err)
  		di->state = DEV_STA_CLOSED;
  
  	return err;
  }
  
  
  /*

   * pseudo signature:
   *
   * int API_dev_write(
   *	struct device_info *di,
   *	void *buf,

   *	int *len,
   *	unsigned long *start

   * )
   *
   * buf:	ptr to buffer from where to get the data to send
   *

   * len: ptr to length to be read
   *      - network: len of packet to be sent (in bytes)
   *      - storage: # of blocks to write (can vary in size depending on define)

   *

   * start: ptr to start block (only used for storage devices, ignored for
   *        network)

   */
  static int API_dev_write(va_list ap)
  {
  	struct device_info *di;
  	void *buf;

  	lbasize_t *len_stor, act_len_stor;
  	lbastart_t *start;
  	int *len_net;

  	int err = 0;
  
  	/* 1. arg is ptr to the device_info struct */

  	di = (struct device_info *)va_arg(ap, uintptr_t);

  	if (di == NULL)
  		return API_EINVAL;
  
  	/* XXX should we check if device is open? i.e. the ->state ? */
  
  	if (di->cookie == NULL)
  		return API_ENODEV;
  
  	/* 2. arg is ptr to buffer from where to get data to write */

  	buf = (void *)va_arg(ap, uintptr_t);

  	if (buf == NULL)
  		return API_EINVAL;

  	if (di->type & DEV_TYP_STOR) {
  		/* 3. arg - ptr to var with # of blocks to write */
  		len_stor = (lbasize_t *)va_arg(ap, uintptr_t);
  		if (!len_stor)
  			return API_EINVAL;
  		if (*len_stor <= 0)
  			return API_EINVAL;
  
  		/* 4. arg - ptr to var with start block */
  		start = (lbastart_t *)va_arg(ap, uintptr_t);
  
  		act_len_stor = dev_write_stor(di->cookie, buf, *len_stor, *start);
  		if (act_len_stor != *len_stor) {
  			debugf("write @ %llu: done %llu out of %llu blocks",
  				   (uint64_t)blk, (uint64_t)act_len_stor,
  				   (uint64_t)len_stor);
  			return API_EIO;
  		}
  
  	} else if (di->type & DEV_TYP_NET) {
  		/* 3. arg points to the var with length of packet to write */
  		len_net = (int *)va_arg(ap, uintptr_t);
  		if (!len_net)
  			return API_EINVAL;
  		if (*len_net <= 0)
  			return API_EINVAL;
  
  		err = dev_write_net(di->cookie, buf, *len_net);
  
  	} else

  		err = API_ENODEV;
  
  	return err;
  }
  
  
  /*
   * pseudo signature:
   *
   * int API_dev_read(
   *	struct device_info *di,
   *	void *buf,
   *	size_t *len,
   *	unsigned long *start
   *	size_t *act_len
   * )
   *
   * buf:	ptr to buffer where to put the read data
   *
   * len: ptr to length to be read
   *      - network: len of packet to read (in bytes)
   *      - storage: # of blocks to read (can vary in size depending on define)
   *
   * start: ptr to start block (only used for storage devices, ignored for
   *        network)
   *
   * act_len: ptr to where to put the len actually read
   */
  static int API_dev_read(va_list ap)
  {
  	struct device_info *di;
  	void *buf;
  	lbasize_t *len_stor, *act_len_stor;
  	lbastart_t *start;
  	int *len_net, *act_len_net;
  
  	/* 1. arg is ptr to the device_info struct */

  	di = (struct device_info *)va_arg(ap, uintptr_t);

  	if (di == NULL)
  		return API_EINVAL;
  
  	/* XXX should we check if device is open? i.e. the ->state ? */
  
  	if (di->cookie == NULL)
  		return API_ENODEV;
  
  	/* 2. arg is ptr to buffer from where to put the read data */

  	buf = (void *)va_arg(ap, uintptr_t);

  	if (buf == NULL)
  		return API_EINVAL;
  
  	if (di->type & DEV_TYP_STOR) {
  		/* 3. arg - ptr to var with # of blocks to read */

  		len_stor = (lbasize_t *)va_arg(ap, uintptr_t);

  		if (!len_stor)
  			return API_EINVAL;
  		if (*len_stor <= 0)
  			return API_EINVAL;
  
  		/* 4. arg - ptr to var with start block */

  		start = (lbastart_t *)va_arg(ap, uintptr_t);

  
  		/* 5. arg - ptr to var where to put the len actually read */

  		act_len_stor = (lbasize_t *)va_arg(ap, uintptr_t);

  		if (!act_len_stor)
  			return API_EINVAL;
  
  		*act_len_stor = dev_read_stor(di->cookie, buf, *len_stor, *start);
  
  	} else if (di->type & DEV_TYP_NET) {
  
  		/* 3. arg points to the var with length of packet to read */

  		len_net = (int *)va_arg(ap, uintptr_t);

  		if (!len_net)
  			return API_EINVAL;
  		if (*len_net <= 0)
  			return API_EINVAL;
  
  		/* 4. - ptr to var where to put the len actually read */

  		act_len_net = (int *)va_arg(ap, uintptr_t);

  		if (!act_len_net)
  			return API_EINVAL;
  
  		*act_len_net = dev_read_net(di->cookie, buf, *len_net);
  
  	} else
  		return API_ENODEV;
  
  	return 0;
  }
  
  
  /*
   * pseudo signature:
   *
   * int API_env_get(const char *name, char **value)
   *
   * name: ptr to name of env var
   */
  static int API_env_get(va_list ap)
  {
  	char *name, **value;

  	if ((name = (char *)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;

  	if ((value = (char **)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;

  	*value = env_get(name);

  
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_env_set(const char *name, const char *value)
   *
   * name: ptr to name of env var
   *
   * value: ptr to value to be set
   */
  static int API_env_set(va_list ap)
  {
  	char *name, *value;

  	if ((name = (char *)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;

  	if ((value = (char *)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;

  	env_set(name, value);

  
  	return 0;
  }
  
  /*
   * pseudo signature:
   *
   * int API_env_enum(const char *last, char **next)
   *
   * last: ptr to name of env var found in last iteration
   */
  static int API_env_enum(va_list ap)
  {

  	int i, buflen;
  	char *last, **next, *s;

  	struct env_entry *match, search;

  	static char *var;

  	last = (char *)va_arg(ap, unsigned long);

  	if ((next = (char **)va_arg(ap, uintptr_t)) == NULL)

  		return API_EINVAL;

  	if (last == NULL) {
  		var = NULL;
  		i = 0;
  	} else {
  		var = strdup(last);
  		s = strchr(var, '=');
  		if (s != NULL)
  			*s = 0;
  		search.key = var;

  		i = hsearch_r(search, ENV_FIND, &match, &env_htab, 0);

  		if (i == 0) {
  			i = API_EINVAL;
  			goto done;

  		}
  	}

  	/* match the next entry after i */
  	i = hmatch_r("", i, &match, &env_htab);
  	if (i == 0)
  		goto done;
  	buflen = strlen(match->key) + strlen(match->data) + 2;
  	var = realloc(var, buflen);
  	snprintf(var, buflen, "%s=%s", match->key, match->data);
  	*next = var;

  	return 0;

  
  done:
  	free(var);
  	var = NULL;
  	*next = NULL;
  	return i;

  }

  /*
   * pseudo signature:
   *
   * int API_display_get_info(int type, struct display_info *di)
   */
  static int API_display_get_info(va_list ap)
  {
  	int type;
  	struct display_info *di;
  
  	type = va_arg(ap, int);
  	di = va_arg(ap, struct display_info *);
  
  	return display_get_info(type, di);
  }
  
  /*
   * pseudo signature:
   *
   * int API_display_draw_bitmap(ulong bitmap, int x, int y)
   */
  static int API_display_draw_bitmap(va_list ap)
  {
  	ulong bitmap;
  	int x, y;
  
  	bitmap = va_arg(ap, ulong);
  	x = va_arg(ap, int);
  	y = va_arg(ap, int);
  
  	return display_draw_bitmap(bitmap, x, y);
  }
  
  /*
   * pseudo signature:
   *
   * void API_display_clear(void)
   */
  static int API_display_clear(va_list ap)
  {
  	display_clear();
  	return 0;
  }

  static cfp_t calls_table[API_MAXCALL] = { NULL, };
  
  /*
   * The main syscall entry point - this is not reentrant, only one call is
   * serviced until finished.
   *
   * e.g. syscall(1, int *, u_int32_t, u_int32_t, u_int32_t, u_int32_t);

   *

   * call:	syscall number
   *
   * retval:	points to the return value placeholder, this is the place the
   *		syscall puts its return value, if NULL the caller does not
   *		expect a return value
   *
   * ...		syscall arguments (variable number)
   *
   * returns:	0 if the call not found, 1 if serviced
   */
  int syscall(int call, int *retval, ...)
  {
  	va_list	ap;
  	int rv;

  	if (call < 0 || call >= calls_no) {

  		debugf("invalid call #%d
  ", call);
  		return 0;
  	}
  
  	if (calls_table[call] == NULL) {
  		debugf("syscall #%d does not have a handler
  ", call);
  		return 0;
  	}
  
  	va_start(ap, retval);
  	rv = calls_table[call](ap);
  	if (retval != NULL)
  		*retval = rv;
  
  	return 1;
  }
  
  void api_init(void)
  {

  	struct api_signature *sig;

  
  	/* TODO put this into linker set one day... */
  	calls_table[API_RSVD] = NULL;
  	calls_table[API_GETC] = &API_getc;
  	calls_table[API_PUTC] = &API_putc;
  	calls_table[API_TSTC] = &API_tstc;
  	calls_table[API_PUTS] = &API_puts;
  	calls_table[API_RESET] = &API_reset;
  	calls_table[API_GET_SYS_INFO] = &API_get_sys_info;
  	calls_table[API_UDELAY] = &API_udelay;
  	calls_table[API_GET_TIMER] = &API_get_timer;
  	calls_table[API_DEV_ENUM] = &API_dev_enum;
  	calls_table[API_DEV_OPEN] = &API_dev_open;
  	calls_table[API_DEV_CLOSE] = &API_dev_close;
  	calls_table[API_DEV_READ] = &API_dev_read;
  	calls_table[API_DEV_WRITE] = &API_dev_write;
  	calls_table[API_ENV_GET] = &API_env_get;
  	calls_table[API_ENV_SET] = &API_env_set;
  	calls_table[API_ENV_ENUM] = &API_env_enum;

  	calls_table[API_DISPLAY_GET_INFO] = &API_display_get_info;
  	calls_table[API_DISPLAY_DRAW_BITMAP] = &API_display_draw_bitmap;
  	calls_table[API_DISPLAY_CLEAR] = &API_display_clear;

  	calls_no = API_MAXCALL;
  
  	debugf("API initialized with %d calls
  ", calls_no);
  
  	dev_stor_init();
  
  	/*
  	 * Produce the signature so the API consumers can find it
  	 */
  	sig = malloc(sizeof(struct api_signature));
  	if (sig == NULL) {
  		printf("API: could not allocate memory for the signature!
  ");
  		return;
  	}

  	env_set_hex("api_address", (unsigned long)sig);

  	debugf("API sig @ 0x%lX
  ", (unsigned long)sig);

  	memcpy(sig->magic, API_SIG_MAGIC, 8);
  	sig->version = API_SIG_VERSION;
  	sig->syscall = &syscall;
  	sig->checksum = 0;
  	sig->checksum = crc32(0, (unsigned char *)sig,
  			      sizeof(struct api_signature));

  	debugf("syscall entry: 0x%lX
  ", (unsigned long)sig->syscall);

  }
  
  void platform_set_mr(struct sys_info *si, unsigned long start, unsigned long size,
  			int flags)
  {
  	int i;
  
  	if (!si->mr || !size || (flags == 0))
  		return;

  	/* find free slot */
  	for (i = 0; i < si->mr_no; i++)
  		if (si->mr[i].flags == 0) {
  			/* insert new mem region */
  			si->mr[i].start = start;
  			si->mr[i].size = size;
  			si->mr[i].flags = flags;
  			return;
  		}
  }