android_kernel_cmhtcleo/drivers/spi/spi_qsd.c

/* linux/driver/spi/spi_qsd.c 
 * 
 * Copyright (C) 2009 Solomon Chiu <solomon_chiu@htc.com>
 *
 * 	This is a temporary solution to substitute Qualcomm's SPI.
 *	Should be replaced by formal SPI driver in the future.
 */

#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/interrupt.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/workqueue.h>
#include <linux/io.h>
#include <asm/gpio.h>
#include <mach/msm_iomap.h>

#define SPI_CONFIG              (0x00000000)
#define SPI_IO_CONTROL          (0x00000004)
#define SPI_OPERATIONAL         (0x00000030)
#define SPI_ERROR_FLAGS_EN      (0x00000038)
#define SPI_ERROR_FLAGS         (0x00000034)
#define SPI_OUTPUT_FIFO         (0x00000100)

#ifdef CONFIG_ARCH_MSM7X30

struct spi_device        *spidev;

extern int samsung_oled_panel_init(struct msm_lcdc_panel_ops *ops);
int qspi_send_16bit(unsigned char id, unsigned data)
{
	unsigned char buffer[4];
	int tmp;
	tmp = (id<<13 | data)<<16;

	buffer[0] = tmp >> 24;
	buffer[1] = (tmp & 0x00FF0000) >> 16;
	buffer[2] = (tmp & 0x0000FF00) >> 8;
	buffer[3] = tmp & 0x000000FF;
	spi_write(spidev,buffer,4);
	return 0;
}
int qspi_send_9bit(struct spi_msg *msg)
{
	int tmp = 0;
	spidev->bits_per_word = 9;
	tmp = (0x0 <<8 | msg->cmd)<<23;
	msg->buffer[0] = tmp >> 24;
	msg->buffer[1] = (tmp & 0x00FF0000) >> 16;

	if(msg->len != 0) {
		int i = 0, j;
		for(j = 2; i < msg->len; i++, j+=2){
			tmp &= 0x00000000;
			tmp = (0x1<<8 | *(msg->data+i))<<23;
			msg->buffer[j] = tmp >> 24;
			msg->buffer[j+1] = (tmp & 0x00FF0000) >> 16;
		}
	}

	spi_read_write_lock(spidev, msg, NULL, 2, 1);

	return 0;
}


int qspi_send(unsigned char id, unsigned data)
{
	unsigned char buffer[2];
	int tmp;
	tmp = (0x7000 | id<<9 | data)<<16;

	spidev->bits_per_word = 16;

	buffer[0] = tmp >> 24;
	buffer[1] = (tmp & 0x00FF0000) >> 16;

	spi_write(spidev,buffer,2);
	return 0;
}


static int msm_spi_probe(struct spi_device *spi)
{
	printk(" %s \n", __func__);
	spidev = spi;
	return 0 ;
}

static int msm_spi_remove(struct platform_device *pdev)
{
	spidev = NULL;
	return 0;
}


static struct spi_driver spi_qsd = {
	.driver = {
		.name  = "spi_qsd",
		.owner = THIS_MODULE,
	},
	.probe         = msm_spi_probe,
	.remove        = __devexit_p(msm_spi_remove),
};


static int __init spi_qsd_init(void)
{
	int rc;
	rc = spi_register_driver(&spi_qsd);
	return rc;
}
module_init(spi_qsd_init);

static void __exit spi_qsd_exit(void)
{
	spi_unregister_driver(&spi_qsd);
}
module_exit(spi_qsd_exit);

#else

void __iomem *spi_base;
struct clk *spi_clk ;

int qspi_send_16bit(unsigned char id, unsigned data)
{
        unsigned err ;

        /* bit-5: OUTPUT_FIFO_NOT_EMPTY */
	clk_enable(spi_clk);
        while( readl(spi_base+SPI_OPERATIONAL) & (1<<5) )
        {
                if( (err=readl(spi_base+SPI_ERROR_FLAGS)) )
                {
                        printk("\rERROR:  SPI_ERROR_FLAGS=%d\r", err);
                        return -1;
                }
        }

	writel( (id<<13 | data)<<16, spi_base+SPI_OUTPUT_FIFO );/*AUO*/
        udelay(1000);
	clk_disable(spi_clk);

	return 0;
}

