Fix some coding style issues

		/* Nothing to do here */

		break;

	case SPI_DELAY_UNIT_SCK:

		/* clock cycles need to be obtained from spi_transfer */

		/* Clock cycles need to be obtained from spi_transfer */

		if (!xfer)

			return -EINVAL;

		/*

	u32 unit = xfer->cs_change_delay.unit;

	int ret;

	/* return early on "fast" mode - for everything but USECS */

	/* Return early on "fast" mode - for everything but USECS */

	if (!delay) {

		if (unit == SPI_DELAY_UNIT_USECS)

			_spi_transfer_delay_ns(default_delay_ns);

	WRITE_ONCE(ctlr->cur_msg_incomplete, true);

	WRITE_ONCE(ctlr->cur_msg_need_completion, false);

	reinit_completion(&ctlr->cur_msg_completion);

	smp_wmb(); /* make these available to spi_finalize_current_message */

	smp_wmb(); /* Make these available to spi_finalize_current_message() */

	ret = ctlr->transfer_one_message(ctlr, msg);

	if (ret) {

		dev_err(&ctlr->dev,

			"failed to transfer one message from queue\n");

		return ret;

	} else {

	}

	WRITE_ONCE(ctlr->cur_msg_need_completion, true);

		smp_mb(); /* see spi_finalize_current_message()... */

	smp_mb(); /* See spi_finalize_current_message()... */

	if (READ_ONCE(ctlr->cur_msg_incomplete))

		wait_for_completion(&ctlr->cur_msg_completion);

	}

	return 0;

}

	spin_unlock_irqrestore(&ctlr->queue_lock, flags);

	ret = __spi_pump_transfer_message(ctlr, msg, was_busy);

	if (!ret)

		kthread_queue_work(ctlr->kworker, &ctlr->pump_messages);

	ctlr->cur_msg = NULL;

	ctlr->fallback = false;

	struct spi_message *next;

	unsigned long flags;

	/* get a pointer to the next message, if any */

	/* Get a pointer to the next message, if any */

	spin_lock_irqsave(&ctlr->queue_lock, flags);

	next = list_first_entry_or_null(&ctlr->queue, struct spi_message,

					queue);

	acpi_dev_free_resource_list(&resource_list);

	if (ret < 0)

		/* found SPI in _CRS but it points to another controller */

		/* Found SPI in _CRS but it points to another controller */

		return ERR_PTR(-ENODEV);

	if (!lookup.max_speed_hz &&

		return status;

	if (ctlr->bus_num >= 0) {

		/* devices with a fixed bus num must check-in with the num */

		/* Devices with a fixed bus num must check-in with the num */

		mutex_lock(&board_lock);

		id = idr_alloc(&spi_master_idr, ctlr, ctlr->bus_num,

			ctlr->bus_num + 1, GFP_KERNEL);

			return id == -ENOSPC ? -EBUSY : id;

		ctlr->bus_num = id;

	} else if (ctlr->dev.of_node) {

		/* allocate dynamic bus number using Linux idr */

		/* Allocate dynamic bus number using Linux idr */

		id = of_alias_get_id(ctlr->dev.of_node, "spi");

		if (id >= 0) {

			ctlr->bus_num = id;

		goto free_bus_id;

	}

	/* setting last_cs to -1 means no chip selected */

	/* Setting last_cs to -1 means no chip selected */

	ctlr->last_cs = -1;

	status = device_add(&ctlr->dev);

			goto free_bus_id;

		}

	}

	/* add statistics */

	/* Add statistics */

	ctlr->pcpu_statistics = spi_alloc_pcpu_stats(dev);

	if (!ctlr->pcpu_statistics) {

		dev_err(dev, "Error allocating per-cpu statistics\n");

	device_del(&ctlr->dev);

	/* free bus id */

	/* Free bus id */

	mutex_lock(&board_lock);

	if (found == ctlr)

		idr_remove(&spi_master_idr, id);

	struct spi_replaced_transfers *rxfer = res;

	size_t i;

	/* call extra callback if requested */

	/* Call extra callback if requested */

	if (rxfer->release)

		rxfer->release(ctlr, msg, res);

	/* insert replaced transfers back into the message */

	/* Insert replaced transfers back into the message */

	list_splice(&rxfer->replaced_transfers, rxfer->replaced_after);

	/* remove the formerly inserted entries */

	/* Remove the formerly inserted entries */

	for (i = 0; i < rxfer->inserted; i++)

		list_del(&rxfer->inserted_transfers[i].transfer_list);

}

	struct spi_transfer *xfer;

	size_t i;

	/* allocate the structure using spi_res */

	/* Allocate the structure using spi_res */

	rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,

			      struct_size(rxfer, inserted_transfers, insert)

			      + extradatasize,

	if (!rxfer)

		return ERR_PTR(-ENOMEM);

	/* the release code to invoke before running the generic release */

	/* The release code to invoke before running the generic release */

	rxfer->release = release;

	/* assign extradata */

	/* Assign extradata */

	if (extradatasize)

		rxfer->extradata =

			&rxfer->inserted_transfers[insert];

	/* init the replaced_transfers list */

	/* Init the replaced_transfers list */

	INIT_LIST_HEAD(&rxfer->replaced_transfers);

	/*

	 */

	rxfer->replaced_after = xfer_first->transfer_list.prev;

	/* remove the requested number of transfers */

	/* Remove the requested number of transfers */

	for (i = 0; i < remove; i++) {

		/*

		 * If the entry after replaced_after it is msg->transfers

		if (rxfer->replaced_after->next == &msg->transfers) {

			dev_err(&msg->spi->dev,

				"requested to remove more spi_transfers than are available\n");

			/* insert replaced transfers back into the message */

			/* Insert replaced transfers back into the message */

			list_splice(&rxfer->replaced_transfers,

				    rxfer->replaced_after);

			/* free the spi_replace_transfer structure */

			/* Free the spi_replace_transfer structure... */

			spi_res_free(rxfer);

			/* and return with an error */

			/* ...and return with an error */

			return ERR_PTR(-EINVAL);

		}

	 * based on the first transfer to get removed.

	 */

	for (i = 0; i < insert; i++) {

		/* we need to run in reverse order */

		/* We need to run in reverse order */

		xfer = &rxfer->inserted_transfers[insert - 1 - i];

		/* copy all spi_transfer data */

		/* Copy all spi_transfer data */

		memcpy(xfer, xfer_first, sizeof(*xfer));

		/* add to list */

		/* Add to list */

		list_add(&xfer->transfer_list, rxfer->replaced_after);

		/* clear cs_change and delay for all but the last */

		/* Clear cs_change and delay for all but the last */

		if (i) {

			xfer->cs_change = false;

			xfer->delay.value = 0;

		}

	}

	/* set up inserted */

	/* Set up inserted... */

	rxfer->inserted = insert;

	/* and register it with spi_res/spi_message */

	/* ...and register it with spi_res/spi_message */

	spi_res_add(msg, rxfer);

	return rxfer;

	size_t offset;

	size_t count, i;

	/* calculate how many we have to replace */

	/* Calculate how many we have to replace */

	count = DIV_ROUND_UP(xfer->len, maxsize);

	/* create replacement */

	/* Create replacement */

	srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp);

	if (IS_ERR(srt))

		return PTR_ERR(srt);

	 */

	xfers[0].len = min_t(size_t, maxsize, xfer[0].len);

	/* all the others need rx_buf/tx_buf also set */

	/* All the others need rx_buf/tx_buf also set */

	for (i = 1, offset = maxsize; i < count; offset += maxsize, i++) {

		/* update rx_buf, tx_buf and dma */

		/* Update rx_buf, tx_buf and dma */

		if (xfers[i].rx_buf)

			xfers[i].rx_buf += offset;

		if (xfers[i].rx_dma)

		if (xfers[i].tx_dma)

			xfers[i].tx_dma += offset;

		/* update length */

		/* Update length */

		xfers[i].len = min(maxsize, xfers[i].len - offset);

	}

	 */

	*xferp = &xfers[count - 1];

	/* increment statistics counters */

	/* Increment statistics counters */

	SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics,

				       transfers_split_maxsize);

	SPI_STATISTICS_INCREMENT_FIELD(msg->spi->pcpu_statistics,

			return ret;

		list_for_each_entry(xfer, &message->transfers, transfer_list) {

			/* don't change cs_change on the last entry in the list */

			/* Don't change cs_change on the last entry in the list */

			if (list_is_last(&xfer->transfer_list, &message->transfers))

				break;

			xfer->cs_change = 1;

				!(spi->mode & SPI_TX_QUAD))

				return -EINVAL;

		}

		/* check transfer rx_nbits */

		/* Check transfer rx_nbits */

		if (xfer->rx_buf) {

			if (spi->mode & SPI_NO_RX)

				return -EINVAL;

	ctlr->bus_lock_flag = 1;

	spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);

	/* mutex remains locked until spi_bus_unlock is called */

	/* Mutex remains locked until spi_bus_unlock() is called */

	return 0;

}

}

