Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Driver for NXP PN533 NFC Chip - core functions
0004  *
0005  * Copyright (C) 2011 Instituto Nokia de Tecnologia
0006  * Copyright (C) 2012-2013 Tieto Poland
0007  */
0008 
0009 #include <linux/device.h>
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/slab.h>
0013 #include <linux/nfc.h>
0014 #include <linux/netdevice.h>
0015 #include <net/nfc/nfc.h>
0016 #include "pn533.h"
0017 
0018 #define VERSION "0.3"
0019 
0020 /* How much time we spend listening for initiators */
0021 #define PN533_LISTEN_TIME 2
0022 /* Delay between each poll frame (ms) */
0023 #define PN533_POLL_INTERVAL 10
0024 
0025 /* structs for pn533 commands */
0026 
0027 /* PN533_CMD_GET_FIRMWARE_VERSION */
0028 struct pn533_fw_version {
0029     u8 ic;
0030     u8 ver;
0031     u8 rev;
0032     u8 support;
0033 };
0034 
0035 /* PN533_CMD_RF_CONFIGURATION */
0036 #define PN533_CFGITEM_RF_FIELD    0x01
0037 #define PN533_CFGITEM_TIMING      0x02
0038 #define PN533_CFGITEM_MAX_RETRIES 0x05
0039 #define PN533_CFGITEM_PASORI      0x82
0040 
0041 #define PN533_CFGITEM_RF_FIELD_AUTO_RFCA 0x2
0042 #define PN533_CFGITEM_RF_FIELD_ON        0x1
0043 #define PN533_CFGITEM_RF_FIELD_OFF       0x0
0044 
0045 #define PN533_CONFIG_TIMING_102 0xb
0046 #define PN533_CONFIG_TIMING_204 0xc
0047 #define PN533_CONFIG_TIMING_409 0xd
0048 #define PN533_CONFIG_TIMING_819 0xe
0049 
0050 #define PN533_CONFIG_MAX_RETRIES_NO_RETRY 0x00
0051 #define PN533_CONFIG_MAX_RETRIES_ENDLESS 0xFF
0052 
0053 struct pn533_config_max_retries {
0054     u8 mx_rty_atr;
0055     u8 mx_rty_psl;
0056     u8 mx_rty_passive_act;
0057 } __packed;
0058 
0059 struct pn533_config_timing {
0060     u8 rfu;
0061     u8 atr_res_timeout;
0062     u8 dep_timeout;
0063 } __packed;
0064 
0065 /* PN533_CMD_IN_LIST_PASSIVE_TARGET */
0066 
0067 /* felica commands opcode */
0068 #define PN533_FELICA_OPC_SENSF_REQ 0
0069 #define PN533_FELICA_OPC_SENSF_RES 1
0070 /* felica SENSF_REQ parameters */
0071 #define PN533_FELICA_SENSF_SC_ALL 0xFFFF
0072 #define PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE 0
0073 #define PN533_FELICA_SENSF_RC_SYSTEM_CODE 1
0074 #define PN533_FELICA_SENSF_RC_ADVANCED_PROTOCOL 2
0075 
0076 /* type B initiator_data values */
0077 #define PN533_TYPE_B_AFI_ALL_FAMILIES 0
0078 #define PN533_TYPE_B_POLL_METHOD_TIMESLOT 0
0079 #define PN533_TYPE_B_POLL_METHOD_PROBABILISTIC 1
0080 
0081 union pn533_cmd_poll_initdata {
0082     struct {
0083         u8 afi;
0084         u8 polling_method;
0085     } __packed type_b;
0086     struct {
0087         u8 opcode;
0088         __be16 sc;
0089         u8 rc;
0090         u8 tsn;
0091     } __packed felica;
0092 };
0093 
0094 struct pn533_poll_modulations {
0095     struct {
0096         u8 maxtg;
0097         u8 brty;
0098         union pn533_cmd_poll_initdata initiator_data;
0099     } __packed data;
0100     u8 len;
0101 };
0102 
0103 static const struct pn533_poll_modulations poll_mod[] = {
0104     [PN533_POLL_MOD_106KBPS_A] = {
0105         .data = {
0106             .maxtg = 1,
0107             .brty = 0,
0108         },
0109         .len = 2,
0110     },
0111     [PN533_POLL_MOD_212KBPS_FELICA] = {
0112         .data = {
0113             .maxtg = 1,
0114             .brty = 1,
0115             .initiator_data.felica = {
0116                 .opcode = PN533_FELICA_OPC_SENSF_REQ,
0117                 .sc = PN533_FELICA_SENSF_SC_ALL,
0118                 .rc = PN533_FELICA_SENSF_RC_SYSTEM_CODE,
0119                 .tsn = 0x03,
0120             },
0121         },
0122         .len = 7,
0123     },
0124     [PN533_POLL_MOD_424KBPS_FELICA] = {
0125         .data = {
0126             .maxtg = 1,
0127             .brty = 2,
0128             .initiator_data.felica = {
0129                 .opcode = PN533_FELICA_OPC_SENSF_REQ,
0130                 .sc = PN533_FELICA_SENSF_SC_ALL,
0131                 .rc = PN533_FELICA_SENSF_RC_SYSTEM_CODE,
0132                 .tsn = 0x03,
0133             },
0134          },
0135         .len = 7,
0136     },
0137     [PN533_POLL_MOD_106KBPS_JEWEL] = {
0138         .data = {
0139             .maxtg = 1,
0140             .brty = 4,
0141         },
0142         .len = 2,
0143     },
0144     [PN533_POLL_MOD_847KBPS_B] = {
0145         .data = {
0146             .maxtg = 1,
0147             .brty = 8,
0148             .initiator_data.type_b = {
0149                 .afi = PN533_TYPE_B_AFI_ALL_FAMILIES,
0150                 .polling_method =
0151                     PN533_TYPE_B_POLL_METHOD_TIMESLOT,
0152             },
0153         },
0154         .len = 3,
0155     },
0156     [PN533_LISTEN_MOD] = {
0157         .len = 0,
0158     },
0159 };
0160 
0161 /* PN533_CMD_IN_ATR */
0162 
0163 struct pn533_cmd_activate_response {
0164     u8 status;
0165     u8 nfcid3t[10];
0166     u8 didt;
0167     u8 bst;
0168     u8 brt;
0169     u8 to;
0170     u8 ppt;
0171     /* optional */
0172     u8 gt[];
0173 } __packed;
0174 
0175 struct pn533_cmd_jump_dep_response {
0176     u8 status;
0177     u8 tg;
0178     u8 nfcid3t[10];
0179     u8 didt;
0180     u8 bst;
0181     u8 brt;
0182     u8 to;
0183     u8 ppt;
0184     /* optional */
0185     u8 gt[];
0186 } __packed;
0187 
0188 struct pn532_autopoll_resp {
0189     u8 type;
0190     u8 ln;
0191     u8 tg;
0192     u8 tgdata[];
0193 };
0194 
0195 /* PN532_CMD_IN_AUTOPOLL */
0196 #define PN532_AUTOPOLL_POLLNR_INFINITE  0xff
0197 #define PN532_AUTOPOLL_PERIOD       0x03 /* in units of 150 ms */
0198 
0199 #define PN532_AUTOPOLL_TYPE_GENERIC_106     0x00
0200 #define PN532_AUTOPOLL_TYPE_GENERIC_212     0x01
0201 #define PN532_AUTOPOLL_TYPE_GENERIC_424     0x02
0202 #define PN532_AUTOPOLL_TYPE_JEWEL       0x04
0203 #define PN532_AUTOPOLL_TYPE_MIFARE      0x10
0204 #define PN532_AUTOPOLL_TYPE_FELICA212       0x11
0205 #define PN532_AUTOPOLL_TYPE_FELICA424       0x12
0206 #define PN532_AUTOPOLL_TYPE_ISOA        0x20
0207 #define PN532_AUTOPOLL_TYPE_ISOB        0x23
0208 #define PN532_AUTOPOLL_TYPE_DEP_PASSIVE_106 0x40
0209 #define PN532_AUTOPOLL_TYPE_DEP_PASSIVE_212 0x41
0210 #define PN532_AUTOPOLL_TYPE_DEP_PASSIVE_424 0x42
0211 #define PN532_AUTOPOLL_TYPE_DEP_ACTIVE_106  0x80
0212 #define PN532_AUTOPOLL_TYPE_DEP_ACTIVE_212  0x81
0213 #define PN532_AUTOPOLL_TYPE_DEP_ACTIVE_424  0x82
0214 
0215 /* PN533_TG_INIT_AS_TARGET */
0216 #define PN533_INIT_TARGET_PASSIVE 0x1
0217 #define PN533_INIT_TARGET_DEP 0x2
0218 
0219 #define PN533_INIT_TARGET_RESP_FRAME_MASK 0x3
0220 #define PN533_INIT_TARGET_RESP_ACTIVE     0x1
0221 #define PN533_INIT_TARGET_RESP_DEP        0x4
0222 
0223 /* The rule: value(high byte) + value(low byte) + checksum = 0 */
0224 static inline u8 pn533_ext_checksum(u16 value)
0225 {
0226     return ~(u8)(((value & 0xFF00) >> 8) + (u8)(value & 0xFF)) + 1;
0227 }
0228 
0229 /* The rule: value + checksum = 0 */
0230 static inline u8 pn533_std_checksum(u8 value)
0231 {
0232     return ~value + 1;
0233 }
0234 
0235 /* The rule: sum(data elements) + checksum = 0 */
0236 static u8 pn533_std_data_checksum(u8 *data, int datalen)
0237 {
0238     u8 sum = 0;
0239     int i;
0240 
0241     for (i = 0; i < datalen; i++)
0242         sum += data[i];
0243 
0244     return pn533_std_checksum(sum);
0245 }
0246 
0247 static void pn533_std_tx_frame_init(void *_frame, u8 cmd_code)
0248 {
0249     struct pn533_std_frame *frame = _frame;
0250 
0251     frame->preamble = 0;
0252     frame->start_frame = cpu_to_be16(PN533_STD_FRAME_SOF);
0253     PN533_STD_FRAME_IDENTIFIER(frame) = PN533_STD_FRAME_DIR_OUT;
0254     PN533_FRAME_CMD(frame) = cmd_code;
0255     frame->datalen = 2;
0256 }
0257 
0258 static void pn533_std_tx_frame_finish(void *_frame)
0259 {
0260     struct pn533_std_frame *frame = _frame;
0261 
0262     frame->datalen_checksum = pn533_std_checksum(frame->datalen);
0263 
0264     PN533_STD_FRAME_CHECKSUM(frame) =
0265         pn533_std_data_checksum(frame->data, frame->datalen);
0266 
0267     PN533_STD_FRAME_POSTAMBLE(frame) = 0;
0268 }
0269 
0270 static void pn533_std_tx_update_payload_len(void *_frame, int len)
0271 {
0272     struct pn533_std_frame *frame = _frame;
0273 
0274     frame->datalen += len;
0275 }
0276 
0277 static bool pn533_std_rx_frame_is_valid(void *_frame, struct pn533 *dev)
0278 {
0279     u8 checksum;
0280     struct pn533_std_frame *stdf = _frame;
0281 
0282     if (stdf->start_frame != cpu_to_be16(PN533_STD_FRAME_SOF))
0283         return false;
0284 
0285     if (likely(!PN533_STD_IS_EXTENDED(stdf))) {
0286         /* Standard frame code */
0287         dev->ops->rx_header_len = PN533_STD_FRAME_HEADER_LEN;
0288 
0289         checksum = pn533_std_checksum(stdf->datalen);
0290         if (checksum != stdf->datalen_checksum)
0291             return false;
0292 
0293         checksum = pn533_std_data_checksum(stdf->data, stdf->datalen);
0294         if (checksum != PN533_STD_FRAME_CHECKSUM(stdf))
0295             return false;
0296     } else {
0297         /* Extended */
0298         struct pn533_ext_frame *eif = _frame;
0299 
0300         dev->ops->rx_header_len = PN533_EXT_FRAME_HEADER_LEN;
0301 
0302         checksum = pn533_ext_checksum(be16_to_cpu(eif->datalen));
0303         if (checksum != eif->datalen_checksum)
0304             return false;
0305 
0306         /* check data checksum */
0307         checksum = pn533_std_data_checksum(eif->data,
0308                            be16_to_cpu(eif->datalen));
0309         if (checksum != PN533_EXT_FRAME_CHECKSUM(eif))
0310             return false;
0311     }
0312 
0313     return true;
0314 }
0315 
0316 bool pn533_rx_frame_is_ack(void *_frame)
0317 {
0318     struct pn533_std_frame *frame = _frame;
0319 
0320     if (frame->start_frame != cpu_to_be16(PN533_STD_FRAME_SOF))
0321         return false;
0322 
0323     if (frame->datalen != 0 || frame->datalen_checksum != 0xFF)
0324         return false;
0325 
0326     return true;
0327 }
0328 EXPORT_SYMBOL_GPL(pn533_rx_frame_is_ack);
0329 
0330 static inline int pn533_std_rx_frame_size(void *frame)
0331 {
0332     struct pn533_std_frame *f = frame;
0333 
0334     /* check for Extended Information frame */
0335     if (PN533_STD_IS_EXTENDED(f)) {
0336         struct pn533_ext_frame *eif = frame;
0337 
0338         return sizeof(struct pn533_ext_frame)
0339             + be16_to_cpu(eif->datalen) + PN533_STD_FRAME_TAIL_LEN;
0340     }
0341 
0342     return sizeof(struct pn533_std_frame) + f->datalen +
0343            PN533_STD_FRAME_TAIL_LEN;
0344 }
0345 
0346 static u8 pn533_std_get_cmd_code(void *frame)
0347 {
0348     struct pn533_std_frame *f = frame;
0349     struct pn533_ext_frame *eif = frame;
0350 
0351     if (PN533_STD_IS_EXTENDED(f))
0352         return PN533_FRAME_CMD(eif);
0353     else
0354         return PN533_FRAME_CMD(f);
0355 }
0356 
0357 bool pn533_rx_frame_is_cmd_response(struct pn533 *dev, void *frame)
0358 {
0359     return (dev->ops->get_cmd_code(frame) ==
0360                 PN533_CMD_RESPONSE(dev->cmd->code));
0361 }
0362 EXPORT_SYMBOL_GPL(pn533_rx_frame_is_cmd_response);
0363 
0364 
0365 static struct pn533_frame_ops pn533_std_frame_ops = {
0366     .tx_frame_init = pn533_std_tx_frame_init,
0367     .tx_frame_finish = pn533_std_tx_frame_finish,
0368     .tx_update_payload_len = pn533_std_tx_update_payload_len,
0369     .tx_header_len = PN533_STD_FRAME_HEADER_LEN,
0370     .tx_tail_len = PN533_STD_FRAME_TAIL_LEN,
0371 
0372     .rx_is_frame_valid = pn533_std_rx_frame_is_valid,
0373     .rx_frame_size = pn533_std_rx_frame_size,
0374     .rx_header_len = PN533_STD_FRAME_HEADER_LEN,
0375     .rx_tail_len = PN533_STD_FRAME_TAIL_LEN,
0376 
0377     .max_payload_len =  PN533_STD_FRAME_MAX_PAYLOAD_LEN,
0378     .get_cmd_code = pn533_std_get_cmd_code,
0379 };
0380 
0381 static void pn533_build_cmd_frame(struct pn533 *dev, u8 cmd_code,
0382                   struct sk_buff *skb)
0383 {
0384     /* payload is already there, just update datalen */
0385     int payload_len = skb->len;
0386     struct pn533_frame_ops *ops = dev->ops;
0387 
0388 
0389     skb_push(skb, ops->tx_header_len);
0390     skb_put(skb, ops->tx_tail_len);
0391 
0392     ops->tx_frame_init(skb->data, cmd_code);
0393     ops->tx_update_payload_len(skb->data, payload_len);
0394     ops->tx_frame_finish(skb->data);
0395 }
0396 
0397 static int pn533_send_async_complete(struct pn533 *dev)
0398 {
0399     struct pn533_cmd *cmd = dev->cmd;
0400     struct sk_buff *resp;
0401     int status, rc = 0;
0402 
0403     if (!cmd) {
0404         dev_dbg(dev->dev, "%s: cmd not set\n", __func__);
0405         goto done;
0406     }
0407 
0408     dev_kfree_skb(cmd->req);
0409 
0410     status = cmd->status;
0411     resp = cmd->resp;
0412 
0413     if (status < 0) {
0414         rc = cmd->complete_cb(dev, cmd->complete_cb_context,
0415                       ERR_PTR(status));
0416         dev_kfree_skb(resp);
0417         goto done;
0418     }
0419 
0420     /* when no response is set we got interrupted */
0421     if (!resp)
0422         resp = ERR_PTR(-EINTR);
0423 
0424     if (!IS_ERR(resp)) {
0425         skb_pull(resp, dev->ops->rx_header_len);
0426         skb_trim(resp, resp->len - dev->ops->rx_tail_len);
0427     }
0428 
0429     rc = cmd->complete_cb(dev, cmd->complete_cb_context, resp);
0430 
0431 done:
0432     kfree(cmd);
0433     dev->cmd = NULL;
0434     return rc;
0435 }
0436 
0437 static int __pn533_send_async(struct pn533 *dev, u8 cmd_code,
0438                   struct sk_buff *req,
0439                   pn533_send_async_complete_t complete_cb,
0440                   void *complete_cb_context)
0441 {
0442     struct pn533_cmd *cmd;
0443     int rc = 0;
0444 
0445     dev_dbg(dev->dev, "Sending command 0x%x\n", cmd_code);
0446 
0447     cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
0448     if (!cmd)
0449         return -ENOMEM;
0450 
0451     cmd->code = cmd_code;
0452     cmd->req = req;
0453     cmd->complete_cb = complete_cb;
0454     cmd->complete_cb_context = complete_cb_context;
0455 
0456     pn533_build_cmd_frame(dev, cmd_code, req);
0457 
0458     mutex_lock(&dev->cmd_lock);
0459 
0460     if (!dev->cmd_pending) {
0461         dev->cmd = cmd;
0462         rc = dev->phy_ops->send_frame(dev, req);
0463         if (rc) {
0464             dev->cmd = NULL;
0465             goto error;
0466         }
0467 
0468         dev->cmd_pending = 1;
0469         goto unlock;
0470     }
0471 
0472     dev_dbg(dev->dev, "%s Queueing command 0x%x\n",
0473         __func__, cmd_code);
0474 
0475     INIT_LIST_HEAD(&cmd->queue);
0476     list_add_tail(&cmd->queue, &dev->cmd_queue);
0477 
0478     goto unlock;
0479 
0480 error:
0481     kfree(cmd);
0482 unlock:
0483     mutex_unlock(&dev->cmd_lock);
0484     return rc;
0485 }
0486 
0487 static int pn533_send_data_async(struct pn533 *dev, u8 cmd_code,
0488                  struct sk_buff *req,
0489                  pn533_send_async_complete_t complete_cb,
0490                  void *complete_cb_context)
0491 {
0492     return __pn533_send_async(dev, cmd_code, req, complete_cb,
0493                 complete_cb_context);
0494 }
0495 
0496 static int pn533_send_cmd_async(struct pn533 *dev, u8 cmd_code,
0497                 struct sk_buff *req,
0498                 pn533_send_async_complete_t complete_cb,
0499                 void *complete_cb_context)
0500 {
0501     return __pn533_send_async(dev, cmd_code, req, complete_cb,
0502                 complete_cb_context);
0503 }
0504 
0505 /*
0506  * pn533_send_cmd_direct_async
0507  *
0508  * The function sends a priority cmd directly to the chip omitting the cmd
0509  * queue. It's intended to be used by chaining mechanism of received responses
0510  * where the host has to request every single chunk of data before scheduling
0511  * next cmd from the queue.
0512  */
0513 static int pn533_send_cmd_direct_async(struct pn533 *dev, u8 cmd_code,
0514                        struct sk_buff *req,
0515                        pn533_send_async_complete_t complete_cb,
0516                        void *complete_cb_context)
0517 {
0518     struct pn533_cmd *cmd;
0519     int rc;
0520 
0521     cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
0522     if (!cmd)
0523         return -ENOMEM;
0524 
0525     cmd->code = cmd_code;
0526     cmd->req = req;
0527     cmd->complete_cb = complete_cb;
0528     cmd->complete_cb_context = complete_cb_context;
0529 
0530     pn533_build_cmd_frame(dev, cmd_code, req);
0531 
0532     dev->cmd = cmd;
0533     rc = dev->phy_ops->send_frame(dev, req);
0534     if (rc < 0) {
0535         dev->cmd = NULL;
0536         kfree(cmd);
0537     }
0538 
0539     return rc;
0540 }
0541 
0542 static void pn533_wq_cmd_complete(struct work_struct *work)
0543 {
0544     struct pn533 *dev = container_of(work, struct pn533, cmd_complete_work);
0545     int rc;
0546 
0547     rc = pn533_send_async_complete(dev);
0548     if (rc != -EINPROGRESS)
0549         queue_work(dev->wq, &dev->cmd_work);
0550 }
0551 
0552 static void pn533_wq_cmd(struct work_struct *work)
0553 {
0554     struct pn533 *dev = container_of(work, struct pn533, cmd_work);
0555     struct pn533_cmd *cmd;
0556     int rc;
0557 
0558     mutex_lock(&dev->cmd_lock);
0559 
0560     if (list_empty(&dev->cmd_queue)) {
0561         dev->cmd_pending = 0;
0562         mutex_unlock(&dev->cmd_lock);
0563         return;
0564     }
0565 
0566     cmd = list_first_entry(&dev->cmd_queue, struct pn533_cmd, queue);
0567 
0568     list_del(&cmd->queue);
0569 
0570     mutex_unlock(&dev->cmd_lock);
0571 
0572     dev->cmd = cmd;
0573     rc = dev->phy_ops->send_frame(dev, cmd->req);
0574     if (rc < 0) {
0575         dev->cmd = NULL;
0576         dev_kfree_skb(cmd->req);
0577         kfree(cmd);
0578         return;
0579     }
0580 
0581 }
0582 
0583 struct pn533_sync_cmd_response {
0584     struct sk_buff *resp;
0585     struct completion done;
0586 };
0587 
0588 static int pn533_send_sync_complete(struct pn533 *dev, void *_arg,
0589                     struct sk_buff *resp)
0590 {
0591     struct pn533_sync_cmd_response *arg = _arg;
0592 
0593     arg->resp = resp;
0594     complete(&arg->done);
0595 
0596     return 0;
0597 }
0598 
0599 /*  pn533_send_cmd_sync
0600  *
0601  *  Please note the req parameter is freed inside the function to
0602  *  limit a number of return value interpretations by the caller.
0603  *
0604  *  1. negative in case of error during TX path -> req should be freed
0605  *
0606  *  2. negative in case of error during RX path -> req should not be freed
0607  *     as it's been already freed at the beginning of RX path by
0608  *     async_complete_cb.
0609  *
0610  *  3. valid pointer in case of successful RX path
0611  *
0612  *  A caller has to check a return value with IS_ERR macro. If the test pass,
0613  *  the returned pointer is valid.
0614  *
0615  */
0616 static struct sk_buff *pn533_send_cmd_sync(struct pn533 *dev, u8 cmd_code,
0617                            struct sk_buff *req)
0618 {
0619     int rc;
0620     struct pn533_sync_cmd_response arg;
0621 
0622     init_completion(&arg.done);
0623 
0624     rc = pn533_send_cmd_async(dev, cmd_code, req,
0625                   pn533_send_sync_complete, &arg);
0626     if (rc) {
0627         dev_kfree_skb(req);
0628         return ERR_PTR(rc);
0629     }
0630 
0631     wait_for_completion(&arg.done);
0632 
0633     return arg.resp;
0634 }
0635 
0636 static struct sk_buff *pn533_alloc_skb(struct pn533 *dev, unsigned int size)
0637 {
0638     struct sk_buff *skb;
0639 
0640     skb = alloc_skb(dev->ops->tx_header_len +
0641             size +
0642             dev->ops->tx_tail_len, GFP_KERNEL);
0643 
0644     if (skb)
0645         skb_reserve(skb, dev->ops->tx_header_len);
0646 
0647     return skb;
0648 }
0649 
0650 struct pn533_target_type_a {
0651     __be16 sens_res;
0652     u8 sel_res;
0653     u8 nfcid_len;
0654     u8 nfcid_data[];
0655 } __packed;
0656 
0657 
0658 #define PN533_TYPE_A_SENS_RES_NFCID1(x) ((u8)((be16_to_cpu(x) & 0x00C0) >> 6))
0659 #define PN533_TYPE_A_SENS_RES_SSD(x) ((u8)((be16_to_cpu(x) & 0x001F) >> 0))
0660 #define PN533_TYPE_A_SENS_RES_PLATCONF(x) ((u8)((be16_to_cpu(x) & 0x0F00) >> 8))
0661 
0662 #define PN533_TYPE_A_SENS_RES_SSD_JEWEL 0x00
0663 #define PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL 0x0C
0664 
0665 #define PN533_TYPE_A_SEL_PROT(x) (((x) & 0x60) >> 5)
0666 #define PN533_TYPE_A_SEL_CASCADE(x) (((x) & 0x04) >> 2)
0667 
0668 #define PN533_TYPE_A_SEL_PROT_MIFARE 0
0669 #define PN533_TYPE_A_SEL_PROT_ISO14443 1
0670 #define PN533_TYPE_A_SEL_PROT_DEP 2
0671 #define PN533_TYPE_A_SEL_PROT_ISO14443_DEP 3
0672 
0673 static bool pn533_target_type_a_is_valid(struct pn533_target_type_a *type_a,
0674                             int target_data_len)
0675 {
0676     u8 ssd;
0677     u8 platconf;
0678 
0679     if (target_data_len < sizeof(struct pn533_target_type_a))
0680         return false;
0681 
0682     /*
0683      * The length check of nfcid[] and ats[] are not being performed because
0684      * the values are not being used
0685      */
0686 
0687     /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
0688     ssd = PN533_TYPE_A_SENS_RES_SSD(type_a->sens_res);
0689     platconf = PN533_TYPE_A_SENS_RES_PLATCONF(type_a->sens_res);
0690 
0691     if ((ssd == PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
0692          platconf != PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL) ||
0693         (ssd != PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
0694          platconf == PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL))
0695         return false;
0696 
0697     /* Requirements 4.8.2.1, 4.8.2.3, 4.8.2.5 and 4.8.2.7 from NFC Forum */
0698     if (PN533_TYPE_A_SEL_CASCADE(type_a->sel_res) != 0)
0699         return false;
0700 
0701     if (type_a->nfcid_len > NFC_NFCID1_MAXSIZE)
0702         return false;
0703 
0704     return true;
0705 }
0706 
0707 static int pn533_target_found_type_a(struct nfc_target *nfc_tgt, u8 *tgt_data,
0708                             int tgt_data_len)
0709 {
0710     struct pn533_target_type_a *tgt_type_a;
0711 
0712     tgt_type_a = (struct pn533_target_type_a *)tgt_data;
0713 
0714     if (!pn533_target_type_a_is_valid(tgt_type_a, tgt_data_len))
0715         return -EPROTO;
0716 
0717     switch (PN533_TYPE_A_SEL_PROT(tgt_type_a->sel_res)) {
0718     case PN533_TYPE_A_SEL_PROT_MIFARE:
0719         nfc_tgt->supported_protocols = NFC_PROTO_MIFARE_MASK;
0720         break;
0721     case PN533_TYPE_A_SEL_PROT_ISO14443:
0722         nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_MASK;
0723         break;
0724     case PN533_TYPE_A_SEL_PROT_DEP:
0725         nfc_tgt->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
0726         break;
0727     case PN533_TYPE_A_SEL_PROT_ISO14443_DEP:
0728         nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_MASK |
0729                             NFC_PROTO_NFC_DEP_MASK;
0730         break;
0731     }
0732 
0733     nfc_tgt->sens_res = be16_to_cpu(tgt_type_a->sens_res);
0734     nfc_tgt->sel_res = tgt_type_a->sel_res;
0735     nfc_tgt->nfcid1_len = tgt_type_a->nfcid_len;
0736     memcpy(nfc_tgt->nfcid1, tgt_type_a->nfcid_data, nfc_tgt->nfcid1_len);
0737 
0738     return 0;
0739 }
0740 
0741 struct pn533_target_felica {
0742     u8 pol_res;
0743     u8 opcode;
0744     u8 nfcid2[NFC_NFCID2_MAXSIZE];
0745     u8 pad[8];
0746     /* optional */
0747     u8 syst_code[];
0748 } __packed;
0749 
0750 #define PN533_FELICA_SENSF_NFCID2_DEP_B1 0x01
0751 #define PN533_FELICA_SENSF_NFCID2_DEP_B2 0xFE
0752 
0753 static bool pn533_target_felica_is_valid(struct pn533_target_felica *felica,
0754                             int target_data_len)
0755 {
0756     if (target_data_len < sizeof(struct pn533_target_felica))
0757         return false;
0758 
0759     if (felica->opcode != PN533_FELICA_OPC_SENSF_RES)
0760         return false;
0761 
0762     return true;
0763 }
0764 
0765 static int pn533_target_found_felica(struct nfc_target *nfc_tgt, u8 *tgt_data,
0766                             int tgt_data_len)
0767 {
0768     struct pn533_target_felica *tgt_felica;
0769 
0770     tgt_felica = (struct pn533_target_felica *)tgt_data;
0771 
0772     if (!pn533_target_felica_is_valid(tgt_felica, tgt_data_len))
0773         return -EPROTO;
0774 
0775     if ((tgt_felica->nfcid2[0] == PN533_FELICA_SENSF_NFCID2_DEP_B1) &&
0776         (tgt_felica->nfcid2[1] == PN533_FELICA_SENSF_NFCID2_DEP_B2))
0777         nfc_tgt->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
0778     else
0779         nfc_tgt->supported_protocols = NFC_PROTO_FELICA_MASK;
0780 
0781     memcpy(nfc_tgt->sensf_res, &tgt_felica->opcode, 9);
0782     nfc_tgt->sensf_res_len = 9;
0783 
0784     memcpy(nfc_tgt->nfcid2, tgt_felica->nfcid2, NFC_NFCID2_MAXSIZE);
0785     nfc_tgt->nfcid2_len = NFC_NFCID2_MAXSIZE;
0786 
0787     return 0;
0788 }
0789 
0790 struct pn533_target_jewel {
0791     __be16 sens_res;
0792     u8 jewelid[4];
0793 } __packed;
0794 
0795 static bool pn533_target_jewel_is_valid(struct pn533_target_jewel *jewel,
0796                             int target_data_len)
0797 {
0798     u8 ssd;
0799     u8 platconf;
0800 
0801     if (target_data_len < sizeof(struct pn533_target_jewel))
0802         return false;
0803 
0804     /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
0805     ssd = PN533_TYPE_A_SENS_RES_SSD(jewel->sens_res);
0806     platconf = PN533_TYPE_A_SENS_RES_PLATCONF(jewel->sens_res);
0807 
0808     if ((ssd == PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
0809          platconf != PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL) ||
0810         (ssd != PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
0811          platconf == PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL))
0812         return false;
0813 
0814     return true;
0815 }
0816 
0817 static int pn533_target_found_jewel(struct nfc_target *nfc_tgt, u8 *tgt_data,
0818                             int tgt_data_len)
0819 {
0820     struct pn533_target_jewel *tgt_jewel;
0821 
0822     tgt_jewel = (struct pn533_target_jewel *)tgt_data;
0823 
0824     if (!pn533_target_jewel_is_valid(tgt_jewel, tgt_data_len))
0825         return -EPROTO;
0826 
0827     nfc_tgt->supported_protocols = NFC_PROTO_JEWEL_MASK;
0828     nfc_tgt->sens_res = be16_to_cpu(tgt_jewel->sens_res);
0829     nfc_tgt->nfcid1_len = 4;
0830     memcpy(nfc_tgt->nfcid1, tgt_jewel->jewelid, nfc_tgt->nfcid1_len);
0831 
0832     return 0;
0833 }
0834 
0835 struct pn533_type_b_prot_info {
0836     u8 bitrate;
0837     u8 fsci_type;
0838     u8 fwi_adc_fo;
0839 } __packed;
0840 
0841 #define PN533_TYPE_B_PROT_FCSI(x) (((x) & 0xF0) >> 4)
0842 #define PN533_TYPE_B_PROT_TYPE(x) (((x) & 0x0F) >> 0)
0843 #define PN533_TYPE_B_PROT_TYPE_RFU_MASK 0x8
0844 
0845 struct pn533_type_b_sens_res {
0846     u8 opcode;
0847     u8 nfcid[4];
0848     u8 appdata[4];
0849     struct pn533_type_b_prot_info prot_info;
0850 } __packed;
0851 
0852 #define PN533_TYPE_B_OPC_SENSB_RES 0x50
0853 
0854 struct pn533_target_type_b {
0855     struct pn533_type_b_sens_res sensb_res;
0856     u8 attrib_res_len;
0857     u8 attrib_res[];
0858 } __packed;
0859 
0860 static bool pn533_target_type_b_is_valid(struct pn533_target_type_b *type_b,
0861                             int target_data_len)
0862 {
0863     if (target_data_len < sizeof(struct pn533_target_type_b))
0864         return false;
0865 
0866     if (type_b->sensb_res.opcode != PN533_TYPE_B_OPC_SENSB_RES)
0867         return false;
0868 
0869     if (PN533_TYPE_B_PROT_TYPE(type_b->sensb_res.prot_info.fsci_type) &
0870                         PN533_TYPE_B_PROT_TYPE_RFU_MASK)
0871         return false;
0872 
0873     return true;
0874 }
0875 
0876 static int pn533_target_found_type_b(struct nfc_target *nfc_tgt, u8 *tgt_data,
0877                             int tgt_data_len)
0878 {
0879     struct pn533_target_type_b *tgt_type_b;
0880 
0881     tgt_type_b = (struct pn533_target_type_b *)tgt_data;
0882 
0883     if (!pn533_target_type_b_is_valid(tgt_type_b, tgt_data_len))
0884         return -EPROTO;
0885 
0886     nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
0887 
0888     return 0;
0889 }
0890 
0891 static void pn533_poll_reset_mod_list(struct pn533 *dev);
0892 static int pn533_target_found(struct pn533 *dev, u8 tg, u8 *tgdata,
0893                   int tgdata_len)
0894 {
0895     struct nfc_target nfc_tgt;
0896     int rc;
0897 
0898     dev_dbg(dev->dev, "%s: modulation=%d\n",
0899         __func__, dev->poll_mod_curr);
0900 
0901     if (tg != 1)
0902         return -EPROTO;
0903 
0904     memset(&nfc_tgt, 0, sizeof(struct nfc_target));
0905 
0906     switch (dev->poll_mod_curr) {
0907     case PN533_POLL_MOD_106KBPS_A:
0908         rc = pn533_target_found_type_a(&nfc_tgt, tgdata, tgdata_len);
0909         break;
0910     case PN533_POLL_MOD_212KBPS_FELICA:
0911     case PN533_POLL_MOD_424KBPS_FELICA:
0912         rc = pn533_target_found_felica(&nfc_tgt, tgdata, tgdata_len);
0913         break;
0914     case PN533_POLL_MOD_106KBPS_JEWEL:
0915         rc = pn533_target_found_jewel(&nfc_tgt, tgdata, tgdata_len);
0916         break;
0917     case PN533_POLL_MOD_847KBPS_B:
0918         rc = pn533_target_found_type_b(&nfc_tgt, tgdata, tgdata_len);
0919         break;
0920     default:
0921         nfc_err(dev->dev,
0922             "Unknown current poll modulation\n");
0923         return -EPROTO;
0924     }
0925 
0926     if (rc)
0927         return rc;
0928 
0929     if (!(nfc_tgt.supported_protocols & dev->poll_protocols)) {
0930         dev_dbg(dev->dev,
0931             "The Tg found doesn't have the desired protocol\n");
0932         return -EAGAIN;
0933     }
0934 
0935     dev_dbg(dev->dev,
0936         "Target found - supported protocols: 0x%x\n",
0937         nfc_tgt.supported_protocols);
0938 
0939     dev->tgt_available_prots = nfc_tgt.supported_protocols;
0940 
0941     pn533_poll_reset_mod_list(dev);
0942     nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
0943 
0944     return 0;
0945 }
0946 
0947 static inline void pn533_poll_next_mod(struct pn533 *dev)
0948 {
0949     dev->poll_mod_curr = (dev->poll_mod_curr + 1) % dev->poll_mod_count;
0950 }
0951 
0952 static void pn533_poll_reset_mod_list(struct pn533 *dev)
0953 {
0954     dev->poll_mod_count = 0;
0955 }
0956 
0957 static void pn533_poll_add_mod(struct pn533 *dev, u8 mod_index)
0958 {
0959     dev->poll_mod_active[dev->poll_mod_count] =
0960         (struct pn533_poll_modulations *)&poll_mod[mod_index];
0961     dev->poll_mod_count++;
0962 }
0963 
0964 static void pn533_poll_create_mod_list(struct pn533 *dev,
0965                        u32 im_protocols, u32 tm_protocols)
0966 {
0967     pn533_poll_reset_mod_list(dev);
0968 
0969     if ((im_protocols & NFC_PROTO_MIFARE_MASK) ||
0970         (im_protocols & NFC_PROTO_ISO14443_MASK) ||
0971         (im_protocols & NFC_PROTO_NFC_DEP_MASK))
0972         pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_A);
0973 
0974     if (im_protocols & NFC_PROTO_FELICA_MASK ||
0975         im_protocols & NFC_PROTO_NFC_DEP_MASK) {
0976         pn533_poll_add_mod(dev, PN533_POLL_MOD_212KBPS_FELICA);
0977         pn533_poll_add_mod(dev, PN533_POLL_MOD_424KBPS_FELICA);
0978     }
0979 
0980     if (im_protocols & NFC_PROTO_JEWEL_MASK)
0981         pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_JEWEL);
0982 
0983     if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
0984         pn533_poll_add_mod(dev, PN533_POLL_MOD_847KBPS_B);
0985 
0986     if (tm_protocols)
0987         pn533_poll_add_mod(dev, PN533_LISTEN_MOD);
0988 }
0989 
0990 static int pn533_start_poll_complete(struct pn533 *dev, struct sk_buff *resp)
0991 {
0992     u8 nbtg, tg, *tgdata;
0993     int rc, tgdata_len;
0994 
0995     /* Toggle the DEP polling */
0996     if (dev->poll_protocols & NFC_PROTO_NFC_DEP_MASK)
0997         dev->poll_dep = 1;
0998 
0999     nbtg = resp->data[0];
1000     tg = resp->data[1];
1001     tgdata = &resp->data[2];
1002     tgdata_len = resp->len - 2;  /* nbtg + tg */
1003 
1004     if (nbtg) {
1005         rc = pn533_target_found(dev, tg, tgdata, tgdata_len);
1006 
1007         /* We must stop the poll after a valid target found */
1008         if (rc == 0)
1009             return 0;
1010     }
1011 
1012     return -EAGAIN;
1013 }
1014 
1015 static struct sk_buff *pn533_alloc_poll_tg_frame(struct pn533 *dev)
1016 {
1017     struct sk_buff *skb;
1018     u8 *felica, *nfcid3;
1019 
1020     u8 *gbytes = dev->gb;
1021     size_t gbytes_len = dev->gb_len;
1022 
1023     u8 felica_params[18] = {0x1, 0xfe, /* DEP */
1024                 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, /* random */
1025                 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
1026                 0xff, 0xff}; /* System code */
1027 
1028     u8 mifare_params[6] = {0x1, 0x1, /* SENS_RES */
1029                    0x0, 0x0, 0x0,
1030                    0x40}; /* SEL_RES for DEP */
1031 
1032     unsigned int skb_len = 36 + /*
1033                      * mode (1), mifare (6),
1034                      * felica (18), nfcid3 (10), gb_len (1)
1035                      */
1036                    gbytes_len +
1037                    1;  /* len Tk*/
1038 
1039     skb = pn533_alloc_skb(dev, skb_len);
1040     if (!skb)
1041         return NULL;
1042 
1043     /* DEP support only */
1044     skb_put_u8(skb, PN533_INIT_TARGET_DEP);
1045 
1046     /* MIFARE params */
1047     skb_put_data(skb, mifare_params, 6);
1048 
1049     /* Felica params */
1050     felica = skb_put_data(skb, felica_params, 18);
1051     get_random_bytes(felica + 2, 6);
1052 
1053     /* NFCID3 */
1054     nfcid3 = skb_put_zero(skb, 10);
1055     memcpy(nfcid3, felica, 8);
1056 
1057     /* General bytes */
1058     skb_put_u8(skb, gbytes_len);
1059 
1060     skb_put_data(skb, gbytes, gbytes_len);
1061 
1062     /* Len Tk */
1063     skb_put_u8(skb, 0);
1064 
1065     return skb;
1066 }
1067 
1068 static void pn533_wq_tm_mi_recv(struct work_struct *work);
1069 static struct sk_buff *pn533_build_response(struct pn533 *dev);
1070 
1071 static int pn533_tm_get_data_complete(struct pn533 *dev, void *arg,
1072                       struct sk_buff *resp)
1073 {
1074     struct sk_buff *skb;
1075     u8 status, ret, mi;
1076     int rc;
1077 
1078     if (IS_ERR(resp)) {
1079         skb_queue_purge(&dev->resp_q);
1080         return PTR_ERR(resp);
1081     }
1082 
1083     status = resp->data[0];
1084 
1085     ret = status & PN533_CMD_RET_MASK;
1086     mi = status & PN533_CMD_MI_MASK;
1087 
1088     skb_pull(resp, sizeof(status));
1089 
1090     if (ret != PN533_CMD_RET_SUCCESS) {
1091         rc = -EIO;
1092         goto error;
1093     }
1094 
1095     skb_queue_tail(&dev->resp_q, resp);
1096 
1097     if (mi) {
1098         queue_work(dev->wq, &dev->mi_tm_rx_work);
1099         return -EINPROGRESS;
1100     }
1101 
1102     skb = pn533_build_response(dev);
1103     if (!skb) {
1104         rc = -EIO;
1105         goto error;
1106     }
1107 
1108     return nfc_tm_data_received(dev->nfc_dev, skb);
1109 
1110 error:
1111     nfc_tm_deactivated(dev->nfc_dev);
1112     dev->tgt_mode = 0;
1113     skb_queue_purge(&dev->resp_q);
1114     dev_kfree_skb(resp);
1115 
1116     return rc;
1117 }
1118 
1119 static void pn533_wq_tm_mi_recv(struct work_struct *work)
1120 {
1121     struct pn533 *dev = container_of(work, struct pn533, mi_tm_rx_work);
1122     struct sk_buff *skb;
1123     int rc;
1124 
1125     skb = pn533_alloc_skb(dev, 0);
1126     if (!skb)
1127         return;
1128 
1129     rc = pn533_send_cmd_direct_async(dev,
1130                     PN533_CMD_TG_GET_DATA,
1131                     skb,
1132                     pn533_tm_get_data_complete,
1133                     NULL);
1134 
1135     if (rc < 0)
1136         dev_kfree_skb(skb);
1137 }
1138 
1139 static int pn533_tm_send_complete(struct pn533 *dev, void *arg,
1140                   struct sk_buff *resp);
1141 static void pn533_wq_tm_mi_send(struct work_struct *work)
1142 {
1143     struct pn533 *dev = container_of(work, struct pn533, mi_tm_tx_work);
1144     struct sk_buff *skb;
1145     int rc;
1146 
1147     /* Grab the first skb in the queue */
1148     skb = skb_dequeue(&dev->fragment_skb);
1149     if (skb == NULL) {  /* No more data */
1150         /* Reset the queue for future use */
1151         skb_queue_head_init(&dev->fragment_skb);
1152         goto error;
1153     }
1154 
1155     /* last entry - remove MI bit */
1156     if (skb_queue_len(&dev->fragment_skb) == 0) {
1157         rc = pn533_send_cmd_direct_async(dev, PN533_CMD_TG_SET_DATA,
1158                     skb, pn533_tm_send_complete, NULL);
1159     } else
1160         rc = pn533_send_cmd_direct_async(dev,
1161                     PN533_CMD_TG_SET_META_DATA,
1162                     skb, pn533_tm_send_complete, NULL);
1163 
1164     if (rc == 0) /* success */
1165         return;
1166 
1167     dev_err(dev->dev,
1168         "Error %d when trying to perform set meta data_exchange", rc);
1169 
1170     dev_kfree_skb(skb);
1171 
1172 error:
1173     dev->phy_ops->send_ack(dev, GFP_KERNEL);
1174     queue_work(dev->wq, &dev->cmd_work);
1175 }
1176 
1177 static void pn533_wq_tg_get_data(struct work_struct *work)
1178 {
1179     struct pn533 *dev = container_of(work, struct pn533, tg_work);
1180     struct sk_buff *skb;
1181     int rc;
1182 
1183     skb = pn533_alloc_skb(dev, 0);
1184     if (!skb)
1185         return;
1186 
1187     rc = pn533_send_data_async(dev, PN533_CMD_TG_GET_DATA, skb,
1188                    pn533_tm_get_data_complete, NULL);
1189 
1190     if (rc < 0)
1191         dev_kfree_skb(skb);
1192 }
1193 
1194 #define ATR_REQ_GB_OFFSET 17
1195 static int pn533_init_target_complete(struct pn533 *dev, struct sk_buff *resp)
1196 {
1197     u8 mode, *cmd, comm_mode = NFC_COMM_PASSIVE, *gb;
1198     size_t gb_len;
1199     int rc;
1200 
1201     if (resp->len < ATR_REQ_GB_OFFSET + 1)
1202         return -EINVAL;
1203 
1204     mode = resp->data[0];
1205     cmd = &resp->data[1];
1206 
1207     dev_dbg(dev->dev, "Target mode 0x%x len %d\n",
1208         mode, resp->len);
1209 
1210     if ((mode & PN533_INIT_TARGET_RESP_FRAME_MASK) ==
1211         PN533_INIT_TARGET_RESP_ACTIVE)
1212         comm_mode = NFC_COMM_ACTIVE;
1213 
1214     if ((mode & PN533_INIT_TARGET_RESP_DEP) == 0)  /* Only DEP supported */
1215         return -EOPNOTSUPP;
1216 
1217     gb = cmd + ATR_REQ_GB_OFFSET;
1218     gb_len = resp->len - (ATR_REQ_GB_OFFSET + 1);
1219 
1220     rc = nfc_tm_activated(dev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1221                   comm_mode, gb, gb_len);
1222     if (rc < 0) {
1223         nfc_err(dev->dev,
1224             "Error when signaling target activation\n");
1225         return rc;
1226     }
1227 
1228     dev->tgt_mode = 1;
1229     queue_work(dev->wq, &dev->tg_work);
1230 
1231     return 0;
1232 }
1233 
1234 static void pn533_listen_mode_timer(struct timer_list *t)
1235 {
1236     struct pn533 *dev = from_timer(dev, t, listen_timer);
1237 
1238     dev->cancel_listen = 1;
1239 
1240     pn533_poll_next_mod(dev);
1241 
1242     queue_delayed_work(dev->wq, &dev->poll_work,
1243                msecs_to_jiffies(PN533_POLL_INTERVAL));
1244 }
1245 
1246 static int pn533_rf_complete(struct pn533 *dev, void *arg,
1247                  struct sk_buff *resp)
1248 {
1249     int rc = 0;
1250 
1251     if (IS_ERR(resp)) {
1252         rc = PTR_ERR(resp);
1253 
1254         nfc_err(dev->dev, "RF setting error %d\n", rc);
1255 
1256         return rc;
1257     }
1258 
1259     queue_delayed_work(dev->wq, &dev->poll_work,
1260                msecs_to_jiffies(PN533_POLL_INTERVAL));
1261 
1262     dev_kfree_skb(resp);
1263     return rc;
1264 }
1265 
1266 static void pn533_wq_rf(struct work_struct *work)
1267 {
1268     struct pn533 *dev = container_of(work, struct pn533, rf_work);
1269     struct sk_buff *skb;
1270     int rc;
1271 
1272     skb = pn533_alloc_skb(dev, 2);
1273     if (!skb)
1274         return;
1275 
1276     skb_put_u8(skb, PN533_CFGITEM_RF_FIELD);
1277     skb_put_u8(skb, PN533_CFGITEM_RF_FIELD_AUTO_RFCA);
1278 
1279     rc = pn533_send_cmd_async(dev, PN533_CMD_RF_CONFIGURATION, skb,
1280                   pn533_rf_complete, NULL);
1281     if (rc < 0) {
1282         dev_kfree_skb(skb);
1283         nfc_err(dev->dev, "RF setting error %d\n", rc);
1284     }
1285 }
1286 
1287 static int pn533_poll_dep_complete(struct pn533 *dev, void *arg,
1288                    struct sk_buff *resp)
1289 {
1290     struct pn533_cmd_jump_dep_response *rsp;
1291     struct nfc_target nfc_target;
1292     u8 target_gt_len;
1293     int rc;
1294 
1295     if (IS_ERR(resp))
1296         return PTR_ERR(resp);
1297 
1298     rsp = (struct pn533_cmd_jump_dep_response *)resp->data;
1299 
1300     rc = rsp->status & PN533_CMD_RET_MASK;
1301     if (rc != PN533_CMD_RET_SUCCESS) {
1302         /* Not target found, turn radio off */
1303         queue_work(dev->wq, &dev->rf_work);
1304 
1305         dev_kfree_skb(resp);
1306         return 0;
1307     }
1308 
1309     dev_dbg(dev->dev, "Creating new target");
1310 
1311     nfc_target.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
1312     nfc_target.nfcid1_len = 10;
1313     memcpy(nfc_target.nfcid1, rsp->nfcid3t, nfc_target.nfcid1_len);
1314     rc = nfc_targets_found(dev->nfc_dev, &nfc_target, 1);
1315     if (rc)
1316         goto error;
1317 
1318     dev->tgt_available_prots = 0;
1319     dev->tgt_active_prot = NFC_PROTO_NFC_DEP;
1320 
1321     /* ATR_RES general bytes are located at offset 17 */
1322     target_gt_len = resp->len - 17;
1323     rc = nfc_set_remote_general_bytes(dev->nfc_dev,
1324                       rsp->gt, target_gt_len);
1325     if (!rc) {
1326         rc = nfc_dep_link_is_up(dev->nfc_dev,
1327                     dev->nfc_dev->targets[0].idx,
1328                     0, NFC_RF_INITIATOR);
1329 
1330         if (!rc)
1331             pn533_poll_reset_mod_list(dev);
1332     }
1333 error:
1334     dev_kfree_skb(resp);
1335     return rc;
1336 }
1337 
1338 #define PASSIVE_DATA_LEN 5
1339 static int pn533_poll_dep(struct nfc_dev *nfc_dev)
1340 {
1341     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1342     struct sk_buff *skb;
1343     int rc, skb_len;
1344     u8 *next, nfcid3[NFC_NFCID3_MAXSIZE];
1345     u8 passive_data[PASSIVE_DATA_LEN] = {0x00, 0xff, 0xff, 0x00, 0x3};
1346 
1347     if (!dev->gb) {
1348         dev->gb = nfc_get_local_general_bytes(nfc_dev, &dev->gb_len);
1349 
1350         if (!dev->gb || !dev->gb_len) {
1351             dev->poll_dep = 0;
1352             queue_work(dev->wq, &dev->rf_work);
1353         }
1354     }
1355 
1356     skb_len = 3 + dev->gb_len; /* ActPass + BR + Next */
1357     skb_len += PASSIVE_DATA_LEN;
1358 
1359     /* NFCID3 */
1360     skb_len += NFC_NFCID3_MAXSIZE;
1361     nfcid3[0] = 0x1;
1362     nfcid3[1] = 0xfe;
1363     get_random_bytes(nfcid3 + 2, 6);
1364 
1365     skb = pn533_alloc_skb(dev, skb_len);
1366     if (!skb)
1367         return -ENOMEM;
1368 
1369     skb_put_u8(skb, 0x01);  /* Active */
1370     skb_put_u8(skb, 0x02);  /* 424 kbps */
1371 
1372     next = skb_put(skb, 1);  /* Next */
1373     *next = 0;
1374 
1375     /* Copy passive data */
1376     skb_put_data(skb, passive_data, PASSIVE_DATA_LEN);
1377     *next |= 1;
1378 
1379     /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
1380     skb_put_data(skb, nfcid3, NFC_NFCID3_MAXSIZE);
1381     *next |= 2;
1382 
1383     skb_put_data(skb, dev->gb, dev->gb_len);
1384     *next |= 4; /* We have some Gi */
1385 
1386     rc = pn533_send_cmd_async(dev, PN533_CMD_IN_JUMP_FOR_DEP, skb,
1387                   pn533_poll_dep_complete, NULL);
1388 
1389     if (rc < 0)
1390         dev_kfree_skb(skb);
1391 
1392     return rc;
1393 }
1394 
1395 static int pn533_autopoll_complete(struct pn533 *dev, void *arg,
1396                    struct sk_buff *resp)
1397 {
1398     struct pn532_autopoll_resp *apr;
1399     struct nfc_target nfc_tgt;
1400     u8 nbtg;
1401     int rc;
1402 
1403     if (IS_ERR(resp)) {
1404         rc = PTR_ERR(resp);
1405 
1406         nfc_err(dev->dev, "%s  autopoll complete error %d\n",
1407             __func__, rc);
1408 
1409         if (rc == -ENOENT) {
1410             if (dev->poll_mod_count != 0)
1411                 return rc;
1412             goto stop_poll;
1413         } else if (rc < 0) {
1414             nfc_err(dev->dev,
1415                 "Error %d when running autopoll\n", rc);
1416             goto stop_poll;
1417         }
1418     }
1419 
1420     nbtg = resp->data[0];
1421     if ((nbtg > 2) || (nbtg <= 0))
1422         return -EAGAIN;
1423 
1424     apr = (struct pn532_autopoll_resp *)&resp->data[1];
1425     while (nbtg--) {
1426         memset(&nfc_tgt, 0, sizeof(struct nfc_target));
1427         switch (apr->type) {
1428         case PN532_AUTOPOLL_TYPE_ISOA:
1429             dev_dbg(dev->dev, "ISOA\n");
1430             rc = pn533_target_found_type_a(&nfc_tgt, apr->tgdata,
1431                                apr->ln - 1);
1432             break;
1433         case PN532_AUTOPOLL_TYPE_FELICA212:
1434         case PN532_AUTOPOLL_TYPE_FELICA424:
1435             dev_dbg(dev->dev, "FELICA\n");
1436             rc = pn533_target_found_felica(&nfc_tgt, apr->tgdata,
1437                                apr->ln - 1);
1438             break;
1439         case PN532_AUTOPOLL_TYPE_JEWEL:
1440             dev_dbg(dev->dev, "JEWEL\n");
1441             rc = pn533_target_found_jewel(&nfc_tgt, apr->tgdata,
1442                               apr->ln - 1);
1443             break;
1444         case PN532_AUTOPOLL_TYPE_ISOB:
1445             dev_dbg(dev->dev, "ISOB\n");
1446             rc = pn533_target_found_type_b(&nfc_tgt, apr->tgdata,
1447                                apr->ln - 1);
1448             break;
1449         case PN532_AUTOPOLL_TYPE_MIFARE:
1450             dev_dbg(dev->dev, "Mifare\n");
1451             rc = pn533_target_found_type_a(&nfc_tgt, apr->tgdata,
1452                                apr->ln - 1);
1453             break;
1454         default:
1455             nfc_err(dev->dev,
1456                     "Unknown current poll modulation\n");
1457             rc = -EPROTO;
1458         }
1459 
1460         if (rc)
1461             goto done;
1462 
1463         if (!(nfc_tgt.supported_protocols & dev->poll_protocols)) {
1464             nfc_err(dev->dev,
1465                     "The Tg found doesn't have the desired protocol\n");
1466             rc = -EAGAIN;
1467             goto done;
1468         }
1469 
1470         dev->tgt_available_prots = nfc_tgt.supported_protocols;
1471         apr = (struct pn532_autopoll_resp *)
1472             (apr->tgdata + (apr->ln - 1));
1473     }
1474 
1475     pn533_poll_reset_mod_list(dev);
1476     nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
1477 
1478 done:
1479     dev_kfree_skb(resp);
1480     return rc;
1481 
1482 stop_poll:
1483     nfc_err(dev->dev, "autopoll operation has been stopped\n");
1484 
1485     pn533_poll_reset_mod_list(dev);
1486     dev->poll_protocols = 0;
1487     return rc;
1488 }
1489 
1490 static int pn533_poll_complete(struct pn533 *dev, void *arg,
1491                    struct sk_buff *resp)
1492 {
1493     struct pn533_poll_modulations *cur_mod;
1494     int rc;
1495 
1496     if (IS_ERR(resp)) {
1497         rc = PTR_ERR(resp);
1498 
1499         nfc_err(dev->dev, "%s  Poll complete error %d\n",
1500             __func__, rc);
1501 
1502         if (rc == -ENOENT) {
1503             if (dev->poll_mod_count != 0)
1504                 return rc;
1505             goto stop_poll;
1506         } else if (rc < 0) {
1507             nfc_err(dev->dev,
1508                 "Error %d when running poll\n", rc);
1509             goto stop_poll;
1510         }
1511     }
1512 
1513     cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
1514 
1515     if (cur_mod->len == 0) { /* Target mode */
1516         del_timer(&dev->listen_timer);
1517         rc = pn533_init_target_complete(dev, resp);
1518         goto done;
1519     }
1520 
1521     /* Initiator mode */
1522     rc = pn533_start_poll_complete(dev, resp);
1523     if (!rc)
1524         goto done;
1525 
1526     if (!dev->poll_mod_count) {
1527         dev_dbg(dev->dev, "Polling has been stopped\n");
1528         goto done;
1529     }
1530 
1531     pn533_poll_next_mod(dev);
1532     /* Not target found, turn radio off */
1533     queue_work(dev->wq, &dev->rf_work);
1534 
1535 done:
1536     dev_kfree_skb(resp);
1537     return rc;
1538 
1539 stop_poll:
1540     nfc_err(dev->dev, "Polling operation has been stopped\n");
1541 
1542     pn533_poll_reset_mod_list(dev);
1543     dev->poll_protocols = 0;
1544     return rc;
1545 }
1546 
1547 static struct sk_buff *pn533_alloc_poll_in_frame(struct pn533 *dev,
1548                     struct pn533_poll_modulations *mod)
1549 {
1550     struct sk_buff *skb;
1551 
1552     skb = pn533_alloc_skb(dev, mod->len);
1553     if (!skb)
1554         return NULL;
1555 
1556     skb_put_data(skb, &mod->data, mod->len);
1557 
1558     return skb;
1559 }
1560 
1561 static int pn533_send_poll_frame(struct pn533 *dev)
1562 {
1563     struct pn533_poll_modulations *mod;
1564     struct sk_buff *skb;
1565     int rc;
1566     u8 cmd_code;
1567 
1568     mod = dev->poll_mod_active[dev->poll_mod_curr];
1569 
1570     dev_dbg(dev->dev, "%s mod len %d\n",
1571         __func__, mod->len);
1572 
1573     if ((dev->poll_protocols & NFC_PROTO_NFC_DEP_MASK) && dev->poll_dep)  {
1574         dev->poll_dep = 0;
1575         return pn533_poll_dep(dev->nfc_dev);
1576     }
1577 
1578     if (mod->len == 0) {  /* Listen mode */
1579         cmd_code = PN533_CMD_TG_INIT_AS_TARGET;
1580         skb = pn533_alloc_poll_tg_frame(dev);
1581     } else {  /* Polling mode */
1582         cmd_code =  PN533_CMD_IN_LIST_PASSIVE_TARGET;
1583         skb = pn533_alloc_poll_in_frame(dev, mod);
1584     }
1585 
1586     if (!skb) {
1587         nfc_err(dev->dev, "Failed to allocate skb\n");
1588         return -ENOMEM;
1589     }
1590 
1591     rc = pn533_send_cmd_async(dev, cmd_code, skb, pn533_poll_complete,
1592                   NULL);
1593     if (rc < 0) {
1594         dev_kfree_skb(skb);
1595         nfc_err(dev->dev, "Polling loop error %d\n", rc);
1596     }
1597 
1598     return rc;
1599 }
1600 
1601 static void pn533_wq_poll(struct work_struct *work)
1602 {
1603     struct pn533 *dev = container_of(work, struct pn533, poll_work.work);
1604     struct pn533_poll_modulations *cur_mod;
1605     int rc;
1606 
1607     cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
1608 
1609     dev_dbg(dev->dev,
1610         "%s cancel_listen %d modulation len %d\n",
1611         __func__, dev->cancel_listen, cur_mod->len);
1612 
1613     if (dev->cancel_listen == 1) {
1614         dev->cancel_listen = 0;
1615         dev->phy_ops->abort_cmd(dev, GFP_ATOMIC);
1616     }
1617 
1618     rc = pn533_send_poll_frame(dev);
1619     if (rc)
1620         return;
1621 
1622     if (cur_mod->len == 0 && dev->poll_mod_count > 1)
1623         mod_timer(&dev->listen_timer, jiffies + PN533_LISTEN_TIME * HZ);
1624 }
1625 
1626 static int pn533_start_poll(struct nfc_dev *nfc_dev,
1627                 u32 im_protocols, u32 tm_protocols)
1628 {
1629     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1630     struct pn533_poll_modulations *cur_mod;
1631     struct sk_buff *skb;
1632     u8 rand_mod;
1633     int rc;
1634 
1635     dev_dbg(dev->dev,
1636         "%s: im protocols 0x%x tm protocols 0x%x\n",
1637         __func__, im_protocols, tm_protocols);
1638 
1639     if (dev->tgt_active_prot) {
1640         nfc_err(dev->dev,
1641             "Cannot poll with a target already activated\n");
1642         return -EBUSY;
1643     }
1644 
1645     if (dev->tgt_mode) {
1646         nfc_err(dev->dev,
1647             "Cannot poll while already being activated\n");
1648         return -EBUSY;
1649     }
1650 
1651     if (tm_protocols) {
1652         dev->gb = nfc_get_local_general_bytes(nfc_dev, &dev->gb_len);
1653         if (dev->gb == NULL)
1654             tm_protocols = 0;
1655     }
1656 
1657     dev->poll_protocols = im_protocols;
1658     dev->listen_protocols = tm_protocols;
1659     if (dev->device_type == PN533_DEVICE_PN532_AUTOPOLL) {
1660         skb = pn533_alloc_skb(dev, 4 + 6);
1661         if (!skb)
1662             return -ENOMEM;
1663 
1664         *((u8 *)skb_put(skb, sizeof(u8))) =
1665             PN532_AUTOPOLL_POLLNR_INFINITE;
1666         *((u8 *)skb_put(skb, sizeof(u8))) = PN532_AUTOPOLL_PERIOD;
1667 
1668         if ((im_protocols & NFC_PROTO_MIFARE_MASK) &&
1669                 (im_protocols & NFC_PROTO_ISO14443_MASK) &&
1670                 (im_protocols & NFC_PROTO_NFC_DEP_MASK))
1671             *((u8 *)skb_put(skb, sizeof(u8))) =
1672                 PN532_AUTOPOLL_TYPE_GENERIC_106;
1673         else {
1674             if (im_protocols & NFC_PROTO_MIFARE_MASK)
1675                 *((u8 *)skb_put(skb, sizeof(u8))) =
1676                     PN532_AUTOPOLL_TYPE_MIFARE;
1677 
1678             if (im_protocols & NFC_PROTO_ISO14443_MASK)
1679                 *((u8 *)skb_put(skb, sizeof(u8))) =
1680                     PN532_AUTOPOLL_TYPE_ISOA;
1681 
1682             if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
1683                 *((u8 *)skb_put(skb, sizeof(u8))) =
1684                     PN532_AUTOPOLL_TYPE_DEP_PASSIVE_106;
1685                 *((u8 *)skb_put(skb, sizeof(u8))) =
1686                     PN532_AUTOPOLL_TYPE_DEP_PASSIVE_212;
1687                 *((u8 *)skb_put(skb, sizeof(u8))) =
1688                     PN532_AUTOPOLL_TYPE_DEP_PASSIVE_424;
1689             }
1690         }
1691 
1692         if (im_protocols & NFC_PROTO_FELICA_MASK ||
1693                 im_protocols & NFC_PROTO_NFC_DEP_MASK) {
1694             *((u8 *)skb_put(skb, sizeof(u8))) =
1695                 PN532_AUTOPOLL_TYPE_FELICA212;
1696             *((u8 *)skb_put(skb, sizeof(u8))) =
1697                 PN532_AUTOPOLL_TYPE_FELICA424;
1698         }
1699 
1700         if (im_protocols & NFC_PROTO_JEWEL_MASK)
1701             *((u8 *)skb_put(skb, sizeof(u8))) =
1702                 PN532_AUTOPOLL_TYPE_JEWEL;
1703 
1704         if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
1705             *((u8 *)skb_put(skb, sizeof(u8))) =
1706                 PN532_AUTOPOLL_TYPE_ISOB;
1707 
1708         if (tm_protocols)
1709             *((u8 *)skb_put(skb, sizeof(u8))) =
1710                 PN532_AUTOPOLL_TYPE_DEP_ACTIVE_106;
1711 
1712         rc = pn533_send_cmd_async(dev, PN533_CMD_IN_AUTOPOLL, skb,
1713                 pn533_autopoll_complete, NULL);
1714 
1715         if (rc < 0)
1716             dev_kfree_skb(skb);
1717         else
1718             dev->poll_mod_count++;
1719 
1720         return rc;
1721     }
1722 
1723     pn533_poll_create_mod_list(dev, im_protocols, tm_protocols);
1724 
1725     /* Do not always start polling from the same modulation */
1726     get_random_bytes(&rand_mod, sizeof(rand_mod));
1727     rand_mod %= dev->poll_mod_count;
1728     dev->poll_mod_curr = rand_mod;
1729 
1730     cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
1731 
1732     rc = pn533_send_poll_frame(dev);
1733 
1734     /* Start listen timer */
1735     if (!rc && cur_mod->len == 0 && dev->poll_mod_count > 1)
1736         mod_timer(&dev->listen_timer, jiffies + PN533_LISTEN_TIME * HZ);
1737 
1738     return rc;
1739 }
1740 
1741 static void pn533_stop_poll(struct nfc_dev *nfc_dev)
1742 {
1743     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1744 
1745     del_timer(&dev->listen_timer);
1746 
1747     if (!dev->poll_mod_count) {
1748         dev_dbg(dev->dev,
1749             "Polling operation was not running\n");
1750         return;
1751     }
1752 
1753     dev->phy_ops->abort_cmd(dev, GFP_KERNEL);
1754     flush_delayed_work(&dev->poll_work);
1755     pn533_poll_reset_mod_list(dev);
1756 }
1757 
1758 static int pn533_activate_target_nfcdep(struct pn533 *dev)
1759 {
1760     struct pn533_cmd_activate_response *rsp;
1761     u16 gt_len;
1762     int rc;
1763     struct sk_buff *skb;
1764     struct sk_buff *resp;
1765 
1766     skb = pn533_alloc_skb(dev, sizeof(u8) * 2); /*TG + Next*/
1767     if (!skb)
1768         return -ENOMEM;
1769 
1770     skb_put_u8(skb, 1); /* TG */
1771     skb_put_u8(skb, 0); /* Next */
1772 
1773     resp = pn533_send_cmd_sync(dev, PN533_CMD_IN_ATR, skb);
1774     if (IS_ERR(resp))
1775         return PTR_ERR(resp);
1776 
1777     rsp = (struct pn533_cmd_activate_response *)resp->data;
1778     rc = rsp->status & PN533_CMD_RET_MASK;
1779     if (rc != PN533_CMD_RET_SUCCESS) {
1780         nfc_err(dev->dev,
1781             "Target activation failed (error 0x%x)\n", rc);
1782         dev_kfree_skb(resp);
1783         return -EIO;
1784     }
1785 
1786     /* ATR_RES general bytes are located at offset 16 */
1787     gt_len = resp->len - 16;
1788     rc = nfc_set_remote_general_bytes(dev->nfc_dev, rsp->gt, gt_len);
1789 
1790     dev_kfree_skb(resp);
1791     return rc;
1792 }
1793 
1794 static int pn533_activate_target(struct nfc_dev *nfc_dev,
1795                  struct nfc_target *target, u32 protocol)
1796 {
1797     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1798     int rc;
1799 
1800     dev_dbg(dev->dev, "%s: protocol=%u\n", __func__, protocol);
1801 
1802     if (dev->poll_mod_count) {
1803         nfc_err(dev->dev,
1804             "Cannot activate while polling\n");
1805         return -EBUSY;
1806     }
1807 
1808     if (dev->tgt_active_prot) {
1809         nfc_err(dev->dev,
1810             "There is already an active target\n");
1811         return -EBUSY;
1812     }
1813 
1814     if (!dev->tgt_available_prots) {
1815         nfc_err(dev->dev,
1816             "There is no available target to activate\n");
1817         return -EINVAL;
1818     }
1819 
1820     if (!(dev->tgt_available_prots & (1 << protocol))) {
1821         nfc_err(dev->dev,
1822             "Target doesn't support requested proto %u\n",
1823             protocol);
1824         return -EINVAL;
1825     }
1826 
1827     if (protocol == NFC_PROTO_NFC_DEP) {
1828         rc = pn533_activate_target_nfcdep(dev);
1829         if (rc) {
1830             nfc_err(dev->dev,
1831                 "Activating target with DEP failed %d\n", rc);
1832             return rc;
1833         }
1834     }
1835 
1836     dev->tgt_active_prot = protocol;
1837     dev->tgt_available_prots = 0;
1838 
1839     return 0;
1840 }
1841 
1842 static int pn533_deactivate_target_complete(struct pn533 *dev, void *arg,
1843                  struct sk_buff *resp)
1844 {
1845     int rc = 0;
1846 
1847     if (IS_ERR(resp)) {
1848         rc = PTR_ERR(resp);
1849 
1850         nfc_err(dev->dev, "Target release error %d\n", rc);
1851 
1852         return rc;
1853     }
1854 
1855     rc = resp->data[0] & PN533_CMD_RET_MASK;
1856     if (rc != PN533_CMD_RET_SUCCESS)
1857         nfc_err(dev->dev,
1858             "Error 0x%x when releasing the target\n", rc);
1859 
1860     dev_kfree_skb(resp);
1861     return rc;
1862 }
1863 
1864 static void pn533_deactivate_target(struct nfc_dev *nfc_dev,
1865                     struct nfc_target *target, u8 mode)
1866 {
1867     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1868     struct sk_buff *skb;
1869     int rc;
1870 
1871     if (!dev->tgt_active_prot) {
1872         nfc_err(dev->dev, "There is no active target\n");
1873         return;
1874     }
1875 
1876     dev->tgt_active_prot = 0;
1877     skb_queue_purge(&dev->resp_q);
1878 
1879     skb = pn533_alloc_skb(dev, sizeof(u8));
1880     if (!skb)
1881         return;
1882 
1883     skb_put_u8(skb, 1); /* TG*/
1884 
1885     rc = pn533_send_cmd_async(dev, PN533_CMD_IN_RELEASE, skb,
1886                   pn533_deactivate_target_complete, NULL);
1887     if (rc < 0) {
1888         dev_kfree_skb(skb);
1889         nfc_err(dev->dev, "Target release error %d\n", rc);
1890     }
1891 }
1892 
1893 
1894 static int pn533_in_dep_link_up_complete(struct pn533 *dev, void *arg,
1895                      struct sk_buff *resp)
1896 {
1897     struct pn533_cmd_jump_dep_response *rsp;
1898     u8 target_gt_len;
1899     int rc;
1900     u8 active = *(u8 *)arg;
1901 
1902     kfree(arg);
1903 
1904     if (IS_ERR(resp))
1905         return PTR_ERR(resp);
1906 
1907     if (dev->tgt_available_prots &&
1908         !(dev->tgt_available_prots & (1 << NFC_PROTO_NFC_DEP))) {
1909         nfc_err(dev->dev,
1910             "The target does not support DEP\n");
1911         rc =  -EINVAL;
1912         goto error;
1913     }
1914 
1915     rsp = (struct pn533_cmd_jump_dep_response *)resp->data;
1916 
1917     rc = rsp->status & PN533_CMD_RET_MASK;
1918     if (rc != PN533_CMD_RET_SUCCESS) {
1919         nfc_err(dev->dev,
1920             "Bringing DEP link up failed (error 0x%x)\n", rc);
1921         goto error;
1922     }
1923 
1924     if (!dev->tgt_available_prots) {
1925         struct nfc_target nfc_target;
1926 
1927         dev_dbg(dev->dev, "Creating new target\n");
1928 
1929         nfc_target.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
1930         nfc_target.nfcid1_len = 10;
1931         memcpy(nfc_target.nfcid1, rsp->nfcid3t, nfc_target.nfcid1_len);
1932         rc = nfc_targets_found(dev->nfc_dev, &nfc_target, 1);
1933         if (rc)
1934             goto error;
1935 
1936         dev->tgt_available_prots = 0;
1937     }
1938 
1939     dev->tgt_active_prot = NFC_PROTO_NFC_DEP;
1940 
1941     /* ATR_RES general bytes are located at offset 17 */
1942     target_gt_len = resp->len - 17;
1943     rc = nfc_set_remote_general_bytes(dev->nfc_dev,
1944                       rsp->gt, target_gt_len);
1945     if (rc == 0)
1946         rc = nfc_dep_link_is_up(dev->nfc_dev,
1947                     dev->nfc_dev->targets[0].idx,
1948                     !active, NFC_RF_INITIATOR);
1949 
1950 error:
1951     dev_kfree_skb(resp);
1952     return rc;
1953 }
1954 
1955 static int pn533_rf_field(struct nfc_dev *nfc_dev, u8 rf);
1956 static int pn533_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
1957                  u8 comm_mode, u8 *gb, size_t gb_len)
1958 {
1959     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1960     struct sk_buff *skb;
1961     int rc, skb_len;
1962     u8 *next, *arg, nfcid3[NFC_NFCID3_MAXSIZE];
1963     u8 passive_data[PASSIVE_DATA_LEN] = {0x00, 0xff, 0xff, 0x00, 0x3};
1964 
1965     if (dev->poll_mod_count) {
1966         nfc_err(dev->dev,
1967             "Cannot bring the DEP link up while polling\n");
1968         return -EBUSY;
1969     }
1970 
1971     if (dev->tgt_active_prot) {
1972         nfc_err(dev->dev,
1973             "There is already an active target\n");
1974         return -EBUSY;
1975     }
1976 
1977     skb_len = 3 + gb_len; /* ActPass + BR + Next */
1978     skb_len += PASSIVE_DATA_LEN;
1979 
1980     /* NFCID3 */
1981     skb_len += NFC_NFCID3_MAXSIZE;
1982     if (target && !target->nfcid2_len) {
1983         nfcid3[0] = 0x1;
1984         nfcid3[1] = 0xfe;
1985         get_random_bytes(nfcid3 + 2, 6);
1986     }
1987 
1988     skb = pn533_alloc_skb(dev, skb_len);
1989     if (!skb)
1990         return -ENOMEM;
1991 
1992     skb_put_u8(skb, !comm_mode);  /* ActPass */
1993     skb_put_u8(skb, 0x02);  /* 424 kbps */
1994 
1995     next = skb_put(skb, 1);  /* Next */
1996     *next = 0;
1997 
1998     /* Copy passive data */
1999     skb_put_data(skb, passive_data, PASSIVE_DATA_LEN);
2000     *next |= 1;
2001 
2002     /* Copy NFCID3 (which is NFCID2 from SENSF_RES) */
2003     if (target && target->nfcid2_len)
2004         memcpy(skb_put(skb, NFC_NFCID3_MAXSIZE), target->nfcid2,
2005                target->nfcid2_len);
2006     else
2007         skb_put_data(skb, nfcid3, NFC_NFCID3_MAXSIZE);
2008     *next |= 2;
2009 
2010     if (gb != NULL && gb_len > 0) {
2011         skb_put_data(skb, gb, gb_len);
2012         *next |= 4; /* We have some Gi */
2013     } else {
2014         *next = 0;
2015     }
2016 
2017     arg = kmalloc(sizeof(*arg), GFP_KERNEL);
2018     if (!arg) {
2019         dev_kfree_skb(skb);
2020         return -ENOMEM;
2021     }
2022 
2023     *arg = !comm_mode;
2024 
2025     pn533_rf_field(dev->nfc_dev, 0);
2026 
2027     rc = pn533_send_cmd_async(dev, PN533_CMD_IN_JUMP_FOR_DEP, skb,
2028                   pn533_in_dep_link_up_complete, arg);
2029 
2030     if (rc < 0) {
2031         dev_kfree_skb(skb);
2032         kfree(arg);
2033     }
2034 
2035     return rc;
2036 }
2037 
2038 static int pn533_dep_link_down(struct nfc_dev *nfc_dev)
2039 {
2040     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2041 
2042     pn533_poll_reset_mod_list(dev);
2043 
2044     if (dev->tgt_mode || dev->tgt_active_prot)
2045         dev->phy_ops->abort_cmd(dev, GFP_KERNEL);
2046 
2047     dev->tgt_active_prot = 0;
2048     dev->tgt_mode = 0;
2049 
2050     skb_queue_purge(&dev->resp_q);
2051 
2052     return 0;
2053 }
2054 
2055 struct pn533_data_exchange_arg {
2056     data_exchange_cb_t cb;
2057     void *cb_context;
2058 };
2059 
2060 static struct sk_buff *pn533_build_response(struct pn533 *dev)
2061 {
2062     struct sk_buff *skb, *tmp, *t;
2063     unsigned int skb_len = 0, tmp_len = 0;
2064 
2065     if (skb_queue_empty(&dev->resp_q))
2066         return NULL;
2067 
2068     if (skb_queue_len(&dev->resp_q) == 1) {
2069         skb = skb_dequeue(&dev->resp_q);
2070         goto out;
2071     }
2072 
2073     skb_queue_walk_safe(&dev->resp_q, tmp, t)
2074         skb_len += tmp->len;
2075 
2076     dev_dbg(dev->dev, "%s total length %d\n",
2077         __func__, skb_len);
2078 
2079     skb = alloc_skb(skb_len, GFP_KERNEL);
2080     if (skb == NULL)
2081         goto out;
2082 
2083     skb_put(skb, skb_len);
2084 
2085     skb_queue_walk_safe(&dev->resp_q, tmp, t) {
2086         memcpy(skb->data + tmp_len, tmp->data, tmp->len);
2087         tmp_len += tmp->len;
2088     }
2089 
2090 out:
2091     skb_queue_purge(&dev->resp_q);
2092 
2093     return skb;
2094 }
2095 
2096 static int pn533_data_exchange_complete(struct pn533 *dev, void *_arg,
2097                     struct sk_buff *resp)
2098 {
2099     struct pn533_data_exchange_arg *arg = _arg;
2100     struct sk_buff *skb;
2101     int rc = 0;
2102     u8 status, ret, mi;
2103 
2104     if (IS_ERR(resp)) {
2105         rc = PTR_ERR(resp);
2106         goto _error;
2107     }
2108 
2109     status = resp->data[0];
2110     ret = status & PN533_CMD_RET_MASK;
2111     mi = status & PN533_CMD_MI_MASK;
2112 
2113     skb_pull(resp, sizeof(status));
2114 
2115     if (ret != PN533_CMD_RET_SUCCESS) {
2116         nfc_err(dev->dev,
2117             "Exchanging data failed (error 0x%x)\n", ret);
2118         rc = -EIO;
2119         goto error;
2120     }
2121 
2122     skb_queue_tail(&dev->resp_q, resp);
2123 
2124     if (mi) {
2125         dev->cmd_complete_mi_arg = arg;
2126         queue_work(dev->wq, &dev->mi_rx_work);
2127         return -EINPROGRESS;
2128     }
2129 
2130     /* Prepare for the next round */
2131     if (skb_queue_len(&dev->fragment_skb) > 0) {
2132         dev->cmd_complete_dep_arg = arg;
2133         queue_work(dev->wq, &dev->mi_tx_work);
2134 
2135         return -EINPROGRESS;
2136     }
2137 
2138     skb = pn533_build_response(dev);
2139     if (!skb) {
2140         rc = -ENOMEM;
2141         goto error;
2142     }
2143 
2144     arg->cb(arg->cb_context, skb, 0);
2145     kfree(arg);
2146     return 0;
2147 
2148 error:
2149     dev_kfree_skb(resp);
2150 _error:
2151     skb_queue_purge(&dev->resp_q);
2152     arg->cb(arg->cb_context, NULL, rc);
2153     kfree(arg);
2154     return rc;
2155 }
2156 
2157 /*
2158  * Receive an incoming pn533 frame. skb contains only header and payload.
2159  * If skb == NULL, it is a notification that the link below is dead.
2160  */
2161 void pn533_recv_frame(struct pn533 *dev, struct sk_buff *skb, int status)
2162 {
2163     if (!dev->cmd)
2164         goto sched_wq;
2165 
2166     dev->cmd->status = status;
2167 
2168     if (status != 0) {
2169         dev_dbg(dev->dev, "%s: Error received: %d\n", __func__, status);
2170         goto sched_wq;
2171     }
2172 
2173     if (skb == NULL) {
2174         dev_err(dev->dev, "NULL Frame -> link is dead\n");
2175         goto sched_wq;
2176     }
2177 
2178     if (pn533_rx_frame_is_ack(skb->data)) {
2179         dev_dbg(dev->dev, "%s: Received ACK frame\n", __func__);
2180         dev_kfree_skb(skb);
2181         return;
2182     }
2183 
2184     print_hex_dump_debug("PN533 RX: ", DUMP_PREFIX_NONE, 16, 1, skb->data,
2185                  dev->ops->rx_frame_size(skb->data), false);
2186 
2187     if (!dev->ops->rx_is_frame_valid(skb->data, dev)) {
2188         nfc_err(dev->dev, "Received an invalid frame\n");
2189         dev->cmd->status = -EIO;
2190     } else if (!pn533_rx_frame_is_cmd_response(dev, skb->data)) {
2191         nfc_err(dev->dev, "It it not the response to the last command\n");
2192         dev->cmd->status = -EIO;
2193     }
2194 
2195     dev->cmd->resp = skb;
2196 
2197 sched_wq:
2198     queue_work(dev->wq, &dev->cmd_complete_work);
2199 }
2200 EXPORT_SYMBOL(pn533_recv_frame);
2201 
2202 /* Split the Tx skb into small chunks */
2203 static int pn533_fill_fragment_skbs(struct pn533 *dev, struct sk_buff *skb)
2204 {
2205     struct sk_buff *frag;
2206     int  frag_size;
2207 
2208     do {
2209         /* Remaining size */
2210         if (skb->len > PN533_CMD_DATAFRAME_MAXLEN)
2211             frag_size = PN533_CMD_DATAFRAME_MAXLEN;
2212         else
2213             frag_size = skb->len;
2214 
2215         /* Allocate and reserve */
2216         frag = pn533_alloc_skb(dev, frag_size);
2217         if (!frag) {
2218             skb_queue_purge(&dev->fragment_skb);
2219             return -ENOMEM;
2220         }
2221 
2222         if (!dev->tgt_mode) {
2223             /* Reserve the TG/MI byte */
2224             skb_reserve(frag, 1);
2225 
2226             /* MI + TG */
2227             if (frag_size  == PN533_CMD_DATAFRAME_MAXLEN)
2228                 *(u8 *)skb_push(frag, sizeof(u8)) =
2229                         (PN533_CMD_MI_MASK | 1);
2230             else
2231                 *(u8 *)skb_push(frag, sizeof(u8)) =  1; /* TG */
2232         }
2233 
2234         skb_put_data(frag, skb->data, frag_size);
2235 
2236         /* Reduce the size of incoming buffer */
2237         skb_pull(skb, frag_size);
2238 
2239         /* Add this to skb_queue */
2240         skb_queue_tail(&dev->fragment_skb, frag);
2241 
2242     } while (skb->len > 0);
2243 
2244     dev_kfree_skb(skb);
2245 
2246     return skb_queue_len(&dev->fragment_skb);
2247 }
2248 
2249 static int pn533_transceive(struct nfc_dev *nfc_dev,
2250                 struct nfc_target *target, struct sk_buff *skb,
2251                 data_exchange_cb_t cb, void *cb_context)
2252 {
2253     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2254     struct pn533_data_exchange_arg *arg = NULL;
2255     int rc;
2256 
2257     if (!dev->tgt_active_prot) {
2258         nfc_err(dev->dev,
2259             "Can't exchange data if there is no active target\n");
2260         rc = -EINVAL;
2261         goto error;
2262     }
2263 
2264     arg = kmalloc(sizeof(*arg), GFP_KERNEL);
2265     if (!arg) {
2266         rc = -ENOMEM;
2267         goto error;
2268     }
2269 
2270     arg->cb = cb;
2271     arg->cb_context = cb_context;
2272 
2273     switch (dev->device_type) {
2274     case PN533_DEVICE_PASORI:
2275         if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
2276             rc = pn533_send_data_async(dev, PN533_CMD_IN_COMM_THRU,
2277                            skb,
2278                            pn533_data_exchange_complete,
2279                            arg);
2280 
2281             break;
2282         }
2283         fallthrough;
2284     default:
2285         /* jumbo frame ? */
2286         if (skb->len > PN533_CMD_DATAEXCH_DATA_MAXLEN) {
2287             rc = pn533_fill_fragment_skbs(dev, skb);
2288             if (rc < 0)
2289                 goto error;
2290 
2291             skb = skb_dequeue(&dev->fragment_skb);
2292             if (!skb) {
2293                 rc = -EIO;
2294                 goto error;
2295             }
2296         } else {
2297             *(u8 *)skb_push(skb, sizeof(u8)) =  1; /* TG */
2298         }
2299 
2300         rc = pn533_send_data_async(dev, PN533_CMD_IN_DATA_EXCHANGE,
2301                        skb, pn533_data_exchange_complete,
2302                        arg);
2303 
2304         break;
2305     }
2306 
2307     if (rc < 0) /* rc from send_async */
2308         goto error;
2309 
2310     return 0;
2311 
2312 error:
2313     kfree(arg);
2314     dev_kfree_skb(skb);
2315     return rc;
2316 }
2317 
2318 static int pn533_tm_send_complete(struct pn533 *dev, void *arg,
2319                   struct sk_buff *resp)
2320 {
2321     u8 status;
2322 
2323     if (IS_ERR(resp))
2324         return PTR_ERR(resp);
2325 
2326     status = resp->data[0];
2327 
2328     /* Prepare for the next round */
2329     if (skb_queue_len(&dev->fragment_skb) > 0) {
2330         queue_work(dev->wq, &dev->mi_tm_tx_work);
2331         return -EINPROGRESS;
2332     }
2333     dev_kfree_skb(resp);
2334 
2335     if (status != 0) {
2336         nfc_tm_deactivated(dev->nfc_dev);
2337 
2338         dev->tgt_mode = 0;
2339 
2340         return 0;
2341     }
2342 
2343     queue_work(dev->wq, &dev->tg_work);
2344 
2345     return 0;
2346 }
2347 
2348 static int pn533_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
2349 {
2350     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2351     int rc;
2352 
2353     /* let's split in multiple chunks if size's too big */
2354     if (skb->len > PN533_CMD_DATAEXCH_DATA_MAXLEN) {
2355         rc = pn533_fill_fragment_skbs(dev, skb);
2356         if (rc < 0)
2357             goto error;
2358 
2359         /* get the first skb */
2360         skb = skb_dequeue(&dev->fragment_skb);
2361         if (!skb) {
2362             rc = -EIO;
2363             goto error;
2364         }
2365 
2366         rc = pn533_send_data_async(dev, PN533_CMD_TG_SET_META_DATA, skb,
2367                         pn533_tm_send_complete, NULL);
2368     } else {
2369         /* Send th skb */
2370         rc = pn533_send_data_async(dev, PN533_CMD_TG_SET_DATA, skb,
2371                         pn533_tm_send_complete, NULL);
2372     }
2373 
2374 error:
2375     if (rc < 0) {
2376         dev_kfree_skb(skb);
2377         skb_queue_purge(&dev->fragment_skb);
2378     }
2379 
2380     return rc;
2381 }
2382 
2383 static void pn533_wq_mi_recv(struct work_struct *work)
2384 {
2385     struct pn533 *dev = container_of(work, struct pn533, mi_rx_work);
2386     struct sk_buff *skb;
2387     int rc;
2388 
2389     skb = pn533_alloc_skb(dev, PN533_CMD_DATAEXCH_HEAD_LEN);
2390     if (!skb)
2391         goto error;
2392 
2393     switch (dev->device_type) {
2394     case PN533_DEVICE_PASORI:
2395         if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
2396             rc = pn533_send_cmd_direct_async(dev,
2397                         PN533_CMD_IN_COMM_THRU,
2398                         skb,
2399                         pn533_data_exchange_complete,
2400                          dev->cmd_complete_mi_arg);
2401 
2402             break;
2403         }
2404         fallthrough;
2405     default:
2406         skb_put_u8(skb, 1); /*TG*/
2407 
2408         rc = pn533_send_cmd_direct_async(dev,
2409                          PN533_CMD_IN_DATA_EXCHANGE,
2410                          skb,
2411                          pn533_data_exchange_complete,
2412                          dev->cmd_complete_mi_arg);
2413 
2414         break;
2415     }
2416 
2417     if (rc == 0) /* success */
2418         return;
2419 
2420     nfc_err(dev->dev,
2421         "Error %d when trying to perform data_exchange\n", rc);
2422 
2423     dev_kfree_skb(skb);
2424     kfree(dev->cmd_complete_mi_arg);
2425 
2426 error:
2427     dev->phy_ops->send_ack(dev, GFP_KERNEL);
2428     queue_work(dev->wq, &dev->cmd_work);
2429 }
2430 
2431 static void pn533_wq_mi_send(struct work_struct *work)
2432 {
2433     struct pn533 *dev = container_of(work, struct pn533, mi_tx_work);
2434     struct sk_buff *skb;
2435     int rc;
2436 
2437     /* Grab the first skb in the queue */
2438     skb = skb_dequeue(&dev->fragment_skb);
2439 
2440     if (skb == NULL) {  /* No more data */
2441         /* Reset the queue for future use */
2442         skb_queue_head_init(&dev->fragment_skb);
2443         goto error;
2444     }
2445 
2446     switch (dev->device_type) {
2447     case PN533_DEVICE_PASORI:
2448         if (dev->tgt_active_prot != NFC_PROTO_FELICA) {
2449             rc = -EIO;
2450             break;
2451         }
2452 
2453         rc = pn533_send_cmd_direct_async(dev, PN533_CMD_IN_COMM_THRU,
2454                          skb,
2455                          pn533_data_exchange_complete,
2456                          dev->cmd_complete_dep_arg);
2457 
2458         break;
2459 
2460     default:
2461         /* Still some fragments? */
2462         rc = pn533_send_cmd_direct_async(dev,
2463                          PN533_CMD_IN_DATA_EXCHANGE,
2464                          skb,
2465                          pn533_data_exchange_complete,
2466                          dev->cmd_complete_dep_arg);
2467 
2468         break;
2469     }
2470 
2471     if (rc == 0) /* success */
2472         return;
2473 
2474     nfc_err(dev->dev,
2475         "Error %d when trying to perform data_exchange\n", rc);
2476 
2477     dev_kfree_skb(skb);
2478     kfree(dev->cmd_complete_dep_arg);
2479 
2480 error:
2481     dev->phy_ops->send_ack(dev, GFP_KERNEL);
2482     queue_work(dev->wq, &dev->cmd_work);
2483 }
2484 
2485 static int pn533_set_configuration(struct pn533 *dev, u8 cfgitem, u8 *cfgdata,
2486                                 u8 cfgdata_len)
2487 {
2488     struct sk_buff *skb;
2489     struct sk_buff *resp;
2490     int skb_len;
2491 
2492     skb_len = sizeof(cfgitem) + cfgdata_len; /* cfgitem + cfgdata */
2493 
2494     skb = pn533_alloc_skb(dev, skb_len);
2495     if (!skb)
2496         return -ENOMEM;
2497 
2498     skb_put_u8(skb, cfgitem);
2499     skb_put_data(skb, cfgdata, cfgdata_len);
2500 
2501     resp = pn533_send_cmd_sync(dev, PN533_CMD_RF_CONFIGURATION, skb);
2502     if (IS_ERR(resp))
2503         return PTR_ERR(resp);
2504 
2505     dev_kfree_skb(resp);
2506     return 0;
2507 }
2508 
2509 static int pn533_get_firmware_version(struct pn533 *dev,
2510                       struct pn533_fw_version *fv)
2511 {
2512     struct sk_buff *skb;
2513     struct sk_buff *resp;
2514 
2515     skb = pn533_alloc_skb(dev, 0);
2516     if (!skb)
2517         return -ENOMEM;
2518 
2519     resp = pn533_send_cmd_sync(dev, PN533_CMD_GET_FIRMWARE_VERSION, skb);
2520     if (IS_ERR(resp))
2521         return PTR_ERR(resp);
2522 
2523     fv->ic = resp->data[0];
2524     fv->ver = resp->data[1];
2525     fv->rev = resp->data[2];
2526     fv->support = resp->data[3];
2527 
2528     dev_kfree_skb(resp);
2529     return 0;
2530 }
2531 
2532 static int pn533_pasori_fw_reset(struct pn533 *dev)
2533 {
2534     struct sk_buff *skb;
2535     struct sk_buff *resp;
2536 
2537     skb = pn533_alloc_skb(dev, sizeof(u8));
2538     if (!skb)
2539         return -ENOMEM;
2540 
2541     skb_put_u8(skb, 0x1);
2542 
2543     resp = pn533_send_cmd_sync(dev, 0x18, skb);
2544     if (IS_ERR(resp))
2545         return PTR_ERR(resp);
2546 
2547     dev_kfree_skb(resp);
2548 
2549     return 0;
2550 }
2551 
2552 static int pn533_rf_field(struct nfc_dev *nfc_dev, u8 rf)
2553 {
2554     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2555     u8 rf_field = !!rf;
2556     int rc;
2557 
2558     rf_field |= PN533_CFGITEM_RF_FIELD_AUTO_RFCA;
2559 
2560     rc = pn533_set_configuration(dev, PN533_CFGITEM_RF_FIELD,
2561                      (u8 *)&rf_field, 1);
2562     if (rc) {
2563         nfc_err(dev->dev, "Error on setting RF field\n");
2564         return rc;
2565     }
2566 
2567     return 0;
2568 }
2569 
2570 static int pn532_sam_configuration(struct nfc_dev *nfc_dev)
2571 {
2572     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2573     struct sk_buff *skb;
2574     struct sk_buff *resp;
2575 
2576     skb = pn533_alloc_skb(dev, 1);
2577     if (!skb)
2578         return -ENOMEM;
2579 
2580     skb_put_u8(skb, 0x01);
2581 
2582     resp = pn533_send_cmd_sync(dev, PN533_CMD_SAM_CONFIGURATION, skb);
2583     if (IS_ERR(resp))
2584         return PTR_ERR(resp);
2585 
2586     dev_kfree_skb(resp);
2587     return 0;
2588 }
2589 
2590 static int pn533_dev_up(struct nfc_dev *nfc_dev)
2591 {
2592     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2593     int rc;
2594 
2595     if (dev->phy_ops->dev_up) {
2596         rc = dev->phy_ops->dev_up(dev);
2597         if (rc)
2598             return rc;
2599     }
2600 
2601     if ((dev->device_type == PN533_DEVICE_PN532) ||
2602         (dev->device_type == PN533_DEVICE_PN532_AUTOPOLL)) {
2603         rc = pn532_sam_configuration(nfc_dev);
2604 
2605         if (rc)
2606             return rc;
2607     }
2608 
2609     return pn533_rf_field(nfc_dev, 1);
2610 }
2611 
2612 static int pn533_dev_down(struct nfc_dev *nfc_dev)
2613 {
2614     struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2615     int ret;
2616 
2617     ret = pn533_rf_field(nfc_dev, 0);
2618     if (dev->phy_ops->dev_down && !ret)
2619         ret = dev->phy_ops->dev_down(dev);
2620 
2621     return ret;
2622 }
2623 
2624 static const struct nfc_ops pn533_nfc_ops = {
2625     .dev_up = pn533_dev_up,
2626     .dev_down = pn533_dev_down,
2627     .dep_link_up = pn533_dep_link_up,
2628     .dep_link_down = pn533_dep_link_down,
2629     .start_poll = pn533_start_poll,
2630     .stop_poll = pn533_stop_poll,
2631     .activate_target = pn533_activate_target,
2632     .deactivate_target = pn533_deactivate_target,
2633     .im_transceive = pn533_transceive,
2634     .tm_send = pn533_tm_send,
2635 };
2636 
2637 static int pn533_setup(struct pn533 *dev)
2638 {
2639     struct pn533_config_max_retries max_retries;
2640     struct pn533_config_timing timing;
2641     u8 pasori_cfg[3] = {0x08, 0x01, 0x08};
2642     int rc;
2643 
2644     switch (dev->device_type) {
2645     case PN533_DEVICE_STD:
2646     case PN533_DEVICE_PASORI:
2647     case PN533_DEVICE_ACR122U:
2648     case PN533_DEVICE_PN532:
2649     case PN533_DEVICE_PN532_AUTOPOLL:
2650         max_retries.mx_rty_atr = 0x2;
2651         max_retries.mx_rty_psl = 0x1;
2652         max_retries.mx_rty_passive_act =
2653             PN533_CONFIG_MAX_RETRIES_NO_RETRY;
2654 
2655         timing.rfu = PN533_CONFIG_TIMING_102;
2656         timing.atr_res_timeout = PN533_CONFIG_TIMING_102;
2657         timing.dep_timeout = PN533_CONFIG_TIMING_204;
2658 
2659         break;
2660 
2661     default:
2662         nfc_err(dev->dev, "Unknown device type %d\n",
2663             dev->device_type);
2664         return -EINVAL;
2665     }
2666 
2667     rc = pn533_set_configuration(dev, PN533_CFGITEM_MAX_RETRIES,
2668                      (u8 *)&max_retries, sizeof(max_retries));
2669     if (rc) {
2670         nfc_err(dev->dev,
2671             "Error on setting MAX_RETRIES config\n");
2672         return rc;
2673     }
2674 
2675 
2676     rc = pn533_set_configuration(dev, PN533_CFGITEM_TIMING,
2677                      (u8 *)&timing, sizeof(timing));
2678     if (rc) {
2679         nfc_err(dev->dev, "Error on setting RF timings\n");
2680         return rc;
2681     }
2682 
2683     switch (dev->device_type) {
2684     case PN533_DEVICE_STD:
2685     case PN533_DEVICE_PN532:
2686     case PN533_DEVICE_PN532_AUTOPOLL:
2687         break;
2688 
2689     case PN533_DEVICE_PASORI:
2690         pn533_pasori_fw_reset(dev);
2691 
2692         rc = pn533_set_configuration(dev, PN533_CFGITEM_PASORI,
2693                          pasori_cfg, 3);
2694         if (rc) {
2695             nfc_err(dev->dev,
2696                 "Error while settings PASORI config\n");
2697             return rc;
2698         }
2699 
2700         pn533_pasori_fw_reset(dev);
2701 
2702         break;
2703     }
2704 
2705     return 0;
2706 }
2707 
2708 int pn533_finalize_setup(struct pn533 *dev)
2709 {
2710 
2711     struct pn533_fw_version fw_ver;
2712     int rc;
2713 
2714     memset(&fw_ver, 0, sizeof(fw_ver));
2715 
2716     rc = pn533_get_firmware_version(dev, &fw_ver);
2717     if (rc) {
2718         nfc_err(dev->dev, "Unable to get FW version\n");
2719         return rc;
2720     }
2721 
2722     nfc_info(dev->dev, "NXP PN5%02X firmware ver %d.%d now attached\n",
2723         fw_ver.ic, fw_ver.ver, fw_ver.rev);
2724 
2725     rc = pn533_setup(dev);
2726     if (rc)
2727         return rc;
2728 
2729     return 0;
2730 }
2731 EXPORT_SYMBOL_GPL(pn533_finalize_setup);
2732 
2733 struct pn533 *pn53x_common_init(u32 device_type,
2734                 enum pn533_protocol_type protocol_type,
2735                 void *phy,
2736                 const struct pn533_phy_ops *phy_ops,
2737                 struct pn533_frame_ops *fops,
2738                 struct device *dev)
2739 {
2740     struct pn533 *priv;
2741 
2742     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
2743     if (!priv)
2744         return ERR_PTR(-ENOMEM);
2745 
2746     priv->phy = phy;
2747     priv->phy_ops = phy_ops;
2748     priv->dev = dev;
2749     if (fops != NULL)
2750         priv->ops = fops;
2751     else
2752         priv->ops = &pn533_std_frame_ops;
2753 
2754     priv->protocol_type = protocol_type;
2755     priv->device_type = device_type;
2756 
2757     mutex_init(&priv->cmd_lock);
2758 
2759     INIT_WORK(&priv->cmd_work, pn533_wq_cmd);
2760     INIT_WORK(&priv->cmd_complete_work, pn533_wq_cmd_complete);
2761     INIT_WORK(&priv->mi_rx_work, pn533_wq_mi_recv);
2762     INIT_WORK(&priv->mi_tx_work, pn533_wq_mi_send);
2763     INIT_WORK(&priv->tg_work, pn533_wq_tg_get_data);
2764     INIT_WORK(&priv->mi_tm_rx_work, pn533_wq_tm_mi_recv);
2765     INIT_WORK(&priv->mi_tm_tx_work, pn533_wq_tm_mi_send);
2766     INIT_DELAYED_WORK(&priv->poll_work, pn533_wq_poll);
2767     INIT_WORK(&priv->rf_work, pn533_wq_rf);
2768     priv->wq = alloc_ordered_workqueue("pn533", 0);
2769     if (priv->wq == NULL)
2770         goto error;
2771 
2772     timer_setup(&priv->listen_timer, pn533_listen_mode_timer, 0);
2773 
2774     skb_queue_head_init(&priv->resp_q);
2775     skb_queue_head_init(&priv->fragment_skb);
2776 
2777     INIT_LIST_HEAD(&priv->cmd_queue);
2778     return priv;
2779 
2780 error:
2781     kfree(priv);
2782     return ERR_PTR(-ENOMEM);
2783 }
2784 EXPORT_SYMBOL_GPL(pn53x_common_init);
2785 
2786 void pn53x_common_clean(struct pn533 *priv)
2787 {
2788     struct pn533_cmd *cmd, *n;
2789 
2790     /* delete the timer before cleanup the worker */
2791     del_timer_sync(&priv->listen_timer);
2792 
2793     flush_delayed_work(&priv->poll_work);
2794     destroy_workqueue(priv->wq);
2795 
2796     skb_queue_purge(&priv->resp_q);
2797 
2798     list_for_each_entry_safe(cmd, n, &priv->cmd_queue, queue) {
2799         list_del(&cmd->queue);
2800         kfree(cmd);
2801     }
2802 
2803     kfree(priv);
2804 }
2805 EXPORT_SYMBOL_GPL(pn53x_common_clean);
2806 
2807 int pn532_i2c_nfc_alloc(struct pn533 *priv, u32 protocols,
2808             struct device *parent)
2809 {
2810     priv->nfc_dev = nfc_allocate_device(&pn533_nfc_ops, protocols,
2811                        priv->ops->tx_header_len +
2812                        PN533_CMD_DATAEXCH_HEAD_LEN,
2813                        priv->ops->tx_tail_len);
2814     if (!priv->nfc_dev)
2815         return -ENOMEM;
2816 
2817     nfc_set_parent_dev(priv->nfc_dev, parent);
2818     nfc_set_drvdata(priv->nfc_dev, priv);
2819     return 0;
2820 }
2821 EXPORT_SYMBOL_GPL(pn532_i2c_nfc_alloc);
2822 
2823 int pn53x_register_nfc(struct pn533 *priv, u32 protocols,
2824             struct device *parent)
2825 {
2826     int rc;
2827 
2828     rc = pn532_i2c_nfc_alloc(priv, protocols, parent);
2829     if (rc)
2830         return rc;
2831 
2832     rc = nfc_register_device(priv->nfc_dev);
2833     if (rc)
2834         nfc_free_device(priv->nfc_dev);
2835 
2836     return rc;
2837 }
2838 EXPORT_SYMBOL_GPL(pn53x_register_nfc);
2839 
2840 void pn53x_unregister_nfc(struct pn533 *priv)
2841 {
2842     nfc_unregister_device(priv->nfc_dev);
2843     nfc_free_device(priv->nfc_dev);
2844 }
2845 EXPORT_SYMBOL_GPL(pn53x_unregister_nfc);
2846 
2847 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
2848 MODULE_AUTHOR("Aloisio Almeida Jr <aloisio.almeida@openbossa.org>");
2849 MODULE_AUTHOR("Waldemar Rymarkiewicz <waldemar.rymarkiewicz@tieto.com>");
2850 MODULE_DESCRIPTION("PN533 driver ver " VERSION);
2851 MODULE_VERSION(VERSION);
2852 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!