Lines Matching refs:dev
277 static bool pn533_std_rx_frame_is_valid(void *_frame, struct pn533 *dev)
287 dev->ops->rx_header_len = PN533_STD_FRAME_HEADER_LEN;
300 dev->ops->rx_header_len = PN533_EXT_FRAME_HEADER_LEN;
357 bool pn533_rx_frame_is_cmd_response(struct pn533 *dev, void *frame)
359 return (dev->ops->get_cmd_code(frame) ==
360 PN533_CMD_RESPONSE(dev->cmd->code));
381 static void pn533_build_cmd_frame(struct pn533 *dev, u8 cmd_code,
386 struct pn533_frame_ops *ops = dev->ops;
397 static int pn533_send_async_complete(struct pn533 *dev)
399 struct pn533_cmd *cmd = dev->cmd;
404 dev_dbg(dev->dev, "%s: cmd not set\n", __func__);
414 rc = cmd->complete_cb(dev, cmd->complete_cb_context,
425 skb_pull(resp, dev->ops->rx_header_len);
426 skb_trim(resp, resp->len - dev->ops->rx_tail_len);
429 rc = cmd->complete_cb(dev, cmd->complete_cb_context, resp);
433 dev->cmd = NULL;
437 static int __pn533_send_async(struct pn533 *dev, u8 cmd_code,
445 dev_dbg(dev->dev, "Sending command 0x%x\n", cmd_code);
456 pn533_build_cmd_frame(dev, cmd_code, req);
458 mutex_lock(&dev->cmd_lock);
460 if (!dev->cmd_pending) {
461 dev->cmd = cmd;
462 rc = dev->phy_ops->send_frame(dev, req);
464 dev->cmd = NULL;
468 dev->cmd_pending = 1;
472 dev_dbg(dev->dev, "%s Queueing command 0x%x\n",
476 list_add_tail(&cmd->queue, &dev->cmd_queue);
483 mutex_unlock(&dev->cmd_lock);
487 static int pn533_send_data_async(struct pn533 *dev, u8 cmd_code,
494 rc = __pn533_send_async(dev, cmd_code, req, complete_cb,
500 static int pn533_send_cmd_async(struct pn533 *dev, u8 cmd_code,
507 rc = __pn533_send_async(dev, cmd_code, req, complete_cb,
521 static int pn533_send_cmd_direct_async(struct pn533 *dev, u8 cmd_code,
538 pn533_build_cmd_frame(dev, cmd_code, req);
540 dev->cmd = cmd;
541 rc = dev->phy_ops->send_frame(dev, req);
543 dev->cmd = NULL;
552 struct pn533 *dev = container_of(work, struct pn533, cmd_complete_work);
555 rc = pn533_send_async_complete(dev);
557 queue_work(dev->wq, &dev->cmd_work);
562 struct pn533 *dev = container_of(work, struct pn533, cmd_work);
566 mutex_lock(&dev->cmd_lock);
568 if (list_empty(&dev->cmd_queue)) {
569 dev->cmd_pending = 0;
570 mutex_unlock(&dev->cmd_lock);
574 cmd = list_first_entry(&dev->cmd_queue, struct pn533_cmd, queue);
578 mutex_unlock(&dev->cmd_lock);
580 dev->cmd = cmd;
581 rc = dev->phy_ops->send_frame(dev, cmd->req);
583 dev->cmd = NULL;
596 static int pn533_send_sync_complete(struct pn533 *dev, void *_arg,
624 static struct sk_buff *pn533_send_cmd_sync(struct pn533 *dev, u8 cmd_code,
632 rc = pn533_send_cmd_async(dev, cmd_code, req,
644 static struct sk_buff *pn533_alloc_skb(struct pn533 *dev, unsigned int size)
648 skb = alloc_skb(dev->ops->tx_header_len +
650 dev->ops->tx_tail_len, GFP_KERNEL);
653 skb_reserve(skb, dev->ops->tx_header_len);
899 static void pn533_poll_reset_mod_list(struct pn533 *dev);
900 static int pn533_target_found(struct pn533 *dev, u8 tg, u8 *tgdata,
906 dev_dbg(dev->dev, "%s: modulation=%d\n",
907 __func__, dev->poll_mod_curr);
914 switch (dev->poll_mod_curr) {
929 nfc_err(dev->dev,
937 if (!(nfc_tgt.supported_protocols & dev->poll_protocols)) {
938 dev_dbg(dev->dev,
943 dev_dbg(dev->dev,
947 dev->tgt_available_prots = nfc_tgt.supported_protocols;
949 pn533_poll_reset_mod_list(dev);
950 nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
955 static inline void pn533_poll_next_mod(struct pn533 *dev)
957 dev->poll_mod_curr = (dev->poll_mod_curr + 1) % dev->poll_mod_count;
960 static void pn533_poll_reset_mod_list(struct pn533 *dev)
962 dev->poll_mod_count = 0;
965 static void pn533_poll_add_mod(struct pn533 *dev, u8 mod_index)
967 dev->poll_mod_active[dev->poll_mod_count] =
969 dev->poll_mod_count++;
972 static void pn533_poll_create_mod_list(struct pn533 *dev,
975 pn533_poll_reset_mod_list(dev);
980 pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_A);
984 pn533_poll_add_mod(dev, PN533_POLL_MOD_212KBPS_FELICA);
985 pn533_poll_add_mod(dev, PN533_POLL_MOD_424KBPS_FELICA);
989 pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_JEWEL);
992 pn533_poll_add_mod(dev, PN533_POLL_MOD_847KBPS_B);
995 pn533_poll_add_mod(dev, PN533_LISTEN_MOD);
998 static int pn533_start_poll_complete(struct pn533 *dev, struct sk_buff *resp)
1004 if (dev->poll_protocols & NFC_PROTO_NFC_DEP_MASK)
1005 dev->poll_dep = 1;
1013 rc = pn533_target_found(dev, tg, tgdata, tgdata_len);
1023 static struct sk_buff *pn533_alloc_poll_tg_frame(struct pn533 *dev)
1028 u8 *gbytes = dev->gb;
1029 size_t gbytes_len = dev->gb_len;
1047 skb = pn533_alloc_skb(dev, skb_len);
1077 static struct sk_buff *pn533_build_response(struct pn533 *dev);
1079 static int pn533_tm_get_data_complete(struct pn533 *dev, void *arg,
1086 dev_dbg(dev->dev, "%s\n", __func__);
1089 skb_queue_purge(&dev->resp_q);
1105 skb_queue_tail(&dev->resp_q, resp);
1108 queue_work(dev->wq, &dev->mi_tm_rx_work);
1112 skb = pn533_build_response(dev);
1118 return nfc_tm_data_received(dev->nfc_dev, skb);
1121 nfc_tm_deactivated(dev->nfc_dev);
1122 dev->tgt_mode = 0;
1123 skb_queue_purge(&dev->resp_q);
1131 struct pn533 *dev = container_of(work, struct pn533, mi_tm_rx_work);
1135 dev_dbg(dev->dev, "%s\n", __func__);
1137 skb = pn533_alloc_skb(dev, 0);
1141 rc = pn533_send_cmd_direct_async(dev,
1151 static int pn533_tm_send_complete(struct pn533 *dev, void *arg,
1155 struct pn533 *dev = container_of(work, struct pn533, mi_tm_tx_work);
1159 dev_dbg(dev->dev, "%s\n", __func__);
1162 skb = skb_dequeue(&dev->fragment_skb);
1165 skb_queue_head_init(&dev->fragment_skb);
1170 if (skb_queue_len(&dev->fragment_skb) == 0) {
1171 rc = pn533_send_cmd_direct_async(dev, PN533_CMD_TG_SET_DATA,
1174 rc = pn533_send_cmd_direct_async(dev,
1181 dev_err(dev->dev,
1187 dev->phy_ops->send_ack(dev, GFP_KERNEL);
1188 queue_work(dev->wq, &dev->cmd_work);
1193 struct pn533 *dev = container_of(work, struct pn533, tg_work);
1197 dev_dbg(dev->dev, "%s\n", __func__);
1199 skb = pn533_alloc_skb(dev, 0);
1203 rc = pn533_send_data_async(dev, PN533_CMD_TG_GET_DATA, skb,
1211 static int pn533_init_target_complete(struct pn533 *dev, struct sk_buff *resp)
1217 dev_dbg(dev->dev, "%s\n", __func__);
1225 dev_dbg(dev->dev, "Target mode 0x%x len %d\n",
1238 rc = nfc_tm_activated(dev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1241 nfc_err(dev->dev,
1246 dev->tgt_mode = 1;
1247 queue_work(dev->wq, &dev->tg_work);
1254 struct pn533 *dev = from_timer(dev, t, listen_timer);
1256 dev_dbg(dev->dev, "Listen mode timeout\n");
1258 dev->cancel_listen = 1;
1260 pn533_poll_next_mod(dev);
1262 queue_delayed_work(dev->wq, &dev->poll_work,
1266 static int pn533_rf_complete(struct pn533 *dev, void *arg,
1271 dev_dbg(dev->dev, "%s\n", __func__);
1276 nfc_err(dev->dev, "RF setting error %d\n", rc);
1281 queue_delayed_work(dev->wq, &dev->poll_work,
1290 struct pn533 *dev = container_of(work, struct pn533, rf_work);
1294 dev_dbg(dev->dev, "%s\n", __func__);
1296 skb = pn533_alloc_skb(dev, 2);
1303 rc = pn533_send_cmd_async(dev, PN533_CMD_RF_CONFIGURATION, skb,
1307 nfc_err(dev->dev, "RF setting error %d\n", rc);
1311 static int pn533_poll_dep_complete(struct pn533 *dev, void *arg,
1329 queue_work(dev->wq, &dev->rf_work);
1335 dev_dbg(dev->dev, "Creating new target");
1340 rc = nfc_targets_found(dev->nfc_dev, &nfc_target, 1);
1344 dev->tgt_available_prots = 0;
1345 dev->tgt_active_prot = NFC_PROTO_NFC_DEP;
1349 rc = nfc_set_remote_general_bytes(dev->nfc_dev,
1352 rc = nfc_dep_link_is_up(dev->nfc_dev,
1353 dev->nfc_dev->targets[0].idx,
1357 pn533_poll_reset_mod_list(dev);
1367 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1373 dev_dbg(dev->dev, "%s", __func__);
1375 if (!dev->gb) {
1376 dev->gb = nfc_get_local_general_bytes(nfc_dev, &dev->gb_len);
1378 if (!dev->gb || !dev->gb_len) {
1379 dev->poll_dep = 0;
1380 queue_work(dev->wq, &dev->rf_work);
1384 skb_len = 3 + dev->gb_len; /* ActPass + BR + Next */
1393 skb = pn533_alloc_skb(dev, skb_len);
1411 skb_put_data(skb, dev->gb, dev->gb_len);
1414 rc = pn533_send_cmd_async(dev, PN533_CMD_IN_JUMP_FOR_DEP, skb,
1423 static int pn533_autopoll_complete(struct pn533 *dev, void *arg,
1434 nfc_err(dev->dev, "%s autopoll complete error %d\n",
1438 if (dev->poll_mod_count != 0)
1442 nfc_err(dev->dev,
1457 dev_dbg(dev->dev, "ISOA\n");
1463 dev_dbg(dev->dev, "FELICA\n");
1468 dev_dbg(dev->dev, "JEWEL\n");
1473 dev_dbg(dev->dev, "ISOB\n");
1478 dev_dbg(dev->dev, "Mifare\n");
1483 nfc_err(dev->dev,
1491 if (!(nfc_tgt.supported_protocols & dev->poll_protocols)) {
1492 nfc_err(dev->dev,
1498 dev->tgt_available_prots = nfc_tgt.supported_protocols;
1503 pn533_poll_reset_mod_list(dev);
1504 nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
1511 nfc_err(dev->dev, "autopoll operation has been stopped\n");
1513 pn533_poll_reset_mod_list(dev);
1514 dev->poll_protocols = 0;
1518 static int pn533_poll_complete(struct pn533 *dev, void *arg,
1524 dev_dbg(dev->dev, "%s\n", __func__);
1529 nfc_err(dev->dev, "%s Poll complete error %d\n",
1533 if (dev->poll_mod_count != 0)
1537 nfc_err(dev->dev,
1543 cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
1546 del_timer(&dev->listen_timer);
1547 rc = pn533_init_target_complete(dev, resp);
1552 rc = pn533_start_poll_complete(dev, resp);
1556 if (!dev->poll_mod_count) {
1557 dev_dbg(dev->dev, "Polling has been stopped\n");
1561 pn533_poll_next_mod(dev);
1563 queue_work(dev->wq, &dev->rf_work);
1570 nfc_err(dev->dev, "Polling operation has been stopped\n");
1572 pn533_poll_reset_mod_list(dev);
1573 dev->poll_protocols = 0;
1577 static struct sk_buff *pn533_alloc_poll_in_frame(struct pn533 *dev,
1582 skb = pn533_alloc_skb(dev, mod->len);
1591 static int pn533_send_poll_frame(struct pn533 *dev)
1598 mod = dev->poll_mod_active[dev->poll_mod_curr];
1600 dev_dbg(dev->dev, "%s mod len %d\n",
1603 if ((dev->poll_protocols & NFC_PROTO_NFC_DEP_MASK) && dev->poll_dep) {
1604 dev->poll_dep = 0;
1605 return pn533_poll_dep(dev->nfc_dev);
1610 skb = pn533_alloc_poll_tg_frame(dev);
1613 skb = pn533_alloc_poll_in_frame(dev, mod);
1617 nfc_err(dev->dev, "Failed to allocate skb\n");
1621 rc = pn533_send_cmd_async(dev, cmd_code, skb, pn533_poll_complete,
1625 nfc_err(dev->dev, "Polling loop error %d\n", rc);
1633 struct pn533 *dev = container_of(work, struct pn533, poll_work.work);
1637 cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
1639 dev_dbg(dev->dev,
1641 __func__, dev->cancel_listen, cur_mod->len);
1643 if (dev->cancel_listen == 1) {
1644 dev->cancel_listen = 0;
1645 dev->phy_ops->abort_cmd(dev, GFP_ATOMIC);
1648 rc = pn533_send_poll_frame(dev);
1652 if (cur_mod->len == 0 && dev->poll_mod_count > 1)
1653 mod_timer(&dev->listen_timer, jiffies + PN533_LISTEN_TIME * HZ);
1659 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1665 dev_dbg(dev->dev,
1669 if (dev->tgt_active_prot) {
1670 nfc_err(dev->dev,
1675 if (dev->tgt_mode) {
1676 nfc_err(dev->dev,
1682 dev->gb = nfc_get_local_general_bytes(nfc_dev, &dev->gb_len);
1683 if (dev->gb == NULL)
1687 dev->poll_protocols = im_protocols;
1688 dev->listen_protocols = tm_protocols;
1689 if (dev->device_type == PN533_DEVICE_PN532_AUTOPOLL) {
1690 skb = pn533_alloc_skb(dev, 4 + 6);
1742 rc = pn533_send_cmd_async(dev, PN533_CMD_IN_AUTOPOLL, skb,
1748 dev->poll_mod_count++;
1753 pn533_poll_create_mod_list(dev, im_protocols, tm_protocols);
1757 rand_mod %= dev->poll_mod_count;
1758 dev->poll_mod_curr = rand_mod;
1760 cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
1762 rc = pn533_send_poll_frame(dev);
1765 if (!rc && cur_mod->len == 0 && dev->poll_mod_count > 1)
1766 mod_timer(&dev->listen_timer, jiffies + PN533_LISTEN_TIME * HZ);
1773 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1775 del_timer(&dev->listen_timer);
1777 if (!dev->poll_mod_count) {
1778 dev_dbg(dev->dev,
1783 dev->phy_ops->abort_cmd(dev, GFP_KERNEL);
1784 flush_delayed_work(&dev->poll_work);
1785 pn533_poll_reset_mod_list(dev);
1788 static int pn533_activate_target_nfcdep(struct pn533 *dev)
1796 dev_dbg(dev->dev, "%s\n", __func__);
1798 skb = pn533_alloc_skb(dev, sizeof(u8) * 2); /*TG + Next*/
1805 resp = pn533_send_cmd_sync(dev, PN533_CMD_IN_ATR, skb);
1812 nfc_err(dev->dev,
1820 rc = nfc_set_remote_general_bytes(dev->nfc_dev, rsp->gt, gt_len);
1829 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1832 dev_dbg(dev->dev, "%s: protocol=%u\n", __func__, protocol);
1834 if (dev->poll_mod_count) {
1835 nfc_err(dev->dev,
1840 if (dev->tgt_active_prot) {
1841 nfc_err(dev->dev,
1846 if (!dev->tgt_available_prots) {
1847 nfc_err(dev->dev,
1852 if (!(dev->tgt_available_prots & (1 << protocol))) {
1853 nfc_err(dev->dev,
1860 rc = pn533_activate_target_nfcdep(dev);
1862 nfc_err(dev->dev,
1868 dev->tgt_active_prot = protocol;
1869 dev->tgt_available_prots = 0;
1874 static int pn533_deactivate_target_complete(struct pn533 *dev, void *arg,
1879 dev_dbg(dev->dev, "%s\n", __func__);
1884 nfc_err(dev->dev, "Target release error %d\n", rc);
1891 nfc_err(dev->dev,
1901 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
1905 dev_dbg(dev->dev, "%s\n", __func__);
1907 if (!dev->tgt_active_prot) {
1908 nfc_err(dev->dev, "There is no active target\n");
1912 dev->tgt_active_prot = 0;
1913 skb_queue_purge(&dev->resp_q);
1915 skb = pn533_alloc_skb(dev, sizeof(u8));
1921 rc = pn533_send_cmd_async(dev, PN533_CMD_IN_RELEASE, skb,
1925 nfc_err(dev->dev, "Target release error %d\n", rc);
1930 static int pn533_in_dep_link_up_complete(struct pn533 *dev, void *arg,
1943 if (dev->tgt_available_prots &&
1944 !(dev->tgt_available_prots & (1 << NFC_PROTO_NFC_DEP))) {
1945 nfc_err(dev->dev,
1955 nfc_err(dev->dev,
1960 if (!dev->tgt_available_prots) {
1963 dev_dbg(dev->dev, "Creating new target\n");
1970 rc = nfc_targets_found(dev->nfc_dev, &nfc_target, 1);
1974 dev->tgt_available_prots = 0;
1977 dev->tgt_active_prot = NFC_PROTO_NFC_DEP;
1981 rc = nfc_set_remote_general_bytes(dev->nfc_dev,
1984 rc = nfc_dep_link_is_up(dev->nfc_dev,
1985 dev->nfc_dev->targets[0].idx,
1997 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2003 dev_dbg(dev->dev, "%s\n", __func__);
2005 if (dev->poll_mod_count) {
2006 nfc_err(dev->dev,
2011 if (dev->tgt_active_prot) {
2012 nfc_err(dev->dev,
2028 skb = pn533_alloc_skb(dev, skb_len);
2065 pn533_rf_field(dev->nfc_dev, 0);
2067 rc = pn533_send_cmd_async(dev, PN533_CMD_IN_JUMP_FOR_DEP, skb,
2080 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2082 dev_dbg(dev->dev, "%s\n", __func__);
2084 pn533_poll_reset_mod_list(dev);
2086 if (dev->tgt_mode || dev->tgt_active_prot)
2087 dev->phy_ops->abort_cmd(dev, GFP_KERNEL);
2089 dev->tgt_active_prot = 0;
2090 dev->tgt_mode = 0;
2092 skb_queue_purge(&dev->resp_q);
2102 static struct sk_buff *pn533_build_response(struct pn533 *dev)
2107 dev_dbg(dev->dev, "%s\n", __func__);
2109 if (skb_queue_empty(&dev->resp_q))
2112 if (skb_queue_len(&dev->resp_q) == 1) {
2113 skb = skb_dequeue(&dev->resp_q);
2117 skb_queue_walk_safe(&dev->resp_q, tmp, t)
2120 dev_dbg(dev->dev, "%s total length %d\n",
2129 skb_queue_walk_safe(&dev->resp_q, tmp, t) {
2135 skb_queue_purge(&dev->resp_q);
2140 static int pn533_data_exchange_complete(struct pn533 *dev, void *_arg,
2148 dev_dbg(dev->dev, "%s\n", __func__);
2162 nfc_err(dev->dev,
2168 skb_queue_tail(&dev->resp_q, resp);
2171 dev->cmd_complete_mi_arg = arg;
2172 queue_work(dev->wq, &dev->mi_rx_work);
2177 if (skb_queue_len(&dev->fragment_skb) > 0) {
2178 dev->cmd_complete_dep_arg = arg;
2179 queue_work(dev->wq, &dev->mi_tx_work);
2184 skb = pn533_build_response(dev);
2197 skb_queue_purge(&dev->resp_q);
2207 void pn533_recv_frame(struct pn533 *dev, struct sk_buff *skb, int status)
2209 if (!dev->cmd)
2212 dev->cmd->status = status;
2215 dev_dbg(dev->dev, "%s: Error received: %d\n", __func__, status);
2225 dev_dbg(dev->dev, "%s: Received ACK frame\n", __func__);
2231 dev->ops->rx_frame_size(skb->data), false);
2233 if (!dev->ops->rx_is_frame_valid(skb->data, dev)) {
2234 nfc_err(dev->dev, "Received an invalid frame\n");
2235 dev->cmd->status = -EIO;
2236 } else if (!pn533_rx_frame_is_cmd_response(dev, skb->data)) {
2237 nfc_err(dev->dev, "It it not the response to the last command\n");
2238 dev->cmd->status = -EIO;
2241 dev->cmd->resp = skb;
2244 queue_work(dev->wq, &dev->cmd_complete_work);
2249 static int pn533_fill_fragment_skbs(struct pn533 *dev, struct sk_buff *skb)
2262 frag = pn533_alloc_skb(dev, frag_size);
2264 skb_queue_purge(&dev->fragment_skb);
2268 if (!dev->tgt_mode) {
2286 skb_queue_tail(&dev->fragment_skb, frag);
2292 return skb_queue_len(&dev->fragment_skb);
2299 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2303 dev_dbg(dev->dev, "%s\n", __func__);
2305 if (!dev->tgt_active_prot) {
2306 nfc_err(dev->dev,
2321 switch (dev->device_type) {
2323 if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
2324 rc = pn533_send_data_async(dev, PN533_CMD_IN_COMM_THRU,
2335 rc = pn533_fill_fragment_skbs(dev, skb);
2339 skb = skb_dequeue(&dev->fragment_skb);
2348 rc = pn533_send_data_async(dev, PN533_CMD_IN_DATA_EXCHANGE,
2366 static int pn533_tm_send_complete(struct pn533 *dev, void *arg,
2371 dev_dbg(dev->dev, "%s\n", __func__);
2379 if (skb_queue_len(&dev->fragment_skb) > 0) {
2380 queue_work(dev->wq, &dev->mi_tm_tx_work);
2386 nfc_tm_deactivated(dev->nfc_dev);
2388 dev->tgt_mode = 0;
2393 queue_work(dev->wq, &dev->tg_work);
2400 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2403 dev_dbg(dev->dev, "%s\n", __func__);
2407 rc = pn533_fill_fragment_skbs(dev, skb);
2412 skb = skb_dequeue(&dev->fragment_skb);
2418 rc = pn533_send_data_async(dev, PN533_CMD_TG_SET_META_DATA, skb,
2422 rc = pn533_send_data_async(dev, PN533_CMD_TG_SET_DATA, skb,
2429 skb_queue_purge(&dev->fragment_skb);
2437 struct pn533 *dev = container_of(work, struct pn533, mi_rx_work);
2441 dev_dbg(dev->dev, "%s\n", __func__);
2443 skb = pn533_alloc_skb(dev, PN533_CMD_DATAEXCH_HEAD_LEN);
2447 switch (dev->device_type) {
2449 if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
2450 rc = pn533_send_cmd_direct_async(dev,
2454 dev->cmd_complete_mi_arg);
2462 rc = pn533_send_cmd_direct_async(dev,
2466 dev->cmd_complete_mi_arg);
2474 nfc_err(dev->dev,
2478 kfree(dev->cmd_complete_mi_arg);
2481 dev->phy_ops->send_ack(dev, GFP_KERNEL);
2482 queue_work(dev->wq, &dev->cmd_work);
2487 struct pn533 *dev = container_of(work, struct pn533, mi_tx_work);
2491 dev_dbg(dev->dev, "%s\n", __func__);
2494 skb = skb_dequeue(&dev->fragment_skb);
2498 skb_queue_head_init(&dev->fragment_skb);
2502 switch (dev->device_type) {
2504 if (dev->tgt_active_prot != NFC_PROTO_FELICA) {
2509 rc = pn533_send_cmd_direct_async(dev, PN533_CMD_IN_COMM_THRU,
2512 dev->cmd_complete_dep_arg);
2518 rc = pn533_send_cmd_direct_async(dev,
2522 dev->cmd_complete_dep_arg);
2530 nfc_err(dev->dev,
2534 kfree(dev->cmd_complete_dep_arg);
2537 dev->phy_ops->send_ack(dev, GFP_KERNEL);
2538 queue_work(dev->wq, &dev->cmd_work);
2541 static int pn533_set_configuration(struct pn533 *dev, u8 cfgitem, u8 *cfgdata,
2548 dev_dbg(dev->dev, "%s\n", __func__);
2552 skb = pn533_alloc_skb(dev, skb_len);
2559 resp = pn533_send_cmd_sync(dev, PN533_CMD_RF_CONFIGURATION, skb);
2567 static int pn533_get_firmware_version(struct pn533 *dev,
2573 skb = pn533_alloc_skb(dev, 0);
2577 resp = pn533_send_cmd_sync(dev, PN533_CMD_GET_FIRMWARE_VERSION, skb);
2590 static int pn533_pasori_fw_reset(struct pn533 *dev)
2595 dev_dbg(dev->dev, "%s\n", __func__);
2597 skb = pn533_alloc_skb(dev, sizeof(u8));
2603 resp = pn533_send_cmd_sync(dev, 0x18, skb);
2614 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2620 rc = pn533_set_configuration(dev, PN533_CFGITEM_RF_FIELD,
2623 nfc_err(dev->dev, "Error on setting RF field\n");
2632 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2636 skb = pn533_alloc_skb(dev, 1);
2642 resp = pn533_send_cmd_sync(dev, PN533_CMD_SAM_CONFIGURATION, skb);
2652 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2655 if (dev->phy_ops->dev_up) {
2656 rc = dev->phy_ops->dev_up(dev);
2661 if ((dev->device_type == PN533_DEVICE_PN532) ||
2662 (dev->device_type == PN533_DEVICE_PN532_AUTOPOLL)) {
2674 struct pn533 *dev = nfc_get_drvdata(nfc_dev);
2678 if (dev->phy_ops->dev_down && !ret)
2679 ret = dev->phy_ops->dev_down(dev);
2697 static int pn533_setup(struct pn533 *dev)
2704 switch (dev->device_type) {
2722 nfc_err(dev->dev, "Unknown device type %d\n",
2723 dev->device_type);
2727 rc = pn533_set_configuration(dev, PN533_CFGITEM_MAX_RETRIES,
2730 nfc_err(dev->dev,
2736 rc = pn533_set_configuration(dev, PN533_CFGITEM_TIMING,
2739 nfc_err(dev->dev, "Error on setting RF timings\n");
2743 switch (dev->device_type) {
2750 pn533_pasori_fw_reset(dev);
2752 rc = pn533_set_configuration(dev, PN533_CFGITEM_PASORI,
2755 nfc_err(dev->dev,
2760 pn533_pasori_fw_reset(dev);
2768 int pn533_finalize_setup(struct pn533 *dev)
2776 rc = pn533_get_firmware_version(dev, &fw_ver);
2778 nfc_err(dev->dev, "Unable to get FW version\n");
2782 nfc_info(dev->dev, "NXP PN5%02X firmware ver %d.%d now attached\n",
2785 rc = pn533_setup(dev);
2798 struct device *dev)
2809 priv->dev = dev;