EXPORT_SYMBOL_GPL(spi_bus_unlock);

/* portable code must never pass more than 32 bytes */

/* Portable code must never pass more than 32 bytes */

#define	SPI_BUFSIZ	max(32, SMP_CACHE_BYTES)

static u8	*buf;

	x[0].tx_buf = local_buf;

	x[1].rx_buf = local_buf + n_tx;

	/* do the i/o */

	/* Do the i/o */

	status = spi_sync(spi, &message);

	if (status == 0)

		memcpy(rxbuf, x[1].rx_buf, n_rx);

/*-------------------------------------------------------------------------*/

#if IS_ENABLED(CONFIG_OF_DYNAMIC)

/* must call put_device() when done with returned spi_device device */

/* Must call put_device() when done with returned spi_device device */

static struct spi_device *of_find_spi_device_by_node(struct device_node *node)

{

	struct device *dev = bus_find_device_by_of_node(&spi_bus_type, node);

	return dev ? to_spi_device(dev) : NULL;

}

/* the spi controllers are not using spi_bus, so we find it with another way */

/* The spi controllers are not using spi_bus, so we find it with another way */

static struct spi_controller *of_find_spi_controller_by_node(struct device_node *node)

{

	struct device *dev;

	if (!dev)

		return NULL;

	/* reference got in class_find_device */

