~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/nfc/nci/core.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  The NFC Controller Interface is the communication protocol between an
  3  *  NFC Controller (NFCC) and a Device Host (DH).
  4  *
  5  *  Copyright (C) 2011 Texas Instruments, Inc.
  6  *
  7  *  Written by Ilan Elias <ilane@ti.com>
  8  *
  9  *  Acknowledgements:
 10  *  This file is based on hci_core.c, which was written
 11  *  by Maxim Krasnyansky.
 12  *
 13  *  This program is free software; you can redistribute it and/or modify
 14  *  it under the terms of the GNU General Public License version 2
 15  *  as published by the Free Software Foundation
 16  *
 17  *  This program is distributed in the hope that it will be useful,
 18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 20  *  GNU General Public License for more details.
 21  *
 22  *  You should have received a copy of the GNU General Public License
 23  *  along with this program; if not, write to the Free Software
 24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 25  *
 26  */
 27 
 28 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
 29 
 30 #include <linux/module.h>
 31 #include <linux/types.h>
 32 #include <linux/workqueue.h>
 33 #include <linux/completion.h>
 34 #include <linux/export.h>
 35 #include <linux/sched.h>
 36 #include <linux/bitops.h>
 37 #include <linux/skbuff.h>
 38 
 39 #include "../nfc.h"
 40 #include <net/nfc/nci.h>
 41 #include <net/nfc/nci_core.h>
 42 #include <linux/nfc.h>
 43 
 44 static void nci_cmd_work(struct work_struct *work);
 45 static void nci_rx_work(struct work_struct *work);
 46 static void nci_tx_work(struct work_struct *work);
 47 
 48 /* ---- NCI requests ---- */
 49 
 50 void nci_req_complete(struct nci_dev *ndev, int result)
 51 {
 52         if (ndev->req_status == NCI_REQ_PEND) {
 53                 ndev->req_result = result;
 54                 ndev->req_status = NCI_REQ_DONE;
 55                 complete(&ndev->req_completion);
 56         }
 57 }
 58 
 59 static void nci_req_cancel(struct nci_dev *ndev, int err)
 60 {
 61         if (ndev->req_status == NCI_REQ_PEND) {
 62                 ndev->req_result = err;
 63                 ndev->req_status = NCI_REQ_CANCELED;
 64                 complete(&ndev->req_completion);
 65         }
 66 }
 67 
 68 /* Execute request and wait for completion. */
 69 static int __nci_request(struct nci_dev *ndev,
 70                          void (*req)(struct nci_dev *ndev, unsigned long opt),
 71                          unsigned long opt, __u32 timeout)
 72 {
 73         int rc = 0;
 74         long completion_rc;
 75 
 76         ndev->req_status = NCI_REQ_PEND;
 77 
 78         init_completion(&ndev->req_completion);
 79         req(ndev, opt);
 80         completion_rc =
 81                 wait_for_completion_interruptible_timeout(&ndev->req_completion,
 82                                                           timeout);
 83 
 84         pr_debug("wait_for_completion return %ld\n", completion_rc);
 85 
 86         if (completion_rc > 0) {
 87                 switch (ndev->req_status) {
 88                 case NCI_REQ_DONE:
 89                         rc = nci_to_errno(ndev->req_result);
 90                         break;
 91 
 92                 case NCI_REQ_CANCELED:
 93                         rc = -ndev->req_result;
 94                         break;
 95 
 96                 default:
 97                         rc = -ETIMEDOUT;
 98                         break;
 99                 }
100         } else {
101                 pr_err("wait_for_completion_interruptible_timeout failed %ld\n",
102                        completion_rc);
103 
104                 rc = ((completion_rc == 0) ? (-ETIMEDOUT) : (completion_rc));
105         }
106 
107         ndev->req_status = ndev->req_result = 0;
108 
109         return rc;
110 }
111 
112 static inline int nci_request(struct nci_dev *ndev,
113                               void (*req)(struct nci_dev *ndev,
114                                           unsigned long opt),
115                               unsigned long opt, __u32 timeout)
116 {
117         int rc;
118 
119         if (!test_bit(NCI_UP, &ndev->flags))
120                 return -ENETDOWN;
121 
122         /* Serialize all requests */
123         mutex_lock(&ndev->req_lock);
124         rc = __nci_request(ndev, req, opt, timeout);
125         mutex_unlock(&ndev->req_lock);
126 
127         return rc;
128 }
129 
130 static void nci_reset_req(struct nci_dev *ndev, unsigned long opt)
131 {
132         struct nci_core_reset_cmd cmd;
133 
134         cmd.reset_type = NCI_RESET_TYPE_RESET_CONFIG;
135         nci_send_cmd(ndev, NCI_OP_CORE_RESET_CMD, 1, &cmd);
136 }
137 
138 static void nci_init_req(struct nci_dev *ndev, unsigned long opt)
139 {
140         nci_send_cmd(ndev, NCI_OP_CORE_INIT_CMD, 0, NULL);
141 }
142 
143 static void nci_init_complete_req(struct nci_dev *ndev, unsigned long opt)
144 {
145         struct nci_rf_disc_map_cmd cmd;
146         struct disc_map_config *cfg = cmd.mapping_configs;
147         __u8 *num = &cmd.num_mapping_configs;
148         int i;
149 
150         /* set rf mapping configurations */
151         *num = 0;
152 
153         /* by default mapping is set to NCI_RF_INTERFACE_FRAME */
154         for (i = 0; i < ndev->num_supported_rf_interfaces; i++) {
155                 if (ndev->supported_rf_interfaces[i] ==
156                     NCI_RF_INTERFACE_ISO_DEP) {
157                         cfg[*num].rf_protocol = NCI_RF_PROTOCOL_ISO_DEP;
158                         cfg[*num].mode = NCI_DISC_MAP_MODE_POLL |
159                                 NCI_DISC_MAP_MODE_LISTEN;
160                         cfg[*num].rf_interface = NCI_RF_INTERFACE_ISO_DEP;
161                         (*num)++;
162                 } else if (ndev->supported_rf_interfaces[i] ==
163                            NCI_RF_INTERFACE_NFC_DEP) {
164                         cfg[*num].rf_protocol = NCI_RF_PROTOCOL_NFC_DEP;
165                         cfg[*num].mode = NCI_DISC_MAP_MODE_POLL |
166                                 NCI_DISC_MAP_MODE_LISTEN;
167                         cfg[*num].rf_interface = NCI_RF_INTERFACE_NFC_DEP;
168                         (*num)++;
169                 }
170 
171                 if (*num == NCI_MAX_NUM_MAPPING_CONFIGS)
172                         break;
173         }
174 
175         nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_MAP_CMD,
176                      (1 + ((*num) * sizeof(struct disc_map_config))), &cmd);
177 }
178 
179 struct nci_set_config_param {
180         __u8    id;
181         size_t  len;
182         __u8    *val;
183 };
184 
185 static void nci_set_config_req(struct nci_dev *ndev, unsigned long opt)
186 {
187         struct nci_set_config_param *param = (struct nci_set_config_param *)opt;
188         struct nci_core_set_config_cmd cmd;
189 
190         BUG_ON(param->len > NCI_MAX_PARAM_LEN);
191 
192         cmd.num_params = 1;
193         cmd.param.id = param->id;
194         cmd.param.len = param->len;
195         memcpy(cmd.param.val, param->val, param->len);
196 
197         nci_send_cmd(ndev, NCI_OP_CORE_SET_CONFIG_CMD, (3 + param->len), &cmd);
198 }
199 
200 static void nci_rf_discover_req(struct nci_dev *ndev, unsigned long opt)
201 {
202         struct nci_rf_disc_cmd cmd;
203         __u32 protocols = opt;
204 
205         cmd.num_disc_configs = 0;
206 
207         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
208             (protocols & NFC_PROTO_JEWEL_MASK ||
209              protocols & NFC_PROTO_MIFARE_MASK ||
210              protocols & NFC_PROTO_ISO14443_MASK ||
211              protocols & NFC_PROTO_NFC_DEP_MASK)) {
212                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
213                         NCI_NFC_A_PASSIVE_POLL_MODE;
214                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
215                 cmd.num_disc_configs++;
216         }
217 
218         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
219             (protocols & NFC_PROTO_ISO14443_B_MASK)) {
220                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
221                         NCI_NFC_B_PASSIVE_POLL_MODE;
222                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
223                 cmd.num_disc_configs++;
224         }
225 
226         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
227             (protocols & NFC_PROTO_FELICA_MASK ||
228              protocols & NFC_PROTO_NFC_DEP_MASK)) {
229                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
230                         NCI_NFC_F_PASSIVE_POLL_MODE;
231                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
232                 cmd.num_disc_configs++;
233         }
234 
235         nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_CMD,
236                      (1 + (cmd.num_disc_configs * sizeof(struct disc_config))),
237                      &cmd);
238 }
239 
240 struct nci_rf_discover_select_param {
241         __u8    rf_discovery_id;
242         __u8    rf_protocol;
243 };
244 
245 static void nci_rf_discover_select_req(struct nci_dev *ndev, unsigned long opt)
246 {
247         struct nci_rf_discover_select_param *param =
248                 (struct nci_rf_discover_select_param *)opt;
249         struct nci_rf_discover_select_cmd cmd;
250 
251         cmd.rf_discovery_id = param->rf_discovery_id;
252         cmd.rf_protocol = param->rf_protocol;
253 
254         switch (cmd.rf_protocol) {
255         case NCI_RF_PROTOCOL_ISO_DEP:
256                 cmd.rf_interface = NCI_RF_INTERFACE_ISO_DEP;
257                 break;
258 
259         case NCI_RF_PROTOCOL_NFC_DEP:
260                 cmd.rf_interface = NCI_RF_INTERFACE_NFC_DEP;
261                 break;
262 
263         default:
264                 cmd.rf_interface = NCI_RF_INTERFACE_FRAME;
265                 break;
266         }
267 
268         nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_SELECT_CMD,
269                      sizeof(struct nci_rf_discover_select_cmd), &cmd);
270 }
271 
272 static void nci_rf_deactivate_req(struct nci_dev *ndev, unsigned long opt)
273 {
274         struct nci_rf_deactivate_cmd cmd;
275 
276         cmd.type = NCI_DEACTIVATE_TYPE_IDLE_MODE;
277 
278         nci_send_cmd(ndev, NCI_OP_RF_DEACTIVATE_CMD,
279                      sizeof(struct nci_rf_deactivate_cmd), &cmd);
280 }
281 
282 static int nci_open_device(struct nci_dev *ndev)
283 {
284         int rc = 0;
285 
286         mutex_lock(&ndev->req_lock);
287 
288         if (test_bit(NCI_UP, &ndev->flags)) {
289                 rc = -EALREADY;
290                 goto done;
291         }
292 
293         if (ndev->ops->open(ndev)) {
294                 rc = -EIO;
295                 goto done;
296         }
297 
298         atomic_set(&ndev->cmd_cnt, 1);
299 
300         set_bit(NCI_INIT, &ndev->flags);
301 
302         rc = __nci_request(ndev, nci_reset_req, 0,
303                            msecs_to_jiffies(NCI_RESET_TIMEOUT));
304 
305         if (!rc) {
306                 rc = __nci_request(ndev, nci_init_req, 0,
307                                    msecs_to_jiffies(NCI_INIT_TIMEOUT));
308         }
309 
310         if (!rc) {
311                 rc = __nci_request(ndev, nci_init_complete_req, 0,
312                                    msecs_to_jiffies(NCI_INIT_TIMEOUT));
313         }
314 
315         clear_bit(NCI_INIT, &ndev->flags);
316 
317         if (!rc) {
318                 set_bit(NCI_UP, &ndev->flags);
319                 nci_clear_target_list(ndev);
320                 atomic_set(&ndev->state, NCI_IDLE);
321         } else {
322                 /* Init failed, cleanup */
323                 skb_queue_purge(&ndev->cmd_q);
324                 skb_queue_purge(&ndev->rx_q);
325                 skb_queue_purge(&ndev->tx_q);
326 
327                 ndev->ops->close(ndev);
328                 ndev->flags = 0;
329         }
330 
331 done:
332         mutex_unlock(&ndev->req_lock);
333         return rc;
334 }
335 
336 static int nci_close_device(struct nci_dev *ndev)
337 {
338         nci_req_cancel(ndev, ENODEV);
339         mutex_lock(&ndev->req_lock);
340 
341         if (!test_and_clear_bit(NCI_UP, &ndev->flags)) {
342                 del_timer_sync(&ndev->cmd_timer);
343                 del_timer_sync(&ndev->data_timer);
344                 mutex_unlock(&ndev->req_lock);
345                 return 0;
346         }
347 
348         /* Drop RX and TX queues */
349         skb_queue_purge(&ndev->rx_q);
350         skb_queue_purge(&ndev->tx_q);
351 
352         /* Flush RX and TX wq */
353         flush_workqueue(ndev->rx_wq);
354         flush_workqueue(ndev->tx_wq);
355 
356         /* Reset device */
357         skb_queue_purge(&ndev->cmd_q);
358         atomic_set(&ndev->cmd_cnt, 1);
359 
360         set_bit(NCI_INIT, &ndev->flags);
361         __nci_request(ndev, nci_reset_req, 0,
362                       msecs_to_jiffies(NCI_RESET_TIMEOUT));
363         clear_bit(NCI_INIT, &ndev->flags);
364 
365         /* Flush cmd wq */
366         flush_workqueue(ndev->cmd_wq);
367 
368         /* After this point our queues are empty
369          * and no works are scheduled. */
370         ndev->ops->close(ndev);
371 
372         /* Clear flags */
373         ndev->flags = 0;
374 
375         mutex_unlock(&ndev->req_lock);
376 
377         return 0;
378 }
379 
380 /* NCI command timer function */
381 static void nci_cmd_timer(unsigned long arg)
382 {
383         struct nci_dev *ndev = (void *) arg;
384 
385         atomic_set(&ndev->cmd_cnt, 1);
386         queue_work(ndev->cmd_wq, &ndev->cmd_work);
387 }
388 
389 /* NCI data exchange timer function */
390 static void nci_data_timer(unsigned long arg)
391 {
392         struct nci_dev *ndev = (void *) arg;
393 
394         set_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags);
395         queue_work(ndev->rx_wq, &ndev->rx_work);
396 }
397 
398 static int nci_dev_up(struct nfc_dev *nfc_dev)
399 {
400         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
401 
402         return nci_open_device(ndev);
403 }
404 
405 static int nci_dev_down(struct nfc_dev *nfc_dev)
406 {
407         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
408 
409         return nci_close_device(ndev);
410 }
411 
412 static int nci_set_local_general_bytes(struct nfc_dev *nfc_dev)
413 {
414         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
415         struct nci_set_config_param param;
416         __u8 local_gb[NFC_MAX_GT_LEN];
417         int i;
418 
419         param.val = nfc_get_local_general_bytes(nfc_dev, &param.len);
420         if ((param.val == NULL) || (param.len == 0))
421                 return 0;
422 
423         if (param.len > NFC_MAX_GT_LEN)
424                 return -EINVAL;
425 
426         for (i = 0; i < param.len; i++)
427                 local_gb[param.len-1-i] = param.val[i];
428 
429         param.id = NCI_PN_ATR_REQ_GEN_BYTES;
430         param.val = local_gb;
431 
432         return nci_request(ndev, nci_set_config_req, (unsigned long)&param,
433                            msecs_to_jiffies(NCI_SET_CONFIG_TIMEOUT));
434 }
435 
436 static int nci_start_poll(struct nfc_dev *nfc_dev,
437                           __u32 im_protocols, __u32 tm_protocols)
438 {
439         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
440         int rc;
441 
442         if ((atomic_read(&ndev->state) == NCI_DISCOVERY) ||
443             (atomic_read(&ndev->state) == NCI_W4_ALL_DISCOVERIES)) {
444                 pr_err("unable to start poll, since poll is already active\n");
445                 return -EBUSY;
446         }
447 
448         if (ndev->target_active_prot) {
449                 pr_err("there is an active target\n");
450                 return -EBUSY;
451         }
452 
453         if ((atomic_read(&ndev->state) == NCI_W4_HOST_SELECT) ||
454             (atomic_read(&ndev->state) == NCI_POLL_ACTIVE)) {
455                 pr_debug("target active or w4 select, implicitly deactivate\n");
456 
457                 rc = nci_request(ndev, nci_rf_deactivate_req, 0,
458                                  msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
459                 if (rc)
460                         return -EBUSY;
461         }
462 
463         if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
464                 rc = nci_set_local_general_bytes(nfc_dev);
465                 if (rc) {
466                         pr_err("failed to set local general bytes\n");
467                         return rc;
468                 }
469         }
470 
471         rc = nci_request(ndev, nci_rf_discover_req, im_protocols,
472                          msecs_to_jiffies(NCI_RF_DISC_TIMEOUT));
473 
474         if (!rc)
475                 ndev->poll_prots = im_protocols;
476 
477         return rc;
478 }
479 
480 static void nci_stop_poll(struct nfc_dev *nfc_dev)
481 {
482         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
483 
484         if ((atomic_read(&ndev->state) != NCI_DISCOVERY) &&
485             (atomic_read(&ndev->state) != NCI_W4_ALL_DISCOVERIES)) {
486                 pr_err("unable to stop poll, since poll is not active\n");
487                 return;
488         }
489 
490         nci_request(ndev, nci_rf_deactivate_req, 0,
491                     msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
492 }
493 
494 static int nci_activate_target(struct nfc_dev *nfc_dev,
495                                struct nfc_target *target, __u32 protocol)
496 {
497         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
498         struct nci_rf_discover_select_param param;
499         struct nfc_target *nci_target = NULL;
500         int i;
501         int rc = 0;
502 
503         pr_debug("target_idx %d, protocol 0x%x\n", target->idx, protocol);
504 
505         if ((atomic_read(&ndev->state) != NCI_W4_HOST_SELECT) &&
506             (atomic_read(&ndev->state) != NCI_POLL_ACTIVE)) {
507                 pr_err("there is no available target to activate\n");
508                 return -EINVAL;
509         }
510 
511         if (ndev->target_active_prot) {
512                 pr_err("there is already an active target\n");
513                 return -EBUSY;
514         }
515 
516         for (i = 0; i < ndev->n_targets; i++) {
517                 if (ndev->targets[i].idx == target->idx) {
518                         nci_target = &ndev->targets[i];
519                         break;
520                 }
521         }
522 
523         if (!nci_target) {
524                 pr_err("unable to find the selected target\n");
525                 return -EINVAL;
526         }
527 
528         if (!(nci_target->supported_protocols & (1 << protocol))) {
529                 pr_err("target does not support the requested protocol 0x%x\n",
530                        protocol);
531                 return -EINVAL;
532         }
533 
534         if (atomic_read(&ndev->state) == NCI_W4_HOST_SELECT) {
535                 param.rf_discovery_id = nci_target->logical_idx;
536 
537                 if (protocol == NFC_PROTO_JEWEL)
538                         param.rf_protocol = NCI_RF_PROTOCOL_T1T;
539                 else if (protocol == NFC_PROTO_MIFARE)
540                         param.rf_protocol = NCI_RF_PROTOCOL_T2T;
541                 else if (protocol == NFC_PROTO_FELICA)
542                         param.rf_protocol = NCI_RF_PROTOCOL_T3T;
543                 else if (protocol == NFC_PROTO_ISO14443 ||
544                          protocol == NFC_PROTO_ISO14443_B)
545                         param.rf_protocol = NCI_RF_PROTOCOL_ISO_DEP;
546                 else
547                         param.rf_protocol = NCI_RF_PROTOCOL_NFC_DEP;
548 
549                 rc = nci_request(ndev, nci_rf_discover_select_req,
550                                  (unsigned long)&param,
551                                  msecs_to_jiffies(NCI_RF_DISC_SELECT_TIMEOUT));
552         }
553 
554         if (!rc)
555                 ndev->target_active_prot = protocol;
556 
557         return rc;
558 }
559 
560 static void nci_deactivate_target(struct nfc_dev *nfc_dev,
561                                   struct nfc_target *target)
562 {
563         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
564 
565         pr_debug("entry\n");
566 
567         if (!ndev->target_active_prot) {
568                 pr_err("unable to deactivate target, no active target\n");
569                 return;
570         }
571 
572         ndev->target_active_prot = 0;
573 
574         if (atomic_read(&ndev->state) == NCI_POLL_ACTIVE) {
575                 nci_request(ndev, nci_rf_deactivate_req, 0,
576                             msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
577         }
578 }
579 
580 static int nci_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
581                            __u8 comm_mode, __u8 *gb, size_t gb_len)
582 {
583         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
584         int rc;
585 
586         pr_debug("target_idx %d, comm_mode %d\n", target->idx, comm_mode);
587 
588         rc = nci_activate_target(nfc_dev, target, NFC_PROTO_NFC_DEP);
589         if (rc)
590                 return rc;
591 
592         rc = nfc_set_remote_general_bytes(nfc_dev, ndev->remote_gb,
593                                           ndev->remote_gb_len);
594         if (!rc)
595                 rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_PASSIVE,
596                                         NFC_RF_INITIATOR);
597 
598         return rc;
599 }
600 
601 static int nci_dep_link_down(struct nfc_dev *nfc_dev)
602 {
603         pr_debug("entry\n");
604 
605         nci_deactivate_target(nfc_dev, NULL);
606 
607         return 0;
608 }
609 
610 
611 static int nci_transceive(struct nfc_dev *nfc_dev, struct nfc_target *target,
612                           struct sk_buff *skb,
613                           data_exchange_cb_t cb, void *cb_context)
614 {
615         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
616         int rc;
617 
618         pr_debug("target_idx %d, len %d\n", target->idx, skb->len);
619 
620         if (!ndev->target_active_prot) {
621                 pr_err("unable to exchange data, no active target\n");
622                 return -EINVAL;
623         }
624 
625         if (test_and_set_bit(NCI_DATA_EXCHANGE, &ndev->flags))
626                 return -EBUSY;
627 
628         /* store cb and context to be used on receiving data */
629         ndev->data_exchange_cb = cb;
630         ndev->data_exchange_cb_context = cb_context;
631 
632         rc = nci_send_data(ndev, NCI_STATIC_RF_CONN_ID, skb);
633         if (rc)
634                 clear_bit(NCI_DATA_EXCHANGE, &ndev->flags);
635 
636         return rc;
637 }
638 
639 static int nci_enable_se(struct nfc_dev *nfc_dev, u32 se_idx)
640 {
641         return 0;
642 }
643 
644 static int nci_disable_se(struct nfc_dev *nfc_dev, u32 se_idx)
645 {
646         return 0;
647 }
648 
649 static int nci_discover_se(struct nfc_dev *nfc_dev)
650 {
651         return 0;
652 }
653 
654 static struct nfc_ops nci_nfc_ops = {
655         .dev_up = nci_dev_up,
656         .dev_down = nci_dev_down,
657         .start_poll = nci_start_poll,
658         .stop_poll = nci_stop_poll,
659         .dep_link_up = nci_dep_link_up,
660         .dep_link_down = nci_dep_link_down,
661         .activate_target = nci_activate_target,
662         .deactivate_target = nci_deactivate_target,
663         .im_transceive = nci_transceive,
664         .enable_se = nci_enable_se,
665         .disable_se = nci_disable_se,
666         .discover_se = nci_discover_se,
667 };
668 
669 /* ---- Interface to NCI drivers ---- */
670 
671 /**
672  * nci_allocate_device - allocate a new nci device
673  *
674  * @ops: device operations
675  * @supported_protocols: NFC protocols supported by the device
676  */
677 struct nci_dev *nci_allocate_device(struct nci_ops *ops,
678                                     __u32 supported_protocols,
679                                     int tx_headroom, int tx_tailroom)
680 {
681         struct nci_dev *ndev;
682 
683         pr_debug("supported_protocols 0x%x\n", supported_protocols);
684 
685         if (!ops->open || !ops->close || !ops->send)
686                 return NULL;
687 
688         if (!supported_protocols)
689                 return NULL;
690 
691         ndev = kzalloc(sizeof(struct nci_dev), GFP_KERNEL);
692         if (!ndev)
693                 return NULL;
694 
695         ndev->ops = ops;
696         ndev->tx_headroom = tx_headroom;
697         ndev->tx_tailroom = tx_tailroom;
698 
699         ndev->nfc_dev = nfc_allocate_device(&nci_nfc_ops,
700                                             supported_protocols,
701                                             tx_headroom + NCI_DATA_HDR_SIZE,
702                                             tx_tailroom);
703         if (!ndev->nfc_dev)
704                 goto free_exit;
705 
706         nfc_set_drvdata(ndev->nfc_dev, ndev);
707 
708         return ndev;
709 
710 free_exit:
711         kfree(ndev);
712         return NULL;
713 }
714 EXPORT_SYMBOL(nci_allocate_device);
715 
716 /**
717  * nci_free_device - deallocate nci device
718  *
719  * @ndev: The nci device to deallocate
720  */
721 void nci_free_device(struct nci_dev *ndev)
722 {
723         nfc_free_device(ndev->nfc_dev);
724         kfree(ndev);
725 }
726 EXPORT_SYMBOL(nci_free_device);
727 
728 /**
729  * nci_register_device - register a nci device in the nfc subsystem
730  *
731  * @dev: The nci device to register
732  */
733 int nci_register_device(struct nci_dev *ndev)
734 {
735         int rc;
736         struct device *dev = &ndev->nfc_dev->dev;
737         char name[32];
738 
739         rc = nfc_register_device(ndev->nfc_dev);
740         if (rc)
741                 goto exit;
742 
743         ndev->flags = 0;
744 
745         INIT_WORK(&ndev->cmd_work, nci_cmd_work);
746         snprintf(name, sizeof(name), "%s_nci_cmd_wq", dev_name(dev));
747         ndev->cmd_wq = create_singlethread_workqueue(name);
748         if (!ndev->cmd_wq) {
749                 rc = -ENOMEM;
750                 goto unreg_exit;
751         }
752 
753         INIT_WORK(&ndev->rx_work, nci_rx_work);
754         snprintf(name, sizeof(name), "%s_nci_rx_wq", dev_name(dev));
755         ndev->rx_wq = create_singlethread_workqueue(name);
756         if (!ndev->rx_wq) {
757                 rc = -ENOMEM;
758                 goto destroy_cmd_wq_exit;
759         }
760 
761         INIT_WORK(&ndev->tx_work, nci_tx_work);
762         snprintf(name, sizeof(name), "%s_nci_tx_wq", dev_name(dev));
763         ndev->tx_wq = create_singlethread_workqueue(name);
764         if (!ndev->tx_wq) {
765                 rc = -ENOMEM;
766                 goto destroy_rx_wq_exit;
767         }
768 
769         skb_queue_head_init(&ndev->cmd_q);
770         skb_queue_head_init(&ndev->rx_q);
771         skb_queue_head_init(&ndev->tx_q);
772 
773         setup_timer(&ndev->cmd_timer, nci_cmd_timer,
774                     (unsigned long) ndev);
775         setup_timer(&ndev->data_timer, nci_data_timer,
776                     (unsigned long) ndev);
777 
778         mutex_init(&ndev->req_lock);
779 
780         goto exit;
781 
782 destroy_rx_wq_exit:
783         destroy_workqueue(ndev->rx_wq);
784 
785 destroy_cmd_wq_exit:
786         destroy_workqueue(ndev->cmd_wq);
787 
788 unreg_exit:
789         nfc_unregister_device(ndev->nfc_dev);
790 
791 exit:
792         return rc;
793 }
794 EXPORT_SYMBOL(nci_register_device);
795 
796 /**
797  * nci_unregister_device - unregister a nci device in the nfc subsystem
798  *
799  * @dev: The nci device to unregister
800  */
801 void nci_unregister_device(struct nci_dev *ndev)
802 {
803         nci_close_device(ndev);
804 
805         destroy_workqueue(ndev->cmd_wq);
806         destroy_workqueue(ndev->rx_wq);
807         destroy_workqueue(ndev->tx_wq);
808 
809         nfc_unregister_device(ndev->nfc_dev);
810 }
811 EXPORT_SYMBOL(nci_unregister_device);
812 
813 /**
814  * nci_recv_frame - receive frame from NCI drivers
815  *
816  * @ndev: The nci device
817  * @skb: The sk_buff to receive
818  */
819 int nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
820 {
821         pr_debug("len %d\n", skb->len);
822 
823         if (!ndev || (!test_bit(NCI_UP, &ndev->flags) &&
824             !test_bit(NCI_INIT, &ndev->flags))) {
825                 kfree_skb(skb);
826                 return -ENXIO;
827         }
828 
829         /* Queue frame for rx worker thread */
830         skb_queue_tail(&ndev->rx_q, skb);
831         queue_work(ndev->rx_wq, &ndev->rx_work);
832 
833         return 0;
834 }
835 EXPORT_SYMBOL(nci_recv_frame);
836 
837 static int nci_send_frame(struct nci_dev *ndev, struct sk_buff *skb)
838 {
839         pr_debug("len %d\n", skb->len);
840 
841         if (!ndev) {
842                 kfree_skb(skb);
843                 return -ENODEV;
844         }
845 
846         /* Get rid of skb owner, prior to sending to the driver. */
847         skb_orphan(skb);
848 
849         return ndev->ops->send(ndev, skb);
850 }
851 
852 /* Send NCI command */
853 int nci_send_cmd(struct nci_dev *ndev, __u16 opcode, __u8 plen, void *payload)
854 {
855         struct nci_ctrl_hdr *hdr;
856         struct sk_buff *skb;
857 
858         pr_debug("opcode 0x%x, plen %d\n", opcode, plen);
859 
860         skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + plen), GFP_KERNEL);
861         if (!skb) {
862                 pr_err("no memory for command\n");
863                 return -ENOMEM;
864         }
865 
866         hdr = (struct nci_ctrl_hdr *) skb_put(skb, NCI_CTRL_HDR_SIZE);
867         hdr->gid = nci_opcode_gid(opcode);
868         hdr->oid = nci_opcode_oid(opcode);
869         hdr->plen = plen;
870 
871         nci_mt_set((__u8 *)hdr, NCI_MT_CMD_PKT);
872         nci_pbf_set((__u8 *)hdr, NCI_PBF_LAST);
873 
874         if (plen)
875                 memcpy(skb_put(skb, plen), payload, plen);
876 
877         skb_queue_tail(&ndev->cmd_q, skb);
878         queue_work(ndev->cmd_wq, &ndev->cmd_work);
879 
880         return 0;
881 }
882 
883 /* ---- NCI TX Data worker thread ---- */
884 
885 static void nci_tx_work(struct work_struct *work)
886 {
887         struct nci_dev *ndev = container_of(work, struct nci_dev, tx_work);
888         struct sk_buff *skb;
889 
890         pr_debug("credits_cnt %d\n", atomic_read(&ndev->credits_cnt));
891 
892         /* Send queued tx data */
893         while (atomic_read(&ndev->credits_cnt)) {
894                 skb = skb_dequeue(&ndev->tx_q);
895                 if (!skb)
896                         return;
897 
898                 /* Check if data flow control is used */
899                 if (atomic_read(&ndev->credits_cnt) !=
900                     NCI_DATA_FLOW_CONTROL_NOT_USED)
901                         atomic_dec(&ndev->credits_cnt);
902 
903                 pr_debug("NCI TX: MT=data, PBF=%d, conn_id=%d, plen=%d\n",
904                          nci_pbf(skb->data),
905                          nci_conn_id(skb->data),
906                          nci_plen(skb->data));
907 
908                 nci_send_frame(ndev, skb);
909 
910                 mod_timer(&ndev->data_timer,
911                           jiffies + msecs_to_jiffies(NCI_DATA_TIMEOUT));
912         }
913 }
914 
915 /* ----- NCI RX worker thread (data & control) ----- */
916 
917 static void nci_rx_work(struct work_struct *work)
918 {
919         struct nci_dev *ndev = container_of(work, struct nci_dev, rx_work);
920         struct sk_buff *skb;
921 
922         while ((skb = skb_dequeue(&ndev->rx_q))) {
923                 /* Process frame */
924                 switch (nci_mt(skb->data)) {
925                 case NCI_MT_RSP_PKT:
926                         nci_rsp_packet(ndev, skb);
927                         break;
928 
929                 case NCI_MT_NTF_PKT:
930                         nci_ntf_packet(ndev, skb);
931                         break;
932 
933                 case NCI_MT_DATA_PKT:
934                         nci_rx_data_packet(ndev, skb);
935                         break;
936 
937                 default:
938                         pr_err("unknown MT 0x%x\n", nci_mt(skb->data));
939                         kfree_skb(skb);
940                         break;
941                 }
942         }
943 
944         /* check if a data exchange timout has occurred */
945         if (test_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags)) {
946                 /* complete the data exchange transaction, if exists */
947                 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
948                         nci_data_exchange_complete(ndev, NULL, -ETIMEDOUT);
949 
950                 clear_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags);
951         }
952 }
953 
954 /* ----- NCI TX CMD worker thread ----- */
955 
956 static void nci_cmd_work(struct work_struct *work)
957 {
958         struct nci_dev *ndev = container_of(work, struct nci_dev, cmd_work);
959         struct sk_buff *skb;
960 
961         pr_debug("cmd_cnt %d\n", atomic_read(&ndev->cmd_cnt));
962 
963         /* Send queued command */
964         if (atomic_read(&ndev->cmd_cnt)) {
965                 skb = skb_dequeue(&ndev->cmd_q);
966                 if (!skb)
967                         return;
968 
969                 atomic_dec(&ndev->cmd_cnt);
970 
971                 pr_debug("NCI TX: MT=cmd, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
972                          nci_pbf(skb->data),
973                          nci_opcode_gid(nci_opcode(skb->data)),
974                          nci_opcode_oid(nci_opcode(skb->data)),
975                          nci_plen(skb->data));
976 
977                 nci_send_frame(ndev, skb);
978 
979                 mod_timer(&ndev->cmd_timer,
980                           jiffies + msecs_to_jiffies(NCI_CMD_TIMEOUT));
981         }
982 }
983 
984 MODULE_LICENSE("GPL");
985 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp