static ssize_t p61_dev_read(struct file *filp, char *buf,
size_t count, loff_t *offset)
{
int ret = -1;
struct p61_dev *p61_dev = filp->private_data;
NFC_DBG_MSG(KERN_ALERT "p61_dev_read - Enter \n");
mutex_lock(&p61_dev->read_mutex);
NFC_DBG_MSG(KERN_ALERT "p61_dev_read - aquried mutex - calling spi_read \n");
NFC_DBG_MSG(KERN_ALERT "p61_dev_read - test1 count [0x%x] \n",count);
/** Read data */
#ifdef IRQ_ENABLE
NFC_DBG_MSG(KERN_ALERT "************ Test11 *****************\n");
if (!gpio_get_value(p61_dev->irq_gpio))
{
while (1)
{
NFC_DBG_MSG(KERN_ALERT "************ Test1 *****************\n");
NFC_DBG_MSG(" %s inside while(1) \n", __FUNCTION__);
p61_dev->irq_enabled = true;
enable_irq(p61_dev->spi->irq);
ret = wait_event_interruptible(p61_dev->read_wq,!p61_dev->irq_enabled);
p61_disable_irq(p61_dev);
if (ret)
{
NFC_DBG_MSG("p61_disable_irq() : Failed\n");
goto fails;
}
NFC_DBG_MSG(KERN_ALERT "************ Test2 *****************\n");
if (gpio_get_value(p61_dev->irq_gpio))
break;
NFC_DBG_MSG("%s: spurious interrupt detected\n", __func__);
}
}
NFC_DBG_MSG(KERN_ALERT "************ gpio already high read data Test11 *****************\n");
#endif
NFC_DBG_MSG(KERN_ALERT "************ Test3 *****************\n");
ret = spi_read (p61_dev -> spi,(void *) buf, count);
if(0>ret)
{
NFC_ERR_MSG(KERN_ALERT "spi_read returns -1 \n");
goto fails;
}
NFC_DBG_MSG(KERN_ALERT "Read ret %d \n",ret);
mutex_unlock(&p61_dev->read_mutex);
if (0 == ret)
{
ret = count;
}
return ret;
fails:
mutex_unlock(&p61_dev->read_mutex);
return ret;
}
static irqreturn_t p61_dev_irq_handler(int irq, void *dev_id)
{
struct p61_dev *p61_dev = dev_id;
P61_DBG_MSG("Entry : %s\n", __FUNCTION__);
p61_disable_irq(p61_dev);
/* Wake up waiting readers */
wake_up(&p61_dev->read_wq);
P61_DBG_MSG("Exit : %s\n", __FUNCTION__);
return IRQ_HANDLED;
}
static int p61_probe(struct spi_device *spi)
{
int ret = -1;
struct p61_spi_platform_data *platform_data = NULL;
struct p61_spi_platform_data platform_data1;
struct p61_dev *p61_dev = NULL;
#ifdef P61_IRQ_ENABLE
unsigned int irq_flags;
#endif
P61_DBG_MSG("%s chip select : %d , bus number = %d \n",
__FUNCTION__, spi->chip_select, spi->master->bus_num);
#if !DRAGON_P61
platform_data = spi->dev.platform_data;
if (platform_data == NULL)
{
/* RC : rename the platformdata1 name */
/* TBD: This is only for Panda as we are passing NULL for platform data */
P61_ERR_MSG("%s : p61 probe fail\n", __func__);
platform_data1.irq_gpio = P61_IRQ;
platform_data1.rst_gpio = P61_RST;
platform_data = &platform_data1;
P61_ERR_MSG("%s : p61 probe fail1\n", __func__);
//return -ENODEV;
}
#else
ret = p61_parse_dt(&spi->dev, &platform_data1);
if (ret) {
pr_err("%s - Failed to parse DT\n", __func__);
goto err_exit;
}
platform_data = &platform_data1;
#endif
p61_dev = kzalloc(sizeof(*p61_dev), GFP_KERNEL);
if (p61_dev == NULL)
{
P61_ERR_MSG("failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
ret = p61_hw_setup (platform_data, p61_dev, spi);
if (ret < 0)
{
P61_ERR_MSG("Failed to p61_enable_P61_IRQ_ENABLE\n");
goto err_exit0;
}
spi->bits_per_word = 8;
spi->mode = SPI_MODE_0;
spi->max_speed_hz = P61_SPI_CLOCK;
//spi->chip_select = SPI_NO_CS;
ret = spi_setup(spi);
if (ret < 0)
{
P61_ERR_MSG("failed to do spi_setup()\n");
goto err_exit0;
}
p61_dev -> spi = spi;
p61_dev -> p61_device.minor = MISC_DYNAMIC_MINOR;
p61_dev -> p61_device.name = "p73";
p61_dev -> p61_device.fops = &p61_dev_fops;
p61_dev -> p61_device.parent = &spi->dev;
p61_dev->irq_gpio = platform_data->irq_gpio;
p61_dev->rst_gpio = platform_data->rst_gpio;
dev_set_drvdata(&spi->dev, p61_dev);
/* init mutex and queues */
init_waitqueue_head(&p61_dev->read_wq);
mutex_init(&p61_dev->read_mutex);
mutex_init(&p61_dev->write_mutex);
#ifdef P61_IRQ_ENABLE
spin_lock_init(&p61_dev->irq_enabled_lock);
#endif
ret = misc_register(&p61_dev->p61_device);
if (ret < 0)
{
P61_ERR_MSG("misc_register failed! %d\n", ret);
goto err_exit0;
}
#ifdef P61_IRQ_ENABLE
p61_dev->spi->irq = gpio_to_irq(platform_data->irq_gpio);
if ( p61_dev->spi->irq < 0)
{
P61_ERR_MSG("gpio_to_irq request failed gpio = 0x%x\n", platform_data->irq_gpio);
goto err_exit1;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
p61_dev->irq_enabled = true;
p61_through_put_t.enable_through_put_measure = false;
irq_flags = IRQF_TRIGGER_RISING | IRQF_ONESHOT;
ret = request_irq(p61_dev->spi->irq, p61_dev_irq_handler,
irq_flags, p61_dev -> p61_device.name, p61_dev);
if (ret)
{
P61_ERR_MSG("request_irq failed\n");
goto err_exit1;
}
p61_disable_irq(p61_dev);
#endif
p61_dev-> enable_poll_mode = 0; /* Default IRQ read mode */
P61_DBG_MSG("Exit : %s\n", __FUNCTION__);
return ret;
err_exit1:
misc_deregister(&p61_dev->p61_device);
err_exit0:
mutex_destroy(&p61_dev->read_mutex);
mutex_destroy(&p61_dev->write_mutex);
if(p61_dev != NULL)
kfree(p61_dev);
err_exit:
P61_DBG_MSG("ERROR: Exit : %s ret %d\n", __FUNCTION__, ret);
return ret;
}
static ssize_t p61_dev_read(struct file *filp, char *buf, size_t count,
loff_t *offset)
{
int ret = -EIO;
struct p61_dev *p61_dev = filp->private_data;
unsigned char rx_buffer[MAX_BUFFER_SIZE];
P61_DBG_MSG("p61_dev_read count %d - Enter \n", count);
mutex_lock(&p61_dev->read_mutex);
if (count > MAX_BUFFER_SIZE)
{
count = MAX_BUFFER_SIZE;
}
memset(&rx_buffer[0], 0x00, sizeof(rx_buffer));
if (p61_dev->enable_poll_mode)
{
P61_DBG_MSG(" %s Poll Mode Enabled \n", __FUNCTION__);
P61_DBG_MSG(KERN_INFO"SPI_READ returned 0x%x", count);
ret = spi_read(p61_dev->spi, (void *)&rx_buffer[0], count);
if (0 > ret)
{
P61_ERR_MSG(KERN_ALERT "spi_read failed [SOF] \n");
goto fail;
}
}
else
{
#ifdef P61_IRQ_ENABLE
P61_DBG_MSG(" %s Interrrupt Mode Enabled \n", __FUNCTION__);
if (!gpio_get_value(p61_dev->irq_gpio))
{
if (filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN;
goto fail;
}
while (1)
{
P61_DBG_MSG(" %s waiting for interrupt \n", __FUNCTION__);
p61_dev->irq_enabled = true;
enable_irq(p61_dev->spi->irq);
ret = wait_event_interruptible(p61_dev->read_wq,!p61_dev->irq_enabled);
p61_disable_irq(p61_dev);
if (ret)
{
P61_ERR_MSG("wait_event_interruptible() : Failed\n");
goto fail;
}
if (gpio_get_value(p61_dev->irq_gpio))
break;
P61_ERR_MSG("%s: spurious interrupt detected\n", __func__);
}
}
#else
P61_ERR_MSG(" %s P61_IRQ_ENABLE not Enabled \n", __FUNCTION__);
#endif
ret = spi_read(p61_dev->spi, (void *)&rx_buffer[0], count);
if (0 > ret)
{
P61_DBG_MSG(KERN_INFO"SPI_READ returned 0x%x", ret);
ret = -EIO;
goto fail;
}
}
if(p61_through_put_t.enable_through_put_measure)
p61_start_throughput_measurement(READ_THROUGH_PUT);
if(p61_through_put_t.enable_through_put_measure)
p61_stop_throughput_measurement (READ_THROUGH_PUT, count);
P61_DBG_MSG(KERN_INFO"total_count = %d", count);
if (copy_to_user(buf, &rx_buffer[0], count))
{
P61_ERR_MSG("%s : failed to copy to user space\n", __func__);
ret = -EFAULT;
goto fail;
}
P61_DBG_MSG("p61_dev_read ret %d Exit\n", ret);
P61_DBG_MSG("p61_dev_read ret %d Exit\n", rx_buffer[0]);
mutex_unlock(&p61_dev->read_mutex);
return ret;
fail:
P61_ERR_MSG("Error p61_dev_read ret %d Exit\n", ret);
mutex_unlock(&p61_dev->read_mutex);
return ret;
}
static ssize_t p61_dev_read(struct file *filp, char *buf, size_t count,
loff_t *offset)
{
int ret = -EIO;
struct p61_dev *p61_dev = filp->private_data;
unsigned char sof = 0x00;
int total_count = 0;
unsigned char rx_buffer[MAX_BUFFER_SIZE];
P61_DBG_MSG("p61_dev_read count %zu - Enter \n", count);
if (count < MAX_BUFFER_SIZE)
{
P61_ERR_MSG(KERN_ALERT "Invalid length (min : 258) [%zu] \n", count);
return -EINVAL;
}
mutex_lock(&p61_dev->read_mutex);
if (count > MAX_BUFFER_SIZE)
{
count = MAX_BUFFER_SIZE;
}
memset(&rx_buffer[0], 0x00, sizeof(rx_buffer));
if (p61_dev->enable_poll_mode)
{
P61_DBG_MSG(" %s Poll Mode Enabled \n", __FUNCTION__);
do
{
sof = 0x00;
P61_DBG_MSG(KERN_INFO"SPI_READ returned 0x%x", sof);
ret = spi_read(p61_dev->spi, (void *)&sof, 1);
if (0 > ret)
{
P61_ERR_MSG(KERN_ALERT "spi_read failed [SOF] \n");
goto fail;
}
P61_DBG_MSG(KERN_INFO"SPI_READ returned 0x%x", sof);
/* if SOF not received, give some time to P61 */
/* RC put the conditional delay only if SOF not received */
if (sof != SOF)
usleep_range(5000, 5100);
} while(sof != SOF);
}
else
{
#ifdef P61_IRQ_ENABLE
P61_DBG_MSG(" %s Interrrupt Mode Enabled \n", __FUNCTION__);
if (!gpio_get_value(p61_dev->irq_gpio))
{
if (filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN;
goto fail;
}
while (1)
{
P61_DBG_MSG(" %s waiting for interrupt \n", __FUNCTION__);
p61_dev->irq_enabled = true;
enable_irq(p61_dev->spi->irq);
ret = wait_event_interruptible(p61_dev->read_wq,!p61_dev->irq_enabled);
p61_disable_irq(p61_dev);
if (ret)
{
P61_ERR_MSG("wait_event_interruptible() : Failed\n");
goto fail;
}
if (gpio_get_value(p61_dev->irq_gpio))
break;
P61_ERR_MSG("%s: spurious interrupt detected\n", __func__);
}
}
#else
P61_ERR_MSG(" %s P61_IRQ_ENABLE not Enabled \n", __FUNCTION__);
#endif
/* read the SOF */
sof = 0x00;
ret = spi_read(p61_dev->spi, (void *)&sof, 1);
if ((0 > ret) || (sof != SOF))
{
P61_DBG_MSG(KERN_INFO"SPI_READ returned 0x%x", sof);
P61_ERR_MSG(KERN_ALERT "spi_read failed [SOF] 0x%x\n", ret);
ret = -EIO;
goto fail;
}
}
total_count = 1;
rx_buffer[0] = sof;
/* Read the HEADR of Two bytes*/
ret = spi_read(p61_dev->spi, (void *)&rx_buffer[1], 2);
if (ret < 0)
{
P61_ERR_MSG(KERN_ALERT "spi_read fails after [PCB] \n");
ret = -EIO;
goto fail;
}
total_count += 2;
/* Get the data length */
count = rx_buffer[2];
P61_DBG_MSG(KERN_INFO"Data Lenth = %zu", count);
/* Read the availabe data along with one byte LRC */
ret = spi_read(p61_dev->spi, (void *)&rx_buffer[3], (count+1));
if (ret < 0)
{
P61_ERR_MSG("spi_read failed \n");
ret = -EIO;
goto fail;
}
total_count = (total_count + (count+1));
P61_DBG_MSG(KERN_INFO"total_count = %d", total_count);
if (copy_to_user(buf, &rx_buffer[0], total_count))
{
P61_ERR_MSG("%s : failed to copy to user space\n", __func__);
ret = -EFAULT;
goto fail;
}
ret = total_count;
P61_DBG_MSG("p61_dev_read ret %d Exit\n", ret);
mutex_unlock(&p61_dev->read_mutex);
return ret;
fail:
P61_ERR_MSG("Error p61_dev_read ret %d Exit\n", ret);
mutex_unlock(&p61_dev->read_mutex);
return ret;
}
static int p61_probe(struct spi_device *spi)
{
int ret = -1;
//struct p61_spi_platform_data *platform_data = NULL;
//struct p61_spi_platform_data platform_data1;
struct p61_dev *p61_dev = NULL;
#ifdef P61_IRQ_ENABLE
unsigned int irq_flags;
#endif
P61_DBG_MSG("%s chip select : %d , bus number = %d \n",
__FUNCTION__, spi->chip_select, spi->master->bus_num);
//platform_data = spi->dev.platform_data;
#if 0
if (platform_data == NULL)
{
/* RC : rename the platformdata1 name */
/* TBD: This is only for Panda as we are passing NULL for platform data */
P61_ERR_MSG("%s : p61 probe fail\n", __func__);
//platform_data1.irq_gpio = P61_IRQ;
//platform_data1.rst_gpio = P61_RST;
//platform_data = &platform_data1;
P61_ERR_MSG("%s : p61 probe fail1\n", __func__);
return -ENODEV;
}
#endif
p61_dev = kzalloc(sizeof(*p61_dev), GFP_KERNEL);
if (p61_dev == NULL)
{
P61_ERR_MSG("failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
ret = p61_parse_dt(&spi->dev, p61_dev);
if (ret) {
pr_err("%s - Failed to parse DT\n", __func__);
goto p61_parse_dt_failed;
}
pr_info("%s: tz_mode=%d, isGpio_cfgDone:%d\n", __func__,
p61_dev->tz_mode, p61_dev->isGpio_cfgDone);
#if 0
ret = p61_hw_setup (platform_data, p61_dev, spi);
if (ret < 0)
{
P61_ERR_MSG("Failed to p61_enable_P61_IRQ_ENABLE\n");
goto err_exit0;
}
#endif
spi->bits_per_word = 8;
spi->mode = SPI_MODE_0;
spi->max_speed_hz = P61_SPI_CLOCK;
//spi->chip_select = SPI_NO_CS;
ret = spi_setup(spi);
if (ret < 0)
{
P61_ERR_MSG("failed to do spi_setup()\n");
goto p61_spi_setup_failed;
}
p61_dev -> spi = spi;
p61_dev -> p61_device.minor = MISC_DYNAMIC_MINOR;
p61_dev -> p61_device.name = "p61";
p61_dev -> p61_device.fops = &p61_dev_fops;
p61_dev -> p61_device.parent = &spi->dev;
// p61_dev->irq_gpio = platform_data->irq_gpio;
//p61_dev->rst_gpio = platform_data->rst_gpio;
dev_set_drvdata(&spi->dev, p61_dev);
/* init mutex and queues */
init_waitqueue_head(&p61_dev->read_wq);
mutex_init(&p61_dev->read_mutex);
mutex_init(&p61_dev->write_mutex);
spin_lock_init(&p61_dev->ese_spi_lock);
#ifdef P61_IRQ_ENABLE
spin_lock_init(&p61_dev->irq_enabled_lock);
#endif
wake_lock_init(&p61_dev->ese_lock, WAKE_LOCK_SUSPEND, "ese_wake_lock");
ret = misc_register(&p61_dev->p61_device);
if (ret < 0)
{
P61_ERR_MSG("misc_register failed! %d\n", ret);
goto err_exit0;
}
#if 0 //test
{
struct device *dev;
p61_device_class = class_create(THIS_MODULE, "ese");
if (IS_ERR(p61_device_class)) {
pr_err("%s class_create() is failed:%lu\n",
__func__, PTR_ERR(p61_device_class));
//status = PTR_ERR(p61_device_class);
//goto vfsspi_probe_class_create_failed;
}
dev = device_create(p61_device_class, NULL,
0, p61_dev, "p61");
pr_err("%s device_create() is failed:%lu\n",
__func__, PTR_ERR(dev));
if ((device_create_file(dev, &dev_attr_test)) < 0)
pr_err("%s device_create_file failed !!!\n", __func__);
else
pr_info("%s device_create_file success.\n", __func__);
//ret = sysfs_create_group(&spi->dev.kobj,
// &p61_attribute_group);
//if (ret < 0)
// pr_err("%s class_create() is failed - \n",
// __func__, PTR_ERR(p61_device_class));
}
#endif
#ifdef P61_IRQ_ENABLE
p61_dev->spi->irq = gpio_to_irq(platform_data->irq_gpio);
if ( p61_dev->spi->irq < 0)
{
P61_ERR_MSG("gpio_to_irq request failed gpio = 0x%x\n",
platform_data->irq_gpio);
goto err_exit1;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
p61_dev->irq_enabled = true;
irq_flags = IRQF_TRIGGER_RISING | IRQF_ONESHOT;
ret = request_irq(p61_dev->spi->irq, p61_dev_irq_handler,
irq_flags, p61_dev -> p61_device.name, p61_dev);
if (ret)
{
P61_ERR_MSG("request_irq failed\n");
goto err_exit1;
}
p61_disable_irq(p61_dev);
#endif
p61_dev-> enable_poll_mode = 1; /* Default IRQ read mode */
P61_DBG_MSG("%s finished...\n", __FUNCTION__);
return ret;
//err_exit1:
misc_deregister(&p61_dev->p61_device);
err_exit0:
mutex_destroy(&p61_dev->read_mutex);
mutex_destroy(&p61_dev->write_mutex);
wake_lock_destroy(&p61_dev->ese_lock);
p61_spi_setup_failed:
p61_parse_dt_failed:
if(p61_dev != NULL)
kfree(p61_dev);
err_exit:
P61_DBG_MSG("ERROR: Exit : %s ret %d\n", __FUNCTION__, ret);
return ret;
}
static int __devinit p61_probe(struct spi_device *spi)
{
int ret = 0;
struct p61_dev *p61_dev=NULL;
unsigned int irq_flags;
printk("P61 with irq without log Entry : %s\n", __FUNCTION__);
NFC_DBG_MSG("chip select : %d , bus number = %d \n", spi->chip_select, spi->master->bus_num);
p61_dev = kzalloc(sizeof(*p61_dev), GFP_KERNEL);
if (p61_dev == NULL)
{
NFC_ERR_MSG("failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
ret = gpio_request( P61_RST, "p61 reset");
if (ret < 0)
{
NFC_ERR_MSG("p61 gpio reset request failed = 0x%x\n", P61_RST);
goto fail_gpio;
}
NFC_ERR_MSG("gpio_request returned = 0x%x\n", ret);
ret = gpio_direction_output(P61_RST,0);
if (ret < 0)
{
NFC_ERR_MSG("p61 gpio rst request failed gpio = 0x%x\n", P61_RST);
goto fail_gpio;
}
NFC_ERR_MSG("gpio_direction_output returned = 0x%x\n", ret);
#ifdef IRQ_ENABLE
ret = gpio_request( P61_IRQ, "p61 irq");
if (ret < 0)
{
NFC_ERR_MSG("p61 gpio request failed gpio = 0x%x\n", P61_IRQ);
goto err_exit0;
}
ret = gpio_direction_input(P61_IRQ);
if (ret < 0)
{
NFC_ERR_MSG("p61 gpio request failed gpio = 0x%x\n", P61_IRQ);
goto err_exit0;
}
#endif
spi->bits_per_word = 8;
spi->mode = SPI_MODE_0;
spi->max_speed_hz = 7000000;//1000000;
//spi->chip_select = SPI_NO_CS;
ret = spi_setup(spi);
if (ret < 0)
{
NFC_ERR_MSG("failed to do spi_setup()\n");
goto err_exit0;
}
p61_dev -> spi = spi;
p61_dev -> p61_device.minor = MISC_DYNAMIC_MINOR;
p61_dev -> p61_device.name = "p61";
p61_dev -> p61_device.fops = &p61_dev_fops;
p61_dev -> p61_device.parent = &spi->dev;
p61_dev -> ven_gpio = P61_RST;
gpio_set_value(P61_RST, 1);
msleep(20);
printk("p61_dev->rst_gpio = %d\n ",P61_RST);
#ifdef IRQ_ENABLE
p61_dev->irq_gpio = P61_IRQ;
#endif
p61_set_data(spi, p61_dev);
/* init mutex and queues */
init_waitqueue_head(&p61_dev->read_wq);
mutex_init(&p61_dev->read_mutex);
//spin_lock_init(&p61_dev->irq_enabled_lock);
#ifdef IRQ_ENABLE
spin_lock_init(&p61_dev->irq_enabled_lock);
#endif
ret = misc_register(&p61_dev->p61_device);
if (ret < 0)
{
NFC_ERR_MSG("misc_register failed! %d\n", ret);
goto err_exit0;
}
#ifdef IRQ_ENABLE
p61_dev->spi->irq = gpio_to_irq(P61_IRQ);
if ( p61_dev->spi->irq < 0)
{
NFC_ERR_MSG("gpio_to_irq request failed gpio = 0x%x\n", P61_IRQ);
goto err_exit0;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
p61_dev->irq_enabled = true;
irq_flags = IRQF_TRIGGER_RISING | IRQF_ONESHOT;
ret = request_irq(p61_dev->spi->irq, p61_dev_irq_handler,
irq_flags, p61_dev -> p61_device.name, p61_dev);
if (ret)
{
NFC_ERR_MSG("request_irq failed\n");
goto err_exit0;
}
p61_disable_irq(p61_dev);
#endif
NFC_DBG_MSG("Exit : %s\n", __FUNCTION__);
return ret;
// err_exit1:
// misc_deregister(&p61_dev->p61_device);
err_exit0:
mutex_destroy(&p61_dev->read_mutex);
if(p61_dev != NULL)
kfree(p61_dev);
fail_gpio:
gpio_free(P61_RST);
err_exit:
return ret;
}