	/* Reference got in class_find_device */

	return container_of(dev, struct spi_controller, dev);

}

	case OF_RECONFIG_CHANGE_ADD:

		ctlr = of_find_spi_controller_by_node(rd->dn->parent);

		if (ctlr == NULL)

			return NOTIFY_OK;	/* not for us */

			return NOTIFY_OK;	/* Not for us */

		if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {

			put_device(&ctlr->dev);

		break;

	case OF_RECONFIG_CHANGE_REMOVE:

		/* already depopulated? */

		/* Already depopulated? */

		if (!of_node_check_flag(rd->dn, OF_POPULATED))

			return NOTIFY_OK;

		/* find our device by node */

		/* Find our device by node */

		spi = of_find_spi_device_by_node(rd->dn);

		if (spi == NULL)

			return NOTIFY_OK;	/* no? not meant for us */

			return NOTIFY_OK;	/* No? not meant for us */

		/* unregister takes one ref away */

		/* Unregister takes one ref away */

		spi_unregister_device(spi);

		/* and put the reference of the find */

		/* And put the reference of the find */

		put_device(&spi->dev);

		break;

	}

struct spi_device {

	struct device		dev;

	struct spi_controller	*controller;

	struct spi_controller	*master;	/* compatibility layer */

	struct spi_controller	*master;	/* Compatibility layer */

	u32			max_speed_hz;

	u8			chip_select;

	u8			bits_per_word;

	bool			rt;

#define SPI_NO_TX	BIT(31)		/* no transmit wire */

#define SPI_NO_RX	BIT(30)		/* no receive wire */

#define SPI_NO_TX	BIT(31)		/* No transmit wire */

#define SPI_NO_RX	BIT(30)		/* No receive wire */

	/*

	 * All bits defined above should be covered by SPI_MODE_KERNEL_MASK.

	 * The SPI_MODE_KERNEL_MASK has the SPI_MODE_USER_MASK counterpart,

	void			*controller_data;

	char			modalias[SPI_NAME_SIZE];

	const char		*driver_override;

	struct gpio_desc	*cs_gpiod;	/* chip select gpio desc */

	struct spi_delay	word_delay; /* inter-word delay */

	struct gpio_desc	*cs_gpiod;	/* Chip select gpio desc */

	struct spi_delay	word_delay; /* Inter-word delay */

	/* CS delays */

	struct spi_delay	cs_setup;

