Re: [PATCH] i2c: cyttsp i2c and spi touchscreen driver init submit

Trilok Soni
2010-08-06T09:06:45Z

Hi Kevin,

Review for SPI code.

> diff --git a/drivers/input/touchscreen/cyttsp_spi.c b/drivers/input/touchscreen/cyttsp_spi.c
> new file mode 100755

> +#include <linux/init.h>
> +#include <linux/module.h>
> +#include <linux/spi/spi.h>
> +#include <linux/delay.h>
> +#include <linux/cyttsp.h>
> +#include "cyttsp_core.h"
> +
> +#define DBG(x)
> +
> +#define CY_SPI_WR_OP 0x00 /* r/~w */
> +#define CY_SPI_RD_OP 0x01
> +#define CY_SPI_CMD_BYTES 4
> +#define CY_SPI_SYNC_BYTES 2
> +#define CY_SPI_SYNC_ACK1 0x62 /* from protocol v.2 */
> +#define CY_SPI_SYNC_ACK2 0x9D /* from protocol v.2 */
> +#define CY_SPI_SYNC_NACK 0x69
> +#define CY_SPI_DATA_SIZE 64
> +#define CY_SPI_DATA_BUF_SIZE (CY_SPI_CMD_BYTES + CY_SPI_DATA_SIZE)
> +#define CY_SPI_BITS_PER_WORD 8
> +
> +struct cyttsp_spi {
> + struct cyttsp_bus_ops ops;
> + struct spi_device *spi_client;
> + void *ttsp_client;
> + u8 wr_buf[CY_SPI_DATA_BUF_SIZE];
> + u8 rd_buf[CY_SPI_DATA_BUF_SIZE];
> +};
> +
> +static void spi_complete(void *arg)
> +{
> + complete(arg);

We don't need anything here on completion?

> +}
> +
> +static int spi_sync_tmo(struct spi_device *spi, struct spi_message *message)
> +{
> + DECLARE_COMPLETION_ONSTACK(done);
> + int status;
> + DBG(printk(KERN_INFO"%s: Enter\n", __func__);)

No need.

> +
> + message->complete = spi_complete;
> + message->context = &done;
> + status = spi_async(spi, message);
> + if (status == 0) {
> + int ret = wait_for_completion_interruptible_timeout(&done, HZ);
> + if (!ret) {
> + printk(KERN_ERR "%s: timeout\n", __func__);
> + status = -EIO;
> + } else
> + status = message->status;
> + }
> + message->context = NULL;
> + return status;
> +}
> +
> +static int cyttsp_spi_xfer_(u8 op, struct cyttsp_spi *ts_spi,
> + u8 reg, u8 *buf, int length)
> +{
> + struct spi_message msg;
> + struct spi_transfer xfer = { 0 };
> + u8 *wr_buf = ts_spi->wr_buf;
> + u8 *rd_buf = ts_spi->rd_buf;
> + int retval;
> + int i;
> + DBG(printk(KERN_INFO "%s: Enter\n", __func__);)

No need.

> +
> + if (length > CY_SPI_DATA_SIZE) {
> + printk(KERN_ERR "%s: length %d is too big.\n",
> + __func__, length);
> + return -EINVAL;
> + }
> + DBG(printk(KERN_INFO "%s: OP=%s length=%d\n", __func__,
> + op == CY_SPI_RD_OP ? "Read" : "Write", length);)

dev_dbg if really needed.

> +
> + wr_buf[0] = 0x00; /* header byte 0 */
> + wr_buf[1] = 0xFF; /* header byte 1 */
> + wr_buf[2] = reg; /* reg index */
> + wr_buf[3] = op; /* r/~w */
> + if (op == CY_SPI_WR_OP)
> + memcpy(wr_buf + CY_SPI_CMD_BYTES, buf, length);
> + DBG(
> + if (op == CY_SPI_RD_OP)
> + memset(rd_buf, CY_SPI_SYNC_NACK, CY_SPI_DATA_BUF_SIZE);)
> + DBG(
> + for (i = 0; i < (length + CY_SPI_CMD_BYTES); i++) {
> + if ((op == CY_SPI_RD_OP) && (i < CY_SPI_CMD_BYTES))
> + printk(KERN_INFO "%s: wr[%d]:0x%02x\n",
> + __func__, i, wr_buf[i]);
> + if (op == CY_SPI_WR_OP)
> + printk(KERN_INFO "%s: wr[%d]:0x%02x\n",
> + __func__, i, wr_buf[i]);
> + })

Let remove such things.

> +
> + xfer.tx_buf = wr_buf;
> + xfer.rx_buf = rd_buf;
> + xfer.len = length + CY_SPI_CMD_BYTES;
> +
> + if ((op == CY_SPI_RD_OP) && (xfer.len < 32))
> + xfer.len += 1;
> +
> + spi_message_init(&msg);
> + spi_message_add_tail(&xfer, &msg);
> + retval = spi_sync_tmo(ts_spi->spi_client, &msg);
> + if (retval < 0) {
> + printk(KERN_ERR "%s: spi_sync_tmo() error %d\n",
> + __func__, retval);
> + retval = 0;
> + }
> + if (op == CY_SPI_RD_OP) {
> + DBG(
> + for (i = 0; i < (length + CY_SPI_CMD_BYTES); i++)
> + printk(KERN_INFO "%s: rd[%d]:0x%02x\n",
> + __func__, i, rd_buf[i]);)
> +
> + for (i = 0; i < (length + CY_SPI_CMD_BYTES - 1); i++) {
> + if ((rd_buf[i] != CY_SPI_SYNC_ACK1) ||
> + (rd_buf[i + 1] != CY_SPI_SYNC_ACK2)) {
> + continue;
> + }
> + if (i <= (CY_SPI_CMD_BYTES - 1)) {
> + memcpy(buf, (rd_buf + i + CY_SPI_SYNC_BYTES),
> + length);
> + return 0;
> + }
> + }
> + DBG(printk(KERN_INFO "%s: byte sync error\n", __func__);)

dev_err if you really need to print for debugging purpose or pr_err(...)

> + retval = 1;
> + }
> + return retval;
> +}
> +
> +static int cyttsp_spi_xfer(u8 op, struct cyttsp_spi *ts,
> + u8 reg, u8 *buf, int length)
> +{
> + int tries;
> + int retval;
> + DBG(printk(KERN_INFO "%s: Enter\n", __func__);)

No need.

> +
> + if (op == CY_SPI_RD_OP) {
> + for (tries = CY_NUM_RETRY; tries; tries--) {
> + retval = cyttsp_spi_xfer_(op, ts, reg, buf, length);
> + if (retval == 0)
> + break;
> + else
> + msleep(10);
> + }
> + } else {
> + retval = cyttsp_spi_xfer_(op, ts, reg, buf, length);
> + }
> + return retval;
> +}
> +
> +static s32 ttsp_spi_read_block_data(void *handle, u8 addr,
> + u8 length, void *data)
> +{
> + int retval;
> + struct cyttsp_spi *ts = container_of(handle, struct cyttsp_spi, ops);
> +
> + DBG(printk(KERN_INFO "%s: Enter\n", __func__);)

No need.

> +
> + retval = cyttsp_spi_xfer(CY_SPI_RD_OP, ts, addr, data, length);
> + if (retval < 0)
> + printk(KERN_ERR "%s: ttsp_spi_read_block_data failed\n",
> + __func__);

dev_err(...)

> +
> + /* Do not print the above error if the data sync bytes were not found.
> + This is a normal condition for the bootloader loader startup and need
> + to retry until data sync bytes are found. */

Use kernel style for multi-line comments.

/*
* You should use this format
* for multi-line commenting
*/

> + if (retval > 0)
> + retval = -1; /* now signal fail; so retry can be done */
> +
> + return retval;
> +}
> +
> +static s32 ttsp_spi_write_block_data(void *handle, u8 addr,
> + u8 length, const void *data)
> +{
> + int retval;
> + struct cyttsp_spi *ts = container_of(handle, struct cyttsp_spi, ops);
> +
> + DBG(printk(KERN_INFO "%s: Enter\n", __func__);)

No need.

> +
> + retval = cyttsp_spi_xfer(CY_SPI_WR_OP, ts, addr, (void *)data, length);
> + if (retval < 0)
> + printk(KERN_ERR "%s: ttsp_spi_write_block_data failed\n",
> + __func__);
> +
> + if (retval == -EIO)
> + return 0;
> + else
> + return retval;
> +}
> +
> +static s32 ttsp_spi_tch_ext(void *handle, void *values)
> +{
> + int retval = 0;
> + struct cyttsp_spi *ts = container_of(handle, struct cyttsp_spi, ops);
> +
> + DBG(printk(KERN_INFO "%s: Enter\n", __func__);)

No need.

> +
> + /* Add custom touch extension handling code here */

You may want to add this as "TODO".

> + /* set: retval < 0 for any returned system errors,
> + retval = 0 if normal touch handling is required,
> + retval > 0 if normal touch handling is *not* required */
> + if (!ts || !values)
> + retval = -EIO;
> +
> + return retval;
> +}
> +
> +static int __devinit cyttsp_spi_probe(struct spi_device *spi)
> +{
> + struct cyttsp_spi *ts_spi;
> + int retval;
> + DBG(printk(KERN_INFO"%s: Enter\n", __func__);)

Un-necessary printk.

> +
> + /* Set up SPI*/
> + spi->bits_per_word = CY_SPI_BITS_PER_WORD;
> + spi->mode = SPI_MODE_0;
> + retval = spi_setup(spi);
> + if (retval < 0) {
> + printk(KERN_ERR "%s: SPI setup error %d\n", __func__, retval);

dev_err(...)

> + return retval;
> + }
> + ts_spi = kzalloc(sizeof(*ts_spi), GFP_KERNEL);
> + if (ts_spi == NULL) {
> + printk(KERN_ERR "%s: Error, kzalloc\n", __func__);

dev_err(...)

> + retval = -ENOMEM;
> + goto error_alloc_data_failed;
> + }
> + ts_spi->spi_client = spi;
> + dev_set_drvdata(&spi->dev, ts_spi);
> + ts_spi->ops.write = ttsp_spi_write_block_data;
> + ts_spi->ops.read = ttsp_spi_read_block_data;
> + ts_spi->ops.ext = ttsp_spi_tch_ext;
> +
> + ts_spi->ttsp_client = cyttsp_core_init(&ts_spi->ops, &spi->dev);
> + if (!ts_spi->ttsp_client)
> + goto ttsp_core_err;
> + printk(KERN_INFO "%s: Successful registration %s\n",
> + __func__, CY_SPI_NAME);

> +
> + return 0;
> +
> +ttsp_core_err:
> + kfree(ts_spi);
> +error_alloc_data_failed:
> + return retval;
> +}
> +
> +/* registered in driver struct */

