mfd: cros ec: spi: Add delay for raising CS

- compatible: "google,cros-ec-spi"

- reg: SPI chip select

Optional properties (SPI):

- google,cros-ec-spi-msg-delay: Some implementations of the EC require some

  additional processing time in order to accept new transactions. If the delay

  between transactions is not long enough the EC may not be able to respond

  properly to subsequent transactions and cause them to hang. This property

  specifies the delay, in usecs, introduced between transactions to account

  for the time required by the EC to get back into a state in which new data

  can be accepted.

Required properties (LPC):

- compatible: "google,cros-ec-lpc"

- reg: List of (IO address, size) pairs defining the interface uses

#include <linux/module.h>

#include <linux/mfd/cros_ec.h>

#include <linux/mfd/cros_ec_commands.h>

#include <linux/of.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/spi/spi.h>

 * @spi: SPI device we are connected to

 * @last_transfer_ns: time that we last finished a transfer, or 0 if there

 *	if no record

 * @end_of_msg_delay: used to set the delay_usecs on the spi_transfer that

 *      is sent when we want to turn off CS at the end of a transaction.

 */

struct cros_ec_spi {

	struct spi_device *spi;

	s64 last_transfer_ns;

	unsigned int end_of_msg_delay;

};

static void debug_packet(struct device *dev, const char *name, u8 *ptr,

	/* turn off CS */

	spi_message_init(&msg);

	if (ec_spi->end_of_msg_delay) {

		/*

		 * Add delay for last transaction, to ensure the rising edge

		 * doesn't come too soon after the end of the data.

		 */

		memset(&trans, 0, sizeof(trans));

		trans.delay_usecs = ec_spi->end_of_msg_delay;

		spi_message_add_tail(&trans, &msg);

	}

	final_ret = spi_sync(ec_spi->spi, &msg);

	ktime_get_ts(&ts);

	ec_spi->last_transfer_ns = timespec_to_ns(&ts);

	return 0;

}

static void cros_ec_spi_dt_probe(struct cros_ec_spi *ec_spi, struct device *dev)

{

	struct device_node *np = dev->of_node;

	u32 val;

	int ret;

	ret = of_property_read_u32(np, "google,cros-ec-spi-msg-delay", &val);

	if (!ret)

		ec_spi->end_of_msg_delay = val;

}

static int cros_ec_spi_probe(struct spi_device *spi)

{

	struct device *dev = &spi->dev;

	if (!ec_dev)

		return -ENOMEM;

	/* Check for any DT properties */

	cros_ec_spi_dt_probe(ec_spi, dev);

	spi_set_drvdata(spi, ec_dev);

	ec_dev->name = "SPI";

	ec_dev->dev = dev;