	struct spi_delay	cs_hold;

	struct spi_delay	cs_inactive;

	/* the statistics */

	/* The statistics */

	struct spi_statistics __percpu	*pcpu_statistics;

	/*

	return dev ? container_of(dev, struct spi_device, dev) : NULL;

}

/* most drivers won't need to care about device refcounting */

/* Most drivers won't need to care about device refcounting */

static inline struct spi_device *spi_dev_get(struct spi_device *spi)

{

	return (spi && get_device(&spi->dev)) ? spi : NULL;

	spi->controller_state = state;

}

/* device driver data */

/* Device driver data */

static inline void spi_set_drvdata(struct spi_device *spi, void *data)

{

extern struct spi_device *spi_new_ancillary_device(struct spi_device *spi, u8 chip_select);

/* use a define to avoid include chaining to get THIS_MODULE */

/* Use a define to avoid include chaining to get THIS_MODULE */

#define spi_register_driver(driver) \

	__spi_register_driver(THIS_MODULE, driver)

	struct list_head list;

	/* other than negative (== assign one dynamically), bus_num is fully

	/* Other than negative (== assign one dynamically), bus_num is fully

	 * board-specific.  usually that simplifies to being SOC-specific.

	 * example:  one SOC has three SPI controllers, numbered 0..2,

	 * and one board's schematics might show it using SPI-2.  software

	 */

	u16			num_chipselect;

	/* some SPI controllers pose alignment requirements on DMAable

	/* Some SPI controllers pose alignment requirements on DMAable

	 * buffers; let protocol drivers know about these requirements.

	 */

	u16			dma_alignment;

	/* spi_device.mode flags override flags for this controller */

	u32			buswidth_override_bits;

	/* bitmask of supported bits_per_word for transfers */

	/* Bitmask of supported bits_per_word for transfers */

	u32			bits_per_word_mask;

#define SPI_BPW_MASK(bits) BIT((bits) - 1)

#define SPI_BPW_RANGE_MASK(min, max) GENMASK((max) - 1, (min) - 1)

	/* limits on transfer speed */

	/* Limits on transfer speed */

	u32			min_speed_hz;

	u32			max_speed_hz;

	/* other constraints relevant to this driver */

	/* Other constraints relevant to this driver */

	u16			flags;

#define SPI_CONTROLLER_HALF_DUPLEX	BIT(0)	/* can't do full duplex */

#define SPI_CONTROLLER_NO_RX		BIT(1)	/* can't do buffer read */

#define SPI_CONTROLLER_NO_TX		BIT(2)	/* can't do buffer write */

#define SPI_CONTROLLER_MUST_RX		BIT(3)	/* requires rx */

#define SPI_CONTROLLER_MUST_TX		BIT(4)	/* requires tx */

#define SPI_CONTROLLER_HALF_DUPLEX	BIT(0)	/* Can't do full duplex */

#define SPI_CONTROLLER_NO_RX		BIT(1)	/* Can't do buffer read */

#define SPI_CONTROLLER_NO_TX		BIT(2)	/* Can't do buffer write */

#define SPI_CONTROLLER_MUST_RX		BIT(3)	/* Requires rx */

#define SPI_CONTROLLER_MUST_TX		BIT(4)	/* Requires tx */

#define SPI_MASTER_GPIO_SS		BIT(5)	/* GPIO CS must select slave */

	/* flag indicating if the allocation of this struct is devres-managed */

	/* Flag indicating if the allocation of this struct is devres-managed */

	bool			devm_allocated;

	/* flag indicating this is an SPI slave controller */

	/* Flag indicating this is an SPI slave controller */

	bool			slave;

	/*

	/* Used to avoid adding the same CS twice */

	struct mutex		add_lock;

	/* lock and mutex for SPI bus locking */

	/* Lock and mutex for SPI bus locking */

	spinlock_t		bus_lock_spinlock;

	struct mutex		bus_lock_mutex;

	/* flag indicating that the SPI bus is locked for exclusive use */

	/* Flag indicating that the SPI bus is locked for exclusive use */

	bool			bus_lock_flag;

	/* Setup mode and clock, etc (spi driver may call many times).

	 */

	int (*set_cs_timing)(struct spi_device *spi);

	/* bidirectional bulk transfers

	/* Bidirectional bulk transfers

	 *

	 * + The transfer() method may not sleep; its main role is

	 *   just to add the message to the queue.

	int			(*transfer)(struct spi_device *spi,

						struct spi_message *mesg);

	/* called on release() to free memory provided by spi_controller */

	/* Called on release() to free memory provided by spi_controller */

	void			(*cleanup)(struct spi_device *spi);

	/*

	s8			unused_native_cs;

	s8			max_native_cs;

	/* statistics */

	/* Statistics */

	struct spi_statistics __percpu	*pcpu_statistics;

	/* DMA channels for use with core dmaengine helpers */

	struct dma_chan		*dma_tx;

	struct dma_chan		*dma_rx;

	/* dummy data for full duplex devices */

	/* Dummy data for full duplex devices */

	void			*dummy_rx;

	void			*dummy_tx;

			     struct spi_transfer *xfer,

			     size_t progress, bool irqs_off);

/* the spi driver core manages memory for the spi_controller classdev */

/* The spi driver core manages memory for the spi_controller classdev */

extern struct spi_controller *__spi_alloc_controller(struct device *host,

						unsigned int size, bool slave);

struct spi_res {