No need.

> +static int __devexit cyttsp_spi_remove(struct spi_device *spi)
> +{
> + struct cyttsp_spi *ts_spi = dev_get_drvdata(&spi->dev);
> + DBG(printk(KERN_INFO"%s: Enter\n", __func__);)

Remove this printk.

> + cyttsp_core_release(ts_spi->ttsp_client);
> + kfree(ts_spi);
> + return 0;
> +}
> +
> +#ifdef CONFIG_PM
> +static int cyttsp_spi_suspend(struct spi_device *spi, pm_message_t message)
> +{
> + return cyttsp_suspend(dev_get_drvdata(&spi->dev));
> +}
> +
> +static int cyttsp_spi_resume(struct spi_device *spi)
> +{
> + return cyttsp_resume(dev_get_drvdata(&spi->dev));
> +}
> +#endif
> +
> +static struct spi_driver cyttsp_spi_driver = {
> + .driver = {
> + .name = CY_SPI_NAME,
> + .bus = &spi_bus_type,
> + .owner = THIS_MODULE,
> + },
> + .probe = cyttsp_spi_probe,
> + .remove = __devexit_p(cyttsp_spi_remove),
> +#ifdef CONFIG_PM
> + .suspend = cyttsp_spi_suspend,
> + .resume = cyttsp_spi_resume,
> +#endif
> +};
> +
> +static int __init cyttsp_spi_init(void)
> +{
> + int err;
> +
> + err = spi_register_driver(&cyttsp_spi_driver);
> + printk(KERN_INFO "%s: Cypress TrueTouch(R) Standard Product SPI "
> + "Touchscreen Driver (Built %s @ %s) returned %d\n",
> + __func__, __DATE__, __TIME__, err);

As Dmitry mentioned on another e-mail, remove such printks. They create un-necessary noise.

> +
> + return err;
> +}
> +module_init(cyttsp_spi_init);
> +
> +static void __exit cyttsp_spi_exit(void)
> +{
> + spi_unregister_driver(&cyttsp_spi_driver);
> + printk(KERN_INFO "%s: module exit\n", __func__);

Ditto.

> +}
> +module_exit(cyttsp_spi_exit);
> +
> +MODULE_ALIAS("spi:cyttsp");
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard Product (TTSP) SPI driver");
> +MODULE_AUTHOR("Cypress");
> +
> diff --git a/include/linux/cyttsp.h b/include/linux/cyttsp.h
> new file mode 100755
> index 0000000..b2a289b
> --- /dev/null
> +++ b/include/linux/cyttsp.h

You may want to move this to include/linux/input/cyttsp.h

---Trilok Soni

--
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.