/* * Copyright (C) 2012-2014 NXP Semiconductors * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "p61.h" #include "pn547.h" #ifdef CONFIG_ESE_SECURE #include "../misc/tzdev/include/tzdev/tee_client_api.h" #endif extern long pn547_dev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg); #define P61_SPI_CLOCK 7000000L /* size of maximum read/write buffer supported by driver */ #define MAX_BUFFER_SIZE 258U /* Different driver debug lever */ enum P61_DEBUG_LEVEL { P61_DEBUG_OFF, P61_FULL_DEBUG }; /* Variable to store current debug level request by ioctl */ static unsigned char debug_level = P61_FULL_DEBUG; static unsigned char pwr_req_on; #define P61_DBG_MSG(msg...) {\ switch (debug_level) {\ case P61_DEBUG_OFF:\ break;\ case P61_FULL_DEBUG:\ pr_info("[NXP-P61] " msg);\ break;\ /*fallthrough*/\ default:\ pr_err("[NXP-P61] Wrong debug level(%d)\n", debug_level);\ break;\ } \ } #define P61_ERR_MSG(msg...) pr_err("[NXP-P61] " msg) #define P61_INFO_MSG(msg...) pr_info("[NXP-P61] " msg) #ifdef CONFIG_ESE_SECURE static TEEC_UUID ese_drv_uuid = { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x65, 0x73, 0x65, 0x44, 0x72, 0x76} }; enum pm_mode { PM_SUSPEND, PM_RESUME, SECURE_CHECK, }; enum secure_state { NOT_CHECKED, ESE_SECURED, ESE_NOT_SECURED, }; #endif /* Device specific macro and structure */ struct p61_device { wait_queue_head_t read_wq; /* wait queue for read interrupt */ struct mutex read_mutex; /* read mutex */ struct mutex write_mutex; /* write mutex */ struct spi_device *spi; /* spi device structure */ struct miscdevice miscdev; /* char device as misc driver */ unsigned int rst_gpio; /* SW Reset gpio */ unsigned int irq_gpio; /* P61 will interrupt DH for any ntf */ bool irq_enabled; /* flag to indicate irq is used */ unsigned char enable_poll_mode; /* enable the poll mode */ spinlock_t irq_enabled_lock; /*spin lock for read irq */ bool tz_mode; spinlock_t ese_spi_lock; bool isGpio_cfgDone; struct wake_lock ese_lock; bool device_opened; struct pinctrl *pinctrl; struct pinctrl_state *ese_on_pin; struct pinctrl_state *ese_off_pin; #ifdef CONFIG_ESE_SECURE struct clk *ese_spi_pclk; struct clk *ese_spi_sclk; int ese_secure_check; #endif const char *ap_vendor; unsigned char *buf; }; static struct p61_device *p61_dev; /* T==1 protocol specific global data */ const unsigned char SOF = 0xA5u; #ifdef CONFIG_ESE_SECURE /** * p61_spi_clk_max_rate: finds the nearest lower rate for a clk * @clk the clock for which to find nearest lower rate * @rate clock frequency in Hz * @return nearest lower rate or negative error value * * Public clock API extends clk_round_rate which is a ceiling function. This * function is a floor function implemented as a binary search using the * ceiling function. */ static long p61_spi_clk_max_rate(struct clk *clk, unsigned long rate) { long lowest_available, nearest_low, step_size, cur; long step_direction = -1; long guess = rate; int max_steps = 10; cur = clk_round_rate(clk, rate); if (cur == rate) return rate; /* if we got here then: cur > rate */ lowest_available = clk_round_rate(clk, 0); if (lowest_available > rate) return -EINVAL; step_size = (rate - lowest_available) >> 1; nearest_low = lowest_available; while (max_steps-- && step_size) { guess += step_size * step_direction; cur = clk_round_rate(clk, guess); if ((cur < rate) && (cur > nearest_low)) nearest_low = cur; /* * if we stepped too far, then start stepping in the other * direction with half the step size */ if (((cur > rate) && (step_direction > 0)) || ((cur < rate) && (step_direction < 0))) { step_direction = -step_direction; step_size >>= 1; } } return nearest_low; } static void p61_spi_clock_set(struct p61_device *p61_dev, unsigned long speed) { long rate; if (!strcmp(p61_dev->ap_vendor, "qualcomm")) { /* finds the nearest lower rate for a clk */ rate = p61_spi_clk_max_rate(p61_dev->ese_spi_sclk, speed); if (rate < 0) { pr_err("%s: no match found for requested clock: %lu\n", __func__, speed); return; } speed = rate; /*pr_info("%s speed:%lu\n", __func__, speed);*/ } else if (!strcmp(p61_dev->ap_vendor, "slsi")) { /* There is half-multiplier */ speed = speed * 4; } clk_set_rate(p61_dev->ese_spi_sclk, speed); } static int p61_clk_control(struct p61_device *p61_dev, bool onoff) { static bool old_value; if (old_value == onoff) { pr_info("%s: ALREADY %s\n", __func__, onoff ? "enabled" : "disabled"); return 0; } if (onoff == true) { /* For slsi AP, clk enable should be run before clk set */ clk_prepare_enable(p61_dev->ese_spi_pclk); clk_prepare_enable(p61_dev->ese_spi_sclk); p61_spi_clock_set(p61_dev, P61_SPI_CLOCK); usleep_range(5000, 5100); P61_INFO_MSG("%s: clock: %lu(%lu)\n", __func__, P61_SPI_CLOCK, clk_get_rate(p61_dev->ese_spi_sclk)); } else { clk_disable_unprepare(p61_dev->ese_spi_pclk); clk_disable_unprepare(p61_dev->ese_spi_sclk); } old_value = onoff; pr_info("%s: clock %s\n", __func__, onoff ? "enabled" : "disabled"); return 0; } static int p61_clk_setup(struct device *dev, struct p61_device *p61_dev) { p61_dev->ese_spi_pclk = clk_get(dev, "pclk"); if (IS_ERR(p61_dev->ese_spi_pclk)) { pr_err("%s: Can't get %s\n", __func__, "pclk"); p61_dev->ese_spi_pclk = NULL; goto err_pclk_get; } p61_dev->ese_spi_sclk = clk_get(dev, "sclk"); if (IS_ERR(p61_dev->ese_spi_sclk)) { pr_err("%s: Can't get %s\n", __func__, "sclk"); p61_dev->ese_spi_sclk = NULL; goto err_sclk_get; } return 0; err_sclk_get: clk_put(p61_dev->ese_spi_pclk); err_pclk_get: return -EPERM; } static uint32_t tz_tee_ese_drv(enum pm_mode mode) { TEEC_Context context; TEEC_Session session; TEEC_Result result; uint32_t returnOrigin = TEEC_NONE; result = TEEC_InitializeContext(NULL, &context); if (result != TEEC_SUCCESS) goto out; result = TEEC_OpenSession(&context, &session, &ese_drv_uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &returnOrigin); if (result != TEEC_SUCCESS) goto finalize_context; /* test with valid cmd id, expected result : TEEC_SUCCESS */ result = TEEC_InvokeCommand(&session, mode, NULL, &returnOrigin); if (result != TEEC_SUCCESS) { P61_ERR_MSG("%s with cmd %d : FAIL\n", __func__, mode); goto close_session; } P61_ERR_MSG("eSE tz_tee_dev return origin %d\n", returnOrigin); close_session: TEEC_CloseSession(&session); finalize_context: TEEC_FinalizeContext(&context); out: P61_INFO_MSG("tz_tee_ese_drv, cmd %d result=%#x origin=%#x\n", mode , result, returnOrigin); return result; } extern int tz_tee_ese_secure_check(void); int tz_tee_ese_secure_check(void) { return tz_tee_ese_drv(SECURE_CHECK); } #endif int ese_spi_pinctrl(int enable) { int ret = 0; pr_info("[p61] %s (%d)\n", __func__, enable); switch (enable) { case 0: #ifdef CONFIG_ESE_SECURE p61_clk_control(p61_dev, false); tz_tee_ese_drv(PM_SUSPEND); #else if (p61_dev->ese_off_pin) { if (pinctrl_select_state(p61_dev->pinctrl, p61_dev->ese_off_pin)) P61_INFO_MSG("ese off pinctrl set error\n"); else P61_INFO_MSG("ese off pinctrl set\n"); } #endif break; case 1: #ifdef CONFIG_ESE_SECURE p61_clk_control(p61_dev, true); tz_tee_ese_drv(PM_RESUME); #else if (p61_dev->ese_on_pin) { if (pinctrl_select_state(p61_dev->pinctrl, p61_dev->ese_on_pin)) P61_INFO_MSG("ese on pinctrl set error\n"); else P61_INFO_MSG("ese on pinctrl set\n"); } #endif break; default: pr_err("%s no matching!\n", __func__); ret = -EINVAL; } return ret; } EXPORT_SYMBOL_GPL(ese_spi_pinctrl); static int p61_xfer(struct p61_device *p61_dev, struct p61_ioctl_transfer *tr) { int status = 0; struct spi_message m; struct spi_transfer t; /*For SDM845 & linux4.9: need to change spi buffer * from stack to dynamic memory */ if (p61_dev == NULL || tr == NULL) return -EFAULT; if (tr->len > DEFAULT_BUFFER_SIZE || !tr->len) return -EMSGSIZE; spi_message_init(&m); memset(&t, 0, sizeof(t)); memset(p61_dev->buf, 0, tr->len); /*memset 0 for read */ if (tr->tx_buffer != NULL) { /*write */ pr_info("%s...write\n", __func__); if (copy_from_user(p61_dev->buf, tr->tx_buffer, tr->len) != 0) return -EFAULT; } t.rx_buf = p61_dev->buf; t.tx_buf = p61_dev->buf; t.len = tr->len; spi_message_add_tail(&t, &m); status = spi_sync(p61_dev->spi, &m); if (status == 0) { if (tr->rx_buffer != NULL) { /*read */ unsigned long missing = 0; pr_info("%s...read\n", __func__); missing = copy_to_user(tr->rx_buffer, p61_dev->buf, tr->len); if (missing != 0) tr->len = tr->len - (unsigned int)missing; } } pr_info("%s p61_xfer,length=%d\n", __func__, tr->len); return status; } /* vfsspi_xfer */ static int p61_rw_spi_message(struct p61_device *p61_dev, unsigned long arg) { struct p61_ioctl_transfer *dup = NULL; int err = 0; dup = kmalloc(sizeof(struct p61_ioctl_transfer), GFP_KERNEL); if (dup == NULL) return -ENOMEM; if (copy_from_user(dup, (void *)arg, sizeof(struct p61_ioctl_transfer)) != 0) { kfree(dup); return -EFAULT; } err = p61_xfer(p61_dev, dup); if (err != 0) { kfree(dup); pr_err("%s p61_xfer failed!\n", __func__); return err; } if (copy_to_user((void *)arg, dup, sizeof(struct p61_ioctl_transfer)) != 0) { kfree(dup); return -EFAULT; } kfree(dup); return 0; } /** * \ingroup spi_driver * \brief Called from SPI LibEse to initilaize the P61 device * * \param[in] struct inode * * \param[in] struct file * * * \retval 0 if ok. */ static int p61_dev_open(struct inode *inode, struct file *filp) { struct p61_device *p61_dev = container_of(filp->private_data, struct p61_device, miscdev); struct spi_device *spidev = NULL; spidev = spi_dev_get(p61_dev->spi); filp->private_data = p61_dev; if (p61_dev->device_opened) { pr_err("%s: already opened!\n", __func__); return -EBUSY; } #ifdef CONFIG_ESE_SECURE if (p61_dev->ese_secure_check == NOT_CHECKED) { int ret = 0; ret = tz_tee_ese_secure_check(); if (ret) { p61_dev->ese_secure_check = ESE_NOT_SECURED; P61_ERR_MSG("eSE spi is not Secured\n"); return -EBUSY; } p61_dev->ese_secure_check = ESE_SECURED; } else if (p61_dev->ese_secure_check == ESE_NOT_SECURED) { P61_ERR_MSG("eSE spi is not Secured\n"); return -EBUSY; } #endif pr_info("[ESE]:%s Major No: %d, Minor No: %d\n", __func__, imajor(inode), iminor(inode)); if (!wake_lock_active(&p61_dev->ese_lock)) { pr_info("%s: [NFC-ESE] wake lock.\n", __func__); wake_lock(&p61_dev->ese_lock); } p61_dev->device_opened = true; return 0; } /** * \ingroup spi_driver * \brief To configure the P61_SET_PWR/P61_SET_DBG/P61_SET_POLL * \n P61_SET_PWR - hard reset (arg=2), soft reset (arg=1) * \n P61_SET_DBG - Enable/Disable (based on arg value) the driver logs * \n P61_SET_POLL - Configure the driver in poll (arg = 1), * interrupt (arg = 0) based read operation * \param[in] struct file * * \param[in] unsigned int * \param[in] unsigned long * * \retval 0 if ok. * */ static long p61_dev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { int ret = 0; struct p61_device *p61_dev = NULL; if (_IOC_TYPE(cmd) != P61_MAGIC) { pr_err("%s invalid magic. cmd=0x%X Received=0x%X Expected=0x%X\n", __func__, cmd, _IOC_TYPE(cmd), P61_MAGIC); return -ENOTTY; } pr_debug("%s entered %x\n", __func__, cmd); p61_dev = filp->private_data; switch (cmd) { case P61_SET_PWR: if (arg == 2) pr_info("%s P61_SET_PWR. No Action.\n", __func__); break; case P61_SET_DBG: debug_level = (unsigned char)arg; P61_DBG_MSG(KERN_INFO"[NXP-P61] - Debug level %d", debug_level); break; case P61_SET_POLL: p61_dev->enable_poll_mode = (unsigned char)arg; if (p61_dev->enable_poll_mode == 0) { P61_DBG_MSG(KERN_INFO"[NXP-P61] - IRQ Mode is set\n"); } else { P61_DBG_MSG(KERN_INFO"[NXP-P61] - Poll Mode is set\n"); p61_dev->enable_poll_mode = 1; } break; #if !defined(CONFIG_NFC_FEATURE_SN100U) case P61_SET_SPI_CONFIG: pr_info("%s P61_SET_SPI_CONFIG. No Action.\n", __func__); break; case P61_ENABLE_SPI_CLK: pr_info("%s P61_ENABLE_SPI_CLK. No Action.\n", __func__); break; case P61_DISABLE_SPI_CLK: pr_info("%s P61_DISABLE_SPI_CLK. No Action.\n", __func__); break; #endif case P61_RW_SPI_DATA: #ifdef CONFIG_ESE_SECURE break; #endif ret = p61_rw_spi_message(p61_dev, arg); break; case P61_SET_SPM_PWR: pr_info("%s P61_SET_SPM_PWR: enter\n", __func__); ret = pn547_dev_ioctl(filp, P61_SET_SPI_PWR, arg); if (arg == 0 || arg == 1 || arg == 3) pwr_req_on = arg; pr_info("%s P61_SET_SPM_PWR: exit\n", __func__); break; case P61_GET_SPM_STATUS: pr_info("%s P61_GET_SPM_STATUS: enter\n", __func__); ret = pn547_dev_ioctl(filp, P61_GET_PWR_STATUS, arg); pr_info("%s P61_GET_SPM_STATUS: exit\n", __func__); break; case P61_GET_ESE_ACCESS: /*P61_DBG_MSG(KERN_ALERT " P61_GET_ESE_ACCESS: enter");*/ ret = pn547_dev_ioctl(filp, P547_GET_ESE_ACCESS, arg); pr_info("%s P61_GET_ESE_ACCESS ret: %d exit\n", __func__, ret); break; case P61_SET_DWNLD_STATUS: P61_DBG_MSG(KERN_ALERT " P61_SET_DWNLD_STATUS: enter\n"); ret = pn547_dev_ioctl(filp, PN547_SET_DWNLD_STATUS, arg); pr_info("%s P61_SET_DWNLD_STATUS: =%lu exit\n", __func__, arg); break; default: pr_info("%s no matching ioctl!\n", __func__); ret = -EINVAL; } return ret; } /* * Called when a process closes the device file. */ static int p61_dev_release(struct inode *inode, struct file *file) { struct p61_device *p61_dev = file->private_data; pr_info("[ESE]: %s\n", __func__); if (wake_lock_active(&p61_dev->ese_lock)) { pr_info("%s: [NFC-ESE] wake unlock.\n", __func__); wake_unlock(&p61_dev->ese_lock); } if (pwr_req_on && (pwr_req_on != 5)) { pr_info("%s: [NFC-ESE] release spi session.\n", __func__); pwr_req_on = 0; pn547_dev_ioctl(file, P61_SET_SPI_PWR, 0); pn547_dev_ioctl(file, P61_SET_SPI_PWR, 5); } p61_dev->device_opened = false; return 0; } /** * \ingroup spi_driver * \brief Write data to P61 on SPI * * \param[in] struct file * * \param[in] const char * * \param[in] size_t * \param[in] loff_t * * * \retval data size * */ static ssize_t p61_dev_write(struct file *filp, const char *buf, size_t count, loff_t *offset) { int ret = -1; struct p61_device *p61_dev; P61_DBG_MSG("p61_dev_write -Enter count %zu\n", count); #ifdef CONFIG_ESE_SECURE return 0; #endif p61_dev = filp->private_data; mutex_lock(&p61_dev->write_mutex); if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; memset(p61_dev->buf, 0, count); if (copy_from_user(p61_dev->buf, &buf[0], count)) { P61_ERR_MSG("%s : failed to copy from user space\n", __func__); mutex_unlock(&p61_dev->write_mutex); return -EFAULT; } /* Write data */ ret = spi_write(p61_dev->spi, p61_dev->buf, count); if (ret < 0) ret = -EIO; else ret = count; mutex_unlock(&p61_dev->write_mutex); pr_info("%s -count %zu %d- Exit\n", __func__, count, ret); return ret; } /** * \ingroup spi_driver * \brief Used to read data from P61 in Poll/interrupt mode configured using * ioctl call * * \param[in] struct file * * \param[in] char * * \param[in] size_t * \param[in] loff_t * * * \retval read size * */ /* for p61 only */ static ssize_t p61_dev_read(struct file *filp, char *buf, size_t count, loff_t *offset) { int ret = -EIO; struct p61_device *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); #ifdef CONFIG_ESE_SECURE return 0; #endif if (count < 1) { P61_ERR_MSG("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)); memset(p61_dev->buf, 0x00, MAX_BUFFER_SIZE); P61_DBG_MSG(" %s Poll Mode Enabled\n", __func__); do { sof = 0x00; ret = spi_read(p61_dev->spi, (void *)&sof, 1); if (ret < 0) { P61_ERR_MSG("spi_read failed [SOF]\n"); goto fail; } //P61_DBG_MSG(KERN_INFO"SPI_READ returned 0x%x\n", 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); P61_DBG_MSG("SPI_READ returned 0x%x...\n", sof); total_count = 1; //rx_buffer[0] = sof; *p61_dev->buf = sof; /* Read the HEADR of Two bytes*/ ret = spi_read(p61_dev->spi, p61_dev->buf + 1, 2); if (ret < 0) { P61_ERR_MSG("spi_read fails after [PCB]\n"); ret = -EIO; goto fail; } total_count += 2; /* Get the data length */ //count = rx_buffer[2]; count = *(p61_dev->buf + 2); pr_info("Data Length = %zu", count); /* Read the available data along with one byte LRC */ ret = spi_read(p61_dev->spi, (void *)(p61_dev->buf + 3), (count+1)); if (ret < 0) { pr_err("%s spi_read failed\n", __func__); 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, p61_dev->buf, 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); pr_info("%s - count %zu %d- Exit\n", __func__, count, ret); mutex_unlock(&p61_dev->read_mutex); return ret; } /** * \ingroup spi_driver * \brief Set the P61 device specific context for future use. * \param[in] struct spi_device * * \param[in] void * * \retval void */ static inline void p61_set_data(struct spi_device *spi, void *data) { dev_set_drvdata(&spi->dev, data); } /** * \ingroup spi_driver * \brief Get the P61 device specific context. * \param[in] const struct spi_device * * \retval Device Parameters */ static inline void *p61_get_data(const struct spi_device *spi) { return dev_get_drvdata(&spi->dev); } static const struct file_operations p61_dev_fops = { .owner = THIS_MODULE, .read = p61_dev_read, .write = p61_dev_write, .open = p61_dev_open, .unlocked_ioctl = p61_dev_ioctl, .release = p61_dev_release, }; #if 0 static ssize_t p61_test_show(struct device *dev, struct device_attribute *attr, char *buf) { unsigned char data; int ret = 0; //struct spi_device *spi = to_spi_device(dev); //ret = spi_read(p61_dev->spi, (void *)&sof, 1); pr_info("%s\n", __func__); data = 'a'; snprintf(buf, 4, "%d\n", data); return ret; } static ssize_t p61_test_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long data; int error; //struct spi_device *spi = to_spi_device(dev); error = kstrtoul(buf, 10, &data); if (error) return error; pr_info("%s [%lu]\n", __func__, data); return count; } static DEVICE_ATTR(test, 0644, p61_test_show, p61_test_store); #endif static int p61_parse_dt(struct device *dev, struct p61_device *p61_dev) { struct device_node *np = dev->of_node; struct device_node *spi_device_node; struct platform_device *spi_pdev; if (!of_property_read_string(np, "p61-ap_vendor", &p61_dev->ap_vendor)) { pr_info("%s: ap_vendor - %s\n", __func__, p61_dev->ap_vendor); } spi_device_node = of_parse_phandle(np, "p61-spi_node", 0); if (!IS_ERR_OR_NULL(spi_device_node)) { spi_pdev = of_find_device_by_node(spi_device_node); #ifndef CONFIG_ESE_SECURE p61_dev->pinctrl = devm_pinctrl_get(&spi_pdev->dev); if (IS_ERR(p61_dev->pinctrl)) P61_INFO_MSG("devm_pinctrl_get failed\n"); p61_dev->ese_on_pin = pinctrl_lookup_state(p61_dev->pinctrl, "ese_on"); if (IS_ERR(p61_dev->ese_on_pin)) { P61_INFO_MSG("pinctrl_lookup_state failed-ese_on\n"); p61_dev->ese_on_pin = NULL; } p61_dev->ese_off_pin = pinctrl_lookup_state(p61_dev->pinctrl, "ese_off"); if (IS_ERR(p61_dev->ese_off_pin)) { P61_INFO_MSG("pinctrl_lookup_state failed-ese_off\n"); p61_dev->ese_off_pin = NULL; } else if (pinctrl_select_state(p61_dev->pinctrl, p61_dev->ese_off_pin)) P61_INFO_MSG("ese off pinctrl set error\n"); else P61_INFO_MSG("ese off pinctrl set\n"); #endif } else { pr_info("target does not use spi pinctrl\n"); } return 0; } /** * \ingroup spi_driver * \brief To probe for P61 SPI interface. If found initialize the SPI clock, * bit rate & SPI mode. It will create the dev entry (P61) for user space. * * \param[in] struct spi_device * * * \retval 0 if ok. * */ static int p61_probe(struct spi_device *spi) { int ret = -1; struct device_node *np = spi->dev.of_node; struct property *prop; int ese_support = 0; pr_info("%s: chip select(%d), bus number(%d)\n", __func__, spi->chip_select, spi->master->bus_num); /*separate NFC / non NFC using GPIO*/ prop = of_find_property(np, "p61-check_ese", NULL); if (prop) { ese_support = gpio_get_value(of_get_named_gpio(np, "p61-check_ese", 0)); if (ese_support > 0) { P61_ERR_MSG("%s : ese support model : %d\n", __func__, ese_support); }else{ P61_ERR_MSG("%s : ese not support model : %d\n", __func__, ese_support); return -ENXIO; } } 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); spi->bits_per_word = 8; spi->mode = SPI_MODE_0; spi->max_speed_hz = P61_SPI_CLOCK; #ifndef CONFIG_ESE_SECURE ret = spi_setup(spi); if (ret < 0) { P61_ERR_MSG("failed to do spi_setup()\n"); goto p61_spi_setup_failed; } #else p61_dev->ese_secure_check = NOT_CHECKED; pr_info("%s: eSE Secured system\n", __func__); ret = p61_clk_setup(&spi->dev, p61_dev); if (ret) pr_err("%s - Failed to do clk_setup\n", __func__); #endif p61_dev->spi = spi; p61_dev->miscdev.minor = MISC_DYNAMIC_MINOR; p61_dev->miscdev.name = "p61"; p61_dev->miscdev.fops = &p61_dev_fops; p61_dev->miscdev.parent = &spi->dev; 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); wake_lock_init(&p61_dev->ese_lock, WAKE_LOCK_SUSPEND, "ese_wake_lock"); p61_dev->device_opened = false; ret = misc_register(&p61_dev->miscdev); if (ret < 0) { P61_ERR_MSG("misc_register failed! %d\n", ret); goto err_exit0; } p61_dev->enable_poll_mode = 1; /* No USE? */ p61_dev->buf = kzalloc(sizeof(unsigned char) * MAX_BUFFER_SIZE, GFP_KERNEL); if (p61_dev->buf == NULL) { P61_ERR_MSG("failed to allocate for spi buffer\n"); ret = -ENOMEM; goto err_exit0; } pr_info("%s: finished\n", __func__); return ret; err_exit0: mutex_destroy(&p61_dev->read_mutex); mutex_destroy(&p61_dev->write_mutex); wake_lock_destroy(&p61_dev->ese_lock); #ifndef CONFIG_ESE_SECURE p61_spi_setup_failed: #endif p61_parse_dt_failed: if (p61_dev != NULL) kfree(p61_dev); err_exit: P61_DBG_MSG("ERROR: Exit : %s ret %d\n", __func__, ret); return ret; } /** * \ingroup spi_driver * \brief Will get called when the device is removed to release the resources. * \param[in] struct spi_device * \retval 0 if ok. */ static int p61_remove(struct spi_device *spi) { struct p61_device *p61_dev = p61_get_data(spi); P61_DBG_MSG("Entry : %s\n", __func__); mutex_destroy(&p61_dev->read_mutex); misc_deregister(&p61_dev->miscdev); wake_lock_destroy(&p61_dev->ese_lock); kfree(p61_dev->buf); kfree(p61_dev); P61_DBG_MSG("Exit : %s\n", __func__); return 0; } static const struct of_device_id p61_match_table[] = { { .compatible = "p61",}, {}, }; static struct spi_driver p61_driver = { .driver = { .name = "p61", .bus = &spi_bus_type, .owner = THIS_MODULE, #ifdef CONFIG_OF .of_match_table = p61_match_table, #endif }, .probe = p61_probe, .remove = p61_remove, }; /** * \ingroup spi_driver * \brief Module init interface * * \param[in] void * * \retval handle * */ static int __init p61_dev_init(void) { debug_level = P61_FULL_DEBUG; P61_DBG_MSG("Entry : %s\n", __func__); return spi_register_driver(&p61_driver); P61_DBG_MSG("Exit : %s\n", __func__); } /** * \ingroup spi_driver * \brief Module exit interface * * \param[in] void * * \retval void * */ static void __exit p61_dev_exit(void) { P61_DBG_MSG("Entry : %s\n", __func__); spi_unregister_driver(&p61_driver); P61_DBG_MSG("Exit : %s\n", __func__); } module_init(p61_dev_init); module_exit(p61_dev_exit); MODULE_AUTHOR("BHUPENDRA PAWAR"); MODULE_DESCRIPTION("NXP P61 SPI driver"); MODULE_LICENSE("GPL");