	struct list_head        entry;

	spi_res_release_t       release;

	unsigned long long      data[]; /* guarantee ull alignment */

	unsigned long long      data[]; /* Guarantee ull alignment */

};

/*---------------------------------------------------------------------------*/

 * and its transfers, ignore them until its completion callback.

 */

struct spi_transfer {

	/* it's ok if tx_buf == rx_buf (right?)

	/* It's ok if tx_buf == rx_buf (right?)

	 * for MicroWire, one buffer must be null

	 * buffers must work with dma_*map_single() calls, unless

	 *   spi_message.is_dma_mapped reports a pre-existing mapping

	 * tell them about such special cases.

	 */

	/* completion is reported through a callback */

	/* Completion is reported through a callback */

	void			(*complete)(void *context);

	void			*context;

	unsigned		frame_length;

	unsigned		actual_length;

	int			status;

	/* for optional use by whatever driver currently owns the

	/* For optional use by whatever driver currently owns the

	 * spi_message ...  between calls to spi_async and then later

	 * complete(), that's the spi_controller controller driver.

	 */

	struct list_head	queue;

	void			*state;

	/* list of spi_res reources when the spi message is processed */

	/* List of spi_res reources when the spi message is processed */

	struct list_head        resources;

	/* spi_prepare_message was called for this message */

	/* spi_prepare_message() was called for this message */

	bool			prepared;

};

	if (ctlr->max_transfer_size)

		tr_max = ctlr->max_transfer_size(spi);

	/* transfer size limit must not be greater than message size limit */

	/* Transfer size limit must not be greater than message size limit */

	return min(tr_max, msg_max);

}

	return spi_sync_transfer(spi, &t, 1);

}

/* this copies txbuf and rxbuf data; for small transfers only! */

/* This copies txbuf and rxbuf data; for small transfers only! */

extern int spi_write_then_read(struct spi_device *spi,

		const void *txbuf, unsigned n_tx,

		void *rxbuf, unsigned n_rx);

	status = spi_write_then_read(spi, &cmd, 1, &result, 1);

	/* return negative errno or unsigned value */

	/* Return negative errno or unsigned value */

	return (status < 0) ? status : result;

}

	status = spi_write_then_read(spi, &cmd, 1, &result, 2);

	/* return negative errno or unsigned value */

	/* Return negative errno or unsigned value */

	return (status < 0) ? status : result;

}

 * are active in some dynamic board configuration models.

 */

struct spi_board_info {

	/* the device name and module name are coupled, like platform_bus;

	/* The device name and module name are coupled, like platform_bus;

	 * "modalias" is normally the driver name.

	 *

	 * platform_data goes to spi_device.dev.platform_data,

	void		*controller_data;

	int		irq;

	/* slower signaling on noisy or low voltage boards */

	/* Slower signaling on noisy or low voltage boards */

	u32		max_speed_hz;

extern int

spi_register_board_info(struct spi_board_info const *info, unsigned n);

#else

/* board init code may ignore whether SPI is configured or not */

/* Board init code may ignore whether SPI is configured or not */

static inline int

spi_register_board_info(struct spi_board_info const *info, unsigned n)

	{ return 0; }