Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Driver for NXP PN533 NFC Chip - USB transport layer
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/usb.h>
0014 #include <linux/nfc.h>
0015 #include <linux/netdevice.h>
0016 #include <net/nfc/nfc.h>
0017 #include "pn533.h"
0018 
0019 #define VERSION "0.1"
0020 
0021 #define PN533_VENDOR_ID 0x4CC
0022 #define PN533_PRODUCT_ID 0x2533
0023 
0024 #define SCM_VENDOR_ID 0x4E6
0025 #define SCL3711_PRODUCT_ID 0x5591
0026 
0027 #define SONY_VENDOR_ID         0x054c
0028 #define PASORI_PRODUCT_ID      0x02e1
0029 
0030 #define ACS_VENDOR_ID 0x072f
0031 #define ACR122U_PRODUCT_ID 0x2200
0032 
0033 static const struct usb_device_id pn533_usb_table[] = {
0034     { USB_DEVICE(PN533_VENDOR_ID, PN533_PRODUCT_ID),
0035       .driver_info = PN533_DEVICE_STD },
0036     { USB_DEVICE(SCM_VENDOR_ID, SCL3711_PRODUCT_ID),
0037       .driver_info = PN533_DEVICE_STD },
0038     { USB_DEVICE(SONY_VENDOR_ID, PASORI_PRODUCT_ID),
0039       .driver_info = PN533_DEVICE_PASORI },
0040     { USB_DEVICE(ACS_VENDOR_ID, ACR122U_PRODUCT_ID),
0041       .driver_info = PN533_DEVICE_ACR122U },
0042     { }
0043 };
0044 MODULE_DEVICE_TABLE(usb, pn533_usb_table);
0045 
0046 struct pn533_usb_phy {
0047     struct usb_device *udev;
0048     struct usb_interface *interface;
0049 
0050     struct urb *out_urb;
0051     struct urb *in_urb;
0052 
0053     struct urb *ack_urb;
0054     u8 *ack_buffer;
0055 
0056     struct pn533 *priv;
0057 };
0058 
0059 static void pn533_recv_response(struct urb *urb)
0060 {
0061     struct pn533_usb_phy *phy = urb->context;
0062     struct sk_buff *skb = NULL;
0063 
0064     if (!urb->status) {
0065         skb = alloc_skb(urb->actual_length, GFP_ATOMIC);
0066         if (!skb) {
0067             nfc_err(&phy->udev->dev, "failed to alloc memory\n");
0068         } else {
0069             skb_put_data(skb, urb->transfer_buffer,
0070                      urb->actual_length);
0071         }
0072     }
0073 
0074     pn533_recv_frame(phy->priv, skb, urb->status);
0075 }
0076 
0077 static int pn533_submit_urb_for_response(struct pn533_usb_phy *phy, gfp_t flags)
0078 {
0079     phy->in_urb->complete = pn533_recv_response;
0080 
0081     return usb_submit_urb(phy->in_urb, flags);
0082 }
0083 
0084 static void pn533_recv_ack(struct urb *urb)
0085 {
0086     struct pn533_usb_phy *phy = urb->context;
0087     struct pn533 *priv = phy->priv;
0088     struct pn533_cmd *cmd = priv->cmd;
0089     struct pn533_std_frame *in_frame;
0090     int rc;
0091 
0092     cmd->status = urb->status;
0093 
0094     switch (urb->status) {
0095     case 0:
0096         break; /* success */
0097     case -ECONNRESET:
0098     case -ENOENT:
0099         dev_dbg(&phy->udev->dev,
0100             "The urb has been stopped (status %d)\n",
0101             urb->status);
0102         goto sched_wq;
0103     case -ESHUTDOWN:
0104     default:
0105         nfc_err(&phy->udev->dev,
0106             "Urb failure (status %d)\n", urb->status);
0107         goto sched_wq;
0108     }
0109 
0110     in_frame = phy->in_urb->transfer_buffer;
0111 
0112     if (!pn533_rx_frame_is_ack(in_frame)) {
0113         nfc_err(&phy->udev->dev, "Received an invalid ack\n");
0114         cmd->status = -EIO;
0115         goto sched_wq;
0116     }
0117 
0118     rc = pn533_submit_urb_for_response(phy, GFP_ATOMIC);
0119     if (rc) {
0120         nfc_err(&phy->udev->dev,
0121             "usb_submit_urb failed with result %d\n", rc);
0122         cmd->status = rc;
0123         goto sched_wq;
0124     }
0125 
0126     return;
0127 
0128 sched_wq:
0129     queue_work(priv->wq, &priv->cmd_complete_work);
0130 }
0131 
0132 static int pn533_submit_urb_for_ack(struct pn533_usb_phy *phy, gfp_t flags)
0133 {
0134     phy->in_urb->complete = pn533_recv_ack;
0135 
0136     return usb_submit_urb(phy->in_urb, flags);
0137 }
0138 
0139 static int pn533_usb_send_ack(struct pn533 *dev, gfp_t flags)
0140 {
0141     struct pn533_usb_phy *phy = dev->phy;
0142     static const u8 ack[6] = {0x00, 0x00, 0xff, 0x00, 0xff, 0x00};
0143     /* spec 7.1.1.3:  Preamble, SoPC (2), ACK Code (2), Postamble */
0144 
0145     if (!phy->ack_buffer) {
0146         phy->ack_buffer = kmemdup(ack, sizeof(ack), flags);
0147         if (!phy->ack_buffer)
0148             return -ENOMEM;
0149     }
0150 
0151     phy->ack_urb->transfer_buffer = phy->ack_buffer;
0152     phy->ack_urb->transfer_buffer_length = sizeof(ack);
0153     return usb_submit_urb(phy->ack_urb, flags);
0154 }
0155 
0156 static int pn533_usb_send_frame(struct pn533 *dev,
0157                 struct sk_buff *out)
0158 {
0159     struct pn533_usb_phy *phy = dev->phy;
0160     int rc;
0161 
0162     if (phy->priv == NULL)
0163         phy->priv = dev;
0164 
0165     phy->out_urb->transfer_buffer = out->data;
0166     phy->out_urb->transfer_buffer_length = out->len;
0167 
0168     print_hex_dump_debug("PN533 TX: ", DUMP_PREFIX_NONE, 16, 1,
0169                  out->data, out->len, false);
0170 
0171     rc = usb_submit_urb(phy->out_urb, GFP_KERNEL);
0172     if (rc)
0173         return rc;
0174 
0175     if (dev->protocol_type == PN533_PROTO_REQ_RESP) {
0176         /* request for response for sent packet directly */
0177         rc = pn533_submit_urb_for_response(phy, GFP_KERNEL);
0178         if (rc)
0179             goto error;
0180     } else if (dev->protocol_type == PN533_PROTO_REQ_ACK_RESP) {
0181         /* request for ACK if that's the case */
0182         rc = pn533_submit_urb_for_ack(phy, GFP_KERNEL);
0183         if (rc)
0184             goto error;
0185     }
0186 
0187     return 0;
0188 
0189 error:
0190     usb_unlink_urb(phy->out_urb);
0191     return rc;
0192 }
0193 
0194 static void pn533_usb_abort_cmd(struct pn533 *dev, gfp_t flags)
0195 {
0196     struct pn533_usb_phy *phy = dev->phy;
0197 
0198     /* ACR122U does not support any command which aborts last
0199      * issued command i.e. as ACK for standard PN533. Additionally,
0200      * it behaves stange, sending broken or incorrect responses,
0201      * when we cancel urb before the chip will send response.
0202      */
0203     if (dev->device_type == PN533_DEVICE_ACR122U)
0204         return;
0205 
0206     /* An ack will cancel the last issued command */
0207     pn533_usb_send_ack(dev, flags);
0208 
0209     /* cancel the urb request */
0210     usb_kill_urb(phy->in_urb);
0211 }
0212 
0213 /* ACR122 specific structs and functions */
0214 
0215 /* ACS ACR122 pn533 frame definitions */
0216 #define PN533_ACR122_TX_FRAME_HEADER_LEN (sizeof(struct pn533_acr122_tx_frame) \
0217                       + 2)
0218 #define PN533_ACR122_TX_FRAME_TAIL_LEN 0
0219 #define PN533_ACR122_RX_FRAME_HEADER_LEN (sizeof(struct pn533_acr122_rx_frame) \
0220                       + 2)
0221 #define PN533_ACR122_RX_FRAME_TAIL_LEN 2
0222 #define PN533_ACR122_FRAME_MAX_PAYLOAD_LEN PN533_STD_FRAME_MAX_PAYLOAD_LEN
0223 
0224 /* CCID messages types */
0225 #define PN533_ACR122_PC_TO_RDR_ICCPOWERON 0x62
0226 #define PN533_ACR122_PC_TO_RDR_ESCAPE 0x6B
0227 
0228 #define PN533_ACR122_RDR_TO_PC_ESCAPE 0x83
0229 
0230 
0231 struct pn533_acr122_ccid_hdr {
0232     u8 type;
0233     u32 datalen;
0234     u8 slot;
0235     u8 seq;
0236 
0237     /*
0238      * 3 msg specific bytes or status, error and 1 specific
0239      * byte for reposnse msg
0240      */
0241     u8 params[3];
0242     u8 data[]; /* payload */
0243 } __packed;
0244 
0245 struct pn533_acr122_apdu_hdr {
0246     u8 class;
0247     u8 ins;
0248     u8 p1;
0249     u8 p2;
0250 } __packed;
0251 
0252 struct pn533_acr122_tx_frame {
0253     struct pn533_acr122_ccid_hdr ccid;
0254     struct pn533_acr122_apdu_hdr apdu;
0255     u8 datalen;
0256     u8 data[]; /* pn533 frame: TFI ... */
0257 } __packed;
0258 
0259 struct pn533_acr122_rx_frame {
0260     struct pn533_acr122_ccid_hdr ccid;
0261     u8 data[]; /* pn533 frame : TFI ... */
0262 } __packed;
0263 
0264 static void pn533_acr122_tx_frame_init(void *_frame, u8 cmd_code)
0265 {
0266     struct pn533_acr122_tx_frame *frame = _frame;
0267 
0268     frame->ccid.type = PN533_ACR122_PC_TO_RDR_ESCAPE;
0269     /* sizeof(apdu_hdr) + sizeof(datalen) */
0270     frame->ccid.datalen = sizeof(frame->apdu) + 1;
0271     frame->ccid.slot = 0;
0272     frame->ccid.seq = 0;
0273     frame->ccid.params[0] = 0;
0274     frame->ccid.params[1] = 0;
0275     frame->ccid.params[2] = 0;
0276 
0277     frame->data[0] = PN533_STD_FRAME_DIR_OUT;
0278     frame->data[1] = cmd_code;
0279     frame->datalen = 2;  /* data[0] + data[1] */
0280 
0281     frame->apdu.class = 0xFF;
0282     frame->apdu.ins = 0;
0283     frame->apdu.p1 = 0;
0284     frame->apdu.p2 = 0;
0285 }
0286 
0287 static void pn533_acr122_tx_frame_finish(void *_frame)
0288 {
0289     struct pn533_acr122_tx_frame *frame = _frame;
0290 
0291     frame->ccid.datalen += frame->datalen;
0292 }
0293 
0294 static void pn533_acr122_tx_update_payload_len(void *_frame, int len)
0295 {
0296     struct pn533_acr122_tx_frame *frame = _frame;
0297 
0298     frame->datalen += len;
0299 }
0300 
0301 static bool pn533_acr122_is_rx_frame_valid(void *_frame, struct pn533 *dev)
0302 {
0303     struct pn533_acr122_rx_frame *frame = _frame;
0304 
0305     if (frame->ccid.type != 0x83)
0306         return false;
0307 
0308     if (!frame->ccid.datalen)
0309         return false;
0310 
0311     if (frame->data[frame->ccid.datalen - 2] == 0x63)
0312         return false;
0313 
0314     return true;
0315 }
0316 
0317 static int pn533_acr122_rx_frame_size(void *frame)
0318 {
0319     struct pn533_acr122_rx_frame *f = frame;
0320 
0321     /* f->ccid.datalen already includes tail length */
0322     return sizeof(struct pn533_acr122_rx_frame) + f->ccid.datalen;
0323 }
0324 
0325 static u8 pn533_acr122_get_cmd_code(void *frame)
0326 {
0327     struct pn533_acr122_rx_frame *f = frame;
0328 
0329     return PN533_FRAME_CMD(f);
0330 }
0331 
0332 static struct pn533_frame_ops pn533_acr122_frame_ops = {
0333     .tx_frame_init = pn533_acr122_tx_frame_init,
0334     .tx_frame_finish = pn533_acr122_tx_frame_finish,
0335     .tx_update_payload_len = pn533_acr122_tx_update_payload_len,
0336     .tx_header_len = PN533_ACR122_TX_FRAME_HEADER_LEN,
0337     .tx_tail_len = PN533_ACR122_TX_FRAME_TAIL_LEN,
0338 
0339     .rx_is_frame_valid = pn533_acr122_is_rx_frame_valid,
0340     .rx_header_len = PN533_ACR122_RX_FRAME_HEADER_LEN,
0341     .rx_tail_len = PN533_ACR122_RX_FRAME_TAIL_LEN,
0342     .rx_frame_size = pn533_acr122_rx_frame_size,
0343 
0344     .max_payload_len = PN533_ACR122_FRAME_MAX_PAYLOAD_LEN,
0345     .get_cmd_code = pn533_acr122_get_cmd_code,
0346 };
0347 
0348 struct pn533_acr122_poweron_rdr_arg {
0349     int rc;
0350     struct completion done;
0351 };
0352 
0353 static void pn533_acr122_poweron_rdr_resp(struct urb *urb)
0354 {
0355     struct pn533_acr122_poweron_rdr_arg *arg = urb->context;
0356 
0357     print_hex_dump_debug("ACR122 RX: ", DUMP_PREFIX_NONE, 16, 1,
0358                urb->transfer_buffer, urb->transfer_buffer_length,
0359                false);
0360 
0361     arg->rc = urb->status;
0362     complete(&arg->done);
0363 }
0364 
0365 static int pn533_acr122_poweron_rdr(struct pn533_usb_phy *phy)
0366 {
0367     /* Power on th reader (CCID cmd) */
0368     u8 cmd[10] = {PN533_ACR122_PC_TO_RDR_ICCPOWERON,
0369               0, 0, 0, 0, 0, 0, 3, 0, 0};
0370     char *buffer;
0371     int transferred;
0372     int rc;
0373     void *cntx;
0374     struct pn533_acr122_poweron_rdr_arg arg;
0375 
0376     buffer = kmemdup(cmd, sizeof(cmd), GFP_KERNEL);
0377     if (!buffer)
0378         return -ENOMEM;
0379 
0380     init_completion(&arg.done);
0381     cntx = phy->in_urb->context;  /* backup context */
0382 
0383     phy->in_urb->complete = pn533_acr122_poweron_rdr_resp;
0384     phy->in_urb->context = &arg;
0385 
0386     print_hex_dump_debug("ACR122 TX: ", DUMP_PREFIX_NONE, 16, 1,
0387                cmd, sizeof(cmd), false);
0388 
0389     rc = usb_bulk_msg(phy->udev, phy->out_urb->pipe, buffer, sizeof(cmd),
0390               &transferred, 5000);
0391     kfree(buffer);
0392     if (rc || (transferred != sizeof(cmd))) {
0393         nfc_err(&phy->udev->dev,
0394             "Reader power on cmd error %d\n", rc);
0395         return rc;
0396     }
0397 
0398     rc =  usb_submit_urb(phy->in_urb, GFP_KERNEL);
0399     if (rc) {
0400         nfc_err(&phy->udev->dev,
0401             "Can't submit reader poweron cmd response %d\n", rc);
0402         return rc;
0403     }
0404 
0405     wait_for_completion(&arg.done);
0406     phy->in_urb->context = cntx; /* restore context */
0407 
0408     return arg.rc;
0409 }
0410 
0411 static void pn533_send_complete(struct urb *urb)
0412 {
0413     struct pn533_usb_phy *phy = urb->context;
0414 
0415     switch (urb->status) {
0416     case 0:
0417         break; /* success */
0418     case -ECONNRESET:
0419     case -ENOENT:
0420         dev_dbg(&phy->udev->dev,
0421             "The urb has been stopped (status %d)\n",
0422             urb->status);
0423         break;
0424     case -ESHUTDOWN:
0425     default:
0426         nfc_err(&phy->udev->dev,
0427             "Urb failure (status %d)\n",
0428             urb->status);
0429     }
0430 }
0431 
0432 static const struct pn533_phy_ops usb_phy_ops = {
0433     .send_frame = pn533_usb_send_frame,
0434     .send_ack = pn533_usb_send_ack,
0435     .abort_cmd = pn533_usb_abort_cmd,
0436 };
0437 
0438 static int pn533_usb_probe(struct usb_interface *interface,
0439             const struct usb_device_id *id)
0440 {
0441     struct pn533 *priv;
0442     struct pn533_usb_phy *phy;
0443     struct usb_host_interface *iface_desc;
0444     struct usb_endpoint_descriptor *endpoint;
0445     int in_endpoint = 0;
0446     int out_endpoint = 0;
0447     int rc = -ENOMEM;
0448     int i;
0449     u32 protocols;
0450     enum pn533_protocol_type protocol_type = PN533_PROTO_REQ_ACK_RESP;
0451     struct pn533_frame_ops *fops = NULL;
0452     unsigned char *in_buf;
0453     int in_buf_len = PN533_EXT_FRAME_HEADER_LEN +
0454              PN533_STD_FRAME_MAX_PAYLOAD_LEN +
0455              PN533_STD_FRAME_TAIL_LEN;
0456 
0457     phy = devm_kzalloc(&interface->dev, sizeof(*phy), GFP_KERNEL);
0458     if (!phy)
0459         return -ENOMEM;
0460 
0461     in_buf = kzalloc(in_buf_len, GFP_KERNEL);
0462     if (!in_buf)
0463         return -ENOMEM;
0464 
0465     phy->udev = usb_get_dev(interface_to_usbdev(interface));
0466     phy->interface = interface;
0467 
0468     iface_desc = interface->cur_altsetting;
0469     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
0470         endpoint = &iface_desc->endpoint[i].desc;
0471 
0472         if (!in_endpoint && usb_endpoint_is_bulk_in(endpoint))
0473             in_endpoint = endpoint->bEndpointAddress;
0474 
0475         if (!out_endpoint && usb_endpoint_is_bulk_out(endpoint))
0476             out_endpoint = endpoint->bEndpointAddress;
0477     }
0478 
0479     if (!in_endpoint || !out_endpoint) {
0480         nfc_err(&interface->dev,
0481             "Could not find bulk-in or bulk-out endpoint\n");
0482         rc = -ENODEV;
0483         goto error;
0484     }
0485 
0486     phy->in_urb = usb_alloc_urb(0, GFP_KERNEL);
0487     phy->out_urb = usb_alloc_urb(0, GFP_KERNEL);
0488     phy->ack_urb = usb_alloc_urb(0, GFP_KERNEL);
0489 
0490     if (!phy->in_urb || !phy->out_urb || !phy->ack_urb)
0491         goto error;
0492 
0493     usb_fill_bulk_urb(phy->in_urb, phy->udev,
0494               usb_rcvbulkpipe(phy->udev, in_endpoint),
0495               in_buf, in_buf_len, NULL, phy);
0496 
0497     usb_fill_bulk_urb(phy->out_urb, phy->udev,
0498               usb_sndbulkpipe(phy->udev, out_endpoint),
0499               NULL, 0, pn533_send_complete, phy);
0500     usb_fill_bulk_urb(phy->ack_urb, phy->udev,
0501               usb_sndbulkpipe(phy->udev, out_endpoint),
0502               NULL, 0, pn533_send_complete, phy);
0503 
0504     switch (id->driver_info) {
0505     case PN533_DEVICE_STD:
0506         protocols = PN533_ALL_PROTOCOLS;
0507         break;
0508 
0509     case PN533_DEVICE_PASORI:
0510         protocols = PN533_NO_TYPE_B_PROTOCOLS;
0511         break;
0512 
0513     case PN533_DEVICE_ACR122U:
0514         protocols = PN533_NO_TYPE_B_PROTOCOLS;
0515         fops = &pn533_acr122_frame_ops;
0516         protocol_type = PN533_PROTO_REQ_RESP;
0517 
0518         rc = pn533_acr122_poweron_rdr(phy);
0519         if (rc < 0) {
0520             nfc_err(&interface->dev,
0521                 "Couldn't poweron the reader (error %d)\n", rc);
0522             goto error;
0523         }
0524         break;
0525 
0526     default:
0527         nfc_err(&interface->dev, "Unknown device type %lu\n",
0528             id->driver_info);
0529         rc = -EINVAL;
0530         goto error;
0531     }
0532 
0533     priv = pn53x_common_init(id->driver_info, protocol_type,
0534                     phy, &usb_phy_ops, fops,
0535                     &phy->udev->dev);
0536 
0537     if (IS_ERR(priv)) {
0538         rc = PTR_ERR(priv);
0539         goto error;
0540     }
0541 
0542     phy->priv = priv;
0543 
0544     rc = pn533_finalize_setup(priv);
0545     if (rc)
0546         goto err_clean;
0547 
0548     usb_set_intfdata(interface, phy);
0549     rc = pn53x_register_nfc(priv, protocols, &interface->dev);
0550     if (rc)
0551         goto err_clean;
0552 
0553     return 0;
0554 
0555 err_clean:
0556     pn53x_common_clean(priv);
0557 error:
0558     usb_kill_urb(phy->in_urb);
0559     usb_kill_urb(phy->out_urb);
0560     usb_kill_urb(phy->ack_urb);
0561 
0562     usb_free_urb(phy->in_urb);
0563     usb_free_urb(phy->out_urb);
0564     usb_free_urb(phy->ack_urb);
0565     usb_put_dev(phy->udev);
0566     kfree(in_buf);
0567     kfree(phy->ack_buffer);
0568 
0569     return rc;
0570 }
0571 
0572 static void pn533_usb_disconnect(struct usb_interface *interface)
0573 {
0574     struct pn533_usb_phy *phy = usb_get_intfdata(interface);
0575 
0576     if (!phy)
0577         return;
0578 
0579     pn53x_unregister_nfc(phy->priv);
0580     pn53x_common_clean(phy->priv);
0581 
0582     usb_set_intfdata(interface, NULL);
0583 
0584     usb_kill_urb(phy->in_urb);
0585     usb_kill_urb(phy->out_urb);
0586     usb_kill_urb(phy->ack_urb);
0587 
0588     kfree(phy->in_urb->transfer_buffer);
0589     usb_free_urb(phy->in_urb);
0590     usb_free_urb(phy->out_urb);
0591     usb_free_urb(phy->ack_urb);
0592     kfree(phy->ack_buffer);
0593 
0594     nfc_info(&interface->dev, "NXP PN533 NFC device disconnected\n");
0595 }
0596 
0597 static struct usb_driver pn533_usb_driver = {
0598     .name =     "pn533_usb",
0599     .probe =    pn533_usb_probe,
0600     .disconnect =   pn533_usb_disconnect,
0601     .id_table = pn533_usb_table,
0602 };
0603 
0604 module_usb_driver(pn533_usb_driver);
0605 
0606 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
0607 MODULE_AUTHOR("Aloisio Almeida Jr <aloisio.almeida@openbossa.org>");
0608 MODULE_AUTHOR("Waldemar Rymarkiewicz <waldemar.rymarkiewicz@tieto.com>");
0609 MODULE_DESCRIPTION("PN533 USB driver ver " VERSION);
0610 MODULE_VERSION(VERSION);
0611 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!