Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Low Level Transport (NDLC) Driver for STMicroelectronics NFC Chip
0004  *
0005  * Copyright (C) 2014-2015  STMicroelectronics SAS. All rights reserved.
0006  */
0007 
0008 #include <linux/sched.h>
0009 #include <net/nfc/nci_core.h>
0010 
0011 #include "st-nci.h"
0012 
0013 #define NDLC_TIMER_T1       100
0014 #define NDLC_TIMER_T1_WAIT  400
0015 #define NDLC_TIMER_T2       1200
0016 
0017 #define PCB_TYPE_DATAFRAME      0x80
0018 #define PCB_TYPE_SUPERVISOR     0xc0
0019 #define PCB_TYPE_MASK           PCB_TYPE_SUPERVISOR
0020 
0021 #define PCB_SYNC_ACK            0x20
0022 #define PCB_SYNC_NACK           0x10
0023 #define PCB_SYNC_WAIT           0x30
0024 #define PCB_SYNC_NOINFO         0x00
0025 #define PCB_SYNC_MASK           PCB_SYNC_WAIT
0026 
0027 #define PCB_DATAFRAME_RETRANSMIT_YES    0x00
0028 #define PCB_DATAFRAME_RETRANSMIT_NO 0x04
0029 #define PCB_DATAFRAME_RETRANSMIT_MASK   PCB_DATAFRAME_RETRANSMIT_NO
0030 
0031 #define PCB_SUPERVISOR_RETRANSMIT_YES   0x00
0032 #define PCB_SUPERVISOR_RETRANSMIT_NO    0x02
0033 #define PCB_SUPERVISOR_RETRANSMIT_MASK  PCB_SUPERVISOR_RETRANSMIT_NO
0034 
0035 #define PCB_FRAME_CRC_INFO_PRESENT  0x08
0036 #define PCB_FRAME_CRC_INFO_NOTPRESENT   0x00
0037 #define PCB_FRAME_CRC_INFO_MASK     PCB_FRAME_CRC_INFO_PRESENT
0038 
0039 #define NDLC_DUMP_SKB(info, skb)                                 \
0040 do {                                                             \
0041     pr_debug("%s:\n", info);                                 \
0042     print_hex_dump(KERN_DEBUG, "ndlc: ", DUMP_PREFIX_OFFSET, \
0043             16, 1, skb->data, skb->len, 0);          \
0044 } while (0)
0045 
0046 int ndlc_open(struct llt_ndlc *ndlc)
0047 {
0048     /* toggle reset pin */
0049     ndlc->ops->enable(ndlc->phy_id);
0050     ndlc->powered = 1;
0051     return 0;
0052 }
0053 EXPORT_SYMBOL(ndlc_open);
0054 
0055 void ndlc_close(struct llt_ndlc *ndlc)
0056 {
0057     struct nci_mode_set_cmd cmd;
0058 
0059     cmd.cmd_type = ST_NCI_SET_NFC_MODE;
0060     cmd.mode = 0;
0061 
0062     /* toggle reset pin */
0063     ndlc->ops->enable(ndlc->phy_id);
0064 
0065     nci_prop_cmd(ndlc->ndev, ST_NCI_CORE_PROP,
0066              sizeof(struct nci_mode_set_cmd), (__u8 *)&cmd);
0067 
0068     ndlc->powered = 0;
0069     ndlc->ops->disable(ndlc->phy_id);
0070 }
0071 EXPORT_SYMBOL(ndlc_close);
0072 
0073 int ndlc_send(struct llt_ndlc *ndlc, struct sk_buff *skb)
0074 {
0075     /* add ndlc header */
0076     u8 pcb = PCB_TYPE_DATAFRAME | PCB_DATAFRAME_RETRANSMIT_NO |
0077         PCB_FRAME_CRC_INFO_NOTPRESENT;
0078 
0079     *(u8 *)skb_push(skb, 1) = pcb;
0080     skb_queue_tail(&ndlc->send_q, skb);
0081 
0082     schedule_work(&ndlc->sm_work);
0083 
0084     return 0;
0085 }
0086 EXPORT_SYMBOL(ndlc_send);
0087 
0088 static void llt_ndlc_send_queue(struct llt_ndlc *ndlc)
0089 {
0090     struct sk_buff *skb;
0091     int r;
0092     unsigned long time_sent;
0093 
0094     if (ndlc->send_q.qlen)
0095         pr_debug("sendQlen=%d unackQlen=%d\n",
0096              ndlc->send_q.qlen, ndlc->ack_pending_q.qlen);
0097 
0098     while (ndlc->send_q.qlen) {
0099         skb = skb_dequeue(&ndlc->send_q);
0100         NDLC_DUMP_SKB("ndlc frame written", skb);
0101         r = ndlc->ops->write(ndlc->phy_id, skb);
0102         if (r < 0) {
0103             ndlc->hard_fault = r;
0104             break;
0105         }
0106         time_sent = jiffies;
0107         *(unsigned long *)skb->cb = time_sent;
0108 
0109         skb_queue_tail(&ndlc->ack_pending_q, skb);
0110 
0111         /* start timer t1 for ndlc aknowledge */
0112         ndlc->t1_active = true;
0113         mod_timer(&ndlc->t1_timer, time_sent +
0114             msecs_to_jiffies(NDLC_TIMER_T1));
0115         /* start timer t2 for chip availability */
0116         ndlc->t2_active = true;
0117         mod_timer(&ndlc->t2_timer, time_sent +
0118             msecs_to_jiffies(NDLC_TIMER_T2));
0119     }
0120 }
0121 
0122 static void llt_ndlc_requeue_data_pending(struct llt_ndlc *ndlc)
0123 {
0124     struct sk_buff *skb;
0125     u8 pcb;
0126 
0127     while ((skb = skb_dequeue_tail(&ndlc->ack_pending_q))) {
0128         pcb = skb->data[0];
0129         switch (pcb & PCB_TYPE_MASK) {
0130         case PCB_TYPE_SUPERVISOR:
0131             skb->data[0] = (pcb & ~PCB_SUPERVISOR_RETRANSMIT_MASK) |
0132                 PCB_SUPERVISOR_RETRANSMIT_YES;
0133             break;
0134         case PCB_TYPE_DATAFRAME:
0135             skb->data[0] = (pcb & ~PCB_DATAFRAME_RETRANSMIT_MASK) |
0136                 PCB_DATAFRAME_RETRANSMIT_YES;
0137             break;
0138         default:
0139             pr_err("UNKNOWN Packet Control Byte=%d\n", pcb);
0140             kfree_skb(skb);
0141             continue;
0142         }
0143         skb_queue_head(&ndlc->send_q, skb);
0144     }
0145 }
0146 
0147 static void llt_ndlc_rcv_queue(struct llt_ndlc *ndlc)
0148 {
0149     struct sk_buff *skb;
0150     u8 pcb;
0151     unsigned long time_sent;
0152 
0153     if (ndlc->rcv_q.qlen)
0154         pr_debug("rcvQlen=%d\n", ndlc->rcv_q.qlen);
0155 
0156     while ((skb = skb_dequeue(&ndlc->rcv_q)) != NULL) {
0157         pcb = skb->data[0];
0158         skb_pull(skb, 1);
0159         if ((pcb & PCB_TYPE_MASK) == PCB_TYPE_SUPERVISOR) {
0160             switch (pcb & PCB_SYNC_MASK) {
0161             case PCB_SYNC_ACK:
0162                 skb = skb_dequeue(&ndlc->ack_pending_q);
0163                 kfree_skb(skb);
0164                 del_timer_sync(&ndlc->t1_timer);
0165                 del_timer_sync(&ndlc->t2_timer);
0166                 ndlc->t2_active = false;
0167                 ndlc->t1_active = false;
0168                 break;
0169             case PCB_SYNC_NACK:
0170                 llt_ndlc_requeue_data_pending(ndlc);
0171                 llt_ndlc_send_queue(ndlc);
0172                 /* start timer t1 for ndlc aknowledge */
0173                 time_sent = jiffies;
0174                 ndlc->t1_active = true;
0175                 mod_timer(&ndlc->t1_timer, time_sent +
0176                     msecs_to_jiffies(NDLC_TIMER_T1));
0177                 break;
0178             case PCB_SYNC_WAIT:
0179                 time_sent = jiffies;
0180                 ndlc->t1_active = true;
0181                 mod_timer(&ndlc->t1_timer, time_sent +
0182                       msecs_to_jiffies(NDLC_TIMER_T1_WAIT));
0183                 break;
0184             default:
0185                 kfree_skb(skb);
0186                 break;
0187             }
0188         } else if ((pcb & PCB_TYPE_MASK) == PCB_TYPE_DATAFRAME) {
0189             nci_recv_frame(ndlc->ndev, skb);
0190         } else {
0191             kfree_skb(skb);
0192         }
0193     }
0194 }
0195 
0196 static void llt_ndlc_sm_work(struct work_struct *work)
0197 {
0198     struct llt_ndlc *ndlc = container_of(work, struct llt_ndlc, sm_work);
0199 
0200     llt_ndlc_send_queue(ndlc);
0201     llt_ndlc_rcv_queue(ndlc);
0202 
0203     if (ndlc->t1_active && timer_pending(&ndlc->t1_timer) == 0) {
0204         pr_debug
0205             ("Handle T1(recv SUPERVISOR) elapsed (T1 now inactive)\n");
0206         ndlc->t1_active = false;
0207 
0208         llt_ndlc_requeue_data_pending(ndlc);
0209         llt_ndlc_send_queue(ndlc);
0210     }
0211 
0212     if (ndlc->t2_active && timer_pending(&ndlc->t2_timer) == 0) {
0213         pr_debug("Handle T2(recv DATA) elapsed (T2 now inactive)\n");
0214         ndlc->t2_active = false;
0215         ndlc->t1_active = false;
0216         del_timer_sync(&ndlc->t1_timer);
0217         del_timer_sync(&ndlc->t2_timer);
0218         ndlc_close(ndlc);
0219         ndlc->hard_fault = -EREMOTEIO;
0220     }
0221 }
0222 
0223 void ndlc_recv(struct llt_ndlc *ndlc, struct sk_buff *skb)
0224 {
0225     if (skb == NULL) {
0226         pr_err("NULL Frame -> link is dead\n");
0227         ndlc->hard_fault = -EREMOTEIO;
0228         ndlc_close(ndlc);
0229     } else {
0230         NDLC_DUMP_SKB("incoming frame", skb);
0231         skb_queue_tail(&ndlc->rcv_q, skb);
0232     }
0233 
0234     schedule_work(&ndlc->sm_work);
0235 }
0236 EXPORT_SYMBOL(ndlc_recv);
0237 
0238 static void ndlc_t1_timeout(struct timer_list *t)
0239 {
0240     struct llt_ndlc *ndlc = from_timer(ndlc, t, t1_timer);
0241 
0242     schedule_work(&ndlc->sm_work);
0243 }
0244 
0245 static void ndlc_t2_timeout(struct timer_list *t)
0246 {
0247     struct llt_ndlc *ndlc = from_timer(ndlc, t, t2_timer);
0248 
0249     schedule_work(&ndlc->sm_work);
0250 }
0251 
0252 int ndlc_probe(void *phy_id, const struct nfc_phy_ops *phy_ops,
0253            struct device *dev, int phy_headroom, int phy_tailroom,
0254            struct llt_ndlc **ndlc_id, struct st_nci_se_status *se_status)
0255 {
0256     struct llt_ndlc *ndlc;
0257 
0258     ndlc = devm_kzalloc(dev, sizeof(struct llt_ndlc), GFP_KERNEL);
0259     if (!ndlc)
0260         return -ENOMEM;
0261 
0262     ndlc->ops = phy_ops;
0263     ndlc->phy_id = phy_id;
0264     ndlc->dev = dev;
0265     ndlc->powered = 0;
0266 
0267     *ndlc_id = ndlc;
0268 
0269     /* initialize timers */
0270     timer_setup(&ndlc->t1_timer, ndlc_t1_timeout, 0);
0271     timer_setup(&ndlc->t2_timer, ndlc_t2_timeout, 0);
0272 
0273     skb_queue_head_init(&ndlc->rcv_q);
0274     skb_queue_head_init(&ndlc->send_q);
0275     skb_queue_head_init(&ndlc->ack_pending_q);
0276 
0277     INIT_WORK(&ndlc->sm_work, llt_ndlc_sm_work);
0278 
0279     return st_nci_probe(ndlc, phy_headroom, phy_tailroom, se_status);
0280 }
0281 EXPORT_SYMBOL(ndlc_probe);
0282 
0283 void ndlc_remove(struct llt_ndlc *ndlc)
0284 {
0285     st_nci_remove(ndlc->ndev);
0286 
0287     /* cancel timers */
0288     del_timer_sync(&ndlc->t1_timer);
0289     del_timer_sync(&ndlc->t2_timer);
0290     ndlc->t2_active = false;
0291     ndlc->t1_active = false;
0292 
0293     skb_queue_purge(&ndlc->rcv_q);
0294     skb_queue_purge(&ndlc->send_q);
0295 }
0296 EXPORT_SYMBOL(ndlc_remove);
[ 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!