int qspi_send_9bit(unsigned char id, unsigned data)
{
        unsigned err ;

        /* bit-5: OUTPUT_FIFO_NOT_EMPTY */
	clk_enable(spi_clk);
        while( readl(spi_base+SPI_OPERATIONAL) & (1<<5) )
        {
                if( (err=readl(spi_base+SPI_ERROR_FLAGS)) )
                {
                        printk("\rERROR:  SPI_ERROR_FLAGS=%d\r", err);
                        return -1;
                }
        }

	writel( ((id<<8) | data)<<23, spi_base+SPI_OUTPUT_FIFO);/*sharp*/

        udelay(1000);
	clk_disable(spi_clk);
	return 0;
}


int qspi_send(unsigned char id, unsigned data)
{
        unsigned err ;

        /* bit-5: OUTPUT_FIFO_NOT_EMPTY */
	clk_enable(spi_clk);
        while( readl(spi_base+SPI_OPERATIONAL) & (1<<5) )
        {
                if( (err=readl(spi_base+SPI_ERROR_FLAGS)) )
                {
                        printk("\rERROR:  SPI_ERROR_FLAGS=%d\r", err);
                        return -1;
                }
        }

        writel( (0x7000 | id<<9 | data)<<16, spi_base+SPI_OUTPUT_FIFO );
        udelay(100);
	clk_disable(spi_clk);
	return 0;
}

static int __init msm_spi_probe(struct platform_device *pdev)
{
	int rc ;
	struct spi_platform_data *pdata = pdev->dev.platform_data;

	spi_base=ioremap(0xA1200000, 4096);
	if(!spi_base)
		return -1;

        spi_clk = clk_get(&pdev->dev, "spi_clk");
        if (IS_ERR(spi_clk)) {
                dev_err(&pdev->dev, "%s: unable to get spi_clk\n", __func__);
                rc = PTR_ERR(spi_clk);
                goto err_probe_clk_get;
        }
        rc = clk_enable(spi_clk);
        if (rc) {
                dev_err(&pdev->dev, "%s: unable to enable spi_clk\n",
                        __func__);
                goto err_probe_clk_enable;
        }

	if(pdata == NULL)
		clk_set_rate(spi_clk, 4800000);
	else
		clk_set_rate(spi_clk, pdata->clk_rate);

	printk(KERN_DEBUG "spi clk = 0x%ld\n", clk_get_rate(spi_clk));
	printk("spi: SPI_CONFIG=%x\n", readl(spi_base+SPI_CONFIG));
	printk("spi: SPI_IO_CONTROL=%x\n", readl(spi_base+SPI_IO_CONTROL));
	printk("spi: SPI_OPERATIONAL=%x\n", readl(spi_base+SPI_OPERATIONAL));
	printk("spi: SPI_ERROR_FLAGS_EN=%x\n", readl(spi_base+SPI_ERROR_FLAGS_EN));
	printk("spi: SPI_ERROR_FLAGS=%x\n", readl(spi_base+SPI_ERROR_FLAGS));
	printk("-%s()\n", __FUNCTION__);
	clk_disable(spi_clk);

	return 0 ;

err_probe_clk_get:
err_probe_clk_enable:
	return -1 ;
}

static int __devexit msm_spi_remove(struct platform_device *pdev)
{
	return 0;
}

static int msm_spi_suspend(struct platform_device *pdev, pm_message_t state)
{
	printk("+%s()\n", __FUNCTION__);
	clk_disable(spi_clk);
	return 0 ;
}

static int msm_spi_resume(struct platform_device *pdev)
{
	printk("+%s()\n", __FUNCTION__);
	clk_enable(spi_clk);
	return 0 ;
}

static struct platform_driver msm_spi_driver = {
	.probe          = msm_spi_probe,
	.driver		= {
		.name	= "spi_qsd",
		.owner	= THIS_MODULE,
	},
#if 0
	.suspend        = msm_spi_suspend,
	.resume         = msm_spi_resume,
#endif
	.remove		= __exit_p(msm_spi_remove),
};

static int __init msm_spi_init(void)
{
	return platform_driver_register(&msm_spi_driver);
}

fs_initcall(msm_spi_init);
#endif