DS90UB921-Q1: SOC could not configure 948 because of I2C error

/*
 * fpd3_serdes.c
 *
 * lvds based serial link interface for onboard communication.
 */

/*
 * Datasheets:-
 * DS90UB913aq/DS90UB914aq http://www.ti.com/lit/ds/snls443a/snls443a.pdf
 * DS90UH925Q http://www.ti.com/lit/ds/symlink/ds90uh925q-q1.pdf
 * DS90UH928Q http://www.ti.com/lit/ds/snls440a/snls440a.pdf
 * DS90UB924Q http://www.ti.com/lit/ds/snls512/snls512.pdf
 * DS90UB921Q http://www.ti.com/lit/ds/symlink/ds90ub921-q1.pdf
 *
 * Documentation:-
 * -> Documentation/video-serdes.txt
 * -> Documentation/devicetree/bindings/video/fpd3-serdes.txt
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/delay.h>
#include <linux/of_gpio.h>
#include <linux/of_device.h>
#include "fpd3_serdes.h"

//#define TI_FPD3_DEBUG(...)
#define TI_FPD3_DEBUG  printk


static const unsigned int fpd3_949_ser_init[] = {
	/* digital reset0, digital reset1 */
    FPD3_SER_RESET,      0x00,
    /* RX CRC check, i2c passthrough */
    FPD3_SER_CONFIG,     0xDA,
    /* DES Device ID ds90ub948q*/
    FPD3_SER_DES_ID,     0x68,
    FPD3_SER_SLAVE_ID0,  (0x20<<1),
    FPD3_SER_SLAVE_AL0,  (0x20<<1),

//  FPD3_SER_I2C_CTRL,   0x9E,
    FPD3_SER_ICR,        0x21,
};



static const unsigned int fpd3_947_ser_init[] = {
	//After power up write the following to the device:
	FPD3_SER_947_ANA_IA_CNTL,		0x10,// select OLDI register
	FPD3_SER_947_ANA_IA_ADDR,		0x49,// force PLL controller in PPM reset state
	FPD3_SER_947_ANA_IA_DATA,		0x16,
	FPD3_SER_947_ANA_IA_ADDR,		0x47,// force PLL LOCK Low
	FPD3_SER_947_ANA_IA_DATA,		0x20,
	FPD3_SER_947_ANA_IA_DATA,		0xA0,// reset PLL divider
	FPD3_SER_947_ANA_IA_DATA,		0x20,
	FPD3_SER_947_ANA_IA_DATA,		0x00,// release PLL LOCK control
	FPD3_SER_947_ANA_IA_ADDR,		0x49,// release PLL state control
	FPD3_SER_947_ANA_IA_DATA,		0x00,

	/* digital reset0, digital reset1 */
	FPD3_SER_RESET,      0x00,
	/* RX CRC check, i2c passthrough */
	FPD3_SER_CONFIG,     0xDA,
	/* DES Device ID ds90ub948q*/
	FPD3_SER_DES_ID,     0x68,
	FPD3_SER_SLAVE_ID0,  (0x20<<1),
	FPD3_SER_SLAVE_AL0,  (0x20<<1),
};

static const unsigned int fpd3_921_ser_init[] = {
	/* digital reset0, digital reset1 */
	FPD3_SER_RESET,				0x00,
	/* RX CRC check, i2c passthrough */
	FPD3_SER_CONFIG,			0xDA,
	/* DES Device ID ds90ub948q*/
	FPD3_SER_DES_ID,     0x68,
	FPD3_SER_SLAVE_ID0,  (0x20<<1),
	FPD3_SER_SLAVE_AL0,  (0x20<<1),
};

static const unsigned int fpd3_949to948_des_init[] = {
	//digital reset0, digital reset1
	FPD3_DES_RESET,		0x07,
	//RX CRC check, i2c passthrough
	FPD3_DES_CONFIG1,	0x78,
	//Prevention of I2C Errors During Abrupt System Faults
	FPD3_DES_BCC_WDG_CTL,0x02,
//	FPD3_DES_I2C_CTRL,	0x8E,
	//SER Device ID ds90ub949q
	FPD3_DES_SER_ID,	0x18,
	FPD3_DES_SLAVE_ID0,	(0x20<<1),
	FPD3_DES_SLAVE_AL0,	(0x20<<1),

	//GPIO1 for lighten - remote gpio control
	FPD3_DES_GPIO_12,	0x99,

	FPD3_DES_GPIO_78,	0x01,

	FPD3_DES_GPIO_78,	0x09,
};

static const unsigned int fpd3_947to948_des_init[] = {
	//digital reset0, digital reset1
	FPD3_DES_RESET,		0x07,
	//RX CRC check, i2c passthrough
	FPD3_DES_CONFIG1,	0x78,
	//Prevention of I2C Errors During Abrupt System Faults
	FPD3_DES_BCC_WDG_CTL,0x02,
//	FPD3_DES_I2C_CTRL,	0x8E},
	//SER Device ID ds90ub947q
	FPD3_DES_SER_ID, 	0x34,
	FPD3_DES_SLAVE_ID0,	(0x20<<1),
	FPD3_DES_SLAVE_AL0,	(0x20<<1),

	//GPIO1 for lighten - remote gpio control
	FPD3_DES_GPIO_12,	0x99,

	FPD3_DES_GPIO_78,	0x01,

	FPD3_DES_GPIO_78,	0x09,
};


