aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/nfc
diff options
context:
space:
mode:
authorDavid S. Miller <davem@davemloft.net>2014-10-05 21:34:39 -0400
committerDavid S. Miller <davem@davemloft.net>2014-10-05 21:34:39 -0400
commita4b4a2b7f98a45c71a906b1126cabea6446a9905 (patch)
tree0d501e78aeb9df90172a9435d673f31bf89290eb /drivers/nfc
parent61b37d2f54961b336a47a501e797a05df20c3b30 (diff)
parent3f08e47291879fb047d7d4464d2beaedfea4eb63 (diff)
Merge tag 'master-2014-10-02' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next
John W. Linville says: ==================== pull request: wireless-next 2014-10-03 Please pull tihs batch of updates intended for the 3.18 stream! For the iwlwifi bits, Emmanuel says: "I have here a few things that depend on the latest mac80211's changes: RRM, TPC, Quiet Period etc... Eyal keeps improving our rate control and we have a new device ID. This last patch should probably have gone to wireless.git, but at that stage, I preferred to send it to -next and CC stable." For (most of) the Atheros bits, Kalle says: "The only new feature is testmode support from me. Ben added a new method to crash the firmware with an assert for debug purposes. As usual, we have lots of smaller fixes from Michal. Matteo fixed a Kconfig dependency with debugfs. I fixed some warnings recently added to checkpatch." For the NFC bits, Samuel says: "We've had major updates for TI and ST Microelectronics drivers, and a few NCI related changes. For TI's trf7970a driver: - Target mode support for trf7970a - Suspend/resume support for trf7970a - DT properties additions to handle different quirks - A bunch of fixes for smartphone IOP related issues For ST Microelectronics' ST21NFCA and ST21NFCB drivers: - ISO15693 support for st21nfcb - checkpatch and sparse related warning fixes - Code cleanups and a few minor fixes Finally, Marvell added ISO15693 support to the NCI stack, together with a couple of NCI fixes." For the Bluetooth bits, Johan says: "This 3.18 pull request replaces the one I did on Monday ("bluetooth-next 2014-09-22", which hasn't been pulled yet). The additions since the last request are: - SCO connection fix for devices not supporting eSCO - Cleanups regarding the SCO establishment logic - Remove unnecessary return value from logging functions - Header compression fix for 6lowpan - Cleanups to the ieee802154/mrf24j40 driver Here's a copy from previous request that this one replaces: ' Here are some more patches for 3.18. They include various fixes to the btusb HCI driver, a fix for LE SMP, as well as adding Jukka to the MAINTAINERS file for generic 6LoWPAN (as requested by Alexander Aring). I've held on to this pull request a bit since we were waiting for a SCO related fix to get sorted out first. However, since the merge window is getting closer I decided not to wait for it. If we do get the fix sorted out there'll probably be a second small pull request later this week. '" And, "Unless 3.17 gets delayed this will probably be our last -next pull request for 3.18. We've got: - New Marvell hardware supportr - Multicast support for 6lowpan - Several of 6lowpan fixes & cleanups - Fix for a (false-positive) lockdep warning in L2CAP - Minor btusb cleanup" On top of all that comes the usual sort of updates to ath5k, ath9k, ath10k, brcmfmac, mwifiex, and wil6210. This time around there are also a number of rtlwifi updates to enable some new hardware and to reconcile the in-kernel drivers with some newer releases of the Realtek vendor drivers. Also of note is some device tree work for the bcma bus. Please let me know if there are problems! ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers/nfc')
-rw-r--r--drivers/nfc/st21nfca/i2c.c34
-rw-r--r--drivers/nfc/st21nfca/st21nfca.c59
-rw-r--r--drivers/nfc/st21nfca/st21nfca.h21
-rw-r--r--drivers/nfc/st21nfca/st21nfca_dep.c59
-rw-r--r--drivers/nfc/st21nfcb/i2c.c67
-rw-r--r--drivers/nfc/st21nfcb/ndlc.c6
-rw-r--r--drivers/nfc/st21nfcb/ndlc.h4
-rw-r--r--drivers/nfc/st21nfcb/st21nfcb.c27
-rw-r--r--drivers/nfc/st21nfcb/st21nfcb.h2
-rw-r--r--drivers/nfc/trf7970a.c1059
10 files changed, 1003 insertions, 335 deletions
diff --git a/drivers/nfc/st21nfca/i2c.c b/drivers/nfc/st21nfca/i2c.c
index ff31939978ae..0ea756b77519 100644
--- a/drivers/nfc/st21nfca/i2c.c
+++ b/drivers/nfc/st21nfca/i2c.c
@@ -271,6 +271,7 @@ static int st21nfca_hci_i2c_write(void *phy_id, struct sk_buff *skb)
271static int get_frame_size(u8 *buf, int buflen) 271static int get_frame_size(u8 *buf, int buflen)
272{ 272{
273 int len = 0; 273 int len = 0;
274
274 if (buf[len + 1] == ST21NFCA_SOF_EOF) 275 if (buf[len + 1] == ST21NFCA_SOF_EOF)
275 return 0; 276 return 0;
276 277
@@ -311,6 +312,7 @@ static int check_crc(u8 *buf, int buflen)
311static int st21nfca_hci_i2c_repack(struct sk_buff *skb) 312static int st21nfca_hci_i2c_repack(struct sk_buff *skb)
312{ 313{
313 int i, j, r, size; 314 int i, j, r, size;
315
314 if (skb->len < 1 || (skb->len > 1 && skb->data[1] != 0)) 316 if (skb->len < 1 || (skb->len > 1 && skb->data[1] != 0))
315 return -EBADMSG; 317 return -EBADMSG;
316 318
@@ -525,24 +527,19 @@ static int st21nfca_hci_i2c_of_request_resources(struct i2c_client *client)
525 } 527 }
526 528
527 /* GPIO request and configuration */ 529 /* GPIO request and configuration */
528 r = devm_gpio_request(&client->dev, gpio, "clf_enable"); 530 r = devm_gpio_request_one(&client->dev, gpio, GPIOF_OUT_INIT_HIGH,
531 "clf_enable");
529 if (r) { 532 if (r) {
530 nfc_err(&client->dev, "Failed to request enable pin\n"); 533 nfc_err(&client->dev, "Failed to request enable pin\n");
531 return -ENODEV; 534 return -ENODEV;
532 } 535 }
533 536
534 r = gpio_direction_output(gpio, 1);
535 if (r) {
536 nfc_err(&client->dev, "Failed to set enable pin direction as output\n");
537 return -ENODEV;
538 }
539 phy->gpio_ena = gpio; 537 phy->gpio_ena = gpio;
540 538
541 /* IRQ */ 539 /* IRQ */
542 r = irq_of_parse_and_map(pp, 0); 540 r = irq_of_parse_and_map(pp, 0);
543 if (r < 0) { 541 if (r < 0) {
544 nfc_err(&client->dev, 542 nfc_err(&client->dev, "Unable to get irq, error: %d\n", r);
545 "Unable to get irq, error: %d\n", r);
546 return r; 543 return r;
547 } 544 }
548 545
@@ -576,32 +573,20 @@ static int st21nfca_hci_i2c_request_resources(struct i2c_client *client)
576 phy->gpio_ena = pdata->gpio_ena; 573 phy->gpio_ena = pdata->gpio_ena;
577 phy->irq_polarity = pdata->irq_polarity; 574 phy->irq_polarity = pdata->irq_polarity;
578 575
579 r = devm_gpio_request(&client->dev, phy->gpio_irq, "wake_up"); 576 r = devm_gpio_request_one(&client->dev, phy->gpio_irq, GPIOF_IN,
577 "wake_up");
580 if (r) { 578 if (r) {
581 pr_err("%s : gpio_request failed\n", __FILE__); 579 pr_err("%s : gpio_request failed\n", __FILE__);
582 return -ENODEV; 580 return -ENODEV;
583 } 581 }
584 582
585 r = gpio_direction_input(phy->gpio_irq);
586 if (r) {
587 pr_err("%s : gpio_direction_input failed\n", __FILE__);
588 return -ENODEV;
589 }
590
591 if (phy->gpio_ena > 0) { 583 if (phy->gpio_ena > 0) {
592 r = devm_gpio_request(&client->dev, 584 r = devm_gpio_request_one(&client->dev, phy->gpio_ena,
593 phy->gpio_ena, "clf_enable"); 585 GPIOF_OUT_INIT_HIGH, "clf_enable");
594 if (r) { 586 if (r) {
595 pr_err("%s : ena gpio_request failed\n", __FILE__); 587 pr_err("%s : ena gpio_request failed\n", __FILE__);
596 return -ENODEV; 588 return -ENODEV;
597 } 589 }
598 r = gpio_direction_output(phy->gpio_ena, 1);
599
600 if (r) {
601 pr_err("%s : ena gpio_direction_output failed\n",
602 __FILE__);
603 return -ENODEV;
604 }
605 } 590 }
606 591
607 /* IRQ */ 592 /* IRQ */
@@ -711,7 +696,6 @@ static struct i2c_driver st21nfca_hci_i2c_driver = {
711 .driver = { 696 .driver = {
712 .owner = THIS_MODULE, 697 .owner = THIS_MODULE,
713 .name = ST21NFCA_HCI_I2C_DRIVER_NAME, 698 .name = ST21NFCA_HCI_I2C_DRIVER_NAME,
714 .owner = THIS_MODULE,
715 .of_match_table = of_match_ptr(of_st21nfca_i2c_match), 699 .of_match_table = of_match_ptr(of_st21nfca_i2c_match),
716 }, 700 },
717 .probe = st21nfca_hci_i2c_probe, 701 .probe = st21nfca_hci_i2c_probe,
diff --git a/drivers/nfc/st21nfca/st21nfca.c b/drivers/nfc/st21nfca/st21nfca.c
index a902b0551c86..a89e56c2c749 100644
--- a/drivers/nfc/st21nfca/st21nfca.c
+++ b/drivers/nfc/st21nfca/st21nfca.c
@@ -34,7 +34,7 @@
34#define ST21NFCA_RF_READER_CMD_PRESENCE_CHECK 0x30 34#define ST21NFCA_RF_READER_CMD_PRESENCE_CHECK 0x30
35 35
36#define ST21NFCA_RF_READER_ISO15693_GATE 0x12 36#define ST21NFCA_RF_READER_ISO15693_GATE 0x12
37#define ST21NFCA_RF_READER_ISO15693_INVENTORY 0x01 37#define ST21NFCA_RF_READER_ISO15693_INVENTORY 0x01
38 38
39/* 39/*
40 * Reader gate for communication with contact-less cards using Type A 40 * Reader gate for communication with contact-less cards using Type A
@@ -45,21 +45,42 @@
45#define ST21NFCA_RF_READER_14443_3_A_ATQA 0x03 45#define ST21NFCA_RF_READER_14443_3_A_ATQA 0x03
46#define ST21NFCA_RF_READER_14443_3_A_SAK 0x04 46#define ST21NFCA_RF_READER_14443_3_A_SAK 0x04
47 47
48#define ST21NFCA_RF_READER_F_DATARATE 0x01
49#define ST21NFCA_RF_READER_F_DATARATE_106 0x01
50#define ST21NFCA_RF_READER_F_DATARATE_212 0x02
51#define ST21NFCA_RF_READER_F_DATARATE_424 0x04
52#define ST21NFCA_RF_READER_F_POL_REQ 0x02
53#define ST21NFCA_RF_READER_F_POL_REQ_DEFAULT 0xffff0000
54#define ST21NFCA_RF_READER_F_NFCID2 0x03
55#define ST21NFCA_RF_READER_F_NFCID1 0x04
56
57#define ST21NFCA_RF_CARD_F_MODE 0x01
58#define ST21NFCA_RF_CARD_F_NFCID2_LIST 0x04
59#define ST21NFCA_RF_CARD_F_NFCID1 0x05
60#define ST21NFCA_RF_CARD_F_SENS_RES 0x06
61#define ST21NFCA_RF_CARD_F_SEL_RES 0x07
62#define ST21NFCA_RF_CARD_F_DATARATE 0x08
63#define ST21NFCA_RF_CARD_F_DATARATE_212_424 0x01
64
48#define ST21NFCA_DEVICE_MGNT_GATE 0x01 65#define ST21NFCA_DEVICE_MGNT_GATE 0x01
49#define ST21NFCA_DEVICE_MGNT_PIPE 0x02 66#define ST21NFCA_DEVICE_MGNT_PIPE 0x02
50 67
51#define ST21NFCA_DM_GETINFO 0x13 68#define ST21NFCA_DM_GETINFO 0x13
52#define ST21NFCA_DM_GETINFO_PIPE_LIST 0x02 69#define ST21NFCA_DM_GETINFO_PIPE_LIST 0x02
53#define ST21NFCA_DM_GETINFO_PIPE_INFO 0x01 70#define ST21NFCA_DM_GETINFO_PIPE_INFO 0x01
54#define ST21NFCA_DM_PIPE_CREATED 0x02 71#define ST21NFCA_DM_PIPE_CREATED 0x02
55#define ST21NFCA_DM_PIPE_OPEN 0x04 72#define ST21NFCA_DM_PIPE_OPEN 0x04
56#define ST21NFCA_DM_RF_ACTIVE 0x80 73#define ST21NFCA_DM_RF_ACTIVE 0x80
57#define ST21NFCA_DM_DISCONNECT 0x30 74#define ST21NFCA_DM_DISCONNECT 0x30
58 75
59#define ST21NFCA_DM_IS_PIPE_OPEN(p) \ 76#define ST21NFCA_DM_IS_PIPE_OPEN(p) \
60 ((p & 0x0f) == (ST21NFCA_DM_PIPE_CREATED | ST21NFCA_DM_PIPE_OPEN)) 77 ((p & 0x0f) == (ST21NFCA_DM_PIPE_CREATED | ST21NFCA_DM_PIPE_OPEN))
61 78
62#define ST21NFCA_NFC_MODE 0x03 /* NFC_MODE parameter*/ 79#define ST21NFCA_NFC_MODE 0x03 /* NFC_MODE parameter*/
80#define ST21NFCA_EVT_FIELD_ON 0x11
81#define ST21NFCA_EVT_CARD_DEACTIVATED 0x12
82#define ST21NFCA_EVT_CARD_ACTIVATED 0x13
83#define ST21NFCA_EVT_FIELD_OFF 0x14
63 84
64static DECLARE_BITMAP(dev_mask, ST21NFCA_NUM_DEVICES); 85static DECLARE_BITMAP(dev_mask, ST21NFCA_NUM_DEVICES);
65 86
@@ -355,8 +376,8 @@ static int st21nfca_hci_start_poll(struct nfc_hci_dev *hdev,
355 if (r < 0) 376 if (r < 0)
356 return r; 377 return r;
357 378
358 pol_req = 379 pol_req = be32_to_cpu((__force __be32)
359 be32_to_cpu(ST21NFCA_RF_READER_F_POL_REQ_DEFAULT); 380 ST21NFCA_RF_READER_F_POL_REQ_DEFAULT);
360 r = nfc_hci_set_param(hdev, ST21NFCA_RF_READER_F_GATE, 381 r = nfc_hci_set_param(hdev, ST21NFCA_RF_READER_F_GATE,
361 ST21NFCA_RF_READER_F_POL_REQ, 382 ST21NFCA_RF_READER_F_POL_REQ,
362 (u8 *) &pol_req, 4); 383 (u8 *) &pol_req, 4);
@@ -790,6 +811,7 @@ static int st21nfca_hci_check_presence(struct nfc_hci_dev *hdev,
790 struct nfc_target *target) 811 struct nfc_target *target)
791{ 812{
792 u8 fwi = 0x11; 813 u8 fwi = 0x11;
814
793 switch (target->hci_reader_gate) { 815 switch (target->hci_reader_gate) {
794 case NFC_HCI_RF_READER_A_GATE: 816 case NFC_HCI_RF_READER_A_GATE:
795 case NFC_HCI_RF_READER_B_GATE: 817 case NFC_HCI_RF_READER_B_GATE:
@@ -839,20 +861,16 @@ static int st21nfca_hci_event_received(struct nfc_hci_dev *hdev, u8 gate,
839 if (gate == ST21NFCA_RF_CARD_F_GATE) { 861 if (gate == ST21NFCA_RF_CARD_F_GATE) {
840 r = st21nfca_tm_event_send_data(hdev, skb, gate); 862 r = st21nfca_tm_event_send_data(hdev, skb, gate);
841 if (r < 0) 863 if (r < 0)
842 goto exit; 864 return r;
843 return 0; 865 return 0;
844 } else {
845 info->dep_info.curr_nfc_dep_pni = 0;
846 return 1;
847 } 866 }
848 break; 867 info->dep_info.curr_nfc_dep_pni = 0;
868 return 1;
849 default: 869 default:
850 return 1; 870 return 1;
851 } 871 }
852 kfree_skb(skb); 872 kfree_skb(skb);
853 return 0; 873 return 0;
854exit:
855 return r;
856} 874}
857 875
858static struct nfc_hci_ops st21nfca_hci_ops = { 876static struct nfc_hci_ops st21nfca_hci_ops = {
@@ -904,8 +922,11 @@ int st21nfca_hci_probe(void *phy_id, struct nfc_phy_ops *phy_ops,
904 * persistent info to discriminate 2 identical chips 922 * persistent info to discriminate 2 identical chips
905 */ 923 */
906 dev_num = find_first_zero_bit(dev_mask, ST21NFCA_NUM_DEVICES); 924 dev_num = find_first_zero_bit(dev_mask, ST21NFCA_NUM_DEVICES);
925
907 if (dev_num >= ST21NFCA_NUM_DEVICES) 926 if (dev_num >= ST21NFCA_NUM_DEVICES)
908 goto err_alloc_hdev; 927 return -ENODEV;
928
929 set_bit(dev_num, dev_mask);
909 930
910 scnprintf(init_data.session_id, sizeof(init_data.session_id), "%s%2x", 931 scnprintf(init_data.session_id, sizeof(init_data.session_id), "%s%2x",
911 "ST21AH", dev_num); 932 "ST21AH", dev_num);
diff --git a/drivers/nfc/st21nfca/st21nfca.h b/drivers/nfc/st21nfca/st21nfca.h
index 96fe5a62dc0d..a0b77f1ba6d9 100644
--- a/drivers/nfc/st21nfca/st21nfca.h
+++ b/drivers/nfc/st21nfca/st21nfca.h
@@ -82,30 +82,9 @@ struct st21nfca_hci_info {
82#define ST21NFCA_WR_XCHG_DATA 0x10 82#define ST21NFCA_WR_XCHG_DATA 0x10
83 83
84#define ST21NFCA_RF_READER_F_GATE 0x14 84#define ST21NFCA_RF_READER_F_GATE 0x14
85#define ST21NFCA_RF_READER_F_DATARATE 0x01
86#define ST21NFCA_RF_READER_F_DATARATE_106 0x01
87#define ST21NFCA_RF_READER_F_DATARATE_212 0x02
88#define ST21NFCA_RF_READER_F_DATARATE_424 0x04
89#define ST21NFCA_RF_READER_F_POL_REQ 0x02
90#define ST21NFCA_RF_READER_F_POL_REQ_DEFAULT 0xffff0000
91#define ST21NFCA_RF_READER_F_NFCID2 0x03
92#define ST21NFCA_RF_READER_F_NFCID1 0x04
93#define ST21NFCA_RF_READER_F_SENS_RES 0x05
94 85
95#define ST21NFCA_RF_CARD_F_GATE 0x24 86#define ST21NFCA_RF_CARD_F_GATE 0x24
96#define ST21NFCA_RF_CARD_F_MODE 0x01
97#define ST21NFCA_RF_CARD_F_NFCID2_LIST 0x04
98#define ST21NFCA_RF_CARD_F_NFCID1 0x05
99#define ST21NFCA_RF_CARD_F_SENS_RES 0x06
100#define ST21NFCA_RF_CARD_F_SEL_RES 0x07
101#define ST21NFCA_RF_CARD_F_DATARATE 0x08
102#define ST21NFCA_RF_CARD_F_DATARATE_106 0x00
103#define ST21NFCA_RF_CARD_F_DATARATE_212_424 0x01
104 87
105#define ST21NFCA_EVT_SEND_DATA 0x10 88#define ST21NFCA_EVT_SEND_DATA 0x10
106#define ST21NFCA_EVT_FIELD_ON 0x11
107#define ST21NFCA_EVT_CARD_DEACTIVATED 0x12
108#define ST21NFCA_EVT_CARD_ACTIVATED 0x13
109#define ST21NFCA_EVT_FIELD_OFF 0x14
110 89
111#endif /* __LOCAL_ST21NFCA_H_ */ 90#endif /* __LOCAL_ST21NFCA_H_ */
diff --git a/drivers/nfc/st21nfca/st21nfca_dep.c b/drivers/nfc/st21nfca/st21nfca_dep.c
index b2d9957b57f8..bfb6df56c505 100644
--- a/drivers/nfc/st21nfca/st21nfca_dep.c
+++ b/drivers/nfc/st21nfca/st21nfca_dep.c
@@ -121,6 +121,7 @@ static void st21nfca_tx_work(struct work_struct *work)
121 121
122 struct nfc_dev *dev; 122 struct nfc_dev *dev;
123 struct sk_buff *skb; 123 struct sk_buff *skb;
124
124 if (info) { 125 if (info) {
125 dev = info->hdev->ndev; 126 dev = info->hdev->ndev;
126 skb = info->dep_info.tx_pending; 127 skb = info->dep_info.tx_pending;
@@ -128,9 +129,8 @@ static void st21nfca_tx_work(struct work_struct *work)
128 device_lock(&dev->dev); 129 device_lock(&dev->dev);
129 130
130 nfc_hci_send_cmd_async(info->hdev, ST21NFCA_RF_READER_F_GATE, 131 nfc_hci_send_cmd_async(info->hdev, ST21NFCA_RF_READER_F_GATE,
131 ST21NFCA_WR_XCHG_DATA, 132 ST21NFCA_WR_XCHG_DATA, skb->data, skb->len,
132 skb->data, skb->len, 133 info->async_cb, info);
133 info->async_cb, info);
134 device_unlock(&dev->dev); 134 device_unlock(&dev->dev);
135 kfree_skb(skb); 135 kfree_skb(skb);
136 } 136 }
@@ -185,8 +185,10 @@ static int st21nfca_tm_send_atr_res(struct nfc_hci_dev *hdev,
185 185
186 info->dep_info.curr_nfc_dep_pni = 0; 186 info->dep_info.curr_nfc_dep_pni = 0;
187 187
188 return nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 188 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
189 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len); 189 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
190 kfree_skb(skb);
191 return r;
190} 192}
191 193
192static int st21nfca_tm_recv_atr_req(struct nfc_hci_dev *hdev, 194static int st21nfca_tm_recv_atr_req(struct nfc_hci_dev *hdev,
@@ -197,10 +199,6 @@ static int st21nfca_tm_recv_atr_req(struct nfc_hci_dev *hdev,
197 int r; 199 int r;
198 200
199 skb_trim(skb, skb->len - 1); 201 skb_trim(skb, skb->len - 1);
200 if (IS_ERR(skb)) {
201 r = PTR_ERR(skb);
202 goto exit;
203 }
204 202
205 if (!skb->len) { 203 if (!skb->len) {
206 r = -EIO; 204 r = -EIO;
@@ -214,6 +212,11 @@ static int st21nfca_tm_recv_atr_req(struct nfc_hci_dev *hdev,
214 212
215 atr_req = (struct st21nfca_atr_req *)skb->data; 213 atr_req = (struct st21nfca_atr_req *)skb->data;
216 214
215 if (atr_req->length < sizeof(struct st21nfca_atr_req)) {
216 r = -EPROTO;
217 goto exit;
218 }
219
217 r = st21nfca_tm_send_atr_res(hdev, atr_req); 220 r = st21nfca_tm_send_atr_res(hdev, atr_req);
218 if (r) 221 if (r)
219 goto exit; 222 goto exit;
@@ -237,7 +240,6 @@ static int st21nfca_tm_send_psl_res(struct nfc_hci_dev *hdev,
237 struct st21nfca_psl_res *psl_res; 240 struct st21nfca_psl_res *psl_res;
238 struct sk_buff *skb; 241 struct sk_buff *skb;
239 u8 bitrate[2] = {0, 0}; 242 u8 bitrate[2] = {0, 0};
240
241 int r; 243 int r;
242 244
243 skb = alloc_skb(sizeof(struct st21nfca_psl_res), GFP_KERNEL); 245 skb = alloc_skb(sizeof(struct st21nfca_psl_res), GFP_KERNEL);
@@ -254,6 +256,8 @@ static int st21nfca_tm_send_psl_res(struct nfc_hci_dev *hdev,
254 256
255 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 257 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
256 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len); 258 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
259 if (r < 0)
260 goto error;
257 261
258 /* 262 /*
259 * ST21NFCA only support P2P passive. 263 * ST21NFCA only support P2P passive.
@@ -269,8 +273,11 @@ static int st21nfca_tm_send_psl_res(struct nfc_hci_dev *hdev,
269 } 273 }
270 274
271 /* Send an event to change bitrate change event to card f */ 275 /* Send an event to change bitrate change event to card f */
272 return nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 276 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
273 ST21NFCA_EVT_CARD_F_BITRATE, bitrate, 2); 277 ST21NFCA_EVT_CARD_F_BITRATE, bitrate, 2);
278error:
279 kfree_skb(skb);
280 return r;
274} 281}
275 282
276static int st21nfca_tm_recv_psl_req(struct nfc_hci_dev *hdev, 283static int st21nfca_tm_recv_psl_req(struct nfc_hci_dev *hdev,
@@ -280,11 +287,6 @@ static int st21nfca_tm_recv_psl_req(struct nfc_hci_dev *hdev,
280 int r; 287 int r;
281 288
282 skb_trim(skb, skb->len - 1); 289 skb_trim(skb, skb->len - 1);
283 if (IS_ERR(skb)) {
284 r = PTR_ERR(skb);
285 skb = NULL;
286 goto exit;
287 }
288 290
289 if (!skb->len) { 291 if (!skb->len) {
290 r = -EIO; 292 r = -EIO;
@@ -314,7 +316,7 @@ int st21nfca_tm_send_dep_res(struct nfc_hci_dev *hdev, struct sk_buff *skb)
314 *skb_push(skb, 1) = skb->len; 316 *skb_push(skb, 1) = skb->len;
315 317
316 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE, 318 r = nfc_hci_send_event(hdev, ST21NFCA_RF_CARD_F_GATE,
317 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len); 319 ST21NFCA_EVT_SEND_DATA, skb->data, skb->len);
318 kfree_skb(skb); 320 kfree_skb(skb);
319 321
320 return r; 322 return r;
@@ -330,11 +332,6 @@ static int st21nfca_tm_recv_dep_req(struct nfc_hci_dev *hdev,
330 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev); 332 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
331 333
332 skb_trim(skb, skb->len - 1); 334 skb_trim(skb, skb->len - 1);
333 if (IS_ERR(skb)) {
334 r = PTR_ERR(skb);
335 skb = NULL;
336 goto exit;
337 }
338 335
339 size = 4; 336 size = 4;
340 337
@@ -368,12 +365,6 @@ static int st21nfca_tm_recv_dep_req(struct nfc_hci_dev *hdev,
368 break; 365 break;
369 } 366 }
370 367
371 if (IS_ERR(skb)) {
372 r = PTR_ERR(skb);
373 skb = NULL;
374 goto exit;
375 }
376
377 skb_pull(skb, size); 368 skb_pull(skb, size);
378 369
379 return nfc_tm_data_received(hdev->ndev, skb); 370 return nfc_tm_data_received(hdev->ndev, skb);
@@ -437,8 +428,6 @@ static void st21nfca_im_send_psl_req(struct nfc_hci_dev *hdev, u8 did, u8 bsi,
437 *skb_push(skb, 1) = info->dep_info.to | 0x10; 428 *skb_push(skb, 1) = info->dep_info.to | 0x10;
438 429
439 st21nfca_im_send_pdu(info, skb); 430 st21nfca_im_send_pdu(info, skb);
440
441 kfree_skb(skb);
442} 431}
443 432
444#define ST21NFCA_CB_TYPE_READER_F 1 433#define ST21NFCA_CB_TYPE_READER_F 1
@@ -452,7 +441,7 @@ static void st21nfca_im_recv_atr_res_cb(void *context, struct sk_buff *skb,
452 if (err != 0) 441 if (err != 0)
453 return; 442 return;
454 443
455 if (IS_ERR(skb)) 444 if (!skb)
456 return; 445 return;
457 446
458 switch (info->async_cb_type) { 447 switch (info->async_cb_type) {
@@ -484,8 +473,7 @@ static void st21nfca_im_recv_atr_res_cb(void *context, struct sk_buff *skb,
484 ST21NFCA_PP2LRI(atr_res->ppi)); 473 ST21NFCA_PP2LRI(atr_res->ppi));
485 break; 474 break;
486 default: 475 default:
487 if (err == 0) 476 kfree_skb(skb);
488 kfree_skb(skb);
489 break; 477 break;
490 } 478 }
491} 479}
@@ -522,7 +510,7 @@ int st21nfca_im_send_atr_req(struct nfc_hci_dev *hdev, u8 *gb, size_t gb_len)
522 memset(atr_req->nfcid3, 0, NFC_NFCID3_MAXSIZE); 510 memset(atr_req->nfcid3, 0, NFC_NFCID3_MAXSIZE);
523 target = hdev->ndev->targets; 511 target = hdev->ndev->targets;
524 512
525 if (target->sensf_res) 513 if (target->sensf_res_len > 0)
526 memcpy(atr_req->nfcid3, target->sensf_res, 514 memcpy(atr_req->nfcid3, target->sensf_res,
527 target->sensf_res_len); 515 target->sensf_res_len);
528 else 516 else
@@ -565,7 +553,7 @@ static void st21nfca_im_recv_dep_res_cb(void *context, struct sk_buff *skb,
565 if (err != 0) 553 if (err != 0)
566 return; 554 return;
567 555
568 if (IS_ERR(skb)) 556 if (!skb)
569 return; 557 return;
570 558
571 switch (info->async_cb_type) { 559 switch (info->async_cb_type) {
@@ -615,8 +603,7 @@ static void st21nfca_im_recv_dep_res_cb(void *context, struct sk_buff *skb,
615 } 603 }
616 604
617exit: 605exit:
618 if (err == 0) 606 kfree_skb(skb);
619 kfree_skb(skb);
620} 607}
621 608
622int st21nfca_im_send_dep_req(struct nfc_hci_dev *hdev, struct sk_buff *skb) 609int st21nfca_im_send_dep_req(struct nfc_hci_dev *hdev, struct sk_buff *skb)
diff --git a/drivers/nfc/st21nfcb/i2c.c b/drivers/nfc/st21nfcb/i2c.c
index 8af880ead5db..c5d2427a3db2 100644
--- a/drivers/nfc/st21nfcb/i2c.c
+++ b/drivers/nfc/st21nfcb/i2c.c
@@ -17,24 +17,16 @@
17 17
18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 19
20#include <linux/crc-ccitt.h>
21#include <linux/module.h> 20#include <linux/module.h>
22#include <linux/i2c.h> 21#include <linux/i2c.h>
23#include <linux/gpio.h> 22#include <linux/gpio.h>
24#include <linux/of_irq.h> 23#include <linux/of_irq.h>
25#include <linux/of_gpio.h> 24#include <linux/of_gpio.h>
26#include <linux/miscdevice.h>
27#include <linux/interrupt.h> 25#include <linux/interrupt.h>
28#include <linux/delay.h> 26#include <linux/delay.h>
29#include <linux/nfc.h> 27#include <linux/nfc.h>
30#include <linux/firmware.h>
31#include <linux/unaligned/access_ok.h>
32#include <linux/platform_data/st21nfcb.h> 28#include <linux/platform_data/st21nfcb.h>
33 29
34#include <net/nfc/nci.h>
35#include <net/nfc/llc.h>
36#include <net/nfc/nfc.h>
37
38#include "ndlc.h" 30#include "ndlc.h"
39 31
40#define DRIVER_DESC "NCI NFC driver for ST21NFCB" 32#define DRIVER_DESC "NCI NFC driver for ST21NFCB"
@@ -63,12 +55,6 @@ struct st21nfcb_i2c_phy {
63 unsigned int irq_polarity; 55 unsigned int irq_polarity;
64 56
65 int powered; 57 int powered;
66
67 /*
68 * < 0 if hardware error occured (e.g. i2c err)
69 * and prevents normal operation.
70 */
71 int hard_fault;
72}; 58};
73 59
74#define I2C_DUMP_SKB(info, skb) \ 60#define I2C_DUMP_SKB(info, skb) \
@@ -122,8 +108,8 @@ static int st21nfcb_nci_i2c_write(void *phy_id, struct sk_buff *skb)
122 108
123 I2C_DUMP_SKB("st21nfcb_nci_i2c_write", skb); 109 I2C_DUMP_SKB("st21nfcb_nci_i2c_write", skb);
124 110
125 if (phy->hard_fault != 0) 111 if (phy->ndlc->hard_fault != 0)
126 return phy->hard_fault; 112 return phy->ndlc->hard_fault;
127 113
128 r = i2c_master_send(client, skb->data, skb->len); 114 r = i2c_master_send(client, skb->data, skb->len);
129 if (r == -EREMOTEIO) { /* Retry, chip was in standby */ 115 if (r == -EREMOTEIO) { /* Retry, chip was in standby */
@@ -168,11 +154,11 @@ static int st21nfcb_nci_i2c_read(struct st21nfcb_i2c_phy *phy,
168 if (r == -EREMOTEIO) { /* Retry, chip was in standby */ 154 if (r == -EREMOTEIO) { /* Retry, chip was in standby */
169 usleep_range(1000, 4000); 155 usleep_range(1000, 4000);
170 r = i2c_master_recv(client, buf, ST21NFCB_NCI_I2C_MIN_SIZE); 156 r = i2c_master_recv(client, buf, ST21NFCB_NCI_I2C_MIN_SIZE);
171 } else if (r != ST21NFCB_NCI_I2C_MIN_SIZE) {
172 nfc_err(&client->dev, "cannot read ndlc & nci header\n");
173 return -EREMOTEIO;
174 } 157 }
175 158
159 if (r != ST21NFCB_NCI_I2C_MIN_SIZE)
160 return -EREMOTEIO;
161
176 len = be16_to_cpu(*(__be16 *) (buf + 2)); 162 len = be16_to_cpu(*(__be16 *) (buf + 2));
177 if (len > ST21NFCB_NCI_I2C_MAX_SIZE) { 163 if (len > ST21NFCB_NCI_I2C_MAX_SIZE) {
178 nfc_err(&client->dev, "invalid frame len\n"); 164 nfc_err(&client->dev, "invalid frame len\n");
@@ -224,7 +210,7 @@ static irqreturn_t st21nfcb_nci_irq_thread_fn(int irq, void *phy_id)
224 client = phy->i2c_dev; 210 client = phy->i2c_dev;
225 dev_dbg(&client->dev, "IRQ\n"); 211 dev_dbg(&client->dev, "IRQ\n");
226 212
227 if (phy->hard_fault) 213 if (phy->ndlc->hard_fault)
228 return IRQ_HANDLED; 214 return IRQ_HANDLED;
229 215
230 if (!phy->powered) { 216 if (!phy->powered) {
@@ -233,13 +219,8 @@ static irqreturn_t st21nfcb_nci_irq_thread_fn(int irq, void *phy_id)
233 } 219 }
234 220
235 r = st21nfcb_nci_i2c_read(phy, &skb); 221 r = st21nfcb_nci_i2c_read(phy, &skb);
236 if (r == -EREMOTEIO) { 222 if (r == -EREMOTEIO || r == -ENOMEM || r == -EBADMSG)
237 phy->hard_fault = r;
238 ndlc_recv(phy->ndlc, NULL);
239 return IRQ_HANDLED;
240 } else if (r == -ENOMEM || r == -EBADMSG) {
241 return IRQ_HANDLED; 223 return IRQ_HANDLED;
242 }
243 224
244 ndlc_recv(phy->ndlc, skb); 225 ndlc_recv(phy->ndlc, skb);
245 226
@@ -273,25 +254,18 @@ static int st21nfcb_nci_i2c_of_request_resources(struct i2c_client *client)
273 } 254 }
274 255
275 /* GPIO request and configuration */ 256 /* GPIO request and configuration */
276 r = devm_gpio_request(&client->dev, gpio, "clf_reset"); 257 r = devm_gpio_request_one(&client->dev, gpio,
258 GPIOF_OUT_INIT_HIGH, "clf_reset");
277 if (r) { 259 if (r) {
278 nfc_err(&client->dev, "Failed to request reset pin\n"); 260 nfc_err(&client->dev, "Failed to request reset pin\n");
279 return -ENODEV; 261 return -ENODEV;
280 } 262 }
281
282 r = gpio_direction_output(gpio, 1);
283 if (r) {
284 nfc_err(&client->dev,
285 "Failed to set reset pin direction as output\n");
286 return -ENODEV;
287 }
288 phy->gpio_reset = gpio; 263 phy->gpio_reset = gpio;
289 264
290 /* IRQ */ 265 /* IRQ */
291 r = irq_of_parse_and_map(pp, 0); 266 r = irq_of_parse_and_map(pp, 0);
292 if (r < 0) { 267 if (r < 0) {
293 nfc_err(&client->dev, 268 nfc_err(&client->dev, "Unable to get irq, error: %d\n", r);
294 "Unable to get irq, error: %d\n", r);
295 return r; 269 return r;
296 } 270 }
297 271
@@ -325,32 +299,20 @@ static int st21nfcb_nci_i2c_request_resources(struct i2c_client *client)
325 phy->gpio_reset = pdata->gpio_reset; 299 phy->gpio_reset = pdata->gpio_reset;
326 phy->irq_polarity = pdata->irq_polarity; 300 phy->irq_polarity = pdata->irq_polarity;
327 301
328 r = devm_gpio_request(&client->dev, phy->gpio_irq, "wake_up"); 302 r = devm_gpio_request_one(&client->dev, phy->gpio_irq,
303 GPIOF_IN, "clf_irq");
329 if (r) { 304 if (r) {
330 pr_err("%s : gpio_request failed\n", __FILE__); 305 pr_err("%s : gpio_request failed\n", __FILE__);
331 return -ENODEV; 306 return -ENODEV;
332 } 307 }
333 308
334 r = gpio_direction_input(phy->gpio_irq); 309 r = devm_gpio_request_one(&client->dev,
335 if (r) { 310 phy->gpio_reset, GPIOF_OUT_INIT_HIGH, "clf_reset");
336 pr_err("%s : gpio_direction_input failed\n", __FILE__);
337 return -ENODEV;
338 }
339
340 r = devm_gpio_request(&client->dev,
341 phy->gpio_reset, "clf_reset");
342 if (r) { 311 if (r) {
343 pr_err("%s : reset gpio_request failed\n", __FILE__); 312 pr_err("%s : reset gpio_request failed\n", __FILE__);
344 return -ENODEV; 313 return -ENODEV;
345 } 314 }
346 315
347 r = gpio_direction_output(phy->gpio_reset, 1);
348 if (r) {
349 pr_err("%s : reset gpio_direction_output failed\n",
350 __FILE__);
351 return -ENODEV;
352 }
353
354 /* IRQ */ 316 /* IRQ */
355 irq = gpio_to_irq(phy->gpio_irq); 317 irq = gpio_to_irq(phy->gpio_irq);
356 if (irq < 0) { 318 if (irq < 0) {
@@ -448,7 +410,6 @@ static struct i2c_driver st21nfcb_nci_i2c_driver = {
448 .driver = { 410 .driver = {
449 .owner = THIS_MODULE, 411 .owner = THIS_MODULE,
450 .name = ST21NFCB_NCI_I2C_DRIVER_NAME, 412 .name = ST21NFCB_NCI_I2C_DRIVER_NAME,
451 .owner = THIS_MODULE,
452 .of_match_table = of_match_ptr(of_st21nfcb_i2c_match), 413 .of_match_table = of_match_ptr(of_st21nfcb_i2c_match),
453 }, 414 },
454 .probe = st21nfcb_nci_i2c_probe, 415 .probe = st21nfcb_nci_i2c_probe,
diff --git a/drivers/nfc/st21nfcb/ndlc.c b/drivers/nfc/st21nfcb/ndlc.c
index 83c97c36112b..e7bff8921d11 100644
--- a/drivers/nfc/st21nfcb/ndlc.c
+++ b/drivers/nfc/st21nfcb/ndlc.c
@@ -112,6 +112,10 @@ static void llt_ndlc_send_queue(struct llt_ndlc *ndlc)
112 ndlc->t1_active = true; 112 ndlc->t1_active = true;
113 mod_timer(&ndlc->t1_timer, time_sent + 113 mod_timer(&ndlc->t1_timer, time_sent +
114 msecs_to_jiffies(NDLC_TIMER_T1)); 114 msecs_to_jiffies(NDLC_TIMER_T1));
115 /* start timer t2 for chip availability */
116 ndlc->t2_active = true;
117 mod_timer(&ndlc->t2_timer, time_sent +
118 msecs_to_jiffies(NDLC_TIMER_T2));
115 } 119 }
116} 120}
117 121
@@ -207,7 +211,7 @@ static void llt_ndlc_sm_work(struct work_struct *work)
207 ndlc->t2_active = false; 211 ndlc->t2_active = false;
208 ndlc->t1_active = false; 212 ndlc->t1_active = false;
209 del_timer_sync(&ndlc->t1_timer); 213 del_timer_sync(&ndlc->t1_timer);
210 214 del_timer_sync(&ndlc->t2_timer);
211 ndlc_close(ndlc); 215 ndlc_close(ndlc);
212 ndlc->hard_fault = -EREMOTEIO; 216 ndlc->hard_fault = -EREMOTEIO;
213 } 217 }
diff --git a/drivers/nfc/st21nfcb/ndlc.h b/drivers/nfc/st21nfcb/ndlc.h
index c30a2f0faa5f..b28140e0cd78 100644
--- a/drivers/nfc/st21nfcb/ndlc.h
+++ b/drivers/nfc/st21nfcb/ndlc.h
@@ -42,6 +42,10 @@ struct llt_ndlc {
42 42
43 struct device *dev; 43 struct device *dev;
44 44
45 /*
46 * < 0 if hardware error occured
47 * and prevents normal operation.
48 */
45 int hard_fault; 49 int hard_fault;
46}; 50};
47 51
diff --git a/drivers/nfc/st21nfcb/st21nfcb.c b/drivers/nfc/st21nfcb/st21nfcb.c
index 4d95863e3063..ea63d5877831 100644
--- a/drivers/nfc/st21nfcb/st21nfcb.c
+++ b/drivers/nfc/st21nfcb/st21nfcb.c
@@ -22,10 +22,11 @@
22#include <net/nfc/nci_core.h> 22#include <net/nfc/nci_core.h>
23 23
24#include "st21nfcb.h" 24#include "st21nfcb.h"
25#include "ndlc.h"
26 25
27#define DRIVER_DESC "NCI NFC driver for ST21NFCB" 26#define DRIVER_DESC "NCI NFC driver for ST21NFCB"
28 27
28#define ST21NFCB_NCI1_X_PROPRIETARY_ISO15693 0x83
29
29static int st21nfcb_nci_open(struct nci_dev *ndev) 30static int st21nfcb_nci_open(struct nci_dev *ndev)
30{ 31{
31 struct st21nfcb_nci_info *info = nci_get_drvdata(ndev); 32 struct st21nfcb_nci_info *info = nci_get_drvdata(ndev);
@@ -65,10 +66,18 @@ static int st21nfcb_nci_send(struct nci_dev *ndev, struct sk_buff *skb)
65 return ndlc_send(info->ndlc, skb); 66 return ndlc_send(info->ndlc, skb);
66} 67}
67 68
69static __u32 st21nfcb_nci_get_rfprotocol(struct nci_dev *ndev,
70 __u8 rf_protocol)
71{
72 return rf_protocol == ST21NFCB_NCI1_X_PROPRIETARY_ISO15693 ?
73 NFC_PROTO_ISO15693_MASK : 0;
74}
75
68static struct nci_ops st21nfcb_nci_ops = { 76static struct nci_ops st21nfcb_nci_ops = {
69 .open = st21nfcb_nci_open, 77 .open = st21nfcb_nci_open,
70 .close = st21nfcb_nci_close, 78 .close = st21nfcb_nci_close,
71 .send = st21nfcb_nci_send, 79 .send = st21nfcb_nci_send,
80 .get_rfprotocol = st21nfcb_nci_get_rfprotocol,
72}; 81};
73 82
74int st21nfcb_nci_probe(struct llt_ndlc *ndlc, int phy_headroom, 83int st21nfcb_nci_probe(struct llt_ndlc *ndlc, int phy_headroom,
@@ -88,29 +97,25 @@ int st21nfcb_nci_probe(struct llt_ndlc *ndlc, int phy_headroom,
88 | NFC_PROTO_FELICA_MASK 97 | NFC_PROTO_FELICA_MASK
89 | NFC_PROTO_ISO14443_MASK 98 | NFC_PROTO_ISO14443_MASK
90 | NFC_PROTO_ISO14443_B_MASK 99 | NFC_PROTO_ISO14443_B_MASK
100 | NFC_PROTO_ISO15693_MASK
91 | NFC_PROTO_NFC_DEP_MASK; 101 | NFC_PROTO_NFC_DEP_MASK;
92 102
93 ndlc->ndev = nci_allocate_device(&st21nfcb_nci_ops, protocols, 103 ndlc->ndev = nci_allocate_device(&st21nfcb_nci_ops, protocols,
94 phy_headroom, phy_tailroom); 104 phy_headroom, phy_tailroom);
95 if (!ndlc->ndev) { 105 if (!ndlc->ndev) {
96 pr_err("Cannot allocate nfc ndev\n"); 106 pr_err("Cannot allocate nfc ndev\n");
97 r = -ENOMEM; 107 return -ENOMEM;
98 goto err_alloc_ndev;
99 } 108 }
100 info->ndlc = ndlc; 109 info->ndlc = ndlc;
101 110
102 nci_set_drvdata(ndlc->ndev, info); 111 nci_set_drvdata(ndlc->ndev, info);
103 112
104 r = nci_register_device(ndlc->ndev); 113 r = nci_register_device(ndlc->ndev);
105 if (r) 114 if (r) {
106 goto err_regdev; 115 pr_err("Cannot register nfc device to nci core\n");
107 116 nci_free_device(ndlc->ndev);
108 return r; 117 }
109err_regdev:
110 nci_free_device(ndlc->ndev);
111 118
112err_alloc_ndev:
113 kfree(info);
114 return r; 119 return r;
115} 120}
116EXPORT_SYMBOL_GPL(st21nfcb_nci_probe); 121EXPORT_SYMBOL_GPL(st21nfcb_nci_probe);
diff --git a/drivers/nfc/st21nfcb/st21nfcb.h b/drivers/nfc/st21nfcb/st21nfcb.h
index 4bbbebb9f34d..ea58a56ad794 100644
--- a/drivers/nfc/st21nfcb/st21nfcb.h
+++ b/drivers/nfc/st21nfcb/st21nfcb.h
@@ -19,8 +19,6 @@
19#ifndef __LOCAL_ST21NFCB_H_ 19#ifndef __LOCAL_ST21NFCB_H_
20#define __LOCAL_ST21NFCB_H_ 20#define __LOCAL_ST21NFCB_H_
21 21
22#include <net/nfc/nci_core.h>
23
24#include "ndlc.h" 22#include "ndlc.h"
25 23
26/* Define private flags: */ 24/* Define private flags: */
diff --git a/drivers/nfc/trf7970a.c b/drivers/nfc/trf7970a.c
index 3b78b031e617..d2ccd2890647 100644
--- a/drivers/nfc/trf7970a.c
+++ b/drivers/nfc/trf7970a.c
@@ -36,7 +36,13 @@
36 * The trf7970a is very timing sensitive and the VIN, EN2, and EN 36 * The trf7970a is very timing sensitive and the VIN, EN2, and EN
37 * pins must asserted in that order and with specific delays in between. 37 * pins must asserted in that order and with specific delays in between.
38 * The delays used in the driver were provided by TI and have been 38 * The delays used in the driver were provided by TI and have been
39 * confirmed to work with this driver. 39 * confirmed to work with this driver. There is a bug with the current
40 * version of the trf7970a that requires that EN2 remain low no matter
41 * what. If it goes high, it will generate an RF field even when in
42 * passive target mode. TI has indicated that the chip will work okay
43 * when EN2 is left low. The 'en2-rf-quirk' device tree property
44 * indicates that trf7970a currently being used has the erratum and
45 * that EN2 must be kept low.
40 * 46 *
41 * Timeouts are implemented using the delayed workqueue kernel facility. 47 * Timeouts are implemented using the delayed workqueue kernel facility.
42 * Timeouts are required so things don't hang when there is no response 48 * Timeouts are required so things don't hang when there is no response
@@ -56,7 +62,7 @@
56 * way to abort a command that's already been sent to the tag is so turn 62 * way to abort a command that's already been sent to the tag is so turn
57 * off power to the tag. If we do that, though, we'd have to go through 63 * off power to the tag. If we do that, though, we'd have to go through
58 * the entire anticollision procedure again but the digital layer doesn't 64 * the entire anticollision procedure again but the digital layer doesn't
59 * support that. So, if an abort is received before trf7970a_in_send_cmd() 65 * support that. So, if an abort is received before trf7970a_send_cmd()
60 * has sent the command to the tag, it simply returns -ECANCELED. If the 66 * has sent the command to the tag, it simply returns -ECANCELED. If the
61 * command has already been sent to the tag, then the driver continues 67 * command has already been sent to the tag, then the driver continues
62 * normally and recieves the response data (or error) but just before 68 * normally and recieves the response data (or error) but just before
@@ -77,6 +83,13 @@
77 * been received and there isn't an error). The delay is 20 ms since delays 83 * been received and there isn't an error). The delay is 20 ms since delays
78 * of ~16 ms have been observed during testing. 84 * of ~16 ms have been observed during testing.
79 * 85 *
86 * When transmitting a frame larger than the FIFO size (127 bytes), the
87 * driver will wait 20 ms for the FIFO to drain past the low-watermark
88 * and generate an interrupt. The low-watermark set to 32 bytes so the
89 * interrupt should fire after 127 - 32 = 95 bytes have been sent. At
90 * the lowest possible bit rate (6.62 kbps for 15693), it will take up
91 * to ~14.35 ms so 20 ms is used for the timeout.
92 *
80 * Type 2 write and sector select commands respond with a 4-bit ACK or NACK. 93 * Type 2 write and sector select commands respond with a 4-bit ACK or NACK.
81 * Having only 4 bits in the FIFO won't normally generate an interrupt so 94 * Having only 4 bits in the FIFO won't normally generate an interrupt so
82 * driver enables the '4_bit_RX' bit of the Special Functions register 1 95 * driver enables the '4_bit_RX' bit of the Special Functions register 1
@@ -99,40 +112,43 @@
99 * Note under Table 1-1 in section 1.6 of 112 * Note under Table 1-1 in section 1.6 of
100 * http://www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least 113 * http://www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least
101 * 10 ms for TI Tag-it HF-I tags; however testing has shown that is not long 114 * 10 ms for TI Tag-it HF-I tags; however testing has shown that is not long
102 * enough. For this reason, the driver waits 20 ms which seems to work 115 * enough so 20 ms is used. So the timer is set to 40 ms - 20 ms to drain
116 * up to 127 bytes in the FIFO at the lowest bit rate plus another 20 ms to
117 * ensure the wait is long enough before sending the EOF. This seems to work
103 * reliably. 118 * reliably.
104 */ 119 */
105 120
106#define TRF7970A_SUPPORTED_PROTOCOLS \ 121#define TRF7970A_SUPPORTED_PROTOCOLS \
107 (NFC_PROTO_MIFARE_MASK | NFC_PROTO_ISO14443_MASK | \ 122 (NFC_PROTO_MIFARE_MASK | NFC_PROTO_ISO14443_MASK | \
108 NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_FELICA_MASK | \ 123 NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_FELICA_MASK | \
109 NFC_PROTO_ISO15693_MASK) 124 NFC_PROTO_ISO15693_MASK | NFC_PROTO_NFC_DEP_MASK)
110 125
111#define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */ 126#define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */
112 127
113/* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
114 * on what the current framing is, the address of the TX length byte 1
115 * register (0x1d), and the 2 byte length of the data to be transmitted.
116 * That totals 5 bytes.
117 */
118#define TRF7970A_TX_SKB_HEADROOM 5
119
120#define TRF7970A_RX_SKB_ALLOC_SIZE 256 128#define TRF7970A_RX_SKB_ALLOC_SIZE 256
121 129
122#define TRF7970A_FIFO_SIZE 128 130#define TRF7970A_FIFO_SIZE 127
123 131
124/* TX length is 3 nibbles long ==> 4KB - 1 bytes max */ 132/* TX length is 3 nibbles long ==> 4KB - 1 bytes max */
125#define TRF7970A_TX_MAX (4096 - 1) 133#define TRF7970A_TX_MAX (4096 - 1)
126 134
135#define TRF7970A_WAIT_FOR_TX_IRQ 20
127#define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20 136#define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20
128#define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 3 137#define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 20
129#define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 20 138#define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 40
139
140/* Guard times for various RF technologies (in us) */
141#define TRF7970A_GUARD_TIME_NFCA 5000
142#define TRF7970A_GUARD_TIME_NFCB 5000
143#define TRF7970A_GUARD_TIME_NFCF 20000
144#define TRF7970A_GUARD_TIME_15693 1000
130 145
131/* Quirks */ 146/* Quirks */
132/* Erratum: When reading IRQ Status register on trf7970a, we must issue a 147/* Erratum: When reading IRQ Status register on trf7970a, we must issue a
133 * read continuous command for IRQ Status and Collision Position registers. 148 * read continuous command for IRQ Status and Collision Position registers.
134 */ 149 */
135#define TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA BIT(0) 150#define TRF7970A_QUIRK_IRQ_STATUS_READ BIT(0)
151#define TRF7970A_QUIRK_EN2_MUST_STAY_LOW BIT(1)
136 152
137/* Direct commands */ 153/* Direct commands */
138#define TRF7970A_CMD_IDLE 0x00 154#define TRF7970A_CMD_IDLE 0x00
@@ -149,8 +165,8 @@
149#define TRF7970A_CMD_CLOSE_SLOT 0x15 165#define TRF7970A_CMD_CLOSE_SLOT 0x15
150#define TRF7970A_CMD_BLOCK_RX 0x16 166#define TRF7970A_CMD_BLOCK_RX 0x16
151#define TRF7970A_CMD_ENABLE_RX 0x17 167#define TRF7970A_CMD_ENABLE_RX 0x17
152#define TRF7970A_CMD_TEST_EXT_RF 0x18 168#define TRF7970A_CMD_TEST_INT_RF 0x18
153#define TRF7970A_CMD_TEST_INT_RF 0x19 169#define TRF7970A_CMD_TEST_EXT_RF 0x19
154#define TRF7970A_CMD_RX_GAIN_ADJUST 0x1a 170#define TRF7970A_CMD_RX_GAIN_ADJUST 0x1a
155 171
156/* Bits determining whether its a direct command or register R/W, 172/* Bits determining whether its a direct command or register R/W,
@@ -224,6 +240,15 @@
224#define TRF7970A_ISO_CTRL_14443B_848 0x0f 240#define TRF7970A_ISO_CTRL_14443B_848 0x0f
225#define TRF7970A_ISO_CTRL_FELICA_212 0x1a 241#define TRF7970A_ISO_CTRL_FELICA_212 0x1a
226#define TRF7970A_ISO_CTRL_FELICA_424 0x1b 242#define TRF7970A_ISO_CTRL_FELICA_424 0x1b
243#define TRF7970A_ISO_CTRL_NFC_NFCA_106 0x01
244#define TRF7970A_ISO_CTRL_NFC_NFCF_212 0x02
245#define TRF7970A_ISO_CTRL_NFC_NFCF_424 0x03
246#define TRF7970A_ISO_CTRL_NFC_CE_14443A 0x00
247#define TRF7970A_ISO_CTRL_NFC_CE_14443B 0x01
248#define TRF7970A_ISO_CTRL_NFC_CE BIT(2)
249#define TRF7970A_ISO_CTRL_NFC_ACTIVE BIT(3)
250#define TRF7970A_ISO_CTRL_NFC_INITIATOR BIT(4)
251#define TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE BIT(5)
227#define TRF7970A_ISO_CTRL_RFID BIT(5) 252#define TRF7970A_ISO_CTRL_RFID BIT(5)
228#define TRF7970A_ISO_CTRL_DIR_MODE BIT(6) 253#define TRF7970A_ISO_CTRL_DIR_MODE BIT(6)
229#define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7) /* true == No CRC */ 254#define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7) /* true == No CRC */
@@ -249,12 +274,32 @@
249#define TRF7970A_MODULATOR_EN_OOK BIT(6) 274#define TRF7970A_MODULATOR_EN_OOK BIT(6)
250#define TRF7970A_MODULATOR_27MHZ BIT(7) 275#define TRF7970A_MODULATOR_27MHZ BIT(7)
251 276
277#define TRF7970A_RX_SPECIAL_SETTINGS_NO_LIM BIT(0)
278#define TRF7970A_RX_SPECIAL_SETTINGS_AGCR BIT(1)
279#define TRF7970A_RX_SPECIAL_SETTINGS_GD_0DB (0x0 << 2)
280#define TRF7970A_RX_SPECIAL_SETTINGS_GD_5DB (0x1 << 2)
281#define TRF7970A_RX_SPECIAL_SETTINGS_GD_10DB (0x2 << 2)
282#define TRF7970A_RX_SPECIAL_SETTINGS_GD_15DB (0x3 << 2)
283#define TRF7970A_RX_SPECIAL_SETTINGS_HBT BIT(4)
284#define TRF7970A_RX_SPECIAL_SETTINGS_M848 BIT(5)
285#define TRF7970A_RX_SPECIAL_SETTINGS_C424 BIT(6)
286#define TRF7970A_RX_SPECIAL_SETTINGS_C212 BIT(7)
287
288#define TRF7970A_REG_IO_CTRL_VRS(v) ((v) & 0x07)
289#define TRF7970A_REG_IO_CTRL_IO_LOW BIT(5)
290#define TRF7970A_REG_IO_CTRL_EN_EXT_PA BIT(6)
291#define TRF7970A_REG_IO_CTRL_AUTO_REG BIT(7)
292
252/* IRQ Status Register Bits */ 293/* IRQ Status Register Bits */
253#define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */ 294#define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */
295#define TRF7970A_IRQ_STATUS_NFC_COL_ERROR BIT(0)
254#define TRF7970A_IRQ_STATUS_COL BIT(1) 296#define TRF7970A_IRQ_STATUS_COL BIT(1)
255#define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2) 297#define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2)
298#define TRF7970A_IRQ_STATUS_NFC_RF BIT(2)
256#define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3) 299#define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3)
300#define TRF7970A_IRQ_STATUS_NFC_SDD BIT(3)
257#define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4) 301#define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4)
302#define TRF7970A_IRQ_STATUS_NFC_PROTO_ERROR BIT(4)
258#define TRF7970A_IRQ_STATUS_FIFO BIT(5) 303#define TRF7970A_IRQ_STATUS_FIFO BIT(5)
259#define TRF7970A_IRQ_STATUS_SRX BIT(6) 304#define TRF7970A_IRQ_STATUS_SRX BIT(6)
260#define TRF7970A_IRQ_STATUS_TX BIT(7) 305#define TRF7970A_IRQ_STATUS_TX BIT(7)
@@ -265,6 +310,10 @@
265 TRF7970A_IRQ_STATUS_PARITY_ERROR | \ 310 TRF7970A_IRQ_STATUS_PARITY_ERROR | \
266 TRF7970A_IRQ_STATUS_CRC_ERROR) 311 TRF7970A_IRQ_STATUS_CRC_ERROR)
267 312
313#define TRF7970A_RSSI_OSC_STATUS_RSSI_MASK (BIT(2) | BIT(1) | BIT(0))
314#define TRF7970A_RSSI_OSC_STATUS_RSSI_X_MASK (BIT(5) | BIT(4) | BIT(3))
315#define TRF7970A_RSSI_OSC_STATUS_RSSI_OSC_OK BIT(6)
316
268#define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0) 317#define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0)
269#define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1) 318#define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1)
270#define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2) 319#define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2)
@@ -281,6 +330,49 @@
281#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0x2 330#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0x2
282#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0x3 331#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0x3
283 332
333#define TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(v) ((v) & 0x07)
334#define TRF7970A_NFC_LOW_FIELD_LEVEL_CLEX_DIS BIT(7)
335
336#define TRF7970A_NFC_TARGET_LEVEL_RFDET(v) ((v) & 0x07)
337#define TRF7970A_NFC_TARGET_LEVEL_HI_RF BIT(3)
338#define TRF7970A_NFC_TARGET_LEVEL_SDD_EN BIT(3)
339#define TRF7970A_NFC_TARGET_LEVEL_LD_S_4BYTES (0x0 << 6)
340#define TRF7970A_NFC_TARGET_LEVEL_LD_S_7BYTES (0x1 << 6)
341#define TRF7970A_NFC_TARGET_LEVEL_LD_S_10BYTES (0x2 << 6)
342
343#define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106 BIT(0)
344#define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212 BIT(1)
345#define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424 (BIT(0) | BIT(1))
346#define TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B BIT(2)
347#define TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 BIT(3)
348#define TRF79070A_NFC_TARGET_PROTOCOL_FELICA BIT(4)
349#define TRF79070A_NFC_TARGET_PROTOCOL_RF_L BIT(6)
350#define TRF79070A_NFC_TARGET_PROTOCOL_RF_H BIT(7)
351
352#define TRF79070A_NFC_TARGET_PROTOCOL_106A \
353 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
354 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
355 TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 | \
356 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
357
358#define TRF79070A_NFC_TARGET_PROTOCOL_106B \
359 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
360 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
361 TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B | \
362 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
363
364#define TRF79070A_NFC_TARGET_PROTOCOL_212F \
365 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
366 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
367 TRF79070A_NFC_TARGET_PROTOCOL_FELICA | \
368 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212)
369
370#define TRF79070A_NFC_TARGET_PROTOCOL_424F \
371 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
372 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
373 TRF79070A_NFC_TARGET_PROTOCOL_FELICA | \
374 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424)
375
284#define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7) 376#define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7)
285 377
286/* NFC (ISO/IEC 14443A) Type 2 Tag commands */ 378/* NFC (ISO/IEC 14443A) Type 2 Tag commands */
@@ -317,13 +409,16 @@
317 (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE) 409 (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE)
318 410
319enum trf7970a_state { 411enum trf7970a_state {
320 TRF7970A_ST_OFF, 412 TRF7970A_ST_PWR_OFF,
413 TRF7970A_ST_RF_OFF,
321 TRF7970A_ST_IDLE, 414 TRF7970A_ST_IDLE,
322 TRF7970A_ST_IDLE_RX_BLOCKED, 415 TRF7970A_ST_IDLE_RX_BLOCKED,
323 TRF7970A_ST_WAIT_FOR_TX_FIFO, 416 TRF7970A_ST_WAIT_FOR_TX_FIFO,
324 TRF7970A_ST_WAIT_FOR_RX_DATA, 417 TRF7970A_ST_WAIT_FOR_RX_DATA,
325 TRF7970A_ST_WAIT_FOR_RX_DATA_CONT, 418 TRF7970A_ST_WAIT_FOR_RX_DATA_CONT,
326 TRF7970A_ST_WAIT_TO_ISSUE_EOF, 419 TRF7970A_ST_WAIT_TO_ISSUE_EOF,
420 TRF7970A_ST_LISTENING,
421 TRF7970A_ST_LISTENING_MD,
327 TRF7970A_ST_MAX 422 TRF7970A_ST_MAX
328}; 423};
329 424
@@ -334,6 +429,7 @@ struct trf7970a {
334 struct regulator *regulator; 429 struct regulator *regulator;
335 struct nfc_digital_dev *ddev; 430 struct nfc_digital_dev *ddev;
336 u32 quirks; 431 u32 quirks;
432 bool is_initiator;
337 bool aborting; 433 bool aborting;
338 struct sk_buff *tx_skb; 434 struct sk_buff *tx_skb;
339 struct sk_buff *rx_skb; 435 struct sk_buff *rx_skb;
@@ -344,8 +440,10 @@ struct trf7970a {
344 u8 iso_ctrl_tech; 440 u8 iso_ctrl_tech;
345 u8 modulator_sys_clk_ctrl; 441 u8 modulator_sys_clk_ctrl;
346 u8 special_fcn_reg1; 442 u8 special_fcn_reg1;
443 unsigned int guard_time;
347 int technology; 444 int technology;
348 int framing; 445 int framing;
446 u8 md_rf_tech;
349 u8 tx_cmd; 447 u8 tx_cmd;
350 bool issue_eof; 448 bool issue_eof;
351 int en2_gpio; 449 int en2_gpio;
@@ -386,15 +484,28 @@ static int trf7970a_read(struct trf7970a *trf, u8 reg, u8 *val)
386 return ret; 484 return ret;
387} 485}
388 486
389static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, 487static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, u8 *buf, size_t len)
390 u8 *buf, size_t len)
391{ 488{
392 u8 addr = reg | TRF7970A_CMD_BIT_RW | TRF7970A_CMD_BIT_CONTINUOUS; 489 u8 addr = reg | TRF7970A_CMD_BIT_RW | TRF7970A_CMD_BIT_CONTINUOUS;
490 struct spi_transfer t[2];
491 struct spi_message m;
393 int ret; 492 int ret;
394 493
395 dev_dbg(trf->dev, "read_cont(0x%x, %zd)\n", addr, len); 494 dev_dbg(trf->dev, "read_cont(0x%x, %zd)\n", addr, len);
396 495
397 ret = spi_write_then_read(trf->spi, &addr, 1, buf, len); 496 spi_message_init(&m);
497
498 memset(&t, 0, sizeof(t));
499
500 t[0].tx_buf = &addr;
501 t[0].len = sizeof(addr);
502 spi_message_add_tail(&t[0], &m);
503
504 t[1].rx_buf = buf;
505 t[1].len = len;
506 spi_message_add_tail(&t[1], &m);
507
508 ret = spi_sync(trf->spi, &m);
398 if (ret) 509 if (ret)
399 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr, 510 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
400 ret); 511 ret);
@@ -424,7 +535,7 @@ static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)
424 535
425 addr = TRF7970A_IRQ_STATUS | TRF7970A_CMD_BIT_RW; 536 addr = TRF7970A_IRQ_STATUS | TRF7970A_CMD_BIT_RW;
426 537
427 if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA) { 538 if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ) {
428 addr |= TRF7970A_CMD_BIT_CONTINUOUS; 539 addr |= TRF7970A_CMD_BIT_CONTINUOUS;
429 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2); 540 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
430 } else { 541 } else {
@@ -440,10 +551,60 @@ static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)
440 return ret; 551 return ret;
441} 552}
442 553
443static void trf7970a_send_upstream(struct trf7970a *trf) 554static int trf7970a_read_target_proto(struct trf7970a *trf, u8 *target_proto)
444{ 555{
445 u8 rssi; 556 int ret;
557 u8 buf[2];
558 u8 addr;
446 559
560 addr = TRF79070A_NFC_TARGET_PROTOCOL | TRF7970A_CMD_BIT_RW |
561 TRF7970A_CMD_BIT_CONTINUOUS;
562
563 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
564 if (ret)
565 dev_err(trf->dev, "%s - target_proto: Read failed: %d\n",
566 __func__, ret);
567 else
568 *target_proto = buf[0];
569
570 return ret;
571}
572
573static int trf7970a_mode_detect(struct trf7970a *trf, u8 *rf_tech)
574{
575 int ret;
576 u8 target_proto, tech;
577
578 ret = trf7970a_read_target_proto(trf, &target_proto);
579 if (ret)
580 return ret;
581
582 switch (target_proto) {
583 case TRF79070A_NFC_TARGET_PROTOCOL_106A:
584 tech = NFC_DIGITAL_RF_TECH_106A;
585 break;
586 case TRF79070A_NFC_TARGET_PROTOCOL_106B:
587 tech = NFC_DIGITAL_RF_TECH_106B;
588 break;
589 case TRF79070A_NFC_TARGET_PROTOCOL_212F:
590 tech = NFC_DIGITAL_RF_TECH_212F;
591 break;
592 case TRF79070A_NFC_TARGET_PROTOCOL_424F:
593 tech = NFC_DIGITAL_RF_TECH_424F;
594 break;
595 default:
596 dev_dbg(trf->dev, "%s - mode_detect: target_proto: 0x%x\n",
597 __func__, target_proto);
598 return -EIO;
599 }
600
601 *rf_tech = tech;
602
603 return ret;
604}
605
606static void trf7970a_send_upstream(struct trf7970a *trf)
607{
447 dev_kfree_skb_any(trf->tx_skb); 608 dev_kfree_skb_any(trf->tx_skb);
448 trf->tx_skb = NULL; 609 trf->tx_skb = NULL;
449 610
@@ -452,13 +613,6 @@ static void trf7970a_send_upstream(struct trf7970a *trf)
452 16, 1, trf->rx_skb->data, trf->rx_skb->len, 613 16, 1, trf->rx_skb->data, trf->rx_skb->len,
453 false); 614 false);
454 615
455 /* According to the manual it is "good form" to reset the fifo and
456 * read the RSSI levels & oscillator status register here. It doesn't
457 * explain why.
458 */
459 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
460 trf7970a_read(trf, TRF7970A_RSSI_OSC_STATUS, &rssi);
461
462 trf->state = TRF7970A_ST_IDLE; 616 trf->state = TRF7970A_ST_IDLE;
463 617
464 if (trf->aborting) { 618 if (trf->aborting) {
@@ -481,6 +635,8 @@ static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)
481{ 635{
482 dev_dbg(trf->dev, "Error - state: %d, errno: %d\n", trf->state, errno); 636 dev_dbg(trf->dev, "Error - state: %d, errno: %d\n", trf->state, errno);
483 637
638 cancel_delayed_work(&trf->timeout_work);
639
484 kfree_skb(trf->rx_skb); 640 kfree_skb(trf->rx_skb);
485 trf->rx_skb = ERR_PTR(errno); 641 trf->rx_skb = ERR_PTR(errno);
486 642
@@ -488,15 +644,29 @@ static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)
488} 644}
489 645
490static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb, 646static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,
491 unsigned int len) 647 unsigned int len, u8 *prefix, unsigned int prefix_len)
492{ 648{
649 struct spi_transfer t[2];
650 struct spi_message m;
493 unsigned int timeout; 651 unsigned int timeout;
494 int ret; 652 int ret;
495 653
496 print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE, 654 print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE,
497 16, 1, skb->data, len, false); 655 16, 1, skb->data, len, false);
498 656
499 ret = spi_write(trf->spi, skb->data, len); 657 spi_message_init(&m);
658
659 memset(&t, 0, sizeof(t));
660
661 t[0].tx_buf = prefix;
662 t[0].len = prefix_len;
663 spi_message_add_tail(&t[0], &m);
664
665 t[1].tx_buf = skb->data;
666 t[1].len = len;
667 spi_message_add_tail(&t[1], &m);
668
669 ret = spi_sync(trf->spi, &m);
500 if (ret) { 670 if (ret) {
501 dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__, 671 dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__,
502 ret); 672 ret);
@@ -514,7 +684,11 @@ static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,
514 timeout = TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF; 684 timeout = TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF;
515 } else { 685 } else {
516 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA; 686 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
517 timeout = trf->timeout; 687
688 if (!trf->timeout)
689 timeout = TRF7970A_WAIT_FOR_TX_IRQ;
690 else
691 timeout = trf->timeout;
518 } 692 }
519 } 693 }
520 694
@@ -532,6 +706,7 @@ static void trf7970a_fill_fifo(struct trf7970a *trf)
532 unsigned int len; 706 unsigned int len;
533 int ret; 707 int ret;
534 u8 fifo_bytes; 708 u8 fifo_bytes;
709 u8 prefix;
535 710
536 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes); 711 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
537 if (ret) { 712 if (ret) {
@@ -541,18 +716,21 @@ static void trf7970a_fill_fifo(struct trf7970a *trf)
541 716
542 dev_dbg(trf->dev, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes); 717 dev_dbg(trf->dev, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
543 718
544 if (fifo_bytes & TRF7970A_FIFO_STATUS_OVERFLOW) { 719 fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
545 dev_err(trf->dev, "%s - fifo overflow: 0x%x\n", __func__,
546 fifo_bytes);
547 trf7970a_send_err_upstream(trf, -EIO);
548 return;
549 }
550 720
551 /* Calculate how much more data can be written to the fifo */ 721 /* Calculate how much more data can be written to the fifo */
552 len = TRF7970A_FIFO_SIZE - fifo_bytes; 722 len = TRF7970A_FIFO_SIZE - fifo_bytes;
723 if (!len) {
724 schedule_delayed_work(&trf->timeout_work,
725 msecs_to_jiffies(TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT));
726 return;
727 }
728
553 len = min(skb->len, len); 729 len = min(skb->len, len);
554 730
555 ret = trf7970a_transmit(trf, skb, len); 731 prefix = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_FIFO_IO_REGISTER;
732
733 ret = trf7970a_transmit(trf, skb, len, &prefix, sizeof(prefix));
556 if (ret) 734 if (ret)
557 trf7970a_send_err_upstream(trf, ret); 735 trf7970a_send_err_upstream(trf, ret);
558} 736}
@@ -576,16 +754,11 @@ static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)
576 754
577 dev_dbg(trf->dev, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes); 755 dev_dbg(trf->dev, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
578 756
757 fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
758
579 if (!fifo_bytes) 759 if (!fifo_bytes)
580 goto no_rx_data; 760 goto no_rx_data;
581 761
582 if (fifo_bytes & TRF7970A_FIFO_STATUS_OVERFLOW) {
583 dev_err(trf->dev, "%s - fifo overflow: 0x%x\n", __func__,
584 fifo_bytes);
585 trf7970a_send_err_upstream(trf, -EIO);
586 return;
587 }
588
589 if (fifo_bytes > skb_tailroom(skb)) { 762 if (fifo_bytes > skb_tailroom(skb)) {
590 skb = skb_copy_expand(skb, skb_headroom(skb), 763 skb = skb_copy_expand(skb, skb_headroom(skb),
591 max_t(int, fifo_bytes, 764 max_t(int, fifo_bytes,
@@ -615,6 +788,21 @@ static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)
615 status = TRF7970A_IRQ_STATUS_SRX; 788 status = TRF7970A_IRQ_STATUS_SRX;
616 } else { 789 } else {
617 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA_CONT; 790 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA_CONT;
791
792 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
793 if (ret) {
794 trf7970a_send_err_upstream(trf, ret);
795 return;
796 }
797
798 fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
799
800 /* If there are bytes in the FIFO, set status to '0' so
801 * the if stmt below doesn't fire and the driver will wait
802 * for the trf7970a to generate another RX interrupt.
803 */
804 if (fifo_bytes)
805 status = 0;
618 } 806 }
619 807
620no_rx_data: 808no_rx_data:
@@ -634,11 +822,11 @@ static irqreturn_t trf7970a_irq(int irq, void *dev_id)
634{ 822{
635 struct trf7970a *trf = dev_id; 823 struct trf7970a *trf = dev_id;
636 int ret; 824 int ret;
637 u8 status; 825 u8 status, fifo_bytes, iso_ctrl;
638 826
639 mutex_lock(&trf->lock); 827 mutex_lock(&trf->lock);
640 828
641 if (trf->state == TRF7970A_ST_OFF) { 829 if (trf->state == TRF7970A_ST_RF_OFF) {
642 mutex_unlock(&trf->lock); 830 mutex_unlock(&trf->lock);
643 return IRQ_NONE; 831 return IRQ_NONE;
644 } 832 }
@@ -660,12 +848,12 @@ static irqreturn_t trf7970a_irq(int irq, void *dev_id)
660 switch (trf->state) { 848 switch (trf->state) {
661 case TRF7970A_ST_IDLE: 849 case TRF7970A_ST_IDLE:
662 case TRF7970A_ST_IDLE_RX_BLOCKED: 850 case TRF7970A_ST_IDLE_RX_BLOCKED:
663 /* If getting interrupts caused by RF noise, turn off the 851 /* If initiator and getting interrupts caused by RF noise,
664 * receiver to avoid unnecessary interrupts. It will be 852 * turn off the receiver to avoid unnecessary interrupts.
665 * turned back on in trf7970a_in_send_cmd() when the next 853 * It will be turned back on in trf7970a_send_cmd() when
666 * command is issued. 854 * the next command is issued.
667 */ 855 */
668 if (status & TRF7970A_IRQ_STATUS_ERROR) { 856 if (trf->is_initiator && (status & TRF7970A_IRQ_STATUS_ERROR)) {
669 trf7970a_cmd(trf, TRF7970A_CMD_BLOCK_RX); 857 trf7970a_cmd(trf, TRF7970A_CMD_BLOCK_RX);
670 trf->state = TRF7970A_ST_IDLE_RX_BLOCKED; 858 trf->state = TRF7970A_ST_IDLE_RX_BLOCKED;
671 } 859 }
@@ -687,8 +875,68 @@ static irqreturn_t trf7970a_irq(int irq, void *dev_id)
687 trf->ignore_timeout = 875 trf->ignore_timeout =
688 !cancel_delayed_work(&trf->timeout_work); 876 !cancel_delayed_work(&trf->timeout_work);
689 trf7970a_drain_fifo(trf, status); 877 trf7970a_drain_fifo(trf, status);
690 } else if (status == TRF7970A_IRQ_STATUS_TX) { 878 } else if (status & TRF7970A_IRQ_STATUS_FIFO) {
879 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS,
880 &fifo_bytes);
881
882 fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
883
884 if (ret)
885 trf7970a_send_err_upstream(trf, ret);
886 else if (!fifo_bytes)
887 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
888 } else if ((status == TRF7970A_IRQ_STATUS_TX) ||
889 (!trf->is_initiator &&
890 (status == (TRF7970A_IRQ_STATUS_TX |
891 TRF7970A_IRQ_STATUS_NFC_RF)))) {
691 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET); 892 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
893
894 if (!trf->timeout) {
895 trf->ignore_timeout = !cancel_delayed_work(
896 &trf->timeout_work);
897 trf->rx_skb = ERR_PTR(0);
898 trf7970a_send_upstream(trf);
899 break;
900 }
901
902 if (trf->is_initiator)
903 break;
904
905 iso_ctrl = trf->iso_ctrl;
906
907 switch (trf->framing) {
908 case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
909 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
910 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
911 trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
912 break;
913 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
914 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
915 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
916 trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
917 break;
918 case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:
919 ret = trf7970a_write(trf,
920 TRF7970A_SPECIAL_FCN_REG1,
921 TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL);
922 if (ret)
923 goto err_unlock_exit;
924
925 trf->special_fcn_reg1 =
926 TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL;
927 break;
928 default:
929 break;
930 }
931
932 if (iso_ctrl != trf->iso_ctrl) {
933 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
934 iso_ctrl);
935 if (ret)
936 goto err_unlock_exit;
937
938 trf->iso_ctrl = iso_ctrl;
939 }
692 } else { 940 } else {
693 trf7970a_send_err_upstream(trf, -EIO); 941 trf7970a_send_err_upstream(trf, -EIO);
694 } 942 }
@@ -697,11 +945,37 @@ static irqreturn_t trf7970a_irq(int irq, void *dev_id)
697 if (status != TRF7970A_IRQ_STATUS_TX) 945 if (status != TRF7970A_IRQ_STATUS_TX)
698 trf7970a_send_err_upstream(trf, -EIO); 946 trf7970a_send_err_upstream(trf, -EIO);
699 break; 947 break;
948 case TRF7970A_ST_LISTENING:
949 if (status & TRF7970A_IRQ_STATUS_SRX) {
950 trf->ignore_timeout =
951 !cancel_delayed_work(&trf->timeout_work);
952 trf7970a_drain_fifo(trf, status);
953 } else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {
954 trf7970a_send_err_upstream(trf, -EIO);
955 }
956 break;
957 case TRF7970A_ST_LISTENING_MD:
958 if (status & TRF7970A_IRQ_STATUS_SRX) {
959 trf->ignore_timeout =
960 !cancel_delayed_work(&trf->timeout_work);
961
962 ret = trf7970a_mode_detect(trf, &trf->md_rf_tech);
963 if (ret) {
964 trf7970a_send_err_upstream(trf, ret);
965 } else {
966 trf->state = TRF7970A_ST_LISTENING;
967 trf7970a_drain_fifo(trf, status);
968 }
969 } else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {
970 trf7970a_send_err_upstream(trf, -EIO);
971 }
972 break;
700 default: 973 default:
701 dev_err(trf->dev, "%s - Driver in invalid state: %d\n", 974 dev_err(trf->dev, "%s - Driver in invalid state: %d\n",
702 __func__, trf->state); 975 __func__, trf->state);
703 } 976 }
704 977
978err_unlock_exit:
705 mutex_unlock(&trf->lock); 979 mutex_unlock(&trf->lock);
706 return IRQ_HANDLED; 980 return IRQ_HANDLED;
707} 981}
@@ -742,7 +1016,7 @@ static void trf7970a_timeout_work_handler(struct work_struct *work)
742 if (trf->ignore_timeout) 1016 if (trf->ignore_timeout)
743 trf->ignore_timeout = false; 1017 trf->ignore_timeout = false;
744 else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT) 1018 else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT)
745 trf7970a_send_upstream(trf); /* No more rx data so send up */ 1019 trf7970a_drain_fifo(trf, TRF7970A_IRQ_STATUS_SRX);
746 else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF) 1020 else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF)
747 trf7970a_issue_eof(trf); 1021 trf7970a_issue_eof(trf);
748 else 1022 else
@@ -765,11 +1039,16 @@ static int trf7970a_init(struct trf7970a *trf)
765 if (ret) 1039 if (ret)
766 goto err_out; 1040 goto err_out;
767 1041
768 /* Must clear NFC Target Detection Level reg due to erratum */ 1042 usleep_range(1000, 2000);
769 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0); 1043
1044 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
1045
1046 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL, 0);
770 if (ret) 1047 if (ret)
771 goto err_out; 1048 goto err_out;
772 1049
1050 trf->modulator_sys_clk_ctrl = 0;
1051
773 ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS, 1052 ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS,
774 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 | 1053 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 |
775 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32); 1054 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32);
@@ -792,6 +1071,10 @@ err_out:
792 1071
793static void trf7970a_switch_rf_off(struct trf7970a *trf) 1072static void trf7970a_switch_rf_off(struct trf7970a *trf)
794{ 1073{
1074 if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1075 (trf->state == TRF7970A_ST_RF_OFF))
1076 return;
1077
795 dev_dbg(trf->dev, "Switching rf off\n"); 1078 dev_dbg(trf->dev, "Switching rf off\n");
796 1079
797 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON; 1080 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
@@ -799,24 +1082,41 @@ static void trf7970a_switch_rf_off(struct trf7970a *trf)
799 trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, trf->chip_status_ctrl); 1082 trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, trf->chip_status_ctrl);
800 1083
801 trf->aborting = false; 1084 trf->aborting = false;
802 trf->state = TRF7970A_ST_OFF; 1085 trf->state = TRF7970A_ST_RF_OFF;
803 1086
804 pm_runtime_mark_last_busy(trf->dev); 1087 pm_runtime_mark_last_busy(trf->dev);
805 pm_runtime_put_autosuspend(trf->dev); 1088 pm_runtime_put_autosuspend(trf->dev);
806} 1089}
807 1090
808static void trf7970a_switch_rf_on(struct trf7970a *trf) 1091static int trf7970a_switch_rf_on(struct trf7970a *trf)
809{ 1092{
1093 int ret;
1094
810 dev_dbg(trf->dev, "Switching rf on\n"); 1095 dev_dbg(trf->dev, "Switching rf on\n");
811 1096
812 pm_runtime_get_sync(trf->dev); 1097 pm_runtime_get_sync(trf->dev);
813 1098
1099 if (trf->state != TRF7970A_ST_RF_OFF) { /* Power on, RF off */
1100 dev_err(trf->dev, "%s - Incorrect state: %d\n", __func__,
1101 trf->state);
1102 return -EINVAL;
1103 }
1104
1105 ret = trf7970a_init(trf);
1106 if (ret) {
1107 dev_err(trf->dev, "%s - Can't initialize: %d\n", __func__, ret);
1108 return ret;
1109 }
1110
814 trf->state = TRF7970A_ST_IDLE; 1111 trf->state = TRF7970A_ST_IDLE;
1112
1113 return 0;
815} 1114}
816 1115
817static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on) 1116static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)
818{ 1117{
819 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1118 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1119 int ret = 0;
820 1120
821 dev_dbg(trf->dev, "Switching RF - state: %d, on: %d\n", trf->state, on); 1121 dev_dbg(trf->dev, "Switching RF - state: %d, on: %d\n", trf->state, on);
822 1122
@@ -824,8 +1124,9 @@ static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)
824 1124
825 if (on) { 1125 if (on) {
826 switch (trf->state) { 1126 switch (trf->state) {
827 case TRF7970A_ST_OFF: 1127 case TRF7970A_ST_PWR_OFF:
828 trf7970a_switch_rf_on(trf); 1128 case TRF7970A_ST_RF_OFF:
1129 ret = trf7970a_switch_rf_on(trf);
829 break; 1130 break;
830 case TRF7970A_ST_IDLE: 1131 case TRF7970A_ST_IDLE:
831 case TRF7970A_ST_IDLE_RX_BLOCKED: 1132 case TRF7970A_ST_IDLE_RX_BLOCKED:
@@ -834,26 +1135,31 @@ static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)
834 dev_err(trf->dev, "%s - Invalid request: %d %d\n", 1135 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
835 __func__, trf->state, on); 1136 __func__, trf->state, on);
836 trf7970a_switch_rf_off(trf); 1137 trf7970a_switch_rf_off(trf);
1138 ret = -EINVAL;
837 } 1139 }
838 } else { 1140 } else {
839 switch (trf->state) { 1141 switch (trf->state) {
840 case TRF7970A_ST_OFF: 1142 case TRF7970A_ST_PWR_OFF:
1143 case TRF7970A_ST_RF_OFF:
841 break; 1144 break;
842 default: 1145 default:
843 dev_err(trf->dev, "%s - Invalid request: %d %d\n", 1146 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
844 __func__, trf->state, on); 1147 __func__, trf->state, on);
1148 ret = -EINVAL;
845 /* FALLTHROUGH */ 1149 /* FALLTHROUGH */
846 case TRF7970A_ST_IDLE: 1150 case TRF7970A_ST_IDLE:
847 case TRF7970A_ST_IDLE_RX_BLOCKED: 1151 case TRF7970A_ST_IDLE_RX_BLOCKED:
1152 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1153 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
848 trf7970a_switch_rf_off(trf); 1154 trf7970a_switch_rf_off(trf);
849 } 1155 }
850 } 1156 }
851 1157
852 mutex_unlock(&trf->lock); 1158 mutex_unlock(&trf->lock);
853 return 0; 1159 return ret;
854} 1160}
855 1161
856static int trf7970a_config_rf_tech(struct trf7970a *trf, int tech) 1162static int trf7970a_in_config_rf_tech(struct trf7970a *trf, int tech)
857{ 1163{
858 int ret = 0; 1164 int ret = 0;
859 1165
@@ -863,22 +1169,27 @@ static int trf7970a_config_rf_tech(struct trf7970a *trf, int tech)
863 case NFC_DIGITAL_RF_TECH_106A: 1169 case NFC_DIGITAL_RF_TECH_106A:
864 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106; 1170 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106;
865 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK; 1171 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
1172 trf->guard_time = TRF7970A_GUARD_TIME_NFCA;
866 break; 1173 break;
867 case NFC_DIGITAL_RF_TECH_106B: 1174 case NFC_DIGITAL_RF_TECH_106B:
868 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106; 1175 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106;
869 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10; 1176 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1177 trf->guard_time = TRF7970A_GUARD_TIME_NFCB;
870 break; 1178 break;
871 case NFC_DIGITAL_RF_TECH_212F: 1179 case NFC_DIGITAL_RF_TECH_212F:
872 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_212; 1180 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_212;
873 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10; 1181 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1182 trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
874 break; 1183 break;
875 case NFC_DIGITAL_RF_TECH_424F: 1184 case NFC_DIGITAL_RF_TECH_424F:
876 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_424; 1185 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_424;
877 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10; 1186 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1187 trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
878 break; 1188 break;
879 case NFC_DIGITAL_RF_TECH_ISO15693: 1189 case NFC_DIGITAL_RF_TECH_ISO15693:
880 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648; 1190 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
881 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK; 1191 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
1192 trf->guard_time = TRF7970A_GUARD_TIME_15693;
882 break; 1193 break;
883 default: 1194 default:
884 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech); 1195 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
@@ -887,12 +1198,54 @@ static int trf7970a_config_rf_tech(struct trf7970a *trf, int tech)
887 1198
888 trf->technology = tech; 1199 trf->technology = tech;
889 1200
1201 /* If in initiator mode and not changing the RF tech due to a
1202 * PSL sequence (indicated by 'trf->iso_ctrl == 0xff' from
1203 * trf7970a_init()), clear the NFC Target Detection Level register
1204 * due to erratum.
1205 */
1206 if (trf->iso_ctrl == 0xff)
1207 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
1208
890 return ret; 1209 return ret;
891} 1210}
892 1211
893static int trf7970a_config_framing(struct trf7970a *trf, int framing) 1212static int trf7970a_is_rf_field(struct trf7970a *trf, bool *is_rf_field)
1213{
1214 int ret;
1215 u8 rssi;
1216
1217 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1218 trf->chip_status_ctrl | TRF7970A_CHIP_STATUS_REC_ON);
1219 if (ret)
1220 return ret;
1221
1222 ret = trf7970a_cmd(trf, TRF7970A_CMD_TEST_EXT_RF);
1223 if (ret)
1224 return ret;
1225
1226 usleep_range(50, 60);
1227
1228 ret = trf7970a_read(trf, TRF7970A_RSSI_OSC_STATUS, &rssi);
1229 if (ret)
1230 return ret;
1231
1232 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1233 trf->chip_status_ctrl);
1234 if (ret)
1235 return ret;
1236
1237 if (rssi & TRF7970A_RSSI_OSC_STATUS_RSSI_MASK)
1238 *is_rf_field = true;
1239 else
1240 *is_rf_field = false;
1241
1242 return 0;
1243}
1244
1245static int trf7970a_in_config_framing(struct trf7970a *trf, int framing)
894{ 1246{
895 u8 iso_ctrl = trf->iso_ctrl_tech; 1247 u8 iso_ctrl = trf->iso_ctrl_tech;
1248 bool is_rf_field = false;
896 int ret; 1249 int ret;
897 1250
898 dev_dbg(trf->dev, "framing: %d\n", framing); 1251 dev_dbg(trf->dev, "framing: %d\n", framing);
@@ -911,6 +1264,8 @@ static int trf7970a_config_framing(struct trf7970a *trf, int framing)
911 case NFC_DIGITAL_FRAMING_NFCF_T3T: 1264 case NFC_DIGITAL_FRAMING_NFCF_T3T:
912 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY: 1265 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY:
913 case NFC_DIGITAL_FRAMING_ISO15693_T5T: 1266 case NFC_DIGITAL_FRAMING_ISO15693_T5T:
1267 case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:
1268 case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:
914 trf->tx_cmd = TRF7970A_CMD_TRANSMIT; 1269 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
915 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N; 1270 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
916 break; 1271 break;
@@ -925,6 +1280,15 @@ static int trf7970a_config_framing(struct trf7970a *trf, int framing)
925 1280
926 trf->framing = framing; 1281 trf->framing = framing;
927 1282
1283 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1284 ret = trf7970a_is_rf_field(trf, &is_rf_field);
1285 if (ret)
1286 return ret;
1287
1288 if (is_rf_field)
1289 return -EBUSY;
1290 }
1291
928 if (iso_ctrl != trf->iso_ctrl) { 1292 if (iso_ctrl != trf->iso_ctrl) {
929 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl); 1293 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
930 if (ret) 1294 if (ret)
@@ -947,7 +1311,7 @@ static int trf7970a_config_framing(struct trf7970a *trf, int framing)
947 1311
948 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON; 1312 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
949 1313
950 usleep_range(5000, 6000); 1314 usleep_range(trf->guard_time, trf->guard_time + 1000);
951 } 1315 }
952 1316
953 return 0; 1317 return 0;
@@ -963,21 +1327,28 @@ static int trf7970a_in_configure_hw(struct nfc_digital_dev *ddev, int type,
963 1327
964 mutex_lock(&trf->lock); 1328 mutex_lock(&trf->lock);
965 1329
966 if (trf->state == TRF7970A_ST_OFF) 1330 trf->is_initiator = true;
967 trf7970a_switch_rf_on(trf); 1331
1332 if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1333 (trf->state == TRF7970A_ST_RF_OFF)) {
1334 ret = trf7970a_switch_rf_on(trf);
1335 if (ret)
1336 goto err_unlock;
1337 }
968 1338
969 switch (type) { 1339 switch (type) {
970 case NFC_DIGITAL_CONFIG_RF_TECH: 1340 case NFC_DIGITAL_CONFIG_RF_TECH:
971 ret = trf7970a_config_rf_tech(trf, param); 1341 ret = trf7970a_in_config_rf_tech(trf, param);
972 break; 1342 break;
973 case NFC_DIGITAL_CONFIG_FRAMING: 1343 case NFC_DIGITAL_CONFIG_FRAMING:
974 ret = trf7970a_config_framing(trf, param); 1344 ret = trf7970a_in_config_framing(trf, param);
975 break; 1345 break;
976 default: 1346 default:
977 dev_dbg(trf->dev, "Unknown type: %d\n", type); 1347 dev_dbg(trf->dev, "Unknown type: %d\n", type);
978 ret = -EINVAL; 1348 ret = -EINVAL;
979 } 1349 }
980 1350
1351err_unlock:
981 mutex_unlock(&trf->lock); 1352 mutex_unlock(&trf->lock);
982 return ret; 1353 return ret;
983} 1354}
@@ -1067,14 +1438,15 @@ static int trf7970a_per_cmd_config(struct trf7970a *trf, struct sk_buff *skb)
1067 return 0; 1438 return 0;
1068} 1439}
1069 1440
1070static int trf7970a_in_send_cmd(struct nfc_digital_dev *ddev, 1441static int trf7970a_send_cmd(struct nfc_digital_dev *ddev,
1071 struct sk_buff *skb, u16 timeout, 1442 struct sk_buff *skb, u16 timeout,
1072 nfc_digital_cmd_complete_t cb, void *arg) 1443 nfc_digital_cmd_complete_t cb, void *arg)
1073{ 1444{
1074 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1445 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1075 char *prefix; 1446 u8 prefix[5];
1076 unsigned int len; 1447 unsigned int len;
1077 int ret; 1448 int ret;
1449 u8 status;
1078 1450
1079 dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n", 1451 dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n",
1080 trf->state, timeout, skb->len); 1452 trf->state, timeout, skb->len);
@@ -1099,12 +1471,14 @@ static int trf7970a_in_send_cmd(struct nfc_digital_dev *ddev,
1099 goto out_err; 1471 goto out_err;
1100 } 1472 }
1101 1473
1102 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE, 1474 if (timeout) {
1103 GFP_KERNEL); 1475 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1104 if (!trf->rx_skb) { 1476 GFP_KERNEL);
1105 dev_dbg(trf->dev, "Can't alloc rx_skb\n"); 1477 if (!trf->rx_skb) {
1106 ret = -ENOMEM; 1478 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1107 goto out_err; 1479 ret = -ENOMEM;
1480 goto out_err;
1481 }
1108 } 1482 }
1109 1483
1110 if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) { 1484 if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {
@@ -1115,9 +1489,11 @@ static int trf7970a_in_send_cmd(struct nfc_digital_dev *ddev,
1115 trf->state = TRF7970A_ST_IDLE; 1489 trf->state = TRF7970A_ST_IDLE;
1116 } 1490 }
1117 1491
1118 ret = trf7970a_per_cmd_config(trf, skb); 1492 if (trf->is_initiator) {
1119 if (ret) 1493 ret = trf7970a_per_cmd_config(trf, skb);
1120 goto out_err; 1494 if (ret)
1495 goto out_err;
1496 }
1121 1497
1122 trf->ddev = ddev; 1498 trf->ddev = ddev;
1123 trf->tx_skb = skb; 1499 trf->tx_skb = skb;
@@ -1127,11 +1503,11 @@ static int trf7970a_in_send_cmd(struct nfc_digital_dev *ddev,
1127 trf->ignore_timeout = false; 1503 trf->ignore_timeout = false;
1128 1504
1129 len = skb->len; 1505 len = skb->len;
1130 prefix = skb_push(skb, TRF7970A_TX_SKB_HEADROOM);
1131 1506
1132 /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends 1507 /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
1133 * on what the current framing is, the address of the TX length byte 1 1508 * on what the current framing is, the address of the TX length byte 1
1134 * register (0x1d), and the 2 byte length of the data to be transmitted. 1509 * register (0x1d), and the 2 byte length of the data to be transmitted.
1510 * That totals 5 bytes.
1135 */ 1511 */
1136 prefix[0] = TRF7970A_CMD_BIT_CTRL | 1512 prefix[0] = TRF7970A_CMD_BIT_CTRL |
1137 TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET); 1513 TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET);
@@ -1150,9 +1526,12 @@ static int trf7970a_in_send_cmd(struct nfc_digital_dev *ddev,
1150 1526
1151 len = min_t(int, skb->len, TRF7970A_FIFO_SIZE); 1527 len = min_t(int, skb->len, TRF7970A_FIFO_SIZE);
1152 1528
1153 usleep_range(1000, 2000); 1529 /* Clear possible spurious interrupt */
1530 ret = trf7970a_read_irqstatus(trf, &status);
1531 if (ret)
1532 goto out_err;
1154 1533
1155 ret = trf7970a_transmit(trf, skb, len); 1534 ret = trf7970a_transmit(trf, skb, len, prefix, sizeof(prefix));
1156 if (ret) { 1535 if (ret) {
1157 kfree_skb(trf->rx_skb); 1536 kfree_skb(trf->rx_skb);
1158 trf->rx_skb = NULL; 1537 trf->rx_skb = NULL;
@@ -1163,46 +1542,272 @@ out_err:
1163 return ret; 1542 return ret;
1164} 1543}
1165 1544
1166static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev, 1545static int trf7970a_tg_config_rf_tech(struct trf7970a *trf, int tech)
1167 int type, int param) 1546{
1547 int ret = 0;
1548
1549 dev_dbg(trf->dev, "rf technology: %d\n", tech);
1550
1551 switch (tech) {
1552 case NFC_DIGITAL_RF_TECH_106A:
1553 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1554 TRF7970A_ISO_CTRL_NFC_CE |
1555 TRF7970A_ISO_CTRL_NFC_CE_14443A;
1556 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
1557 break;
1558 case NFC_DIGITAL_RF_TECH_212F:
1559 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1560 TRF7970A_ISO_CTRL_NFC_NFCF_212;
1561 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1562 break;
1563 case NFC_DIGITAL_RF_TECH_424F:
1564 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1565 TRF7970A_ISO_CTRL_NFC_NFCF_424;
1566 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1567 break;
1568 default:
1569 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
1570 return -EINVAL;
1571 }
1572
1573 trf->technology = tech;
1574
1575 /* Normally we write the ISO_CTRL register in
1576 * trf7970a_tg_config_framing() because the framing can change
1577 * the value written. However, when sending a PSL RES,
1578 * digital_tg_send_psl_res_complete() doesn't call
1579 * trf7970a_tg_config_framing() so we must write the register
1580 * here.
1581 */
1582 if ((trf->framing == NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED) &&
1583 (trf->iso_ctrl_tech != trf->iso_ctrl)) {
1584 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
1585 trf->iso_ctrl_tech);
1586
1587 trf->iso_ctrl = trf->iso_ctrl_tech;
1588 }
1589
1590 return ret;
1591}
1592
1593/* Since this is a target routine, several of the framing calls are
1594 * made between receiving the request and sending the response so they
1595 * should take effect until after the response is sent. This is accomplished
1596 * by skipping the ISO_CTRL register write here and doing it in the interrupt
1597 * handler.
1598 */
1599static int trf7970a_tg_config_framing(struct trf7970a *trf, int framing)
1600{
1601 u8 iso_ctrl = trf->iso_ctrl_tech;
1602 int ret;
1603
1604 dev_dbg(trf->dev, "framing: %d\n", framing);
1605
1606 switch (framing) {
1607 case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:
1608 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
1609 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
1610 break;
1611 case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
1612 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
1613 case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:
1614 /* These ones are applied in the interrupt handler */
1615 iso_ctrl = trf->iso_ctrl; /* Don't write to ISO_CTRL yet */
1616 break;
1617 case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:
1618 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1619 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
1620 break;
1621 case NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED:
1622 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1623 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
1624 break;
1625 default:
1626 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
1627 return -EINVAL;
1628 }
1629
1630 trf->framing = framing;
1631
1632 if (iso_ctrl != trf->iso_ctrl) {
1633 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1634 if (ret)
1635 return ret;
1636
1637 trf->iso_ctrl = iso_ctrl;
1638
1639 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
1640 trf->modulator_sys_clk_ctrl);
1641 if (ret)
1642 return ret;
1643 }
1644
1645 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1646 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1647 trf->chip_status_ctrl |
1648 TRF7970A_CHIP_STATUS_RF_ON);
1649 if (ret)
1650 return ret;
1651
1652 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
1653 }
1654
1655 return 0;
1656}
1657
1658static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev, int type,
1659 int param)
1660{
1661 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1662 int ret;
1663
1664 dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
1665
1666 mutex_lock(&trf->lock);
1667
1668 trf->is_initiator = false;
1669
1670 if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1671 (trf->state == TRF7970A_ST_RF_OFF)) {
1672 ret = trf7970a_switch_rf_on(trf);
1673 if (ret)
1674 goto err_unlock;
1675 }
1676
1677 switch (type) {
1678 case NFC_DIGITAL_CONFIG_RF_TECH:
1679 ret = trf7970a_tg_config_rf_tech(trf, param);
1680 break;
1681 case NFC_DIGITAL_CONFIG_FRAMING:
1682 ret = trf7970a_tg_config_framing(trf, param);
1683 break;
1684 default:
1685 dev_dbg(trf->dev, "Unknown type: %d\n", type);
1686 ret = -EINVAL;
1687 }
1688
1689err_unlock:
1690 mutex_unlock(&trf->lock);
1691 return ret;
1692}
1693
1694static int _trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
1695 nfc_digital_cmd_complete_t cb, void *arg, bool mode_detect)
1168{ 1696{
1169 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1697 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1698 int ret;
1699
1700 mutex_lock(&trf->lock);
1170 1701
1171 dev_dbg(trf->dev, "Unsupported interface\n"); 1702 if ((trf->state != TRF7970A_ST_IDLE) &&
1703 (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1704 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1705 trf->state);
1706 ret = -EIO;
1707 goto out_err;
1708 }
1172 1709
1173 return -EINVAL; 1710 if (trf->aborting) {
1711 dev_dbg(trf->dev, "Abort process complete\n");
1712 trf->aborting = false;
1713 ret = -ECANCELED;
1714 goto out_err;
1715 }
1716
1717 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1718 GFP_KERNEL);
1719 if (!trf->rx_skb) {
1720 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1721 ret = -ENOMEM;
1722 goto out_err;
1723 }
1724
1725 ret = trf7970a_write(trf, TRF7970A_RX_SPECIAL_SETTINGS,
1726 TRF7970A_RX_SPECIAL_SETTINGS_HBT |
1727 TRF7970A_RX_SPECIAL_SETTINGS_M848 |
1728 TRF7970A_RX_SPECIAL_SETTINGS_C424 |
1729 TRF7970A_RX_SPECIAL_SETTINGS_C212);
1730 if (ret)
1731 goto out_err;
1732
1733 ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL,
1734 TRF7970A_REG_IO_CTRL_VRS(0x1));
1735 if (ret)
1736 goto out_err;
1737
1738 ret = trf7970a_write(trf, TRF7970A_NFC_LOW_FIELD_LEVEL,
1739 TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(0x3));
1740 if (ret)
1741 goto out_err;
1742
1743 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL,
1744 TRF7970A_NFC_TARGET_LEVEL_RFDET(0x7));
1745 if (ret)
1746 goto out_err;
1747
1748 trf->ddev = ddev;
1749 trf->cb = cb;
1750 trf->cb_arg = arg;
1751 trf->timeout = timeout;
1752 trf->ignore_timeout = false;
1753
1754 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1755 if (ret)
1756 goto out_err;
1757
1758 trf->state = mode_detect ? TRF7970A_ST_LISTENING_MD :
1759 TRF7970A_ST_LISTENING;
1760
1761 schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
1762
1763out_err:
1764 mutex_unlock(&trf->lock);
1765 return ret;
1174} 1766}
1175 1767
1176static int trf7970a_tg_send_cmd(struct nfc_digital_dev *ddev, 1768static int trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
1177 struct sk_buff *skb, u16 timeout,
1178 nfc_digital_cmd_complete_t cb, void *arg) 1769 nfc_digital_cmd_complete_t cb, void *arg)
1179{ 1770{
1180 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1771 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1181 1772
1182 dev_dbg(trf->dev, "Unsupported interface\n"); 1773 dev_dbg(trf->dev, "Listen - state: %d, timeout: %d ms\n",
1774 trf->state, timeout);
1183 1775
1184 return -EINVAL; 1776 return _trf7970a_tg_listen(ddev, timeout, cb, arg, false);
1185} 1777}
1186 1778
1187static int trf7970a_tg_listen(struct nfc_digital_dev *ddev, 1779static int trf7970a_tg_listen_md(struct nfc_digital_dev *ddev,
1188 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg) 1780 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
1189{ 1781{
1190 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1782 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1783 int ret;
1784
1785 dev_dbg(trf->dev, "Listen MD - state: %d, timeout: %d ms\n",
1786 trf->state, timeout);
1191 1787
1192 dev_dbg(trf->dev, "Unsupported interface\n"); 1788 ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
1789 NFC_DIGITAL_RF_TECH_106A);
1790 if (ret)
1791 return ret;
1193 1792
1194 return -EINVAL; 1793 ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1794 NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
1795 if (ret)
1796 return ret;
1797
1798 return _trf7970a_tg_listen(ddev, timeout, cb, arg, true);
1195} 1799}
1196 1800
1197static int trf7970a_tg_listen_mdaa(struct nfc_digital_dev *ddev, 1801static int trf7970a_tg_get_rf_tech(struct nfc_digital_dev *ddev, u8 *rf_tech)
1198 struct digital_tg_mdaa_params *mdaa_params,
1199 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
1200{ 1802{
1201 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1803 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1202 1804
1203 dev_dbg(trf->dev, "Unsupported interface\n"); 1805 dev_dbg(trf->dev, "Get RF Tech - state: %d, rf_tech: %d\n",
1806 trf->state, trf->md_rf_tech);
1204 1807
1205 return -EINVAL; 1808 *rf_tech = trf->md_rf_tech;
1809
1810 return 0;
1206} 1811}
1207 1812
1208static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev) 1813static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)
@@ -1220,6 +1825,11 @@ static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)
1220 case TRF7970A_ST_WAIT_TO_ISSUE_EOF: 1825 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1221 trf->aborting = true; 1826 trf->aborting = true;
1222 break; 1827 break;
1828 case TRF7970A_ST_LISTENING:
1829 trf->ignore_timeout = !cancel_delayed_work(&trf->timeout_work);
1830 trf7970a_send_err_upstream(trf, -ECANCELED);
1831 dev_dbg(trf->dev, "Abort process complete\n");
1832 break;
1223 default: 1833 default:
1224 break; 1834 break;
1225 } 1835 }
@@ -1229,15 +1839,114 @@ static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)
1229 1839
1230static struct nfc_digital_ops trf7970a_nfc_ops = { 1840static struct nfc_digital_ops trf7970a_nfc_ops = {
1231 .in_configure_hw = trf7970a_in_configure_hw, 1841 .in_configure_hw = trf7970a_in_configure_hw,
1232 .in_send_cmd = trf7970a_in_send_cmd, 1842 .in_send_cmd = trf7970a_send_cmd,
1233 .tg_configure_hw = trf7970a_tg_configure_hw, 1843 .tg_configure_hw = trf7970a_tg_configure_hw,
1234 .tg_send_cmd = trf7970a_tg_send_cmd, 1844 .tg_send_cmd = trf7970a_send_cmd,
1235 .tg_listen = trf7970a_tg_listen, 1845 .tg_listen = trf7970a_tg_listen,
1236 .tg_listen_mdaa = trf7970a_tg_listen_mdaa, 1846 .tg_listen_md = trf7970a_tg_listen_md,
1847 .tg_get_rf_tech = trf7970a_tg_get_rf_tech,
1237 .switch_rf = trf7970a_switch_rf, 1848 .switch_rf = trf7970a_switch_rf,
1238 .abort_cmd = trf7970a_abort_cmd, 1849 .abort_cmd = trf7970a_abort_cmd,
1239}; 1850};
1240 1851
1852static int trf7970a_power_up(struct trf7970a *trf)
1853{
1854 int ret;
1855
1856 dev_dbg(trf->dev, "Powering up - state: %d\n", trf->state);
1857
1858 if (trf->state != TRF7970A_ST_PWR_OFF)
1859 return 0;
1860
1861 ret = regulator_enable(trf->regulator);
1862 if (ret) {
1863 dev_err(trf->dev, "%s - Can't enable VIN: %d\n", __func__, ret);
1864 return ret;
1865 }
1866
1867 usleep_range(5000, 6000);
1868
1869 if (!(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) {
1870 gpio_set_value(trf->en2_gpio, 1);
1871 usleep_range(1000, 2000);
1872 }
1873
1874 gpio_set_value(trf->en_gpio, 1);
1875
1876 usleep_range(20000, 21000);
1877
1878 trf->state = TRF7970A_ST_RF_OFF;
1879
1880 return 0;
1881}
1882
1883static int trf7970a_power_down(struct trf7970a *trf)
1884{
1885 int ret;
1886
1887 dev_dbg(trf->dev, "Powering down - state: %d\n", trf->state);
1888
1889 if (trf->state == TRF7970A_ST_PWR_OFF)
1890 return 0;
1891
1892 if (trf->state != TRF7970A_ST_RF_OFF) {
1893 dev_dbg(trf->dev, "Can't power down - not RF_OFF state (%d)\n",
1894 trf->state);
1895 return -EBUSY;
1896 }
1897
1898 gpio_set_value(trf->en_gpio, 0);
1899 gpio_set_value(trf->en2_gpio, 0);
1900
1901 ret = regulator_disable(trf->regulator);
1902 if (ret)
1903 dev_err(trf->dev, "%s - Can't disable VIN: %d\n", __func__,
1904 ret);
1905
1906 trf->state = TRF7970A_ST_PWR_OFF;
1907
1908 return ret;
1909}
1910
1911static int trf7970a_startup(struct trf7970a *trf)
1912{
1913 int ret;
1914
1915 ret = trf7970a_power_up(trf);
1916 if (ret)
1917 return ret;
1918
1919 pm_runtime_set_active(trf->dev);
1920 pm_runtime_enable(trf->dev);
1921 pm_runtime_mark_last_busy(trf->dev);
1922
1923 return 0;
1924}
1925
1926static void trf7970a_shutdown(struct trf7970a *trf)
1927{
1928 switch (trf->state) {
1929 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1930 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1931 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1932 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1933 case TRF7970A_ST_LISTENING:
1934 trf7970a_send_err_upstream(trf, -ECANCELED);
1935 /* FALLTHROUGH */
1936 case TRF7970A_ST_IDLE:
1937 case TRF7970A_ST_IDLE_RX_BLOCKED:
1938 trf7970a_switch_rf_off(trf);
1939 break;
1940 default:
1941 break;
1942 }
1943
1944 pm_runtime_disable(trf->dev);
1945 pm_runtime_set_suspended(trf->dev);
1946
1947 trf7970a_power_down(trf);
1948}
1949
1241static int trf7970a_get_autosuspend_delay(struct device_node *np) 1950static int trf7970a_get_autosuspend_delay(struct device_node *np)
1242{ 1951{
1243 int autosuspend_delay, ret; 1952 int autosuspend_delay, ret;
@@ -1246,15 +1955,18 @@ static int trf7970a_get_autosuspend_delay(struct device_node *np)
1246 if (ret) 1955 if (ret)
1247 autosuspend_delay = TRF7970A_AUTOSUSPEND_DELAY; 1956 autosuspend_delay = TRF7970A_AUTOSUSPEND_DELAY;
1248 1957
1249 of_node_put(np);
1250
1251 return autosuspend_delay; 1958 return autosuspend_delay;
1252} 1959}
1253 1960
1961static int trf7970a_get_vin_voltage_override(struct device_node *np,
1962 u32 *vin_uvolts)
1963{
1964 return of_property_read_u32(np, "vin-voltage-override", vin_uvolts);
1965}
1966
1254static int trf7970a_probe(struct spi_device *spi) 1967static int trf7970a_probe(struct spi_device *spi)
1255{ 1968{
1256 struct device_node *np = spi->dev.of_node; 1969 struct device_node *np = spi->dev.of_node;
1257 const struct spi_device_id *id = spi_get_device_id(spi);
1258 struct trf7970a *trf; 1970 struct trf7970a *trf;
1259 int uvolts, autosuspend_delay, ret; 1971 int uvolts, autosuspend_delay, ret;
1260 1972
@@ -1267,14 +1979,22 @@ static int trf7970a_probe(struct spi_device *spi)
1267 if (!trf) 1979 if (!trf)
1268 return -ENOMEM; 1980 return -ENOMEM;
1269 1981
1270 trf->state = TRF7970A_ST_OFF; 1982 trf->state = TRF7970A_ST_PWR_OFF;
1271 trf->dev = &spi->dev; 1983 trf->dev = &spi->dev;
1272 trf->spi = spi; 1984 trf->spi = spi;
1273 trf->quirks = id->driver_data;
1274 1985
1275 spi->mode = SPI_MODE_1; 1986 spi->mode = SPI_MODE_1;
1276 spi->bits_per_word = 8; 1987 spi->bits_per_word = 8;
1277 1988
1989 ret = spi_setup(spi);
1990 if (ret < 0) {
1991 dev_err(trf->dev, "Can't set up SPI Communication\n");
1992 return ret;
1993 }
1994
1995 if (of_property_read_bool(np, "irq-status-read-quirk"))
1996 trf->quirks |= TRF7970A_QUIRK_IRQ_STATUS_READ;
1997
1278 /* There are two enable pins - both must be present */ 1998 /* There are two enable pins - both must be present */
1279 trf->en_gpio = of_get_named_gpio(np, "ti,enable-gpios", 0); 1999 trf->en_gpio = of_get_named_gpio(np, "ti,enable-gpios", 0);
1280 if (!gpio_is_valid(trf->en_gpio)) { 2000 if (!gpio_is_valid(trf->en_gpio)) {
@@ -1283,7 +2003,7 @@ static int trf7970a_probe(struct spi_device *spi)
1283 } 2003 }
1284 2004
1285 ret = devm_gpio_request_one(trf->dev, trf->en_gpio, 2005 ret = devm_gpio_request_one(trf->dev, trf->en_gpio,
1286 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "EN"); 2006 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "trf7970a EN");
1287 if (ret) { 2007 if (ret) {
1288 dev_err(trf->dev, "Can't request EN GPIO: %d\n", ret); 2008 dev_err(trf->dev, "Can't request EN GPIO: %d\n", ret);
1289 return ret; 2009 return ret;
@@ -1296,12 +2016,15 @@ static int trf7970a_probe(struct spi_device *spi)
1296 } 2016 }
1297 2017
1298 ret = devm_gpio_request_one(trf->dev, trf->en2_gpio, 2018 ret = devm_gpio_request_one(trf->dev, trf->en2_gpio,
1299 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "EN2"); 2019 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "trf7970a EN2");
1300 if (ret) { 2020 if (ret) {
1301 dev_err(trf->dev, "Can't request EN2 GPIO: %d\n", ret); 2021 dev_err(trf->dev, "Can't request EN2 GPIO: %d\n", ret);
1302 return ret; 2022 return ret;
1303 } 2023 }
1304 2024
2025 if (of_property_read_bool(np, "en2-rf-quirk"))
2026 trf->quirks |= TRF7970A_QUIRK_EN2_MUST_STAY_LOW;
2027
1305 ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL, 2028 ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL,
1306 trf7970a_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT, 2029 trf7970a_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1307 "trf7970a", trf); 2030 "trf7970a", trf);
@@ -1326,15 +2049,17 @@ static int trf7970a_probe(struct spi_device *spi)
1326 goto err_destroy_lock; 2049 goto err_destroy_lock;
1327 } 2050 }
1328 2051
1329 uvolts = regulator_get_voltage(trf->regulator); 2052 ret = trf7970a_get_vin_voltage_override(np, &uvolts);
2053 if (ret)
2054 uvolts = regulator_get_voltage(trf->regulator);
1330 2055
1331 if (uvolts > 4000000) 2056 if (uvolts > 4000000)
1332 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3; 2057 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3;
1333 2058
1334 trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops, 2059 trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops,
1335 TRF7970A_SUPPORTED_PROTOCOLS, 2060 TRF7970A_SUPPORTED_PROTOCOLS,
1336 NFC_DIGITAL_DRV_CAPS_IN_CRC, TRF7970A_TX_SKB_HEADROOM, 2061 NFC_DIGITAL_DRV_CAPS_IN_CRC |
1337 0); 2062 NFC_DIGITAL_DRV_CAPS_TG_CRC, 0, 0);
1338 if (!trf->ddev) { 2063 if (!trf->ddev) {
1339 dev_err(trf->dev, "Can't allocate NFC digital device\n"); 2064 dev_err(trf->dev, "Can't allocate NFC digital device\n");
1340 ret = -ENOMEM; 2065 ret = -ENOMEM;
@@ -1349,19 +2074,23 @@ static int trf7970a_probe(struct spi_device *spi)
1349 2074
1350 pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay); 2075 pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay);
1351 pm_runtime_use_autosuspend(trf->dev); 2076 pm_runtime_use_autosuspend(trf->dev);
1352 pm_runtime_enable(trf->dev); 2077
2078 ret = trf7970a_startup(trf);
2079 if (ret)
2080 goto err_free_ddev;
1353 2081
1354 ret = nfc_digital_register_device(trf->ddev); 2082 ret = nfc_digital_register_device(trf->ddev);
1355 if (ret) { 2083 if (ret) {
1356 dev_err(trf->dev, "Can't register NFC digital device: %d\n", 2084 dev_err(trf->dev, "Can't register NFC digital device: %d\n",
1357 ret); 2085 ret);
1358 goto err_free_ddev; 2086 goto err_shutdown;
1359 } 2087 }
1360 2088
1361 return 0; 2089 return 0;
1362 2090
2091err_shutdown:
2092 trf7970a_shutdown(trf);
1363err_free_ddev: 2093err_free_ddev:
1364 pm_runtime_disable(trf->dev);
1365 nfc_digital_free_device(trf->ddev); 2094 nfc_digital_free_device(trf->ddev);
1366err_disable_regulator: 2095err_disable_regulator:
1367 regulator_disable(trf->regulator); 2096 regulator_disable(trf->regulator);
@@ -1376,25 +2105,10 @@ static int trf7970a_remove(struct spi_device *spi)
1376 2105
1377 mutex_lock(&trf->lock); 2106 mutex_lock(&trf->lock);
1378 2107
1379 switch (trf->state) { 2108 trf7970a_shutdown(trf);
1380 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1381 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1382 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1383 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1384 trf7970a_send_err_upstream(trf, -ECANCELED);
1385 /* FALLTHROUGH */
1386 case TRF7970A_ST_IDLE:
1387 case TRF7970A_ST_IDLE_RX_BLOCKED:
1388 pm_runtime_put_sync(trf->dev);
1389 break;
1390 default:
1391 break;
1392 }
1393 2109
1394 mutex_unlock(&trf->lock); 2110 mutex_unlock(&trf->lock);
1395 2111
1396 pm_runtime_disable(trf->dev);
1397
1398 nfc_digital_unregister_device(trf->ddev); 2112 nfc_digital_unregister_device(trf->ddev);
1399 nfc_digital_free_device(trf->ddev); 2113 nfc_digital_free_device(trf->ddev);
1400 2114
@@ -1405,72 +2119,83 @@ static int trf7970a_remove(struct spi_device *spi)
1405 return 0; 2119 return 0;
1406} 2120}
1407 2121
1408#ifdef CONFIG_PM_RUNTIME 2122#ifdef CONFIG_PM_SLEEP
1409static int trf7970a_pm_runtime_suspend(struct device *dev) 2123static int trf7970a_suspend(struct device *dev)
2124{
2125 struct spi_device *spi = container_of(dev, struct spi_device, dev);
2126 struct trf7970a *trf = spi_get_drvdata(spi);
2127
2128 dev_dbg(dev, "Suspend\n");
2129
2130 mutex_lock(&trf->lock);
2131
2132 trf7970a_shutdown(trf);
2133
2134 mutex_unlock(&trf->lock);
2135
2136 return 0;
2137}
2138
2139static int trf7970a_resume(struct device *dev)
1410{ 2140{
1411 struct spi_device *spi = container_of(dev, struct spi_device, dev); 2141 struct spi_device *spi = container_of(dev, struct spi_device, dev);
1412 struct trf7970a *trf = spi_get_drvdata(spi); 2142 struct trf7970a *trf = spi_get_drvdata(spi);
1413 int ret; 2143 int ret;
1414 2144
1415 dev_dbg(dev, "Runtime suspend\n"); 2145 dev_dbg(dev, "Resume\n");
1416 2146
1417 if (trf->state != TRF7970A_ST_OFF) { 2147 mutex_lock(&trf->lock);
1418 dev_dbg(dev, "Can't suspend - not in OFF state (%d)\n",
1419 trf->state);
1420 return -EBUSY;
1421 }
1422 2148
1423 gpio_set_value(trf->en_gpio, 0); 2149 ret = trf7970a_startup(trf);
1424 gpio_set_value(trf->en2_gpio, 0);
1425 2150
1426 ret = regulator_disable(trf->regulator); 2151 mutex_unlock(&trf->lock);
1427 if (ret)
1428 dev_err(dev, "%s - Can't disable VIN: %d\n", __func__, ret);
1429 2152
1430 return ret; 2153 return ret;
1431} 2154}
2155#endif
1432 2156
1433static int trf7970a_pm_runtime_resume(struct device *dev) 2157#ifdef CONFIG_PM_RUNTIME
2158static int trf7970a_pm_runtime_suspend(struct device *dev)
1434{ 2159{
1435 struct spi_device *spi = container_of(dev, struct spi_device, dev); 2160 struct spi_device *spi = container_of(dev, struct spi_device, dev);
1436 struct trf7970a *trf = spi_get_drvdata(spi); 2161 struct trf7970a *trf = spi_get_drvdata(spi);
1437 int ret; 2162 int ret;
1438 2163
1439 dev_dbg(dev, "Runtime resume\n"); 2164 dev_dbg(dev, "Runtime suspend\n");
1440 2165
1441 ret = regulator_enable(trf->regulator); 2166 mutex_lock(&trf->lock);
1442 if (ret) {
1443 dev_err(dev, "%s - Can't enable VIN: %d\n", __func__, ret);
1444 return ret;
1445 }
1446 2167
1447 usleep_range(5000, 6000); 2168 ret = trf7970a_power_down(trf);
1448 2169
1449 gpio_set_value(trf->en2_gpio, 1); 2170 mutex_unlock(&trf->lock);
1450 usleep_range(1000, 2000);
1451 gpio_set_value(trf->en_gpio, 1);
1452 2171
1453 usleep_range(20000, 21000); 2172 return ret;
2173}
1454 2174
1455 ret = trf7970a_init(trf); 2175static int trf7970a_pm_runtime_resume(struct device *dev)
1456 if (ret) { 2176{
1457 dev_err(dev, "%s - Can't initialize: %d\n", __func__, ret); 2177 struct spi_device *spi = container_of(dev, struct spi_device, dev);
1458 return ret; 2178 struct trf7970a *trf = spi_get_drvdata(spi);
1459 } 2179 int ret;
1460 2180
1461 pm_runtime_mark_last_busy(dev); 2181 dev_dbg(dev, "Runtime resume\n");
1462 2182
1463 return 0; 2183 ret = trf7970a_power_up(trf);
2184 if (!ret)
2185 pm_runtime_mark_last_busy(dev);
2186
2187 return ret;
1464} 2188}
1465#endif 2189#endif
1466 2190
1467static const struct dev_pm_ops trf7970a_pm_ops = { 2191static const struct dev_pm_ops trf7970a_pm_ops = {
2192 SET_SYSTEM_SLEEP_PM_OPS(trf7970a_suspend, trf7970a_resume)
1468 SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend, 2193 SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend,
1469 trf7970a_pm_runtime_resume, NULL) 2194 trf7970a_pm_runtime_resume, NULL)
1470}; 2195};
1471 2196
1472static const struct spi_device_id trf7970a_id_table[] = { 2197static const struct spi_device_id trf7970a_id_table[] = {
1473 { "trf7970a", TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA }, 2198 { "trf7970a", 0 },
1474 { } 2199 { }
1475}; 2200};
1476MODULE_DEVICE_TABLE(spi, trf7970a_id_table); 2201MODULE_DEVICE_TABLE(spi, trf7970a_id_table);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-18 08:44:18 -0500