net/nfc/nci/core.c

   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  *  Copyright (C) 2014 Marvell International Ltd.
   7  *
   8  *  Written by Ilan Elias <ilane@ti.com>
   9  *
  10  *  Acknowledgements:
  11  *  This file is based on hci_core.c, which was written
  12  *  by Maxim Krasnyansky.
  13  *
  14  *  This program is free software; you can redistribute it and/or modify
  15  *  it under the terms of the GNU General Public License version 2
  16  *  as published by the Free Software Foundation
  17  *
  18  *  This program is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License
  24  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  25  *
  26  */
  27
  28 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
  29
  30 #include <linux/module.h>
  31 #include <linux/kernel.h>
  32 #include <linux/types.h>
  33 #include <linux/workqueue.h>
  34 #include <linux/completion.h>
  35 #include <linux/export.h>
  36 #include <linux/sched.h>
  37 #include <linux/bitops.h>
  38 #include <linux/skbuff.h>
  39
  40 #include "../nfc.h"
  41 #include <net/nfc/nci.h>
  42 #include <net/nfc/nci_core.h>
  43 #include <linux/nfc.h>
  44
  45 struct core_conn_create_data {
  46         int length;
  47         struct nci_core_conn_create_cmd *cmd;
  48 };
  49
  50 static void nci_cmd_work(struct work_struct *work);
  51 static void nci_rx_work(struct work_struct *work);
  52 static void nci_tx_work(struct work_struct *work);
  53
  54 struct nci_conn_info *nci_get_conn_info_by_conn_id(struct nci_dev *ndev,
  55                                                    int conn_id)
  56 {
  57         struct nci_conn_info *conn_info;
  58
  59         list_for_each_entry(conn_info, &ndev->conn_info_list, list) {
  60                 if (conn_info->conn_id == conn_id)
  61                         return conn_info;
  62         }
  63
  64         return NULL;
  65 }
  66
  67 int nci_get_conn_info_by_dest_type_params(struct nci_dev *ndev, u8 dest_type,
  68                                           struct dest_spec_params *params)
  69 {
  70         struct nci_conn_info *conn_info;
  71
  72         list_for_each_entry(conn_info, &ndev->conn_info_list, list) {
  73                 if (conn_info->dest_type == dest_type) {
  74                         if (!params)
  75                                 return conn_info->conn_id;
  76
  77                         if (params->id == conn_info->dest_params->id &&
  78                             params->protocol == conn_info->dest_params->protocol)
  79                                 return conn_info->conn_id;
  80                 }
  81         }
  82
  83         return -EINVAL;
  84 }
  85 EXPORT_SYMBOL(nci_get_conn_info_by_dest_type_params);
  86
  87 /* ---- NCI requests ---- */
  88
  89 void nci_req_complete(struct nci_dev *ndev, int result)
  90 {
  91         if (ndev->req_status == NCI_REQ_PEND) {
  92                 ndev->req_result = result;
  93                 ndev->req_status = NCI_REQ_DONE;
  94                 complete(&ndev->req_completion);
  95         }
  96 }
  97 EXPORT_SYMBOL(nci_req_complete);
  98
  99 static void nci_req_cancel(struct nci_dev *ndev, int err)
 100 {
 101         if (ndev->req_status == NCI_REQ_PEND) {
 102                 ndev->req_result = err;
 103                 ndev->req_status = NCI_REQ_CANCELED;
 104                 complete(&ndev->req_completion);
 105         }
 106 }
 107
 108 /* Execute request and wait for completion. */
 109 static int __nci_request(struct nci_dev *ndev,
 110                          void (*req)(struct nci_dev *ndev, unsigned long opt),
 111                          unsigned long opt, __u32 timeout)
 112 {
 113         int rc = 0;
 114         long completion_rc;
 115
 116         ndev->req_status = NCI_REQ_PEND;
 117
 118         reinit_completion(&ndev->req_completion);
 119         req(ndev, opt);
 120         completion_rc =
 121                 wait_for_completion_interruptible_timeout(&ndev->req_completion,
 122                                                           timeout);
 123
 124         pr_debug("wait_for_completion return %ld\n", completion_rc);
 125
 126         if (completion_rc > 0) {
 127                 switch (ndev->req_status) {
 128                 case NCI_REQ_DONE:
 129                         rc = nci_to_errno(ndev->req_result);
 130                         break;
 131
 132                 case NCI_REQ_CANCELED:
 133                         rc = -ndev->req_result;
 134                         break;
 135
 136                 default:
 137                         rc = -ETIMEDOUT;
 138                         break;
 139                 }
 140         } else {
 141                 pr_err("wait_for_completion_interruptible_timeout failed %ld\n",
 142                        completion_rc);
 143
 144                 rc = ((completion_rc == 0) ? (-ETIMEDOUT) : (completion_rc));
 145         }
 146
 147         ndev->req_status = ndev->req_result = 0;
 148
 149         return rc;
 150 }
 151
 152 inline int nci_request(struct nci_dev *ndev,
 153                        void (*req)(struct nci_dev *ndev,
 154                                    unsigned long opt),
 155                        unsigned long opt, __u32 timeout)
 156 {
 157         int rc;
 158
 159         if (!test_bit(NCI_UP, &ndev->flags))
 160                 return -ENETDOWN;
 161
 162         /* Serialize all requests */
 163         mutex_lock(&ndev->req_lock);
 164         rc = __nci_request(ndev, req, opt, timeout);
 165         mutex_unlock(&ndev->req_lock);
 166
 167         return rc;
 168 }
 169
 170 static void nci_reset_req(struct nci_dev *ndev, unsigned long opt)
 171 {
 172         struct nci_core_reset_cmd cmd;
 173
 174         cmd.reset_type = NCI_RESET_TYPE_RESET_CONFIG;
 175         nci_send_cmd(ndev, NCI_OP_CORE_RESET_CMD, 1, &cmd);
 176 }
 177
 178 static void nci_init_req(struct nci_dev *ndev, unsigned long opt)
 179 {
 180         nci_send_cmd(ndev, NCI_OP_CORE_INIT_CMD, 0, NULL);
 181 }
 182
 183 static void nci_init_complete_req(struct nci_dev *ndev, unsigned long opt)
 184 {
 185         struct nci_rf_disc_map_cmd cmd;
 186         struct disc_map_config *cfg = cmd.mapping_configs;
 187         __u8 *num = &cmd.num_mapping_configs;
 188         int i;
 189
 190         /* set rf mapping configurations */
 191         *num = 0;
 192
 193         /* by default mapping is set to NCI_RF_INTERFACE_FRAME */
 194         for (i = 0; i < ndev->num_supported_rf_interfaces; i++) {
 195                 if (ndev->supported_rf_interfaces[i] ==
 196                     NCI_RF_INTERFACE_ISO_DEP) {
 197                         cfg[*num].rf_protocol = NCI_RF_PROTOCOL_ISO_DEP;
 198                         cfg[*num].mode = NCI_DISC_MAP_MODE_POLL |
 199                                 NCI_DISC_MAP_MODE_LISTEN;
 200                         cfg[*num].rf_interface = NCI_RF_INTERFACE_ISO_DEP;
 201                         (*num)++;
 202                 } else if (ndev->supported_rf_interfaces[i] ==
 203                            NCI_RF_INTERFACE_NFC_DEP) {
 204                         cfg[*num].rf_protocol = NCI_RF_PROTOCOL_NFC_DEP;
 205                         cfg[*num].mode = NCI_DISC_MAP_MODE_POLL |
 206                                 NCI_DISC_MAP_MODE_LISTEN;
 207                         cfg[*num].rf_interface = NCI_RF_INTERFACE_NFC_DEP;
 208                         (*num)++;
 209                 }
 210
 211                 if (*num == NCI_MAX_NUM_MAPPING_CONFIGS)
 212                         break;
 213         }
 214
 215         nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_MAP_CMD,
 216                      (1 + ((*num) * sizeof(struct disc_map_config))), &cmd);
 217 }
 218
 219 struct nci_set_config_param {
 220         __u8    id;
 221         size_t  len;
 222         __u8    *val;
 223 };
 224
 225 static void nci_set_config_req(struct nci_dev *ndev, unsigned long opt)
 226 {
 227         struct nci_set_config_param *param = (struct nci_set_config_param *)opt;
 228         struct nci_core_set_config_cmd cmd;
 229
 230         BUG_ON(param->len > NCI_MAX_PARAM_LEN);
 231
 232         cmd.num_params = 1;
 233         cmd.param.id = param->id;
 234         cmd.param.len = param->len;
 235         memcpy(cmd.param.val, param->val, param->len);
 236
 237         nci_send_cmd(ndev, NCI_OP_CORE_SET_CONFIG_CMD, (3 + param->len), &cmd);
 238 }
 239
 240 struct nci_rf_discover_param {
 241         __u32   im_protocols;
 242         __u32   tm_protocols;
 243 };
 244
 245 static void nci_rf_discover_req(struct nci_dev *ndev, unsigned long opt)
 246 {
 247         struct nci_rf_discover_param *param =
 248                 (struct nci_rf_discover_param *)opt;
 249         struct nci_rf_disc_cmd cmd;
 250
 251         cmd.num_disc_configs = 0;
 252
 253         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
 254             (param->im_protocols & NFC_PROTO_JEWEL_MASK ||
 255              param->im_protocols & NFC_PROTO_MIFARE_MASK ||
 256              param->im_protocols & NFC_PROTO_ISO14443_MASK ||
 257              param->im_protocols & NFC_PROTO_NFC_DEP_MASK)) {
 258                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
 259                         NCI_NFC_A_PASSIVE_POLL_MODE;
 260                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
 261                 cmd.num_disc_configs++;
 262         }
 263
 264         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
 265             (param->im_protocols & NFC_PROTO_ISO14443_B_MASK)) {
 266                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
 267                         NCI_NFC_B_PASSIVE_POLL_MODE;
 268                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
 269                 cmd.num_disc_configs++;
 270         }
 271
 272         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
 273             (param->im_protocols & NFC_PROTO_FELICA_MASK ||
 274              param->im_protocols & NFC_PROTO_NFC_DEP_MASK)) {
 275                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
 276                         NCI_NFC_F_PASSIVE_POLL_MODE;
 277                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
 278                 cmd.num_disc_configs++;
 279         }
 280
 281         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
 282             (param->im_protocols & NFC_PROTO_ISO15693_MASK)) {
 283                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
 284                         NCI_NFC_V_PASSIVE_POLL_MODE;
 285                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
 286                 cmd.num_disc_configs++;
 287         }
 288
 289         if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS - 1) &&
 290             (param->tm_protocols & NFC_PROTO_NFC_DEP_MASK)) {
 291                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
 292                         NCI_NFC_A_PASSIVE_LISTEN_MODE;
 293                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
 294                 cmd.num_disc_configs++;
 295                 cmd.disc_configs[cmd.num_disc_configs].rf_tech_and_mode =
 296                         NCI_NFC_F_PASSIVE_LISTEN_MODE;
 297                 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
 298                 cmd.num_disc_configs++;
 299         }
 300
 301         nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_CMD,
 302                      (1 + (cmd.num_disc_configs * sizeof(struct disc_config))),
 303                      &cmd);
 304 }
 305
 306 struct nci_rf_discover_select_param {
 307         __u8    rf_discovery_id;
 308         __u8    rf_protocol;
 309 };
 310
 311 static void nci_rf_discover_select_req(struct nci_dev *ndev, unsigned long opt)
 312 {
 313         struct nci_rf_discover_select_param *param =
 314                 (struct nci_rf_discover_select_param *)opt;
 315         struct nci_rf_discover_select_cmd cmd;
 316
 317         cmd.rf_discovery_id = param->rf_discovery_id;
 318         cmd.rf_protocol = param->rf_protocol;
 319
 320         switch (cmd.rf_protocol) {
 321         case NCI_RF_PROTOCOL_ISO_DEP:
 322                 cmd.rf_interface = NCI_RF_INTERFACE_ISO_DEP;
 323                 break;
 324
 325         case NCI_RF_PROTOCOL_NFC_DEP:
 326                 cmd.rf_interface = NCI_RF_INTERFACE_NFC_DEP;
 327                 break;
 328
 329         default:
 330                 cmd.rf_interface = NCI_RF_INTERFACE_FRAME;
 331                 break;
 332         }
 333
 334         nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_SELECT_CMD,
 335                      sizeof(struct nci_rf_discover_select_cmd), &cmd);
 336 }
 337
 338 static void nci_rf_deactivate_req(struct nci_dev *ndev, unsigned long opt)
 339 {
 340         struct nci_rf_deactivate_cmd cmd;
 341
 342         cmd.type = opt;
 343
 344         nci_send_cmd(ndev, NCI_OP_RF_DEACTIVATE_CMD,
 345                      sizeof(struct nci_rf_deactivate_cmd), &cmd);
 346 }
 347
 348 struct nci_cmd_param {
 349         __u16 opcode;
 350         size_t len;
 351         __u8 *payload;
 352 };
 353
 354 static void nci_generic_req(struct nci_dev *ndev, unsigned long opt)
 355 {
 356         struct nci_cmd_param *param =
 357                 (struct nci_cmd_param *)opt;
 358
 359         nci_send_cmd(ndev, param->opcode, param->len, param->payload);
 360 }
 361
 362 int nci_prop_cmd(struct nci_dev *ndev, __u8 oid, size_t len, __u8 *payload)
 363 {
 364         struct nci_cmd_param param;
 365
 366         param.opcode = nci_opcode_pack(NCI_GID_PROPRIETARY, oid);
 367         param.len = len;
 368         param.payload = payload;
 369
 370         return __nci_request(ndev, nci_generic_req, (unsigned long)&param,
 371                              msecs_to_jiffies(NCI_CMD_TIMEOUT));
 372 }
 373 EXPORT_SYMBOL(nci_prop_cmd);
 374
 375 int nci_core_cmd(struct nci_dev *ndev, __u16 opcode, size_t len, __u8 *payload)
 376 {
 377         struct nci_cmd_param param;
 378
 379         param.opcode = opcode;
 380         param.len = len;
 381         param.payload = payload;
 382
 383         return __nci_request(ndev, nci_generic_req, (unsigned long)&param,
 384                              msecs_to_jiffies(NCI_CMD_TIMEOUT));
 385 }
 386 EXPORT_SYMBOL(nci_core_cmd);
 387
 388 int nci_core_reset(struct nci_dev *ndev)
 389 {
 390         return __nci_request(ndev, nci_reset_req, 0,
 391                              msecs_to_jiffies(NCI_RESET_TIMEOUT));
 392 }
 393 EXPORT_SYMBOL(nci_core_reset);
 394
 395 int nci_core_init(struct nci_dev *ndev)
 396 {
 397         return __nci_request(ndev, nci_init_req, 0,
 398                              msecs_to_jiffies(NCI_INIT_TIMEOUT));
 399 }
 400 EXPORT_SYMBOL(nci_core_init);
 401
 402 struct nci_loopback_data {
 403         u8 conn_id;
 404         struct sk_buff *data;
 405 };
 406
 407 static void nci_send_data_req(struct nci_dev *ndev, unsigned long opt)
 408 {
 409         struct nci_loopback_data *data = (struct nci_loopback_data *)opt;
 410
 411         nci_send_data(ndev, data->conn_id, data->data);
 412 }
 413
 414 static void nci_nfcc_loopback_cb(void *context, struct sk_buff *skb, int err)
 415 {
 416         struct nci_dev *ndev = (struct nci_dev *)context;
 417         struct nci_conn_info    *conn_info;
 418
 419         conn_info = nci_get_conn_info_by_conn_id(ndev, ndev->cur_conn_id);
 420         if (!conn_info) {
 421                 nci_req_complete(ndev, NCI_STATUS_REJECTED);
 422                 return;
 423         }
 424
 425         conn_info->rx_skb = skb;
 426
 427         nci_req_complete(ndev, NCI_STATUS_OK);
 428 }
 429
 430 int nci_nfcc_loopback(struct nci_dev *ndev, void *data, size_t data_len,
 431                       struct sk_buff **resp)
 432 {
 433         int r;
 434         struct nci_loopback_data loopback_data;
 435         struct nci_conn_info *conn_info;
 436         struct sk_buff *skb;
 437         int conn_id = nci_get_conn_info_by_dest_type_params(ndev,
 438                                         NCI_DESTINATION_NFCC_LOOPBACK, NULL);
 439
 440         if (conn_id < 0) {
 441                 r = nci_core_conn_create(ndev, NCI_DESTINATION_NFCC_LOOPBACK,
 442                                          0, 0, NULL);
 443                 if (r != NCI_STATUS_OK)
 444                         return r;
 445
 446                 conn_id = nci_get_conn_info_by_dest_type_params(ndev,
 447                                         NCI_DESTINATION_NFCC_LOOPBACK,
 448                                         NULL);
 449         }
 450
 451         conn_info = nci_get_conn_info_by_conn_id(ndev, conn_id);
 452         if (!conn_info)
 453                 return -EPROTO;
 454
 455         /* store cb and context to be used on receiving data */
 456         conn_info->data_exchange_cb = nci_nfcc_loopback_cb;
 457         conn_info->data_exchange_cb_context = ndev;
 458
 459         skb = nci_skb_alloc(ndev, NCI_DATA_HDR_SIZE + data_len, GFP_KERNEL);
 460         if (!skb)
 461                 return -ENOMEM;
 462
 463         skb_reserve(skb, NCI_DATA_HDR_SIZE);
 464         skb_put_data(skb, data, data_len);
 465
 466         loopback_data.conn_id = conn_id;
 467         loopback_data.data = skb;
 468
 469         ndev->cur_conn_id = conn_id;
 470         r = nci_request(ndev, nci_send_data_req, (unsigned long)&loopback_data,
 471                         msecs_to_jiffies(NCI_DATA_TIMEOUT));
 472         if (r == NCI_STATUS_OK && resp)
 473                 *resp = conn_info->rx_skb;
 474
 475         return r;
 476 }
 477 EXPORT_SYMBOL(nci_nfcc_loopback);
 478
 479 static int nci_open_device(struct nci_dev *ndev)
 480 {
 481         int rc = 0;
 482
 483         mutex_lock(&ndev->req_lock);
 484
 485         if (test_bit(NCI_UP, &ndev->flags)) {
 486                 rc = -EALREADY;
 487                 goto done;
 488         }
 489
 490         if (ndev->ops->open(ndev)) {
 491                 rc = -EIO;
 492                 goto done;
 493         }
 494
 495         atomic_set(&ndev->cmd_cnt, 1);
 496
 497         set_bit(NCI_INIT, &ndev->flags);
 498
 499         if (ndev->ops->init)
 500                 rc = ndev->ops->init(ndev);
 501
 502         if (!rc) {
 503                 rc = __nci_request(ndev, nci_reset_req, 0,
 504                                    msecs_to_jiffies(NCI_RESET_TIMEOUT));
 505         }
 506
 507         if (!rc && ndev->ops->setup) {
 508                 rc = ndev->ops->setup(ndev);
 509         }
 510
 511         if (!rc) {
 512                 rc = __nci_request(ndev, nci_init_req, 0,
 513                                    msecs_to_jiffies(NCI_INIT_TIMEOUT));
 514         }
 515
 516         if (!rc && ndev->ops->post_setup)
 517                 rc = ndev->ops->post_setup(ndev);
 518
 519         if (!rc) {
 520                 rc = __nci_request(ndev, nci_init_complete_req, 0,
 521                                    msecs_to_jiffies(NCI_INIT_TIMEOUT));
 522         }
 523
 524         clear_bit(NCI_INIT, &ndev->flags);
 525
 526         if (!rc) {
 527                 set_bit(NCI_UP, &ndev->flags);
 528                 nci_clear_target_list(ndev);
 529                 atomic_set(&ndev->state, NCI_IDLE);
 530         } else {
 531                 /* Init failed, cleanup */
 532                 skb_queue_purge(&ndev->cmd_q);
 533                 skb_queue_purge(&ndev->rx_q);
 534                 skb_queue_purge(&ndev->tx_q);
 535
 536                 ndev->ops->close(ndev);
 537                 ndev->flags = 0;
 538         }
 539
 540 done:
 541         mutex_unlock(&ndev->req_lock);
 542         return rc;
 543 }
 544
 545 static int nci_close_device(struct nci_dev *ndev)
 546 {
 547         nci_req_cancel(ndev, ENODEV);
 548         mutex_lock(&ndev->req_lock);
 549
 550         if (!test_and_clear_bit(NCI_UP, &ndev->flags)) {
 551                 del_timer_sync(&ndev->cmd_timer);
 552                 del_timer_sync(&ndev->data_timer);
 553                 mutex_unlock(&ndev->req_lock);
 554                 return 0;
 555         }
 556
 557         /* Drop RX and TX queues */
 558         skb_queue_purge(&ndev->rx_q);
 559         skb_queue_purge(&ndev->tx_q);
 560
 561         /* Flush RX and TX wq */
 562         flush_workqueue(ndev->rx_wq);
 563         flush_workqueue(ndev->tx_wq);
 564
 565         /* Reset device */
 566         skb_queue_purge(&ndev->cmd_q);
 567         atomic_set(&ndev->cmd_cnt, 1);
 568
 569         set_bit(NCI_INIT, &ndev->flags);
 570         __nci_request(ndev, nci_reset_req, 0,
 571                       msecs_to_jiffies(NCI_RESET_TIMEOUT));
 572
 573         /* After this point our queues are empty
 574          * and no works are scheduled.
 575          */
 576         ndev->ops->close(ndev);
 577
 578         clear_bit(NCI_INIT, &ndev->flags);
 579
 580         del_timer_sync(&ndev->cmd_timer);
 581
 582         /* Flush cmd wq */
 583         flush_workqueue(ndev->cmd_wq);
 584
 585         /* Clear flags */
 586         ndev->flags = 0;
 587
 588         mutex_unlock(&ndev->req_lock);
 589
 590         return 0;
 591 }
 592
 593 /* NCI command timer function */
 594 static void nci_cmd_timer(unsigned long arg)
 595 {
 596         struct nci_dev *ndev = (void *) arg;
 597
 598         atomic_set(&ndev->cmd_cnt, 1);
 599         queue_work(ndev->cmd_wq, &ndev->cmd_work);
 600 }
 601
 602 /* NCI data exchange timer function */
 603 static void nci_data_timer(unsigned long arg)
 604 {
 605         struct nci_dev *ndev = (void *) arg;
 606
 607         set_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags);
 608         queue_work(ndev->rx_wq, &ndev->rx_work);
 609 }
 610
 611 static int nci_dev_up(struct nfc_dev *nfc_dev)
 612 {
 613         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 614
 615         return nci_open_device(ndev);
 616 }
 617
 618 static int nci_dev_down(struct nfc_dev *nfc_dev)
 619 {
 620         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 621
 622         return nci_close_device(ndev);
 623 }
 624
 625 int nci_set_config(struct nci_dev *ndev, __u8 id, size_t len, __u8 *val)
 626 {
 627         struct nci_set_config_param param;
 628
 629         if (!val || !len)
 630                 return 0;
 631
 632         param.id = id;
 633         param.len = len;
 634         param.val = val;
 635
 636         return __nci_request(ndev, nci_set_config_req, (unsigned long)&param,
 637                              msecs_to_jiffies(NCI_SET_CONFIG_TIMEOUT));
 638 }
 639 EXPORT_SYMBOL(nci_set_config);
 640
 641 static void nci_nfcee_discover_req(struct nci_dev *ndev, unsigned long opt)
 642 {
 643         struct nci_nfcee_discover_cmd cmd;
 644         __u8 action = opt;
 645
 646         cmd.discovery_action = action;
 647
 648         nci_send_cmd(ndev, NCI_OP_NFCEE_DISCOVER_CMD, 1, &cmd);
 649 }
 650
 651 int nci_nfcee_discover(struct nci_dev *ndev, u8 action)
 652 {
 653         return __nci_request(ndev, nci_nfcee_discover_req, action,
 654                                 msecs_to_jiffies(NCI_CMD_TIMEOUT));
 655 }
 656 EXPORT_SYMBOL(nci_nfcee_discover);
 657
 658 static void nci_nfcee_mode_set_req(struct nci_dev *ndev, unsigned long opt)
 659 {
 660         struct nci_nfcee_mode_set_cmd *cmd =
 661                                         (struct nci_nfcee_mode_set_cmd *)opt;
 662
 663         nci_send_cmd(ndev, NCI_OP_NFCEE_MODE_SET_CMD,
 664                      sizeof(struct nci_nfcee_mode_set_cmd), cmd);
 665 }
 666
 667 int nci_nfcee_mode_set(struct nci_dev *ndev, u8 nfcee_id, u8 nfcee_mode)
 668 {
 669         struct nci_nfcee_mode_set_cmd cmd;
 670
 671         cmd.nfcee_id = nfcee_id;
 672         cmd.nfcee_mode = nfcee_mode;
 673
 674         return __nci_request(ndev, nci_nfcee_mode_set_req,
 675                              (unsigned long)&cmd,
 676                              msecs_to_jiffies(NCI_CMD_TIMEOUT));
 677 }
 678 EXPORT_SYMBOL(nci_nfcee_mode_set);
 679
 680 static void nci_core_conn_create_req(struct nci_dev *ndev, unsigned long opt)
 681 {
 682         struct core_conn_create_data *data =
 683                                         (struct core_conn_create_data *)opt;
 684
 685         nci_send_cmd(ndev, NCI_OP_CORE_CONN_CREATE_CMD, data->length, data->cmd);
 686 }
 687
 688 int nci_core_conn_create(struct nci_dev *ndev, u8 destination_type,
 689                          u8 number_destination_params,
 690                          size_t params_len,
 691                          struct core_conn_create_dest_spec_params *params)
 692 {
 693         int r;
 694         struct nci_core_conn_create_cmd *cmd;
 695         struct core_conn_create_data data;
 696
 697         data.length = params_len + sizeof(struct nci_core_conn_create_cmd);
 698         cmd = kzalloc(data.length, GFP_KERNEL);
 699         if (!cmd)
 700                 return -ENOMEM;
 701
 702         cmd->destination_type = destination_type;
 703         cmd->number_destination_params = number_destination_params;
 704
 705         data.cmd = cmd;
 706
 707         if (params) {
 708                 memcpy(cmd->params, params, params_len);
 709                 if (params->length > 0)
 710                         memcpy(&ndev->cur_params,
 711                                &params->value[DEST_SPEC_PARAMS_ID_INDEX],
 712                                sizeof(struct dest_spec_params));
 713                 else
 714                         ndev->cur_params.id = 0;
 715         } else {
 716                 ndev->cur_params.id = 0;
 717         }
 718         ndev->cur_dest_type = destination_type;
 719
 720         r = __nci_request(ndev, nci_core_conn_create_req, (unsigned long)&data,
 721                           msecs_to_jiffies(NCI_CMD_TIMEOUT));
 722         kfree(cmd);
 723         return r;
 724 }
 725 EXPORT_SYMBOL(nci_core_conn_create);
 726
 727 static void nci_core_conn_close_req(struct nci_dev *ndev, unsigned long opt)
 728 {
 729         __u8 conn_id = opt;
 730
 731         nci_send_cmd(ndev, NCI_OP_CORE_CONN_CLOSE_CMD, 1, &conn_id);
 732 }
 733
 734 int nci_core_conn_close(struct nci_dev *ndev, u8 conn_id)
 735 {
 736         ndev->cur_conn_id = conn_id;
 737         return __nci_request(ndev, nci_core_conn_close_req, conn_id,
 738                              msecs_to_jiffies(NCI_CMD_TIMEOUT));
 739 }
 740 EXPORT_SYMBOL(nci_core_conn_close);
 741
 742 static int nci_set_local_general_bytes(struct nfc_dev *nfc_dev)
 743 {
 744         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 745         struct nci_set_config_param param;
 746         int rc;
 747
 748         param.val = nfc_get_local_general_bytes(nfc_dev, &param.len);
 749         if ((param.val == NULL) || (param.len == 0))
 750                 return 0;
 751
 752         if (param.len > NFC_MAX_GT_LEN)
 753                 return -EINVAL;
 754
 755         param.id = NCI_PN_ATR_REQ_GEN_BYTES;
 756
 757         rc = nci_request(ndev, nci_set_config_req, (unsigned long)&param,
 758                          msecs_to_jiffies(NCI_SET_CONFIG_TIMEOUT));
 759         if (rc)
 760                 return rc;
 761
 762         param.id = NCI_LN_ATR_RES_GEN_BYTES;
 763
 764         return nci_request(ndev, nci_set_config_req, (unsigned long)&param,
 765                            msecs_to_jiffies(NCI_SET_CONFIG_TIMEOUT));
 766 }
 767
 768 static int nci_set_listen_parameters(struct nfc_dev *nfc_dev)
 769 {
 770         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 771         int rc;
 772         __u8 val;
 773
 774         val = NCI_LA_SEL_INFO_NFC_DEP_MASK;
 775
 776         rc = nci_set_config(ndev, NCI_LA_SEL_INFO, 1, &val);
 777         if (rc)
 778                 return rc;
 779
 780         val = NCI_LF_PROTOCOL_TYPE_NFC_DEP_MASK;
 781
 782         rc = nci_set_config(ndev, NCI_LF_PROTOCOL_TYPE, 1, &val);
 783         if (rc)
 784                 return rc;
 785
 786         val = NCI_LF_CON_BITR_F_212 | NCI_LF_CON_BITR_F_424;
 787
 788         return nci_set_config(ndev, NCI_LF_CON_BITR_F, 1, &val);
 789 }
 790
 791 static int nci_start_poll(struct nfc_dev *nfc_dev,
 792                           __u32 im_protocols, __u32 tm_protocols)
 793 {
 794         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 795         struct nci_rf_discover_param param;
 796         int rc;
 797
 798         if ((atomic_read(&ndev->state) == NCI_DISCOVERY) ||
 799             (atomic_read(&ndev->state) == NCI_W4_ALL_DISCOVERIES)) {
 800                 pr_err("unable to start poll, since poll is already active\n");
 801                 return -EBUSY;
 802         }
 803
 804         if (ndev->target_active_prot) {
 805                 pr_err("there is an active target\n");
 806                 return -EBUSY;
 807         }
 808
 809         if ((atomic_read(&ndev->state) == NCI_W4_HOST_SELECT) ||
 810             (atomic_read(&ndev->state) == NCI_POLL_ACTIVE)) {
 811                 pr_debug("target active or w4 select, implicitly deactivate\n");
 812
 813                 rc = nci_request(ndev, nci_rf_deactivate_req,
 814                                  NCI_DEACTIVATE_TYPE_IDLE_MODE,
 815                                  msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
 816                 if (rc)
 817                         return -EBUSY;
 818         }
 819
 820         if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) {
 821                 rc = nci_set_local_general_bytes(nfc_dev);
 822                 if (rc) {
 823                         pr_err("failed to set local general bytes\n");
 824                         return rc;
 825                 }
 826         }
 827
 828         if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
 829                 rc = nci_set_listen_parameters(nfc_dev);
 830                 if (rc)
 831                         pr_err("failed to set listen parameters\n");
 832         }
 833
 834         param.im_protocols = im_protocols;
 835         param.tm_protocols = tm_protocols;
 836         rc = nci_request(ndev, nci_rf_discover_req, (unsigned long)&param,
 837                          msecs_to_jiffies(NCI_RF_DISC_TIMEOUT));
 838
 839         if (!rc)
 840                 ndev->poll_prots = im_protocols;
 841
 842         return rc;
 843 }
 844
 845 static void nci_stop_poll(struct nfc_dev *nfc_dev)
 846 {
 847         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 848
 849         if ((atomic_read(&ndev->state) != NCI_DISCOVERY) &&
 850             (atomic_read(&ndev->state) != NCI_W4_ALL_DISCOVERIES)) {
 851                 pr_err("unable to stop poll, since poll is not active\n");
 852                 return;
 853         }
 854
 855         nci_request(ndev, nci_rf_deactivate_req, NCI_DEACTIVATE_TYPE_IDLE_MODE,
 856                     msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
 857 }
 858
 859 static int nci_activate_target(struct nfc_dev *nfc_dev,
 860                                struct nfc_target *target, __u32 protocol)
 861 {
 862         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 863         struct nci_rf_discover_select_param param;
 864         struct nfc_target *nci_target = NULL;
 865         int i;
 866         int rc = 0;
 867
 868         pr_debug("target_idx %d, protocol 0x%x\n", target->idx, protocol);
 869
 870         if ((atomic_read(&ndev->state) != NCI_W4_HOST_SELECT) &&
 871             (atomic_read(&ndev->state) != NCI_POLL_ACTIVE)) {
 872                 pr_err("there is no available target to activate\n");
 873                 return -EINVAL;
 874         }
 875
 876         if (ndev->target_active_prot) {
 877                 pr_err("there is already an active target\n");
 878                 return -EBUSY;
 879         }
 880
 881         for (i = 0; i < ndev->n_targets; i++) {
 882                 if (ndev->targets[i].idx == target->idx) {
 883                         nci_target = &ndev->targets[i];
 884                         break;
 885                 }
 886         }
 887
 888         if (!nci_target) {
 889                 pr_err("unable to find the selected target\n");
 890                 return -EINVAL;
 891         }
 892
 893         if (!(nci_target->supported_protocols & (1 << protocol))) {
 894                 pr_err("target does not support the requested protocol 0x%x\n",
 895                        protocol);
 896                 return -EINVAL;
 897         }
 898
 899         if (atomic_read(&ndev->state) == NCI_W4_HOST_SELECT) {
 900                 param.rf_discovery_id = nci_target->logical_idx;
 901
 902                 if (protocol == NFC_PROTO_JEWEL)
 903                         param.rf_protocol = NCI_RF_PROTOCOL_T1T;
 904                 else if (protocol == NFC_PROTO_MIFARE)
 905                         param.rf_protocol = NCI_RF_PROTOCOL_T2T;
 906                 else if (protocol == NFC_PROTO_FELICA)
 907                         param.rf_protocol = NCI_RF_PROTOCOL_T3T;
 908                 else if (protocol == NFC_PROTO_ISO14443 ||
 909                          protocol == NFC_PROTO_ISO14443_B)
 910                         param.rf_protocol = NCI_RF_PROTOCOL_ISO_DEP;
 911                 else
 912                         param.rf_protocol = NCI_RF_PROTOCOL_NFC_DEP;
 913
 914                 rc = nci_request(ndev, nci_rf_discover_select_req,
 915                                  (unsigned long)&param,
 916                                  msecs_to_jiffies(NCI_RF_DISC_SELECT_TIMEOUT));
 917         }
 918
 919         if (!rc)
 920                 ndev->target_active_prot = protocol;
 921
 922         return rc;
 923 }
 924
 925 static void nci_deactivate_target(struct nfc_dev *nfc_dev,
 926                                   struct nfc_target *target,
 927                                   __u8 mode)
 928 {
 929         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 930         u8 nci_mode = NCI_DEACTIVATE_TYPE_IDLE_MODE;
 931
 932         pr_debug("entry\n");
 933
 934         if (!ndev->target_active_prot) {
 935                 pr_err("unable to deactivate target, no active target\n");
 936                 return;
 937         }
 938
 939         ndev->target_active_prot = 0;
 940
 941         switch (mode) {
 942         case NFC_TARGET_MODE_SLEEP:
 943                 nci_mode = NCI_DEACTIVATE_TYPE_SLEEP_MODE;
 944                 break;
 945         }
 946
 947         if (atomic_read(&ndev->state) == NCI_POLL_ACTIVE) {
 948                 nci_request(ndev, nci_rf_deactivate_req, nci_mode,
 949                             msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
 950         }
 951 }
 952
 953 static int nci_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
 954                            __u8 comm_mode, __u8 *gb, size_t gb_len)
 955 {
 956         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 957         int rc;
 958
 959         pr_debug("target_idx %d, comm_mode %d\n", target->idx, comm_mode);
 960
 961         rc = nci_activate_target(nfc_dev, target, NFC_PROTO_NFC_DEP);
 962         if (rc)
 963                 return rc;
 964
 965         rc = nfc_set_remote_general_bytes(nfc_dev, ndev->remote_gb,
 966                                           ndev->remote_gb_len);
 967         if (!rc)
 968                 rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_PASSIVE,
 969                                         NFC_RF_INITIATOR);
 970
 971         return rc;
 972 }
 973
 974 static int nci_dep_link_down(struct nfc_dev *nfc_dev)
 975 {
 976         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
 977         int rc;
 978
 979         pr_debug("entry\n");
 980
 981         if (nfc_dev->rf_mode == NFC_RF_INITIATOR) {
 982                 nci_deactivate_target(nfc_dev, NULL, NCI_DEACTIVATE_TYPE_IDLE_MODE);
 983         } else {
 984                 if (atomic_read(&ndev->state) == NCI_LISTEN_ACTIVE ||
 985                     atomic_read(&ndev->state) == NCI_DISCOVERY) {
 986                         nci_request(ndev, nci_rf_deactivate_req, 0,
 987                                 msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
 988                 }
 989
 990                 rc = nfc_tm_deactivated(nfc_dev);
 991                 if (rc)
 992                         pr_err("error when signaling tm deactivation\n");
 993         }
 994
 995         return 0;
 996 }
 997
 998
 999 static int nci_transceive(struct nfc_dev *nfc_dev, struct nfc_target *target,
1000                           struct sk_buff *skb,
1001                           data_exchange_cb_t cb, void *cb_context)
1002 {
1003         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
1004         int rc;
1005         struct nci_conn_info    *conn_info;
1006
1007         conn_info = ndev->rf_conn_info;
1008         if (!conn_info)
1009                 return -EPROTO;
1010
1011         pr_debug("target_idx %d, len %d\n", target->idx, skb->len);
1012
1013         if (!ndev->target_active_prot) {
1014                 pr_err("unable to exchange data, no active target\n");
1015                 return -EINVAL;
1016         }
1017
1018         if (test_and_set_bit(NCI_DATA_EXCHANGE, &ndev->flags))
1019                 return -EBUSY;
1020
1021         /* store cb and context to be used on receiving data */
1022         conn_info->data_exchange_cb = cb;
1023         conn_info->data_exchange_cb_context = cb_context;
1024
1025         rc = nci_send_data(ndev, NCI_STATIC_RF_CONN_ID, skb);
1026         if (rc)
1027                 clear_bit(NCI_DATA_EXCHANGE, &ndev->flags);
1028
1029         return rc;
1030 }
1031
1032 static int nci_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
1033 {
1034         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
1035         int rc;
1036
1037         rc = nci_send_data(ndev, NCI_STATIC_RF_CONN_ID, skb);
1038         if (rc)
1039                 pr_err("unable to send data\n");
1040
1041         return rc;
1042 }
1043
1044 static int nci_enable_se(struct nfc_dev *nfc_dev, u32 se_idx)
1045 {
1046         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
1047
1048         if (ndev->ops->enable_se)
1049                 return ndev->ops->enable_se(ndev, se_idx);
1050
1051         return 0;
1052 }
1053
1054 static int nci_disable_se(struct nfc_dev *nfc_dev, u32 se_idx)
1055 {
1056         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
1057
1058         if (ndev->ops->disable_se)
1059                 return ndev->ops->disable_se(ndev, se_idx);
1060
1061         return 0;
1062 }
1063
1064 static int nci_discover_se(struct nfc_dev *nfc_dev)
1065 {
1066         int r;
1067         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
1068
1069         if (ndev->ops->discover_se) {
1070                 r = nci_nfcee_discover(ndev, NCI_NFCEE_DISCOVERY_ACTION_ENABLE);
1071                 if (r != NCI_STATUS_OK)
1072                         return -EPROTO;
1073
1074                 return ndev->ops->discover_se(ndev);
1075         }
1076
1077         return 0;
1078 }
1079
1080 static int nci_se_io(struct nfc_dev *nfc_dev, u32 se_idx,
1081                      u8 *apdu, size_t apdu_length,
1082                      se_io_cb_t cb, void *cb_context)
1083 {
1084         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
1085
1086         if (ndev->ops->se_io)
1087                 return ndev->ops->se_io(ndev, se_idx, apdu,
1088                                 apdu_length, cb, cb_context);
1089
1090         return 0;
1091 }
1092
1093 static int nci_fw_download(struct nfc_dev *nfc_dev, const char *firmware_name)
1094 {
1095         struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
1096
1097         if (!ndev->ops->fw_download)
1098                 return -ENOTSUPP;
1099
1100         return ndev->ops->fw_download(ndev, firmware_name);
1101 }
1102
1103 static struct nfc_ops nci_nfc_ops = {
1104         .dev_up = nci_dev_up,
1105         .dev_down = nci_dev_down,
1106         .start_poll = nci_start_poll,
1107         .stop_poll = nci_stop_poll,
1108         .dep_link_up = nci_dep_link_up,
1109         .dep_link_down = nci_dep_link_down,
1110         .activate_target = nci_activate_target,
1111         .deactivate_target = nci_deactivate_target,
1112         .im_transceive = nci_transceive,
1113         .tm_send = nci_tm_send,
1114         .enable_se = nci_enable_se,
1115         .disable_se = nci_disable_se,
1116         .discover_se = nci_discover_se,
1117         .se_io = nci_se_io,
1118         .fw_download = nci_fw_download,
1119 };
1120
1121 /* ---- Interface to NCI drivers ---- */
1122 /**
1123  * nci_allocate_device - allocate a new nci device
1124  *
1125  * @ops: device operations
1126  * @supported_protocols: NFC protocols supported by the device
1127  */
1128 struct nci_dev *nci_allocate_device(struct nci_ops *ops,
1129                                     __u32 supported_protocols,
1130                                     int tx_headroom, int tx_tailroom)
1131 {
1132         struct nci_dev *ndev;
1133
1134         pr_debug("supported_protocols 0x%x\n", supported_protocols);
1135
1136         if (!ops->open || !ops->close || !ops->send)
1137                 return NULL;
1138
1139         if (!supported_protocols)
1140                 return NULL;
1141
1142         ndev = kzalloc(sizeof(struct nci_dev), GFP_KERNEL);
1143         if (!ndev)
1144                 return NULL;
1145
1146         ndev->ops = ops;
1147
1148         if (ops->n_prop_ops > NCI_MAX_PROPRIETARY_CMD) {
1149                 pr_err("Too many proprietary commands: %zd\n",
1150                        ops->n_prop_ops);
1151                 ops->prop_ops = NULL;
1152                 ops->n_prop_ops = 0;
1153         }
1154
1155         ndev->tx_headroom = tx_headroom;
1156         ndev->tx_tailroom = tx_tailroom;
1157         init_completion(&ndev->req_completion);
1158
1159         ndev->nfc_dev = nfc_allocate_device(&nci_nfc_ops,
1160                                             supported_protocols,
1161                                             tx_headroom + NCI_DATA_HDR_SIZE,
1162                                             tx_tailroom);
1163         if (!ndev->nfc_dev)
1164                 goto free_nci;
1165
1166         ndev->hci_dev = nci_hci_allocate(ndev);
1167         if (!ndev->hci_dev)
1168                 goto free_nfc;
1169
1170         nfc_set_drvdata(ndev->nfc_dev, ndev);
1171
1172         return ndev;
1173
1174 free_nfc:
1175         nfc_free_device(ndev->nfc_dev);
1176 free_nci:
1177         kfree(ndev);
1178         return NULL;
1179 }
1180 EXPORT_SYMBOL(nci_allocate_device);
1181
1182 /**
1183  * nci_free_device - deallocate nci device
1184  *
1185  * @ndev: The nci device to deallocate
1186  */
1187 void nci_free_device(struct nci_dev *ndev)
1188 {
1189         nfc_free_device(ndev->nfc_dev);
1190         kfree(ndev);
1191 }
1192 EXPORT_SYMBOL(nci_free_device);
1193
1194 /**
1195  * nci_register_device - register a nci device in the nfc subsystem
1196  *
1197  * @dev: The nci device to register
1198  */
1199 int nci_register_device(struct nci_dev *ndev)
1200 {
1201         int rc;
1202         struct device *dev = &ndev->nfc_dev->dev;
1203         char name[32];
1204
1205         ndev->flags = 0;
1206
1207         INIT_WORK(&ndev->cmd_work, nci_cmd_work);
1208         snprintf(name, sizeof(name), "%s_nci_cmd_wq", dev_name(dev));
1209         ndev->cmd_wq = create_singlethread_workqueue(name);
1210         if (!ndev->cmd_wq) {
1211                 rc = -ENOMEM;
1212                 goto exit;
1213         }
1214
1215         INIT_WORK(&ndev->rx_work, nci_rx_work);
1216         snprintf(name, sizeof(name), "%s_nci_rx_wq", dev_name(dev));
1217         ndev->rx_wq = create_singlethread_workqueue(name);
1218         if (!ndev->rx_wq) {
1219                 rc = -ENOMEM;
1220                 goto destroy_cmd_wq_exit;
1221         }
1222
1223         INIT_WORK(&ndev->tx_work, nci_tx_work);
1224         snprintf(name, sizeof(name), "%s_nci_tx_wq", dev_name(dev));
1225         ndev->tx_wq = create_singlethread_workqueue(name);
1226         if (!ndev->tx_wq) {
1227                 rc = -ENOMEM;
1228                 goto destroy_rx_wq_exit;
1229         }
1230
1231         skb_queue_head_init(&ndev->cmd_q);
1232         skb_queue_head_init(&ndev->rx_q);
1233         skb_queue_head_init(&ndev->tx_q);
1234
1235         setup_timer(&ndev->cmd_timer, nci_cmd_timer,
1236                     (unsigned long) ndev);
1237         setup_timer(&ndev->data_timer, nci_data_timer,
1238                     (unsigned long) ndev);
1239
1240         mutex_init(&ndev->req_lock);
1241         INIT_LIST_HEAD(&ndev->conn_info_list);
1242
1243         rc = nfc_register_device(ndev->nfc_dev);
1244         if (rc)
1245                 goto destroy_rx_wq_exit;
1246
1247         goto exit;
1248
1249 destroy_rx_wq_exit:
1250         destroy_workqueue(ndev->rx_wq);
1251
1252 destroy_cmd_wq_exit:
1253         destroy_workqueue(ndev->cmd_wq);
1254
1255 exit:
1256         return rc;
1257 }
1258 EXPORT_SYMBOL(nci_register_device);
1259
1260 /**
1261  * nci_unregister_device - unregister a nci device in the nfc subsystem
1262  *
1263  * @dev: The nci device to unregister
1264  */
1265 void nci_unregister_device(struct nci_dev *ndev)
1266 {
1267         struct nci_conn_info    *conn_info, *n;
1268
1269         nci_close_device(ndev);
1270
1271         destroy_workqueue(ndev->cmd_wq);
1272         destroy_workqueue(ndev->rx_wq);
1273         destroy_workqueue(ndev->tx_wq);
1274
1275         list_for_each_entry_safe(conn_info, n, &ndev->conn_info_list, list) {
1276                 list_del(&conn_info->list);
1277                 /* conn_info is allocated with devm_kzalloc */
1278         }
1279
1280         nfc_unregister_device(ndev->nfc_dev);
1281 }
1282 EXPORT_SYMBOL(nci_unregister_device);
1283
1284 /**
1285  * nci_recv_frame - receive frame from NCI drivers
1286  *
1287  * @ndev: The nci device
1288  * @skb: The sk_buff to receive
1289  */
1290 int nci_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
1291 {
1292         pr_debug("len %d\n", skb->len);
1293
1294         if (!ndev || (!test_bit(NCI_UP, &ndev->flags) &&
1295             !test_bit(NCI_INIT, &ndev->flags))) {
1296                 kfree_skb(skb);
1297                 return -ENXIO;
1298         }
1299
1300         /* Queue frame for rx worker thread */
1301         skb_queue_tail(&ndev->rx_q, skb);
1302         queue_work(ndev->rx_wq, &ndev->rx_work);
1303
1304         return 0;
1305 }
1306 EXPORT_SYMBOL(nci_recv_frame);
1307
1308 int nci_send_frame(struct nci_dev *ndev, struct sk_buff *skb)
1309 {
1310         pr_debug("len %d\n", skb->len);
1311
1312         if (!ndev) {
1313                 kfree_skb(skb);
1314                 return -ENODEV;
1315         }
1316
1317         /* Get rid of skb owner, prior to sending to the driver. */
1318         skb_orphan(skb);
1319
1320         /* Send copy to sniffer */
1321         nfc_send_to_raw_sock(ndev->nfc_dev, skb,
1322                              RAW_PAYLOAD_NCI, NFC_DIRECTION_TX);
1323
1324         return ndev->ops->send(ndev, skb);
1325 }
1326 EXPORT_SYMBOL(nci_send_frame);
1327
1328 /* Send NCI command */
1329 int nci_send_cmd(struct nci_dev *ndev, __u16 opcode, __u8 plen, void *payload)
1330 {
1331         struct nci_ctrl_hdr *hdr;
1332         struct sk_buff *skb;
1333
1334         pr_debug("opcode 0x%x, plen %d\n", opcode, plen);
1335
1336         skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + plen), GFP_KERNEL);
1337         if (!skb) {
1338                 pr_err("no memory for command\n");
1339                 return -ENOMEM;
1340         }
1341
1342         hdr = skb_put(skb, NCI_CTRL_HDR_SIZE);
1343         hdr->gid = nci_opcode_gid(opcode);
1344         hdr->oid = nci_opcode_oid(opcode);
1345         hdr->plen = plen;
1346
1347         nci_mt_set((__u8 *)hdr, NCI_MT_CMD_PKT);
1348         nci_pbf_set((__u8 *)hdr, NCI_PBF_LAST);
1349
1350         if (plen)
1351                 skb_put_data(skb, payload, plen);
1352
1353         skb_queue_tail(&ndev->cmd_q, skb);
1354         queue_work(ndev->cmd_wq, &ndev->cmd_work);
1355
1356         return 0;
1357 }
1358 EXPORT_SYMBOL(nci_send_cmd);
1359
1360 /* Proprietary commands API */
1361 static struct nci_driver_ops *ops_cmd_lookup(struct nci_driver_ops *ops,
1362                                              size_t n_ops,
1363                                              __u16 opcode)
1364 {
1365         size_t i;
1366         struct nci_driver_ops *op;
1367
1368         if (!ops || !n_ops)
1369                 return NULL;
1370
1371         for (i = 0; i < n_ops; i++) {
1372                 op = &ops[i];
1373                 if (op->opcode == opcode)
1374                         return op;
1375         }
1376
1377         return NULL;
1378 }
1379
1380 static int nci_op_rsp_packet(struct nci_dev *ndev, __u16 rsp_opcode,
1381                              struct sk_buff *skb, struct nci_driver_ops *ops,
1382                              size_t n_ops)
1383 {
1384         struct nci_driver_ops *op;
1385
1386         op = ops_cmd_lookup(ops, n_ops, rsp_opcode);
1387         if (!op || !op->rsp)
1388                 return -ENOTSUPP;
1389
1390         return op->rsp(ndev, skb);
1391 }
1392
1393 static int nci_op_ntf_packet(struct nci_dev *ndev, __u16 ntf_opcode,
1394                              struct sk_buff *skb, struct nci_driver_ops *ops,
1395                              size_t n_ops)
1396 {
1397         struct nci_driver_ops *op;
1398
1399         op = ops_cmd_lookup(ops, n_ops, ntf_opcode);
1400         if (!op || !op->ntf)
1401                 return -ENOTSUPP;
1402
1403         return op->ntf(ndev, skb);
1404 }
1405
1406 int nci_prop_rsp_packet(struct nci_dev *ndev, __u16 opcode,
1407                         struct sk_buff *skb)
1408 {
1409         return nci_op_rsp_packet(ndev, opcode, skb, ndev->ops->prop_ops,
1410                                  ndev->ops->n_prop_ops);
1411 }
1412
1413 int nci_prop_ntf_packet(struct nci_dev *ndev, __u16 opcode,
1414                         struct sk_buff *skb)
1415 {
1416         return nci_op_ntf_packet(ndev, opcode, skb, ndev->ops->prop_ops,
1417                                  ndev->ops->n_prop_ops);
1418 }
1419
1420 int nci_core_rsp_packet(struct nci_dev *ndev, __u16 opcode,
1421                         struct sk_buff *skb)
1422 {
1423         return nci_op_rsp_packet(ndev, opcode, skb, ndev->ops->core_ops,
1424                                   ndev->ops->n_core_ops);
1425 }
1426
1427 int nci_core_ntf_packet(struct nci_dev *ndev, __u16 opcode,
1428                         struct sk_buff *skb)
1429 {
1430         return nci_op_ntf_packet(ndev, opcode, skb, ndev->ops->core_ops,
1431                                  ndev->ops->n_core_ops);
1432 }
1433
1434 /* ---- NCI TX Data worker thread ---- */
1435
1436 static void nci_tx_work(struct work_struct *work)
1437 {
1438         struct nci_dev *ndev = container_of(work, struct nci_dev, tx_work);
1439         struct nci_conn_info    *conn_info;
1440         struct sk_buff *skb;
1441
1442         conn_info = nci_get_conn_info_by_conn_id(ndev, ndev->cur_conn_id);
1443         if (!conn_info)
1444                 return;
1445
1446         pr_debug("credits_cnt %d\n", atomic_read(&conn_info->credits_cnt));
1447
1448         /* Send queued tx data */
1449         while (atomic_read(&conn_info->credits_cnt)) {
1450                 skb = skb_dequeue(&ndev->tx_q);
1451                 if (!skb)
1452                         return;
1453
1454                 /* Check if data flow control is used */
1455                 if (atomic_read(&conn_info->credits_cnt) !=
1456                     NCI_DATA_FLOW_CONTROL_NOT_USED)
1457                         atomic_dec(&conn_info->credits_cnt);
1458
1459                 pr_debug("NCI TX: MT=data, PBF=%d, conn_id=%d, plen=%d\n",
1460                          nci_pbf(skb->data),
1461                          nci_conn_id(skb->data),
1462                          nci_plen(skb->data));
1463
1464                 nci_send_frame(ndev, skb);
1465
1466                 mod_timer(&ndev->data_timer,
1467                           jiffies + msecs_to_jiffies(NCI_DATA_TIMEOUT));
1468         }
1469 }
1470
1471 /* ----- NCI RX worker thread (data & control) ----- */
1472
1473 static void nci_rx_work(struct work_struct *work)
1474 {
1475         struct nci_dev *ndev = container_of(work, struct nci_dev, rx_work);
1476         struct sk_buff *skb;
1477
1478         while ((skb = skb_dequeue(&ndev->rx_q))) {
1479
1480                 /* Send copy to sniffer */
1481                 nfc_send_to_raw_sock(ndev->nfc_dev, skb,
1482                                      RAW_PAYLOAD_NCI, NFC_DIRECTION_RX);
1483
1484                 /* Process frame */
1485                 switch (nci_mt(skb->data)) {
1486                 case NCI_MT_RSP_PKT:
1487                         nci_rsp_packet(ndev, skb);
1488                         break;
1489
1490                 case NCI_MT_NTF_PKT:
1491                         nci_ntf_packet(ndev, skb);
1492                         break;
1493
1494                 case NCI_MT_DATA_PKT:
1495                         nci_rx_data_packet(ndev, skb);
1496                         break;
1497
1498                 default:
1499                         pr_err("unknown MT 0x%x\n", nci_mt(skb->data));
1500                         kfree_skb(skb);
1501                         break;
1502                 }
1503         }
1504
1505         /* check if a data exchange timout has occurred */
1506         if (test_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags)) {
1507                 /* complete the data exchange transaction, if exists */
1508                 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
1509                         nci_data_exchange_complete(ndev, NULL,
1510                                                    ndev->cur_conn_id,
1511                                                    -ETIMEDOUT);
1512
1513                 clear_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags);
1514         }
1515 }
1516
1517 /* ----- NCI TX CMD worker thread ----- */
1518
1519 static void nci_cmd_work(struct work_struct *work)
1520 {
1521         struct nci_dev *ndev = container_of(work, struct nci_dev, cmd_work);
1522         struct sk_buff *skb;
1523
1524         pr_debug("cmd_cnt %d\n", atomic_read(&ndev->cmd_cnt));
1525
1526         /* Send queued command */
1527         if (atomic_read(&ndev->cmd_cnt)) {
1528                 skb = skb_dequeue(&ndev->cmd_q);
1529                 if (!skb)
1530                         return;
1531
1532                 atomic_dec(&ndev->cmd_cnt);
1533
1534                 pr_debug("NCI TX: MT=cmd, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
1535                          nci_pbf(skb->data),
1536                          nci_opcode_gid(nci_opcode(skb->data)),
1537                          nci_opcode_oid(nci_opcode(skb->data)),
1538                          nci_plen(skb->data));
1539
1540                 nci_send_frame(ndev, skb);
1541
1542                 mod_timer(&ndev->cmd_timer,
1543                           jiffies + msecs_to_jiffies(NCI_CMD_TIMEOUT));
1544         }
1545 }
1546
1547 MODULE_LICENSE("GPL");