Commit 9df461ec authored by Andy Shevchenko's avatar Andy Shevchenko Committed by Mark Brown
Browse files

spi: pxa2xx: replace ugly table by approximation 

The Quark SoC data sheet describes the baud rate setting using fractional
divider. The subset of possible values represented by a table suggests that the
divisor has one block that could divide by 5. This explains the number of the
beast in some cases in the table. Thus, in this particular case the divisor can
be evaluated as

	5^i * 2^j * 2 * k,

where

	i = [0, 1]
	j = [0, 23]
	k = [1, 256]

There are few cases as mentioned in the data sheet, i.e. better form of the
clock signal will be in case if DDS_CLK_RATE either 2^n or 2/5. It's also
possible to use any value that is less or equal to 0x33333 (1/5/16 = 1/80).

All three cases are compared to each other and the one that suits better is
chosen by the approximation algorithm. Anyone can play with the script [1] that
represents the algorithm.

[1] https://gist.github.com/06b084488b3629898121



Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 025ffe88

drivers/spi/spi-pxa2xx.c

+114 −62
Original line number Original line Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include <linux/errno.h>

#include <linux/errno.h>

#include <linux/err.h>

#include <linux/err.h>

#include <linux/interrupt.h>

#include <linux/interrupt.h>

#include <linux/kernel.h>

#include <linux/platform_device.h>

#include <linux/platform_device.h>

#include <linux/spi/pxa2xx_spi.h>

#include <linux/spi/pxa2xx_spi.h>

#include <linux/spi/spi.h>

#include <linux/spi/spi.h>
@@ -63,54 +64,6 @@ MODULE_ALIAS("platform:pxa2xx-spi"); 
#define LPSS_TX_LOTHRESH_DFLT	160

#define LPSS_TX_LOTHRESH_DFLT	160

#define LPSS_TX_HITHRESH_DFLT	224

#define LPSS_TX_HITHRESH_DFLT	224





struct quark_spi_rate {

	u32 bitrate;

	u32 dds_clk_rate;

	u32 clk_div;

};



/*

 * 'rate', 'dds', 'clk_div' lookup table, which is defined in

 * the Quark SPI datasheet.

 */

static const struct quark_spi_rate quark_spi_rate_table[] = {

/*	bitrate,	dds_clk_rate,	clk_div */

	{50000000,	0x800000,	0},

	{40000000,	0x666666,	0},

	{25000000,	0x400000,	0},

	{20000000,	0x666666,	1},

	{16667000,	0x800000,	2},

	{13333000,	0x666666,	2},

	{12500000,	0x200000,	0},

	{10000000,	0x800000,	4},

	{8000000,	0x666666,	4},

	{6250000,	0x400000,	3},

	{5000000,	0x400000,	4},

	{4000000,	0x666666,	9},

	{3125000,	0x80000,	0},

	{2500000,	0x400000,	9},

	{2000000,	0x666666,	19},

	{1563000,	0x40000,	0},

	{1250000,	0x200000,	9},

	{1000000,	0x400000,	24},

	{800000,	0x666666,	49},

	{781250,	0x20000,	0},

	{625000,	0x200000,	19},

	{500000,	0x400000,	49},

	{400000,	0x666666,	99},

	{390625,	0x10000,	0},

	{250000,	0x400000,	99},

	{200000,	0x666666,	199},

	{195313,	0x8000,		0},

	{125000,	0x100000,	49},

	{100000,	0x200000,	124},

	{50000,		0x100000,	124},

	{25000,		0x80000,	124},

	{10016,		0x20000,	77},

	{5040,		0x20000,	154},

	{1002,		0x8000,		194},

};



/* Offset from drv_data->lpss_base */

/* Offset from drv_data->lpss_base */

#define GENERAL_REG		0x08

#define GENERAL_REG		0x08

#define GENERAL_REG_RXTO_HOLDOFF_DISABLE BIT(24)

#define GENERAL_REG_RXTO_HOLDOFF_DISABLE BIT(24)
@@ -697,25 +650,124 @@ static irqreturn_t ssp_int(int irq, void *dev_id) 
}

}





/*

/*

 * The Quark SPI data sheet gives a table, and for the given 'rate',

 * The Quark SPI has an additional 24 bit register (DDS_CLK_RATE) to multiply

 * the 'dds' and 'clk_div' can be found in the table.

 * input frequency by fractions of 2^24. It also has a divider by 5.

 *

 * There are formulas to get baud rate value for given input frequency and

 * divider parameters, such as DDS_CLK_RATE and SCR:

 *

 * Fsys = 200MHz

 *

 * Fssp = Fsys * DDS_CLK_RATE / 2^24			(1)

 * Baud rate = Fsclk = Fssp / (2 * (SCR + 1))		(2)

 *

 * DDS_CLK_RATE either 2^n or 2^n / 5.

 * SCR is in range 0 .. 255

 *

 * Divisor = 5^i * 2^j * 2 * k

 *       i = [0, 1]      i = 1 iff j = 0 or j > 3

 *       j = [0, 23]     j = 0 iff i = 1

 *       k = [1, 256]

 * Special case: j = 0, i = 1: Divisor = 2 / 5

 *

 * Accordingly to the specification the recommended values for DDS_CLK_RATE

 * are:

 *	Case 1:		2^n, n = [0, 23]

 *	Case 2:		2^24 * 2 / 5 (0x666666)

 *	Case 3:		less than or equal to 2^24 / 5 / 16 (0x33333)

 *

 * In all cases the lowest possible value is better.

 *

 * The function calculates parameters for all cases and chooses the one closest

 * to the asked baud rate.

 */

 */

