/*
   *  Functions for incremental construction of fcx enabled I/O control blocks.
   *
   *    Copyright IBM Corp. 2008
   *    Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
   */
  
  #include <linux/kernel.h>
  #include <linux/types.h>
  #include <linux/string.h>
  #include <linux/errno.h>
  #include <linux/err.h>
  #include <linux/module.h>
  #include <asm/fcx.h>
  #include <asm/itcw.h>
  
  /**
   * struct itcw - incremental tcw helper data type
   *
   * This structure serves as a handle for the incremental construction of a
   * tcw and associated tccb, tsb, data tidaw-list plus an optional interrogate
   * tcw and associated data. The data structures are contained inside a single
   * contiguous buffer provided by the user.
   *
   * The itcw construction functions take care of overall data integrity:
   * - reset unused fields to zero
   * - fill in required pointers
   * - ensure required alignment for data structures
   * - prevent data structures to cross 4k-byte boundary where required
   * - calculate tccb-related length fields
   * - optionally provide ready-made interrogate tcw and associated structures
   *
   * Restrictions apply to the itcws created with these construction functions:
   * - tida only supported for data address, not for tccb
   * - only contiguous tidaw-lists (no ttic)
   * - total number of bytes required per itcw may not exceed 4k bytes
   * - either read or write operation (may not work with r=0 and w=0)
   *
   * Example:
   * struct itcw *itcw;
   * void *buffer;
   * size_t size;
   *
   * size = itcw_calc_size(1, 2, 0);
   * buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
   * if (!buffer)
   *	return -ENOMEM;
   * itcw = itcw_init(buffer, size, ITCW_OP_READ, 1, 2, 0);
   * if (IS_ERR(itcw))
   *	return PTR_ER(itcw);
   * itcw_add_dcw(itcw, 0x2, 0, NULL, 0, 72);
   * itcw_add_tidaw(itcw, 0, 0x30000, 20);
   * itcw_add_tidaw(itcw, 0, 0x40000, 52);
   * itcw_finalize(itcw);
   *
   */
  struct itcw {
  	struct tcw *tcw;
  	struct tcw *intrg_tcw;
  	int num_tidaws;
  	int max_tidaws;
  	int intrg_num_tidaws;
  	int intrg_max_tidaws;
  };
  
  /**
   * itcw_get_tcw - return pointer to tcw associated with the itcw
   * @itcw: address of the itcw
   *
   * Return pointer to the tcw associated with the itcw.
   */
  struct tcw *itcw_get_tcw(struct itcw *itcw)
  {
  	return itcw->tcw;
  }
  EXPORT_SYMBOL(itcw_get_tcw);
  
  /**
   * itcw_calc_size - return the size of an itcw with the given parameters
   * @intrg: if non-zero, add an interrogate tcw
   * @max_tidaws: maximum number of tidaws to be used for data addressing or zero
   * if no tida is to be used.
   * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing
   * by the interrogate tcw, if specified
   *
   * Calculate and return the number of bytes required to hold an itcw with the
   * given parameters and assuming tccbs with maximum size.
   *
   * Note that the resulting size also contains bytes needed for alignment
   * padding as well as padding to ensure that data structures don't cross a
   * 4k-boundary where required.
   */
  size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws)
  {
  	size_t len;
  	int cross_count;
  
  	/* Main data. */
  	len = sizeof(struct itcw);
  	len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +
  	       /* TSB */ sizeof(struct tsb) +
  	       /* TIDAL */ max_tidaws * sizeof(struct tidaw);
  	/* Interrogate data. */
  	if (intrg) {
  		len += /* TCW */ sizeof(struct tcw) + /* TCCB */ TCCB_MAX_SIZE +
  		       /* TSB */ sizeof(struct tsb) +
  		       /* TIDAL */ intrg_max_tidaws * sizeof(struct tidaw);
  	}
  
  	/* Maximum required alignment padding. */
  	len += /* Initial TCW */ 63 + /* Interrogate TCCB */ 7;
  
  	/* TIDAW lists may not cross a 4k boundary. To cross a
  	 * boundary we need to add a TTIC TIDAW. We need to reserve
  	 * one additional TIDAW for a TTIC that we may need to add due
  	 * to the placement of the data chunk in memory, and a further
  	 * TIDAW for each page boundary that the TIDAW list may cross
  	 * due to it's own size.
  	 */
  	if (max_tidaws) {
  		cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)
  				   >> PAGE_SHIFT);
  		len += cross_count * sizeof(struct tidaw);
  	}
  	if (intrg_max_tidaws) {
  		cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)
  				   >> PAGE_SHIFT);
  		len += cross_count * sizeof(struct tidaw);
  	}
  	return len;
  }
  EXPORT_SYMBOL(itcw_calc_size);
  
  #define CROSS4K(x, l)	(((x) & ~4095) != ((x + l) & ~4095))
  
  static inline void *fit_chunk(addr_t *start, addr_t end, size_t len,
  			      int align, int check_4k)
  {
  	addr_t addr;
  
  	addr = ALIGN(*start, align);
  	if (check_4k && CROSS4K(addr, len)) {
  		addr = ALIGN(addr, 4096);
  		addr = ALIGN(addr, align);
  	}
  	if (addr + len > end)
  		return ERR_PTR(-ENOSPC);
  	*start = addr + len;
  	return (void *) addr;
  }
  
  /**
   * itcw_init - initialize incremental tcw data structure
   * @buffer: address of buffer to use for data structures
   * @size: number of bytes in buffer
   * @op: %ITCW_OP_READ for a read operation tcw, %ITCW_OP_WRITE for a write
   * operation tcw
   * @intrg: if non-zero, add and initialize an interrogate tcw
   * @max_tidaws: maximum number of tidaws to be used for data addressing or zero
   * if no tida is to be used.
   * @intrg_max_tidaws: maximum number of tidaws to be used for data addressing
   * by the interrogate tcw, if specified
   *
   * Prepare the specified buffer to be used as an incremental tcw, i.e. a
   * helper data structure that can be used to construct a valid tcw by
   * successive calls to other helper functions. Note: the buffer needs to be
   * located below the 2G address limit. The resulting tcw has the following
   * restrictions:
   *  - no tccb tidal
   *  - input/output tidal is contiguous (no ttic)
   *  - total data should not exceed 4k
   *  - tcw specifies either read or write operation
   *
   * On success, return pointer to the resulting incremental tcw data structure,
   * ERR_PTR otherwise.
   */
  struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
  		       int max_tidaws, int intrg_max_tidaws)
  {
  	struct itcw *itcw;
  	void *chunk;
  	addr_t start;
  	addr_t end;
  	int cross_count;
  
  	/* Check for 2G limit. */
  	start = (addr_t) buffer;
  	end = start + size;
  	if (end > (1 << 31))
  		return ERR_PTR(-EINVAL);
  	memset(buffer, 0, size);
  	/* ITCW. */
  	chunk = fit_chunk(&start, end, sizeof(struct itcw), 1, 0);
  	if (IS_ERR(chunk))
  		return chunk;
  	itcw = chunk;
  	/* allow for TTIC tidaws that may be needed to cross a page boundary */
  	cross_count = 0;
  	if (max_tidaws)
  		cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)
  				   >> PAGE_SHIFT);
  	itcw->max_tidaws = max_tidaws + cross_count;
  	cross_count = 0;
  	if (intrg_max_tidaws)
  		cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)
  				   >> PAGE_SHIFT);
  	itcw->intrg_max_tidaws = intrg_max_tidaws + cross_count;
  	/* Main TCW. */
  	chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);
  	if (IS_ERR(chunk))
  		return chunk;
  	itcw->tcw = chunk;
  	tcw_init(itcw->tcw, (op == ITCW_OP_READ) ? 1 : 0,
  		 (op == ITCW_OP_WRITE) ? 1 : 0);
  	/* Interrogate TCW. */
  	if (intrg) {
  		chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);
  		if (IS_ERR(chunk))
  			return chunk;
  		itcw->intrg_tcw = chunk;
  		tcw_init(itcw->intrg_tcw, 1, 0);
  		tcw_set_intrg(itcw->tcw, itcw->intrg_tcw);
  	}
  	/* Data TIDAL. */
  	if (max_tidaws > 0) {
  		chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
  				  itcw->max_tidaws, 16, 0);
  		if (IS_ERR(chunk))
  			return chunk;
  		tcw_set_data(itcw->tcw, chunk, 1);
  	}
  	/* Interrogate data TIDAL. */
  	if (intrg && (intrg_max_tidaws > 0)) {
  		chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
  				  itcw->intrg_max_tidaws, 16, 0);
  		if (IS_ERR(chunk))
  			return chunk;
  		tcw_set_data(itcw->intrg_tcw, chunk, 1);
  	}
  	/* TSB. */
  	chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);
  	if (IS_ERR(chunk))
  		return chunk;
  	tsb_init(chunk);
  	tcw_set_tsb(itcw->tcw, chunk);
  	/* Interrogate TSB. */
  	if (intrg) {
  		chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);
  		if (IS_ERR(chunk))
  			return chunk;
  		tsb_init(chunk);
  		tcw_set_tsb(itcw->intrg_tcw, chunk);
  	}
  	/* TCCB. */
  	chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);
  	if (IS_ERR(chunk))
  		return chunk;
  	tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_DEFAULT);
  	tcw_set_tccb(itcw->tcw, chunk);
  	/* Interrogate TCCB. */
  	if (intrg) {
  		chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);
  		if (IS_ERR(chunk))
  			return chunk;
  		tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_INTRG);
  		tcw_set_tccb(itcw->intrg_tcw, chunk);
  		tccb_add_dcw(chunk, TCCB_MAX_SIZE, DCW_CMD_INTRG, 0, NULL,
  			     sizeof(struct dcw_intrg_data), 0);
  		tcw_finalize(itcw->intrg_tcw, 0);
  	}
  	return itcw;
  }
  EXPORT_SYMBOL(itcw_init);
  
  /**
   * itcw_add_dcw - add a dcw to the itcw
   * @itcw: address of the itcw
   * @cmd: the dcw command
   * @flags: flags for the dcw
   * @cd: address of control data for this dcw or NULL if none is required
   * @cd_count: number of control data bytes for this dcw
   * @count: number of data bytes for this dcw
   *
   * Add a new dcw to the specified itcw by writing the dcw information specified
   * by @cmd, @flags, @cd, @cd_count and @count to the tca of the tccb. Return
   * a pointer to the newly added dcw on success or -%ENOSPC if the new dcw
   * would exceed the available space.
   *
   * Note: the tcal field of the tccb header will be updated to reflect added
   * content.
   */
  struct dcw *itcw_add_dcw(struct itcw *itcw, u8 cmd, u8 flags, void *cd,
  			 u8 cd_count, u32 count)
  {
  	return tccb_add_dcw(tcw_get_tccb(itcw->tcw), TCCB_MAX_SIZE, cmd,
  			    flags, cd, cd_count, count);
  }
  EXPORT_SYMBOL(itcw_add_dcw);
  
  /**
   * itcw_add_tidaw - add a tidaw to the itcw
   * @itcw: address of the itcw
   * @flags: flags for the new tidaw
   * @addr: address value for the new tidaw
   * @count: count value for the new tidaw
   *
   * Add a new tidaw to the input/output data tidaw-list of the specified itcw
   * (depending on the value of the r-flag and w-flag). Return a pointer to
   * the new tidaw on success or -%ENOSPC if the new tidaw would exceed the
   * available space.
   *
   * Note: TTIC tidaws are automatically added when needed, so explicitly calling
   * this interface with the TTIC flag is not supported. The last-tidaw flag
   * for the last tidaw in the list will be set by itcw_finalize.
   */
  struct tidaw *itcw_add_tidaw(struct itcw *itcw, u8 flags, void *addr, u32 count)
  {
  	struct tidaw *following;
  
  	if (itcw->num_tidaws >= itcw->max_tidaws)
  		return ERR_PTR(-ENOSPC);
  	/*
  	 * Is the tidaw, which follows the one we are about to fill, on the next
  	 * page? Then we have to insert a TTIC tidaw first, that points to the
  	 * tidaw on the new page.
  	 */
  	following = ((struct tidaw *) tcw_get_data(itcw->tcw))
  		+ itcw->num_tidaws + 1;
  	if (itcw->num_tidaws && !((unsigned long) following & ~PAGE_MASK)) {
  		tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++,
  			      TIDAW_FLAGS_TTIC, following, 0);
  		if (itcw->num_tidaws >= itcw->max_tidaws)
  			return ERR_PTR(-ENOSPC);
  	}
  	return tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++, flags, addr, count);
  }
  EXPORT_SYMBOL(itcw_add_tidaw);
  
  /**
   * itcw_set_data - set data address and tida flag of the itcw
   * @itcw: address of the itcw
   * @addr: the data address
   * @use_tidal: zero of the data address specifies a contiguous block of data,
   * non-zero if it specifies a list if tidaws.
   *
   * Set the input/output data address of the itcw (depending on the value of the
   * r-flag and w-flag). If @use_tidal is non-zero, the corresponding tida flag
   * is set as well.
   */
  void itcw_set_data(struct itcw *itcw, void *addr, int use_tidal)
  {
  	tcw_set_data(itcw->tcw, addr, use_tidal);
  }
  EXPORT_SYMBOL(itcw_set_data);
  
  /**
   * itcw_finalize - calculate length and count fields of the itcw
   * @itcw: address of the itcw
   *
   * Calculate tcw input-/output-count and tccbl fields and add a tcat the tccb.
   * In case input- or output-tida is used, the tidaw-list must be stored in
   * continuous storage (no ttic). The tcal field in the tccb must be
   * up-to-date.
   */
  void itcw_finalize(struct itcw *itcw)
  {
  	tcw_finalize(itcw->tcw, itcw->num_tidaws);
  }
  EXPORT_SYMBOL(itcw_finalize);