sound/soc/codecs/rt5677-spi.c - kernel/quantenna - Git at Google

 /*
  * rt5677-spi.c  --  RT5677 ALSA SoC audio codec driver
  *
  * Copyright 2013 Realtek Semiconductor Corp.
  * Author: Oder Chiou <oder_chiou@realtek.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */

 #include <linux/module.h>
 #include <linux/input.h>
 #include <linux/spi/spi.h>
 #include <linux/device.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/sched.h>
 #include <linux/kthread.h>
 #include <linux/uaccess.h>
 #include <linux/miscdevice.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_qos.h>
 #include <linux/sysfs.h>
 #include <linux/clk.h>
 #include <linux/firmware.h>

 #include "rt5677-spi.h"

 #define RT5677_SPI_BURST_LEN	240
 #define RT5677_SPI_HEADER	5
 #define RT5677_SPI_FREQ		6000000

 /* The AddressPhase and DataPhase of SPI commands are MSB first on the wire.
  * DataPhase word size of 16-bit commands is 2 bytes.
  * DataPhase word size of 32-bit commands is 4 bytes.
  * DataPhase word size of burst commands is 8 bytes.
  * The DSP CPU is little-endian.
  */
 #define RT5677_SPI_WRITE_BURST	0x5
 #define RT5677_SPI_READ_BURST	0x4
 #define RT5677_SPI_WRITE_32	0x3
 #define RT5677_SPI_READ_32	0x2
 #define RT5677_SPI_WRITE_16	0x1
 #define RT5677_SPI_READ_16	0x0

 static struct spi_device *g_spi;
 static DEFINE_MUTEX(spi_mutex);

 /* Select a suitable transfer command for the next transfer to ensure
  * the transfer address is always naturally aligned while minimizing
  * the total number of transfers required.
  *
  * 3 transfer commands are available:
  * RT5677_SPI_READ/WRITE_16:	Transfer 2 bytes
  * RT5677_SPI_READ/WRITE_32:	Transfer 4 bytes
  * RT5677_SPI_READ/WRITE_BURST:	Transfer any multiples of 8 bytes
  *
  * For example, reading 260 bytes at 0x60030002 uses the following commands:
  * 0x60030002 RT5677_SPI_READ_16	2 bytes
  * 0x60030004 RT5677_SPI_READ_32	4 bytes
  * 0x60030008 RT5677_SPI_READ_BURST	240 bytes
  * 0x600300F8 RT5677_SPI_READ_BURST	8 bytes
  * 0x60030100 RT5677_SPI_READ_32	4 bytes
  * 0x60030104 RT5677_SPI_READ_16	2 bytes
  *
  * Input:
  * @read: true for read commands; false for write commands
  * @align: alignment of the next transfer address
  * @remain: number of bytes remaining to transfer
  *
  * Output:
  * @len: number of bytes to transfer with the selected command
  * Returns the selected command
  */
 static u8 rt5677_spi_select_cmd(bool read, u32 align, u32 remain, u32 *len)
 {
 	u8 cmd;

 	if (align == 2 || align == 6 || remain == 2) {
 		cmd = RT5677_SPI_READ_16;
 		*len = 2;
 	} else if (align == 4 || remain <= 6) {
 		cmd = RT5677_SPI_READ_32;
 		*len = 4;
 	} else {
 		cmd = RT5677_SPI_READ_BURST;
 		*len = min_t(u32, remain & ~7, RT5677_SPI_BURST_LEN);
 	}
 	return read ? cmd : cmd + 1;
 }

 /* Copy dstlen bytes from src to dst, while reversing byte order for each word.
  * If srclen < dstlen, zeros are padded.
  */
 static void rt5677_spi_reverse(u8 *dst, u32 dstlen, const u8 *src, u32 srclen)
 {
 	u32 w, i, si;
 	u32 word_size = min_t(u32, dstlen, 8);

 	for (w = 0; w < dstlen; w += word_size) {
 		for (i = 0; i < word_size; i++) {
 			si = w + word_size - i - 1;
 			dst[w + i] = si < srclen ? src[si] : 0;
 		}
 	}
 }

 /* Read DSP address space using SPI. addr and len have to be 2-byte aligned. */
 int rt5677_spi_read(u32 addr, void *rxbuf, size_t len)
 {
 	u32 offset;
 	int status = 0;
 	struct spi_transfer t[2];
 	struct spi_message m;
 	/* +4 bytes is for the DummyPhase following the AddressPhase */
 	u8 header[RT5677_SPI_HEADER + 4];
 	u8 body[RT5677_SPI_BURST_LEN];
 	u8 spi_cmd;
 	u8 *cb = rxbuf;

 	if (!g_spi)
 		return -ENODEV;

 	if ((addr & 1) || (len & 1)) {
 		dev_err(&g_spi->dev, "Bad read align 0x%x(%zu)\n", addr, len);
 		return -EACCES;
 	}

 	memset(t, 0, sizeof(t));
 	t[0].tx_buf = header;
 	t[0].len = sizeof(header);
 	t[0].speed_hz = RT5677_SPI_FREQ;
 	t[1].rx_buf = body;
 	t[1].speed_hz = RT5677_SPI_FREQ;
 	spi_message_init_with_transfers(&m, t, ARRAY_SIZE(t));

 	for (offset = 0; offset < len; offset += t[1].len) {
 		spi_cmd = rt5677_spi_select_cmd(true, (addr + offset) & 7,
 				len - offset, &t[1].len);

 		/* Construct SPI message header */
 		header[0] = spi_cmd;
 		header[1] = ((addr + offset) & 0xff000000) >> 24;
 		header[2] = ((addr + offset) & 0x00ff0000) >> 16;
 		header[3] = ((addr + offset) & 0x0000ff00) >> 8;
 		header[4] = ((addr + offset) & 0x000000ff) >> 0;

 		mutex_lock(&spi_mutex);
 		status |= spi_sync(g_spi, &m);
 		mutex_unlock(&spi_mutex);

 		/* Copy data back to caller buffer */
 		rt5677_spi_reverse(cb + offset, t[1].len, body, t[1].len);
 	}
 	return status;
 }
 EXPORT_SYMBOL_GPL(rt5677_spi_read);

 /* Write DSP address space using SPI. addr has to be 2-byte aligned.
  * If len is not 2-byte aligned, an extra byte of zero is written at the end
  * as padding.
  */
 int rt5677_spi_write(u32 addr, const void *txbuf, size_t len)
 {
 	u32 offset, len_with_pad = len;
 	int status = 0;
 	struct spi_transfer t;
 	struct spi_message m;
 	/* +1 byte is for the DummyPhase following the DataPhase */
 	u8 buf[RT5677_SPI_HEADER + RT5677_SPI_BURST_LEN + 1];
 	u8 *body = buf + RT5677_SPI_HEADER;
 	u8 spi_cmd;
 	const u8 *cb = txbuf;

 	if (!g_spi)
 		return -ENODEV;

 	if (addr & 1) {
 		dev_err(&g_spi->dev, "Bad write align 0x%x(%zu)\n", addr, len);
 		return -EACCES;
 	}

 	if (len & 1)
 		len_with_pad = len + 1;

 	memset(&t, 0, sizeof(t));
 	t.tx_buf = buf;
 	t.speed_hz = RT5677_SPI_FREQ;
 	spi_message_init_with_transfers(&m, &t, 1);

 	for (offset = 0; offset < len_with_pad;) {
 		spi_cmd = rt5677_spi_select_cmd(false, (addr + offset) & 7,
 				len_with_pad - offset, &t.len);

 		/* Construct SPI message header */
 		buf[0] = spi_cmd;
 		buf[1] = ((addr + offset) & 0xff000000) >> 24;
 		buf[2] = ((addr + offset) & 0x00ff0000) >> 16;
 		buf[3] = ((addr + offset) & 0x0000ff00) >> 8;
 		buf[4] = ((addr + offset) & 0x000000ff) >> 0;

 		/* Fetch data from caller buffer */
 		rt5677_spi_reverse(body, t.len, cb + offset, len - offset);
 		offset += t.len;
 		t.len += RT5677_SPI_HEADER + 1;

 		mutex_lock(&spi_mutex);
 		status |= spi_sync(g_spi, &m);
 		mutex_unlock(&spi_mutex);
 	}
 	return status;
 }
 EXPORT_SYMBOL_GPL(rt5677_spi_write);

 int rt5677_spi_write_firmware(u32 addr, const struct firmware *fw)
 {
 	return rt5677_spi_write(addr, fw->data, fw->size);
 }
 EXPORT_SYMBOL_GPL(rt5677_spi_write_firmware);

 static int rt5677_spi_probe(struct spi_device *spi)
 {
 	g_spi = spi;
 	return 0;
 }

 static struct spi_driver rt5677_spi_driver = {
 	.driver = {
 		.name = "rt5677",
 	},
 	.probe = rt5677_spi_probe,
 };
 module_spi_driver(rt5677_spi_driver);

 MODULE_DESCRIPTION("ASoC RT5677 SPI driver");
 MODULE_AUTHOR("Oder Chiou <oder_chiou@realtek.com>");
 MODULE_LICENSE("GPL v2");
	/*
	* rt5677-spi.c -- RT5677 ALSA SoC audio codec driver
	*
	* Copyright 2013 Realtek Semiconductor Corp.
	* Author: Oder Chiou <oder_chiou@realtek.com>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*/

	#include <linux/module.h>
	#include <linux/input.h>
	#include <linux/spi/spi.h>
	#include <linux/device.h>
	#include <linux/init.h>
	#include <linux/delay.h>
	#include <linux/interrupt.h>
	#include <linux/irq.h>
	#include <linux/slab.h>
	#include <linux/gpio.h>
	#include <linux/sched.h>
	#include <linux/kthread.h>
	#include <linux/uaccess.h>
	#include <linux/miscdevice.h>
	#include <linux/regulator/consumer.h>
	#include <linux/pm_qos.h>
	#include <linux/sysfs.h>
	#include <linux/clk.h>
	#include <linux/firmware.h>

	#include "rt5677-spi.h"

	#define RT5677_SPI_BURST_LEN 240
	#define RT5677_SPI_HEADER 5
	#define RT5677_SPI_FREQ 6000000

	/* The AddressPhase and DataPhase of SPI commands are MSB first on the wire.
	* DataPhase word size of 16-bit commands is 2 bytes.
	* DataPhase word size of 32-bit commands is 4 bytes.
	* DataPhase word size of burst commands is 8 bytes.
	* The DSP CPU is little-endian.
	*/
	#define RT5677_SPI_WRITE_BURST 0x5
	#define RT5677_SPI_READ_BURST 0x4
	#define RT5677_SPI_WRITE_32 0x3
	#define RT5677_SPI_READ_32 0x2
	#define RT5677_SPI_WRITE_16 0x1
	#define RT5677_SPI_READ_16 0x0

	static struct spi_device *g_spi;
	static DEFINE_MUTEX(spi_mutex);

	/* Select a suitable transfer command for the next transfer to ensure
	* the transfer address is always naturally aligned while minimizing
	* the total number of transfers required.
	*
	* 3 transfer commands are available:
	* RT5677_SPI_READ/WRITE_16: Transfer 2 bytes
	* RT5677_SPI_READ/WRITE_32: Transfer 4 bytes
	* RT5677_SPI_READ/WRITE_BURST: Transfer any multiples of 8 bytes
	*
	* For example, reading 260 bytes at 0x60030002 uses the following commands:
	* 0x60030002 RT5677_SPI_READ_16 2 bytes
	* 0x60030004 RT5677_SPI_READ_32 4 bytes
	* 0x60030008 RT5677_SPI_READ_BURST 240 bytes
	* 0x600300F8 RT5677_SPI_READ_BURST 8 bytes
	* 0x60030100 RT5677_SPI_READ_32 4 bytes
	* 0x60030104 RT5677_SPI_READ_16 2 bytes
	*
	* Input:
	* @read: true for read commands; false for write commands
	* @align: alignment of the next transfer address
	* @remain: number of bytes remaining to transfer
	*
	* Output:
	* @len: number of bytes to transfer with the selected command
	* Returns the selected command
	*/
	static u8 rt5677_spi_select_cmd(bool read, u32 align, u32 remain, u32 *len)
	{
	u8 cmd;

	if (align == 2 \|\| align == 6 \|\| remain == 2) {
	cmd = RT5677_SPI_READ_16;
	*len = 2;
	} else if (align == 4 \|\| remain <= 6) {
	cmd = RT5677_SPI_READ_32;
	*len = 4;
	} else {
	cmd = RT5677_SPI_READ_BURST;
	*len = min_t(u32, remain & ~7, RT5677_SPI_BURST_LEN);
	}
	return read ? cmd : cmd + 1;
	}

	/* Copy dstlen bytes from src to dst, while reversing byte order for each word.
	* If srclen < dstlen, zeros are padded.
	*/
	static void rt5677_spi_reverse(u8 dst, u32 dstlen, const u8 src, u32 srclen)
	{
	u32 w, i, si;
	u32 word_size = min_t(u32, dstlen, 8);

	for (w = 0; w < dstlen; w += word_size) {
	for (i = 0; i < word_size; i++) {
	si = w + word_size - i - 1;
	dst[w + i] = si < srclen ? src[si] : 0;
	}
	}
	}

	/* Read DSP address space using SPI. addr and len have to be 2-byte aligned. */
	int rt5677_spi_read(u32 addr, void *rxbuf, size_t len)
	{
	u32 offset;
	int status = 0;
	struct spi_transfer t[2];
	struct spi_message m;
	/* +4 bytes is for the DummyPhase following the AddressPhase */
	u8 header[RT5677_SPI_HEADER + 4];
	u8 body[RT5677_SPI_BURST_LEN];
	u8 spi_cmd;
	u8 *cb = rxbuf;

	if (!g_spi)
	return -ENODEV;

	if ((addr & 1) \|\| (len & 1)) {
	dev_err(&g_spi->dev, "Bad read align 0x%x(%zu)\n", addr, len);
	return -EACCES;
	}

	memset(t, 0, sizeof(t));
	t[0].tx_buf = header;
	t[0].len = sizeof(header);
	t[0].speed_hz = RT5677_SPI_FREQ;
	t[1].rx_buf = body;
	t[1].speed_hz = RT5677_SPI_FREQ;
	spi_message_init_with_transfers(&m, t, ARRAY_SIZE(t));

	for (offset = 0; offset < len; offset += t[1].len) {
	spi_cmd = rt5677_spi_select_cmd(true, (addr + offset) & 7,
	len - offset, &t[1].len);

	/* Construct SPI message header */
	header[0] = spi_cmd;
	header[1] = ((addr + offset) & 0xff000000) >> 24;
	header[2] = ((addr + offset) & 0x00ff0000) >> 16;
	header[3] = ((addr + offset) & 0x0000ff00) >> 8;
	header[4] = ((addr + offset) & 0x000000ff) >> 0;

	mutex_lock(&spi_mutex);
	status \|= spi_sync(g_spi, &m);
	mutex_unlock(&spi_mutex);

	/* Copy data back to caller buffer */
	rt5677_spi_reverse(cb + offset, t[1].len, body, t[1].len);
	}
	return status;
	}
	EXPORT_SYMBOL_GPL(rt5677_spi_read);

	/* Write DSP address space using SPI. addr has to be 2-byte aligned.
	* If len is not 2-byte aligned, an extra byte of zero is written at the end
	* as padding.
	*/
	int rt5677_spi_write(u32 addr, const void *txbuf, size_t len)
	{
	u32 offset, len_with_pad = len;
	int status = 0;
	struct spi_transfer t;
	struct spi_message m;
	/* +1 byte is for the DummyPhase following the DataPhase */
	u8 buf[RT5677_SPI_HEADER + RT5677_SPI_BURST_LEN + 1];
	u8 *body = buf + RT5677_SPI_HEADER;
	u8 spi_cmd;
	const u8 *cb = txbuf;

	if (!g_spi)
	return -ENODEV;

	if (addr & 1) {
	dev_err(&g_spi->dev, "Bad write align 0x%x(%zu)\n", addr, len);
	return -EACCES;
	}

	if (len & 1)
	len_with_pad = len + 1;

	memset(&t, 0, sizeof(t));
	t.tx_buf = buf;
	t.speed_hz = RT5677_SPI_FREQ;
	spi_message_init_with_transfers(&m, &t, 1);

	for (offset = 0; offset < len_with_pad;) {
	spi_cmd = rt5677_spi_select_cmd(false, (addr + offset) & 7,
	len_with_pad - offset, &t.len);

	/* Construct SPI message header */
	buf[0] = spi_cmd;
	buf[1] = ((addr + offset) & 0xff000000) >> 24;
	buf[2] = ((addr + offset) & 0x00ff0000) >> 16;
	buf[3] = ((addr + offset) & 0x0000ff00) >> 8;
	buf[4] = ((addr + offset) & 0x000000ff) >> 0;

	/* Fetch data from caller buffer */
	rt5677_spi_reverse(body, t.len, cb + offset, len - offset);
	offset += t.len;
	t.len += RT5677_SPI_HEADER + 1;

	mutex_lock(&spi_mutex);
	status \|= spi_sync(g_spi, &m);
	mutex_unlock(&spi_mutex);
	}
	return status;
	}
	EXPORT_SYMBOL_GPL(rt5677_spi_write);

	int rt5677_spi_write_firmware(u32 addr, const struct firmware *fw)
	{
	return rt5677_spi_write(addr, fw->data, fw->size);
	}
	EXPORT_SYMBOL_GPL(rt5677_spi_write_firmware);

	static int rt5677_spi_probe(struct spi_device *spi)
	{
	g_spi = spi;
	return 0;
	}

	static struct spi_driver rt5677_spi_driver = {
	.driver = {
	.name = "rt5677",
	},
	.probe = rt5677_spi_probe,
	};
	module_spi_driver(rt5677_spi_driver);

	MODULE_DESCRIPTION("ASoC RT5677 SPI driver");
	MODULE_AUTHOR("Oder Chiou <oder_chiou@realtek.com>");
	MODULE_LICENSE("GPL v2");