static u32 quark_x1000_set_clk_regvals(u32 rate, u32 *dds, u32 *clk_div)

static unsigned int quark_x1000_get_clk_div(int rate, u32 *dds)

{

{

	unsigned int i;

	unsigned long xtal = 200000000;

	unsigned long fref = xtal / 2;		/* mandatory division by 2,

						   see (2) */

						/* case 3 */

	unsigned long fref1 = fref / 2;		/* case 1 */

	unsigned long fref2 = fref * 2 / 5;	/* case 2 */

	unsigned long scale;

	unsigned long q, q1, q2;

	long r, r1, r2;

	u32 mul;



	/* Case 1 */



	/* Set initial value for DDS_CLK_RATE */

	mul = (1 << 24) >> 1;





	for (i = 0; i < ARRAY_SIZE(quark_spi_rate_table); i++) {

	/* Calculate initial quot */

		if (rate >= quark_spi_rate_table[i].bitrate) {

	q1 = DIV_ROUND_CLOSEST(fref1, rate);

			*dds = quark_spi_rate_table[i].dds_clk_rate;



			*clk_div = quark_spi_rate_table[i].clk_div;

	/* Scale q1 if it's too big */

			return quark_spi_rate_table[i].bitrate;

	if (q1 > 256) {

		/* Scale q1 to range [1, 512] */

		scale = fls_long(q1 - 1);

		if (scale > 9) {

			q1 >>= scale - 9;

			mul >>= scale - 9;

		}



		/* Round the result if we have a remainder */

		q1 += q1 & 1;

	}

	}



	/* Decrease DDS_CLK_RATE as much as we can without loss in precision */

	scale = __ffs(q1);

	q1 >>= scale;

	mul >>= scale;



	/* Get the remainder */

	r1 = abs(fref1 / (1 << (24 - fls_long(mul))) / q1 - rate);



	/* Case 2 */



	q2 = DIV_ROUND_CLOSEST(fref2, rate);

	r2 = abs(fref2 / q2 - rate);



	/*

	 * Choose the best between two: less remainder we have the better. We

	 * can't go case 2 if q2 is greater than 256 since SCR register can

	 * hold only values 0 .. 255.

	 */

	if (r2 >= r1 || q2 > 256) {

		/* case 1 is better */

		r = r1;

		q = q1;

	} else {

		/* case 2 is better */

		r = r2;

		q = q2;

		mul = (1 << 24) * 2 / 5;

	}

	}





	*dds = quark_spi_rate_table[i-1].dds_clk_rate;

	/* Check case 3 only If the divisor is big enough */

	*clk_div = quark_spi_rate_table[i-1].clk_div;

	if (fref / rate >= 80) {

		u64 fssp;

		u32 m;



		/* Calculate initial quot */

		q1 = DIV_ROUND_CLOSEST(fref, rate);

		m = (1 << 24) / q1;



		/* Get the remainder */

		fssp = (u64)fref * m;

		do_div(fssp, 1 << 24);

		r1 = abs(fssp - rate);



		/* Choose this one if it suits better */

		if (r1 < r) {

			/* case 3 is better */

			q = 1;

			mul = m;

		}

	}





	return quark_spi_rate_table[i-1].bitrate;

	*dds = mul;

	return q - 1;

}

}





static unsigned int ssp_get_clk_div(struct driver_data *drv_data, int rate)

static unsigned int ssp_get_clk_div(struct driver_data *drv_data, int rate)
@@ -738,7 +790,7 @@ static unsigned int pxa2xx_ssp_get_clk_div(struct driver_data *drv_data, 




	switch (drv_data->ssp_type) {

	switch (drv_data->ssp_type) {

	case QUARK_X1000_SSP:

	case QUARK_X1000_SSP:

		quark_x1000_set_clk_regvals(rate, &chip->dds_rate, &clk_div);

		clk_div = quark_x1000_get_clk_div(rate, &chip->dds_rate);

	default:

	default:

		clk_div = ssp_get_clk_div(drv_data, rate);

		clk_div = ssp_get_clk_div(drv_data, rate);

	}

	}

CRA Git | Maintained and supported by SUSTech CRA and CCSE