static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct pn547_dev *pn547_dev = NULL; pn547_client = client; pr_info(PN547_DRV_NAME ": pn547_probe() start\n"); pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } pn547_parse_dt(&client->dev, pn547_dev); pn547_dev->client = client; pr_info(PN547_DRV_NAME ":IRQ : %d\nVEN : %d\nFIRM : %d\n", pn547_dev->irq_gpio, pn547_dev->ven_gpio, pn547_dev->firm_gpio); ret = gpio_request(pn547_dev->irq_gpio, "nfc_int"); if (ret) { pr_info(PN547_DRV_NAME ":pn547_probe() : nfc_int request failed!\n"); goto err_int; } ret = gpio_request(pn547_dev->ven_gpio, "nfc_ven"); if (ret) { pr_info(PN547_DRV_NAME ":pn547_probe() : nfc_ven request failed!\n"); goto err_ven; } ret = gpio_request(pn547_dev->firm_gpio, "nfc_firm"); if (ret) { pr_info(PN547_DRV_NAME ":pn547_probe() : nfc_firm request failed!\n"); goto err_firm; } pn547_gpio_enable(pn547_dev); ret = gpio_direction_output(pn547_dev->ven_gpio,0); ret = gpio_direction_output(pn547_dev->firm_gpio,0); ret = gpio_direction_input(pn547_dev->irq_gpio); #ifdef CONFIG_LGE_NFC_USE_PMIC pn547_get_clk_source(pn547_client, pn547_dev); #endif /* init mutex and queues */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); spin_lock_init(&pn547_dev->irq_enabled_lock); pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; pn547_dev->pn547_device.name = PN547_DRV_NAME; pn547_dev->pn547_device.fops = &pn547_dev_fops; ret = misc_register(&pn547_dev->pn547_device); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } wake_lock_init(&nfc_wake_lock, WAKE_LOCK_SUSPEND, "NFCWAKE"); /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%s : requesting IRQ %d\n", __func__, client->irq); pn547_dev->irq_enabled = true; ret = request_irq(pn547_gpio_to_irq(pn547_dev), pn547_dev_irq_handler, IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND, client->name, pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } enable_irq_wake(pn547_get_irq_pin(pn547_dev)); pn547_disable_irq(pn547_dev); i2c_set_clientdata(client, pn547_dev); pr_info(PN547_DRV_NAME ": pn547_probe() end\n"); return 0; err_request_irq_failed: misc_deregister(&pn547_dev->pn547_device); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); gpio_free(pn547_dev->firm_gpio); err_firm: gpio_free(pn547_dev->ven_gpio); err_ven: gpio_free(pn547_dev->irq_gpio); err_int: kfree(pn547_dev); err_exit: pr_err(PN547_DRV_NAME ": pn547_dev is null\n"); pr_err(PN547_DRV_NAME ": pn547_probe() end with error!\n"); return ret; }
static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct pn547_dev *pn547_dev; #ifdef FEATURE_PN547_USE_PMIC_CLK int rc; #endif #ifdef FEATURE_PN547_USE_DTREE struct device_node *np; np = client->dev.of_node; if(np == NULL){ pr_err("%s : pn547_probe np\n", __func__); return -ENODEV; } #else struct pn547_i2c_platform_data *platform_data; platform_data = client->dev.platform_data; if (platform_data == NULL) { pr_err("%s : nfc probe fail\n", __func__); return -ENODEV; } #endif #ifdef FEATURE_PN547_KERNEL_LOG pr_info("+-----------------------------------------+\n"); pr_info("| NXP pn547 Driver Probe! |\n"); pr_info("+-----------------------------------------+\n"); #endif pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } #ifdef FEATURE_PN547_USE_DTREE pn547_dev->irq_gpio = (unsigned int)of_get_named_gpio_flags(np,"nxp,irq-gpio",0,NULL); pn547_dev->ven_gpio = (unsigned int)of_get_named_gpio_flags(np,"nxp,ven-gpio",0,NULL); pn547_dev->firm_gpio = (unsigned int)of_get_named_gpio_flags(np,"nxp,firm-gpio",0, NULL); #else pn547_dev->irq_gpio = platform_data->irq_gpio; pn547_dev->ven_gpio = platform_data->ven_gpio; pn547_dev->firm_gpio = platform_data->firm_gpio; #endif pn547_dev->client = client; pr_info("%s (ven, firm, irq)=(%d, %d, %d)\n", __func__, pn547_dev->ven_gpio, pn547_dev->firm_gpio, pn547_dev->irq_gpio); ret = gpio_request(pn547_dev->irq_gpio, "nfc_int"); if (ret) { pr_err("%s : error : gpio_request nfc_int\n", __func__); return -ENODEV; } ret = gpio_direction_input(pn547_dev->irq_gpio); if (ret) { pr_err("%s : error : gpio_direction_input irq_gpio\n", __func__); goto err_ven; } ret = gpio_request(pn547_dev->ven_gpio, "nfc_ven"); if (ret) { pr_err("%s : error : gpio_request nfc_ven\n", __func__); goto err_ven; } #if !defined(FEATURE_PN547_VEN_PMIC_GPIO) ret = gpio_direction_output(pn547_dev->ven_gpio, 0); if (ret ) { pr_err("%s : error : gpio_direction_output ven_gpio\n", __func__); goto err_firm; } #endif ret = gpio_request(pn547_dev->firm_gpio, "nfc_firm"); if (ret) { pr_err("%s : error : gpio_request nfc_firm\n", __func__); goto err_firm; } #if !defined(FEATURE_PN547_FW_DL_PMIC_GPIO) ret = gpio_direction_output(pn547_dev->firm_gpio, 0); if (ret ) { pr_err("%s : error : gpio_direction_output firm_gpio\n", __func__); goto err_firm_direction; } #endif /* init mutex and queues */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); spin_lock_init(&pn547_dev->irq_enabled_lock); #if defined(FEATURE_PN547_IRQ_IN_SUSPEND) wake_lock_init(&pn547_dev->pn547_wake_lock, WAKE_LOCK_SUSPEND, "pn547"); #endif pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; pn547_dev->pn547_device.name = "pn547"; pn547_dev->pn547_device.fops = &pn547_dev_fops; ret = misc_register(&pn547_dev->pn547_device); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%s : requesting IRQ %d\n", __func__, client->irq); pn547_dev->irq_enabled = true; ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_HIGH, client->name, pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } pn547_disable_irq(pn547_dev); i2c_set_clientdata(client, pn547_dev); #ifdef FEATURE_PN547_USE_PMIC_CLK #ifdef FEATURE_PN547_KERNEL_LOG pr_info("[%s] device name [%s]\n", __func__,np->name); pr_info("[%s] device full name [%s]\n", __func__,np->full_name); #endif xo_handle_a2 = clk_get_sys(np->name, "xo"); if (IS_ERR(xo_handle_a2)) { dev_err(&client->dev,"[%s] clk_get err \n", __func__); } rc = clk_prepare_enable(xo_handle_a2); if (rc) { dev_err(&client->dev,"[%s] clk_prepare_enable fail rc[%d]\n", __func__, rc); } #endif /* FEATURE_PN547_USE_PMIC_CLK */ return 0; err_request_irq_failed: misc_deregister(&pn547_dev->pn547_device); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); #if defined(FEATURE_PN547_IRQ_IN_SUSPEND) wake_lock_destroy(&pn547_dev->pn547_wake_lock); #endif #if !defined(FEATURE_PN547_FW_DL_PMIC_GPIO) err_firm_direction: #endif gpio_free(pn547_dev->firm_gpio); err_firm: gpio_free(pn547_dev->ven_gpio); err_ven: gpio_free(pn547_dev->irq_gpio); kfree(pn547_dev); err_exit: return ret; }
static long pn547_dev_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct pn547_dev *pn547_dev = filp->private_data; unsigned long flags; switch (cmd) { case pn547_SET_PWR: if (arg == 2) { /* power on with firmware download (requires hw reset) */ dprintk(PN547_DRV_NAME ":%s power on with firmware\n", __func__); gpio_set_value(pn547_dev->ven_gpio, 1); gpio_set_value(pn547_dev->firm_gpio, 1); msleep(10); gpio_set_value(pn547_dev->ven_gpio, 0); msleep(10); gpio_set_value(pn547_dev->ven_gpio, 1); msleep(10); } else if (arg == 1) { /* power on */ pr_info(PN547_DRV_NAME ":%s power on\n", __func__); if (sPowerState == NFC_POWER_OFF) { #ifdef CONFIG_LGE_NFC_USE_PMIC pn547_change_clk(pn547_dev, CLK_PIN); #endif gpio_set_value(pn547_dev->firm_gpio, 0); gpio_set_value(pn547_dev->ven_gpio, 1); msleep(10); #ifdef CONFIG_LGE_NFC_SET_IRQ_WAKEUP pn547_enable_irq(pn547_dev); #endif spin_lock_irqsave(&pn547_dev->irq_enabled_lock, flags); //pr_err("%s NFC_POWER_ON\n", __func__); // for debug sPowerState = NFC_POWER_ON; spin_unlock_irqrestore(&pn547_dev->irq_enabled_lock, flags); } else { pr_err("%s NFC is alread On!\n", __func__); } } else if (arg == 0) { /* power off */ pr_info(PN547_DRV_NAME ":%s power off\n", __func__); if (sPowerState == NFC_POWER_ON) { #ifdef CONFIG_LGE_NFC_USE_PMIC pn547_change_clk(pn547_dev, CLK_DISABLE); #endif gpio_set_value(pn547_dev->firm_gpio, 0); gpio_set_value(pn547_dev->ven_gpio, 0); msleep(10); #ifdef CONFIG_LGE_NFC_SET_IRQ_WAKEUP pn547_disable_irq(pn547_dev); #endif spin_lock_irqsave(&pn547_dev->irq_enabled_lock, flags); if (sIsWakeLocked == true) { pr_err("%s: Release Wake_Lock\n", __func__); wake_unlock(&nfc_wake_lock); sIsWakeLocked = false; } //pr_err("%s NFC_POWER_OFF\n", __func__); // for debug sPowerState = NFC_POWER_OFF; spin_unlock_irqrestore(&pn547_dev->irq_enabled_lock, flags); } else { pr_err("%s NFC is alread Off!\n", __func__); } } else { pr_err("%s bad arg %ld\n", __func__, arg); return -EINVAL; } break; case pn547_HW_REVISION: { return pn547_get_hw_revision(); } default: pr_err("%s bad ioctl %d\n", __func__, cmd); return -EINVAL; } return 0; }
static ssize_t pn547_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset) { struct pn547_dev *pn547_dev = filp->private_data; char tmp[MAX_BUFFER_SIZE]; int ret; if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; pr_debug("%s : reading %zu bytes.\n", __func__, count); mutex_lock(&pn547_dev->read_mutex); if (!gpio_get_value(pn547_dev->irq_gpio)) { if (filp->f_flags & O_NONBLOCK) { ret = -EAGAIN; goto fail; } pn547_dev->irq_enabled = true; #ifdef NXP_KR_PENDING_READ irq_nfc = false; #endif enable_irq(pn547_dev->client->irq); #ifdef NXP_KR_PENDING_READ ret = wait_event_interruptible(pn547_dev->read_wq, irq_nfc); if(ret != 0) { pr_info("wait_event_interruptible return : %d\n", ret); } #else ret = wait_event_interruptible(pn547_dev->read_wq, gpio_get_value(pn547_dev->irq_gpio)); #endif pn547_disable_irq(pn547_dev); #ifdef NXP_KR_PENDING_READ if(release_pending == true) { release_pending = false; ret = -1; goto fail; } #endif if (ret) goto fail; } #ifdef FEATURE_PN547_KERNEL_LOG pr_info("==> %s #2 (ven, firm, irq)=(%d, %d, %d)\n", __func__, VEN_GET_VALUE(pn547_dev->ven_gpio), FW_DL_GET_VALUE(pn547_dev->firm_gpio), gpio_get_value(pn547_dev->irq_gpio)); #endif /* Read data */ ret = i2c_master_recv(pn547_dev->client, tmp, count); mutex_unlock(&pn547_dev->read_mutex); wake_lock_timeout(&pn547_dev->pn547_wake_lock, 100); if (ret < 0) { pr_err("%s: i2c_master_recv returned %d\n", __func__, ret); return ret; } if (ret > count) { pr_err("%s: received too many bytes from i2c (%d)\n", __func__, ret); return -EIO; } if (copy_to_user(buf, tmp, ret)) { pr_warning("%s : failed to copy to user space\n", __func__); return -EFAULT; } return ret; fail: mutex_unlock(&pn547_dev->read_mutex); return ret; }
static __devinit int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int irq_gpio = -1; int updata_gpio = -1; int ven_gpio = -1; int irq; int addr; int ret; dev_dbg(&client->dev, "IRQ: %d\n", client->irq); if(client->dev.of_node) { irq_gpio = of_get_named_gpio_flags(client->dev.of_node, "nxp,irq-gpio", 0, NULL); updata_gpio = of_get_named_gpio_flags(client->dev.of_node, "nxp,updata-gpio", 0, NULL); ven_gpio = of_get_named_gpio_flags(client->dev.of_node, "nxp,ven-gpio", 0, NULL); printk("pn547,--irq_gpio---:%d\n", irq_gpio); printk("pn547,--updata_gpio---:%d\n", updata_gpio); printk("pn547,--ven_gpio---:%d\n", ven_gpio); } irq = client->irq; addr = client->addr; if (pn547_dev != NULL) { dev_warn(&client->dev, "only one PN547 supported.\n"); return -EBUSY; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } pn547_dev = kzalloc(sizeof(struct pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } pn547_dev->client = client; pn547_dev->irq_gpio = irq_gpio; pn547_dev->updata_gpio = updata_gpio; pn547_dev->ven_gpio = ven_gpio; pn547_dev->request_resources = pn547_nfc_request_resources; pn547_dev->free_resources = pn547_nfc_free_resources; pn547_dev->enable = pn547_nfc_enable; pn547_dev->disable = pn547_nfc_disable; pn547_dev->test = pn547_nfc_test; pn547_dev->irq_status = pn547_pt_irq_status; /* init mutex and queues */ pn547_dev->read_irq = PN547_NONE; init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); spin_lock_init(&pn547_dev->irq_enabled_lock); i2c_set_clientdata(client, pn547_dev); if (!pn547_dev->request_resources) { dev_err(&client->dev, "request_resources() missing\n"); ret = -EINVAL; goto err_request_resources; } ret = pn547_dev->request_resources(); if (ret < 0) { dev_err(&client->dev, "Cannot get platform resources\n"); goto err_request_resources; } //enable clk 19.2M printk("[dsc] enable clk 19.2M\n"); nfc_rf_clk = clk_get(&client->dev, "nfc_rf_clk"); if (nfc_rf_clk != NULL) { if (clk_prepare_enable(nfc_rf_clk)) pr_err("failed request NFC_CLK.\n"); } else { pr_err("%s:nfc_rf_clk is null\n",__FUNCTION__); } pn547_dev->irq_enabled = true; ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_HIGH, client->name, pn547_dev); if(ret){ pr_err("faile to get the irq for nfc-c.\n"); } /*device_init_wakeup(&client->dev,1); ret=irq_set_irq_wake(client->irq,1); if(ret){ pr_err("faile to enable the irq for nfc-c to wake.\n"); }*/ printk("--client->irq:%d,client->name:%s\n", client->irq,client->name); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq; } printk("pn547_dev->client->irq:%d\n",pn547_dev->client->irq); pn547_disable_irq(pn547_dev); pn547_dev->miscdev.minor = MISC_DYNAMIC_MINOR; pn547_dev->miscdev.name = PN547_DRIVER_NAME; pn547_dev->miscdev.fops = &pn547_dev_fops; pn547_dev->miscdev.parent = &client->dev; ret = misc_register(&pn547_dev->miscdev); if (ret){ dev_err(&client->dev, "%s : misc_register failed\n", __func__); goto err_misc_register; } #ifdef ZTEMT_NFC_CONFIG_FB pn547_dev->fb_notif.notifier_call = PN547_fb_notifier_callback; ret = fb_register_client(&pn547_dev->fb_notif); if (ret) pr_err("%s:Unable to register fb_notifier: %d\n", __func__, ret); #endif printk("%s: dev: %p, client %p:dev_name%s\n",__func__, pn547_dev, client,dev_name(&client->dev)); #ifdef NXP_PN547_STANDBY_MODE set_standby_mode(pn547_dev); #endif return 0; err_misc_register: free_irq(client->irq, pn547_dev); err_request_irq: if (pn547_dev->free_resources) pn547_dev->free_resources(); err_request_resources: mutex_destroy(&pn547_dev->read_mutex); kfree(pn547_dev); err_exit: return ret; }
static ssize_t pn547_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset) { //ztemt changed by chengdongsheng 2012.12.20 avoid the filp->private_data was null //struct pn547_dev *dev = filp->private_data; struct pn547_dev *dev = pn547_dev; //ztemt end struct i2c_client *client = dev->client; char tmp[MAX_BUFFER_SIZE]; int ret; if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; #ifdef NXP_PN547_DEBUG printk(KERN_DEBUG "%s: reading %zu bytes.\n", __func__, count); #endif mutex_lock(&dev->read_mutex); if ( !pn547_irq_status(dev) ) { if (filp->f_flags & O_NONBLOCK) { ret = -EAGAIN; goto fail; } dev->irq_enabled = true; enable_irq(dev->client->irq); ret = wait_event_interruptible(dev->read_wq, (dev->read_irq == PN547_INT)); pn547_disable_irq(dev); if (ret) goto fail; } /* Read data */ ret = i2c_master_recv(dev->client, tmp, count); dev->read_irq = PN547_NONE; mutex_unlock(&dev->read_mutex); if (ret < 0) { dev_err(&client->dev, "%s: i2c_master_recv returned %d\n", __func__, ret); return ret; } if (ret > count) { dev_err(&client->dev, "%s: received too many bytes from i2c (%d)\n", __func__, ret); return -EIO; } #ifdef NXP_PN547_DEBUG print_hex_dump(KERN_DEBUG, " read: ", DUMP_PREFIX_NONE, 16, 1, tmp, ret, false); #endif if (copy_to_user(buf, tmp, ret)) { dev_err(&client->dev, "%s : failed to copy to user space\n", __func__); return -EFAULT; } return ret; fail: mutex_unlock(&dev->read_mutex); return ret; }
static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; int rc = 0; struct clk *nfc_clk = NULL; struct pn547_i2c_platform_data *platform_data; struct pn547_dev *pn547_dev; printk("### %s begin! \n",__func__); dev_info(&client->dev, "%s ++\n", __func__); platform_data = kzalloc(sizeof(struct pn547_i2c_platform_data), GFP_KERNEL); if (platform_data == NULL) { dev_err(&client->dev, "failed to allocate memory\n"); ret = -ENOMEM; goto err_platform_data; } printk("### %s 11 begin! \n",__func__); ret = pn547_parse_dt(&client->dev, platform_data); if (ret < 0) { dev_err(&client->dev, "failed to parse device tree: %d\n", ret); goto err_parse_dt; } printk("pn547 dev kobj_name=%s,init_name=%s,id=%d\n",client->dev.kobj.name,client->dev.init_name, client->dev.id); nfc_clk = clk_get(&client->dev, "nfc_pn547clk"); if (nfc_clk == NULL) { dev_err(&client->dev, "failed to get clk: %d\n", ret); goto err_parse_dt; } rc = clk_set_rate(nfc_clk,19200000); if(rc){ dev_err(&client->dev, "Clock set rate failed: %d\n",rc); } ret = clk_prepare_enable(nfc_clk); if (ret) { dev_err(&client->dev, "failed to enable clk: %d\n", ret); goto err_parse_dt; } ret = pn547_gpio_request(&client->dev, platform_data); if (ret) { dev_err(&client->dev, "failed to request gpio\n"); goto err_gpio_request; } dev_dbg(&client->dev, "%s:\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "%s: i2c check failed\n", __func__); ret = -ENODEV; goto err_i2c; } printk("### %s 22 begin! \n",__func__); pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } client->irq = gpio_to_irq(platform_data->irq_gpio); pn547_dev->irq_gpio = platform_data->irq_gpio; pn547_dev->ven_gpio = platform_data->ven_gpio; pn547_dev->firm_gpio = platform_data->fwdl_en_gpio; pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; pn547_dev->client = client; pn547_dev->dev = &client->dev; pn547_dev->do_reading = 0; /* Initialise mutex and work queue */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); spin_lock_init(&pn547_dev->irq_enabled_lock); wake_lock_init(&pn547_dev->wl,WAKE_LOCK_SUSPEND,"nfc_locker"); pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; pn547_dev->pn547_device.name = "pn544"; pn547_dev->pn547_device.fops = &pn547_dev_fops; printk("### %s 33 begin! \n",__func__); ret = misc_register(&pn547_dev->pn547_device); if (ret) { dev_err(&client->dev, "%s: misc_register err %d\n", __func__, ret); goto err_misc_register; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ dev_info(&client->dev, "%s : requesting IRQ %d\n", __func__, client->irq); pn547_dev->irq_enabled = true; ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND | IRQF_ONESHOT, client->name, pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } pn547_disable_irq(pn547_dev); i2c_set_clientdata(client, pn547_dev); return 0; err_request_irq_failed: misc_deregister(&pn547_dev->pn547_device); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); kfree(pn547_dev); err_exit: err_i2c: pn547_gpio_release(platform_data); err_gpio_request: err_parse_dt: kfree(platform_data); err_platform_data: dev_err(&client->dev, "%s: err %d\n", __func__, ret); return ret; }
static ssize_t pn547_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset) { struct pn547_dev *pn547_dev = filp->private_data; char tmp[MAX_BUFFER_SIZE]; int ret; //pr_info("%s ++ \n", __func__); if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; //pr_info("%s : read request for %zu bytes.\n", __func__, count); /* not add wake lock in the dev read function */ //wake_lock(&pn547_dev->wl); mutex_lock(&pn547_dev->read_mutex); if (!gpio_get_value(pn547_dev->irq_gpio)) { if (filp->f_flags & O_NONBLOCK) { ret = -EAGAIN; goto fail; } //pr_info("Waiting for PN547 IRQ.\n"); pn547_dev->irq_enabled = true; pn547_dev->do_reading = 0; enable_irq(pn547_dev->client->irq); ret = wait_event_interruptible(pn547_dev->read_wq, pn547_dev->do_reading); pn547_disable_irq(pn547_dev); //pr_info("PN547 IRQ high.\n"); if (pn547_dev->cancel_read) { pn547_dev->cancel_read = false; ret = -1; goto fail; } if (ret) goto fail; } //mutex_lock(&pn547_dev->read_mutex); /* Read data */ ret = i2c_master_recv(pn547_dev->client, tmp, count); mutex_unlock(&pn547_dev->read_mutex); //wake_unlock(&pn547_dev->wl); //pr_info("%s : i2c read %zu bytes. status : %d\n", __func__, count, ret); if (ret < 0) { pr_err("%s: PN547 i2c_master_recv returned %d\n", __func__, ret); //mutex_unlock(&pn547_dev->read_mutex); return ret; } if (ret > count) { pr_err("%s: received too many bytes from i2c (%d)\n", __func__, ret); //mutex_unlock(&pn547_dev->read_mutex); return -EIO; } if (copy_to_user(buf, tmp, ret)) { pr_warning("%s : failed to copy to user space\n", __func__); //mutex_unlock(&pn547_dev->read_mutex); return -EFAULT; } //mutex_unlock(&pn547_dev->read_mutex); return ret; fail: mutex_unlock(&pn547_dev->read_mutex); //wake_unlock(&pn547_dev->wl); pr_err("%s : goto fail, and ret : %d \n", __func__,ret); return ret; }