static const unsigned int fpd3_921to948_des_init[] = {
	//digital reset0, digital reset1
	FPD3_DES_RESET,		0x07,
	//RX CRC check, i2c passthrough
	FPD3_DES_CONFIG1,	0x78,
	//Prevention of I2C Errors During Abrupt System Faults
	FPD3_DES_BCC_WDG_CTL,0x02,
//	FPD3_DES_I2C_CTRL,	0x8E},
	//SER Device ID ds90ub921q
	FPD3_DES_SER_ID,	0x18,
	FPD3_DES_SLAVE_ID0,	(0x20<<1),
	FPD3_DES_SLAVE_AL0,	(0x20<<1),

	//GPIO1 for lighten - remote gpio control
	FPD3_DES_GPIO_12,	0x99,

	FPD3_DES_GPIO_78,	0x01,

	FPD3_DES_GPIO_78,	0x09,
};

int fpd3_serdes_initialize(struct i2c_client *client)
{
	struct fpd3_serdes_data *data = i2c_get_clientdata(client);
	const struct fpd3_serdes_platform_data *pdata = data->pdata;
	const unsigned int *seq;
	int i, len, reg, ret = 0, count = 0;

	if(!client)
		return -ENODEV;

	/* Wait for the device to initialize and show up device ID */
	if((pdata->dev_type >= FPD3_SER_DEV)&&(pdata->dev_type < FPD3_DES_DEV))
	{
		reg = FPD3_SER_DEV_ID;
	}
	else if(pdata->dev_type >= FPD3_DES_DEV)
	{
		reg = FPD3_DES_DEV_ID;
	}
	//读取设备ID，判断设备是否连接  (默认读取10次)
	while (ret != pdata->device_id && count < FPD3_MAX_POLL_COUNT) {
		ret = i2c_read_le8(client, reg);
		count++;
		mdelay(3);
	}
	if (count == FPD3_MAX_POLL_COUNT) {
		dev_err(&client->dev, "Not a %s chip", pdata->name);
		return -ENODEV;
	}
	
	//调用 fpd3_921_ser_init 之类数组初始化寄存器
	len = pdata->init_len;
	seq = pdata->init_seq;
	for (i = 0; i < len; i += 2) {
		ret = i2c_write_le8(client, seq[i], seq[i+1]);
		if (ret)
			i2c_write_le8(client, seq[i], seq[i+1]);
		if (seq[i] == 0x01)
			udelay(1000);
		else
			udelay(10);
	}

	return ret;
}
EXPORT_SYMBOL(fpd3_serdes_initialize);





static int fpd3_serdes_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	const struct of_device_id *of_dev_id;
	const struct fpd3_serdes_platform_data *pdata;
	struct fpd3_serdes_data *data;
	int status;

	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->client = client;
	i2c_set_clientdata(client, data);

	fpd3_serdes_remove_conflict(client);

	of_dev_id = of_match_device(fpd3_serdes_dt_ids, &client->dev);
	if (!of_dev_id) {
		dev_err(&client->dev, "Unable to match device");
		return -EINVAL;
	}
	pdata = of_dev_id->data;
	data->pdata = pdata;


	status = fpd3_serdes_initialize(client);
	if(status)
	{
		if((pdata->dev_type >= FPD3_SER_DEV)&&(pdata->dev_type < FPD3_DES_DEV))
			goto free_gpio;
		else if(pdata->dev_type >= FPD3_DES_DEV)
			goto fail;
	}

	dev_err(&client->dev, "%s %s ready", pdata->dev_type == FPD3_SER_DEV ?
		"Serializer" : "Deserializer", data->pdata->name);
	
	return 0;
free_gpio:
	fpd3_of_gpio_free(data);
fail:
	TI_FPD3_DEBUG(KERN_INFO"kfree memory %s -- %d\n",__func__,__LINE__);
	TI_FPD3_DEBUG(KERN_INFO"i2c device %s : 0x%2x disconnect.\n",data->pdata->name,client->addr);
	devm_kfree(&client->dev,data);
	return status;
}

static int fpd3_serdes_remove(struct i2c_client *client)
{
	struct fpd3_serdes_data	*data = i2c_get_clientdata(client);

	fpd3_of_gpio_free(data);
	devm_kfree(&client->dev,data);

	return 0;
}

static struct i2c_driver fpd3_serdes_driver = {
	.driver = {
		.name = "fpd3_serdes",
		.owner = THIS_MODULE,
		.of_match_table	= fpd3_serdes_dt_ids,
	},
	.probe = fpd3_serdes_probe,
	.remove = fpd3_serdes_remove,
	.id_table = fpd3_serdes_i2c_ids
};

static int __init fpd3_i2c_init(void)
{
	return i2c_add_driver(&fpd3_serdes_driver);
}

static void __exit fpd3_i2c_exit(void)
{
	i2c_del_driver(&fpd3_serdes_driver);
}

fs_initcall(fpd3_i2c_init);
module_exit(fpd3_i2c_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Nikhil Devshatwar");