net/nfc/hci/core.c

   1 /*
   2  * Copyright (C) 2012  Intel Corporation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #define pr_fmt(fmt) "hci: %s: " fmt, __func__
  19
  20 #include <linux/init.h>
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/nfc.h>
  24
  25 #include <net/nfc/nfc.h>
  26 #include <net/nfc/hci.h>
  27 #include <net/nfc/llc.h>
  28
  29 #include "hci.h"
  30
  31 /* Largest headroom needed for outgoing HCI commands */
  32 #define HCI_CMDS_HEADROOM 1
  33
  34 int nfc_hci_result_to_errno(u8 result)
  35 {
  36         switch (result) {
  37         case NFC_HCI_ANY_OK:
  38                 return 0;
  39         case NFC_HCI_ANY_E_REG_PAR_UNKNOWN:
  40                 return -EOPNOTSUPP;
  41         case NFC_HCI_ANY_E_TIMEOUT:
  42                 return -ETIME;
  43         default:
  44                 return -1;
  45         }
  46 }
  47 EXPORT_SYMBOL(nfc_hci_result_to_errno);
  48
  49 static void nfc_hci_msg_tx_work(struct work_struct *work)
  50 {
  51         struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
  52                                                 msg_tx_work);
  53         struct hci_msg *msg;
  54         struct sk_buff *skb;
  55         int r = 0;
  56
  57         mutex_lock(&hdev->msg_tx_mutex);
  58         if (hdev->shutting_down)
  59                 goto exit;
  60
  61         if (hdev->cmd_pending_msg) {
  62                 if (timer_pending(&hdev->cmd_timer) == 0) {
  63                         if (hdev->cmd_pending_msg->cb)
  64                                 hdev->cmd_pending_msg->cb(hdev->
  65                                                           cmd_pending_msg->
  66                                                           cb_context,
  67                                                           NULL,
  68                                                           -ETIME);
  69                         kfree(hdev->cmd_pending_msg);
  70                         hdev->cmd_pending_msg = NULL;
  71                 } else {
  72                         goto exit;
  73                 }
  74         }
  75
  76 next_msg:
  77         if (list_empty(&hdev->msg_tx_queue))
  78                 goto exit;
  79
  80         msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg, msg_l);
  81         list_del(&msg->msg_l);
  82
  83         pr_debug("msg_tx_queue has a cmd to send\n");
  84         while ((skb = skb_dequeue(&msg->msg_frags)) != NULL) {
  85                 r = nfc_llc_xmit_from_hci(hdev->llc, skb);
  86                 if (r < 0) {
  87                         kfree_skb(skb);
  88                         skb_queue_purge(&msg->msg_frags);
  89                         if (msg->cb)
  90                                 msg->cb(msg->cb_context, NULL, r);
  91                         kfree(msg);
  92                         break;
  93                 }
  94         }
  95
  96         if (r)
  97                 goto next_msg;
  98
  99         if (msg->wait_response == false) {
 100                 kfree(msg);
 101                 goto next_msg;
 102         }
 103
 104         hdev->cmd_pending_msg = msg;
 105         mod_timer(&hdev->cmd_timer, jiffies +
 106                   msecs_to_jiffies(hdev->cmd_pending_msg->completion_delay));
 107
 108 exit:
 109         mutex_unlock(&hdev->msg_tx_mutex);
 110 }
 111
 112 static void nfc_hci_msg_rx_work(struct work_struct *work)
 113 {
 114         struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
 115                                                 msg_rx_work);
 116         struct sk_buff *skb;
 117         struct hcp_message *message;
 118         u8 pipe;
 119         u8 type;
 120         u8 instruction;
 121
 122         while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) {
 123                 pipe = skb->data[0];
 124                 skb_pull(skb, NFC_HCI_HCP_PACKET_HEADER_LEN);
 125                 message = (struct hcp_message *)skb->data;
 126                 type = HCP_MSG_GET_TYPE(message->header);
 127                 instruction = HCP_MSG_GET_CMD(message->header);
 128                 skb_pull(skb, NFC_HCI_HCP_MESSAGE_HEADER_LEN);
 129
 130                 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, skb);
 131         }
 132 }
 133
 134 static void __nfc_hci_cmd_completion(struct nfc_hci_dev *hdev, int err,
 135                                      struct sk_buff *skb)
 136 {
 137         del_timer_sync(&hdev->cmd_timer);
 138
 139         if (hdev->cmd_pending_msg->cb)
 140                 hdev->cmd_pending_msg->cb(hdev->cmd_pending_msg->cb_context,
 141                                           skb, err);
 142         else
 143                 kfree_skb(skb);
 144
 145         kfree(hdev->cmd_pending_msg);
 146         hdev->cmd_pending_msg = NULL;
 147
 148         schedule_work(&hdev->msg_tx_work);
 149 }
 150
 151 void nfc_hci_resp_received(struct nfc_hci_dev *hdev, u8 result,
 152                            struct sk_buff *skb)
 153 {
 154         mutex_lock(&hdev->msg_tx_mutex);
 155
 156         if (hdev->cmd_pending_msg == NULL) {
 157                 kfree_skb(skb);
 158                 goto exit;
 159         }
 160
 161         __nfc_hci_cmd_completion(hdev, nfc_hci_result_to_errno(result), skb);
 162
 163 exit:
 164         mutex_unlock(&hdev->msg_tx_mutex);
 165 }
 166
 167 void nfc_hci_cmd_received(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd,
 168                           struct sk_buff *skb)
 169 {
 170         kfree_skb(skb);
 171 }
 172
 173 u32 nfc_hci_sak_to_protocol(u8 sak)
 174 {
 175         switch (NFC_HCI_TYPE_A_SEL_PROT(sak)) {
 176         case NFC_HCI_TYPE_A_SEL_PROT_MIFARE:
 177                 return NFC_PROTO_MIFARE_MASK;
 178         case NFC_HCI_TYPE_A_SEL_PROT_ISO14443:
 179                 return NFC_PROTO_ISO14443_MASK;
 180         case NFC_HCI_TYPE_A_SEL_PROT_DEP:
 181                 return NFC_PROTO_NFC_DEP_MASK;
 182         case NFC_HCI_TYPE_A_SEL_PROT_ISO14443_DEP:
 183                 return NFC_PROTO_ISO14443_MASK | NFC_PROTO_NFC_DEP_MASK;
 184         default:
 185                 return 0xffffffff;
 186         }
 187 }
 188 EXPORT_SYMBOL(nfc_hci_sak_to_protocol);
 189
 190 int nfc_hci_target_discovered(struct nfc_hci_dev *hdev, u8 gate)
 191 {
 192         struct nfc_target *targets;
 193         struct sk_buff *atqa_skb = NULL;
 194         struct sk_buff *sak_skb = NULL;
 195         struct sk_buff *uid_skb = NULL;
 196         int r;
 197
 198         pr_debug("from gate %d\n", gate);
 199
 200         targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
 201         if (targets == NULL)
 202                 return -ENOMEM;
 203
 204         switch (gate) {
 205         case NFC_HCI_RF_READER_A_GATE:
 206                 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
 207                                       NFC_HCI_RF_READER_A_ATQA, &atqa_skb);
 208                 if (r < 0)
 209                         goto exit;
 210
 211                 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
 212                                       NFC_HCI_RF_READER_A_SAK, &sak_skb);
 213                 if (r < 0)
 214                         goto exit;
 215
 216                 if (atqa_skb->len != 2 || sak_skb->len != 1) {
 217                         r = -EPROTO;
 218                         goto exit;
 219                 }
 220
 221                 targets->supported_protocols =
 222                                 nfc_hci_sak_to_protocol(sak_skb->data[0]);
 223                 if (targets->supported_protocols == 0xffffffff) {
 224                         r = -EPROTO;
 225                         goto exit;
 226                 }
 227
 228                 targets->sens_res = be16_to_cpu(*(__be16 *)atqa_skb->data);
 229                 targets->sel_res = sak_skb->data[0];
 230
 231                 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
 232                                       NFC_HCI_RF_READER_A_UID, &uid_skb);
 233                 if (r < 0)
 234                         goto exit;
 235
 236                 if (uid_skb->len == 0 || uid_skb->len > NFC_NFCID1_MAXSIZE) {
 237                         r = -EPROTO;
 238                         goto exit;
 239                 }
 240
 241                 memcpy(targets->nfcid1, uid_skb->data, uid_skb->len);
 242                 targets->nfcid1_len = uid_skb->len;
 243
 244                 if (hdev->ops->complete_target_discovered) {
 245                         r = hdev->ops->complete_target_discovered(hdev, gate,
 246                                                                   targets);
 247                         if (r < 0)
 248                                 goto exit;
 249                 }
 250                 break;
 251         case NFC_HCI_RF_READER_B_GATE:
 252                 targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
 253                 break;
 254         default:
 255                 if (hdev->ops->target_from_gate)
 256                         r = hdev->ops->target_from_gate(hdev, gate, targets);
 257                 else
 258                         r = -EPROTO;
 259                 if (r < 0)
 260                         goto exit;
 261
 262                 if (hdev->ops->complete_target_discovered) {
 263                         r = hdev->ops->complete_target_discovered(hdev, gate,
 264                                                                   targets);
 265                         if (r < 0)
 266                                 goto exit;
 267                 }
 268                 break;
 269         }
 270
 271         /* if driver set the new gate, we will skip the old one */
 272         if (targets->hci_reader_gate == 0x00)
 273                 targets->hci_reader_gate = gate;
 274
 275         r = nfc_targets_found(hdev->ndev, targets, 1);
 276
 277 exit:
 278         kfree(targets);
 279         kfree_skb(atqa_skb);
 280         kfree_skb(sak_skb);
 281         kfree_skb(uid_skb);
 282
 283         return r;
 284 }
 285 EXPORT_SYMBOL(nfc_hci_target_discovered);
 286
 287 void nfc_hci_event_received(struct nfc_hci_dev *hdev, u8 pipe, u8 event,
 288                             struct sk_buff *skb)
 289 {
 290         int r = 0;
 291         u8 gate = nfc_hci_pipe2gate(hdev, pipe);
 292
 293         if (gate == 0xff) {
 294                 pr_err("Discarded event %x to unopened pipe %x\n", event, pipe);
 295                 goto exit;
 296         }
 297
 298         if (hdev->ops->event_received) {
 299                 r = hdev->ops->event_received(hdev, gate, event, skb);
 300                 if (r <= 0)
 301                         goto exit_noskb;
 302         }
 303
 304         switch (event) {
 305         case NFC_HCI_EVT_TARGET_DISCOVERED:
 306                 if (skb->len < 1) {     /* no status data? */
 307                         r = -EPROTO;
 308                         goto exit;
 309                 }
 310
 311                 if (skb->data[0] == 3) {
 312                         /* TODO: Multiple targets in field, none activated
 313                          * poll is supposedly stopped, but there is no
 314                          * single target to activate, so nothing to report
 315                          * up.
 316                          * if we need to restart poll, we must save the
 317                          * protocols from the initial poll and reuse here.
 318                          */
 319                 }
 320
 321                 if (skb->data[0] != 0) {
 322                         r = -EPROTO;
 323                         goto exit;
 324                 }
 325
 326                 r = nfc_hci_target_discovered(hdev, gate);
 327                 break;
 328         default:
 329                 pr_info("Discarded unknown event %x to gate %x\n", event, gate);
 330                 r = -EINVAL;
 331                 break;
 332         }
 333
 334 exit:
 335         kfree_skb(skb);
 336
 337 exit_noskb:
 338         if (r)
 339                 nfc_hci_driver_failure(hdev, r);
 340 }
 341
 342 static void nfc_hci_cmd_timeout(unsigned long data)
 343 {
 344         struct nfc_hci_dev *hdev = (struct nfc_hci_dev *)data;
 345
 346         schedule_work(&hdev->msg_tx_work);
 347 }
 348
 349 static int hci_dev_connect_gates(struct nfc_hci_dev *hdev, u8 gate_count,
 350                                  struct nfc_hci_gate *gates)
 351 {
 352         int r;
 353         while (gate_count--) {
 354                 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID,
 355                                          gates->gate, gates->pipe);
 356                 if (r < 0)
 357                         return r;
 358                 gates++;
 359         }
 360
 361         return 0;
 362 }
 363
 364 static int hci_dev_session_init(struct nfc_hci_dev *hdev)
 365 {
 366         struct sk_buff *skb = NULL;
 367         int r;
 368
 369         if (hdev->init_data.gates[0].gate != NFC_HCI_ADMIN_GATE)
 370                 return -EPROTO;
 371
 372         r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID,
 373                                  hdev->init_data.gates[0].gate,
 374                                  hdev->init_data.gates[0].pipe);
 375         if (r < 0)
 376                 goto exit;
 377
 378         r = nfc_hci_get_param(hdev, NFC_HCI_ADMIN_GATE,
 379                               NFC_HCI_ADMIN_SESSION_IDENTITY, &skb);
 380         if (r < 0)
 381                 goto disconnect_all;
 382
 383         if (skb->len && skb->len == strlen(hdev->init_data.session_id) &&
 384                 (memcmp(hdev->init_data.session_id, skb->data,
 385                            skb->len) == 0) && hdev->ops->load_session) {
 386                 /* Restore gate<->pipe table from some proprietary location. */
 387
 388                 r = hdev->ops->load_session(hdev);
 389
 390                 if (r < 0)
 391                         goto disconnect_all;
 392         } else {
 393
 394                 r = nfc_hci_disconnect_all_gates(hdev);
 395                 if (r < 0)
 396                         goto exit;
 397
 398                 r = hci_dev_connect_gates(hdev, hdev->init_data.gate_count,
 399                                           hdev->init_data.gates);
 400                 if (r < 0)
 401                         goto disconnect_all;
 402
 403                 r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE,
 404                                 NFC_HCI_ADMIN_SESSION_IDENTITY,
 405                                 hdev->init_data.session_id,
 406                                 strlen(hdev->init_data.session_id));
 407         }
 408         if (r == 0)
 409                 goto exit;
 410
 411 disconnect_all:
 412         nfc_hci_disconnect_all_gates(hdev);
 413
 414 exit:
 415         kfree_skb(skb);
 416
 417         return r;
 418 }
 419
 420 static int hci_dev_version(struct nfc_hci_dev *hdev)
 421 {
 422         int r;
 423         struct sk_buff *skb;
 424
 425         r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
 426                               NFC_HCI_ID_MGMT_VERSION_SW, &skb);
 427         if (r == -EOPNOTSUPP) {
 428                 pr_info("Software/Hardware info not available\n");
 429                 return 0;
 430         }
 431         if (r < 0)
 432                 return r;
 433
 434         if (skb->len != 3) {
 435                 kfree_skb(skb);
 436                 return -EINVAL;
 437         }
 438
 439         hdev->sw_romlib = (skb->data[0] & 0xf0) >> 4;
 440         hdev->sw_patch = skb->data[0] & 0x0f;
 441         hdev->sw_flashlib_major = skb->data[1];
 442         hdev->sw_flashlib_minor = skb->data[2];
 443
 444         kfree_skb(skb);
 445
 446         r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
 447                               NFC_HCI_ID_MGMT_VERSION_HW, &skb);
 448         if (r < 0)
 449                 return r;
 450
 451         if (skb->len != 3) {
 452                 kfree_skb(skb);
 453                 return -EINVAL;
 454         }
 455
 456         hdev->hw_derivative = (skb->data[0] & 0xe0) >> 5;
 457         hdev->hw_version = skb->data[0] & 0x1f;
 458         hdev->hw_mpw = (skb->data[1] & 0xc0) >> 6;
 459         hdev->hw_software = skb->data[1] & 0x3f;
 460         hdev->hw_bsid = skb->data[2];
 461
 462         kfree_skb(skb);
 463
 464         pr_info("SOFTWARE INFO:\n");
 465         pr_info("RomLib         : %d\n", hdev->sw_romlib);
 466         pr_info("Patch          : %d\n", hdev->sw_patch);
 467         pr_info("FlashLib Major : %d\n", hdev->sw_flashlib_major);
 468         pr_info("FlashLib Minor : %d\n", hdev->sw_flashlib_minor);
 469         pr_info("HARDWARE INFO:\n");
 470         pr_info("Derivative     : %d\n", hdev->hw_derivative);
 471         pr_info("HW Version     : %d\n", hdev->hw_version);
 472         pr_info("#MPW           : %d\n", hdev->hw_mpw);
 473         pr_info("Software       : %d\n", hdev->hw_software);
 474         pr_info("BSID Version   : %d\n", hdev->hw_bsid);
 475
 476         return 0;
 477 }
 478
 479 static int hci_dev_up(struct nfc_dev *nfc_dev)
 480 {
 481         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 482         int r = 0;
 483
 484         if (hdev->ops->open) {
 485                 r = hdev->ops->open(hdev);
 486                 if (r < 0)
 487                         return r;
 488         }
 489
 490         r = nfc_llc_start(hdev->llc);
 491         if (r < 0)
 492                 goto exit_close;
 493
 494         r = hci_dev_session_init(hdev);
 495         if (r < 0)
 496                 goto exit_llc;
 497
 498         r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 499                                NFC_HCI_EVT_END_OPERATION, NULL, 0);
 500         if (r < 0)
 501                 goto exit_llc;
 502
 503         if (hdev->ops->hci_ready) {
 504                 r = hdev->ops->hci_ready(hdev);
 505                 if (r < 0)
 506                         goto exit_llc;
 507         }
 508
 509         r = hci_dev_version(hdev);
 510         if (r < 0)
 511                 goto exit_llc;
 512
 513         return 0;
 514
 515 exit_llc:
 516         nfc_llc_stop(hdev->llc);
 517
 518 exit_close:
 519         if (hdev->ops->close)
 520                 hdev->ops->close(hdev);
 521
 522         return r;
 523 }
 524
 525 static int hci_dev_down(struct nfc_dev *nfc_dev)
 526 {
 527         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 528
 529         nfc_llc_stop(hdev->llc);
 530
 531         if (hdev->ops->close)
 532                 hdev->ops->close(hdev);
 533
 534         memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
 535
 536         return 0;
 537 }
 538
 539 static int hci_start_poll(struct nfc_dev *nfc_dev,
 540                           u32 im_protocols, u32 tm_protocols)
 541 {
 542         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 543
 544         if (hdev->ops->start_poll)
 545                 return hdev->ops->start_poll(hdev, im_protocols, tm_protocols);
 546         else
 547                 return nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 548                                           NFC_HCI_EVT_READER_REQUESTED,
 549                                           NULL, 0);
 550 }
 551
 552 static void hci_stop_poll(struct nfc_dev *nfc_dev)
 553 {
 554         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 555
 556         if (hdev->ops->stop_poll)
 557                 hdev->ops->stop_poll(hdev);
 558         else
 559                 nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 560                                    NFC_HCI_EVT_END_OPERATION, NULL, 0);
 561 }
 562
 563 static int hci_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
 564                                 __u8 comm_mode, __u8 *gb, size_t gb_len)
 565 {
 566         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 567
 568         if (!hdev->ops->dep_link_up)
 569                 return 0;
 570
 571         return hdev->ops->dep_link_up(hdev, target, comm_mode,
 572                                       gb, gb_len);
 573 }
 574
 575 static int hci_dep_link_down(struct nfc_dev *nfc_dev)
 576 {
 577         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 578
 579         if (!hdev->ops->dep_link_down)
 580                 return 0;
 581
 582         return hdev->ops->dep_link_down(hdev);
 583 }
 584
 585 static int hci_activate_target(struct nfc_dev *nfc_dev,
 586                                struct nfc_target *target, u32 protocol)
 587 {
 588         return 0;
 589 }
 590
 591 static void hci_deactivate_target(struct nfc_dev *nfc_dev,
 592                                   struct nfc_target *target)
 593 {
 594 }
 595
 596 #define HCI_CB_TYPE_TRANSCEIVE 1
 597
 598 static void hci_transceive_cb(void *context, struct sk_buff *skb, int err)
 599 {
 600         struct nfc_hci_dev *hdev = context;
 601
 602         switch (hdev->async_cb_type) {
 603         case HCI_CB_TYPE_TRANSCEIVE:
 604                 /*
 605                  * TODO: Check RF Error indicator to make sure data is valid.
 606                  * It seems that HCI cmd can complete without error, but data
 607                  * can be invalid if an RF error occured? Ignore for now.
 608                  */
 609                 if (err == 0)
 610                         skb_trim(skb, skb->len - 1); /* RF Err ind */
 611
 612                 hdev->async_cb(hdev->async_cb_context, skb, err);
 613                 break;
 614         default:
 615                 if (err == 0)
 616                         kfree_skb(skb);
 617                 break;
 618         }
 619 }
 620
 621 static int hci_transceive(struct nfc_dev *nfc_dev, struct nfc_target *target,
 622                           struct sk_buff *skb, data_exchange_cb_t cb,
 623                           void *cb_context)
 624 {
 625         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 626         int r;
 627
 628         pr_debug("target_idx=%d\n", target->idx);
 629
 630         switch (target->hci_reader_gate) {
 631         case NFC_HCI_RF_READER_A_GATE:
 632         case NFC_HCI_RF_READER_B_GATE:
 633                 if (hdev->ops->im_transceive) {
 634                         r = hdev->ops->im_transceive(hdev, target, skb, cb,
 635                                                      cb_context);
 636                         if (r <= 0)     /* handled */
 637                                 break;
 638                 }
 639
 640                 *skb_push(skb, 1) = 0;  /* CTR, see spec:10.2.2.1 */
 641
 642                 hdev->async_cb_type = HCI_CB_TYPE_TRANSCEIVE;
 643                 hdev->async_cb = cb;
 644                 hdev->async_cb_context = cb_context;
 645
 646                 r = nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
 647                                            NFC_HCI_WR_XCHG_DATA, skb->data,
 648                                            skb->len, hci_transceive_cb, hdev);
 649                 break;
 650         default:
 651                 if (hdev->ops->im_transceive) {
 652                         r = hdev->ops->im_transceive(hdev, target, skb, cb,
 653                                                      cb_context);
 654                         if (r == 1)
 655                                 r = -ENOTSUPP;
 656                 } else {
 657                         r = -ENOTSUPP;
 658                 }
 659                 break;
 660         }
 661
 662         kfree_skb(skb);
 663
 664         return r;
 665 }
 666
 667 static int hci_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
 668 {
 669         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 670
 671         if (!hdev->ops->tm_send) {
 672                 kfree_skb(skb);
 673                 return -ENOTSUPP;
 674         }
 675
 676         return hdev->ops->tm_send(hdev, skb);
 677 }
 678
 679 static int hci_check_presence(struct nfc_dev *nfc_dev,
 680                               struct nfc_target *target)
 681 {
 682         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 683
 684         if (!hdev->ops->check_presence)
 685                 return 0;
 686
 687         return hdev->ops->check_presence(hdev, target);
 688 }
 689
 690 static int hci_discover_se(struct nfc_dev *nfc_dev)
 691 {
 692         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 693
 694         if (hdev->ops->discover_se)
 695                 return hdev->ops->discover_se(hdev);
 696
 697         return 0;
 698 }
 699
 700 static int hci_enable_se(struct nfc_dev *nfc_dev, u32 se_idx)
 701 {
 702         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 703
 704         if (hdev->ops->enable_se)
 705                 return hdev->ops->enable_se(hdev, se_idx);
 706
 707         return 0;
 708 }
 709
 710 static int hci_disable_se(struct nfc_dev *nfc_dev, u32 se_idx)
 711 {
 712         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 713
 714         if (hdev->ops->disable_se)
 715                 return hdev->ops->disable_se(hdev, se_idx);
 716
 717         return 0;
 718 }
 719
 720 static void nfc_hci_failure(struct nfc_hci_dev *hdev, int err)
 721 {
 722         mutex_lock(&hdev->msg_tx_mutex);
 723
 724         if (hdev->cmd_pending_msg == NULL) {
 725                 nfc_driver_failure(hdev->ndev, err);
 726                 goto exit;
 727         }
 728
 729         __nfc_hci_cmd_completion(hdev, err, NULL);
 730
 731 exit:
 732         mutex_unlock(&hdev->msg_tx_mutex);
 733 }
 734
 735 static void nfc_hci_llc_failure(struct nfc_hci_dev *hdev, int err)
 736 {
 737         nfc_hci_failure(hdev, err);
 738 }
 739
 740 static void nfc_hci_recv_from_llc(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 741 {
 742         struct hcp_packet *packet;
 743         u8 type;
 744         u8 instruction;
 745         struct sk_buff *hcp_skb;
 746         u8 pipe;
 747         struct sk_buff *frag_skb;
 748         int msg_len;
 749
 750         packet = (struct hcp_packet *)skb->data;
 751         if ((packet->header & ~NFC_HCI_FRAGMENT) == 0) {
 752                 skb_queue_tail(&hdev->rx_hcp_frags, skb);
 753                 return;
 754         }
 755
 756         /* it's the last fragment. Does it need re-aggregation? */
 757         if (skb_queue_len(&hdev->rx_hcp_frags)) {
 758                 pipe = packet->header & NFC_HCI_FRAGMENT;
 759                 skb_queue_tail(&hdev->rx_hcp_frags, skb);
 760
 761                 msg_len = 0;
 762                 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
 763                         msg_len += (frag_skb->len -
 764                                     NFC_HCI_HCP_PACKET_HEADER_LEN);
 765                 }
 766
 767                 hcp_skb = nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN +
 768                                              msg_len, GFP_KERNEL);
 769                 if (hcp_skb == NULL) {
 770                         nfc_hci_failure(hdev, -ENOMEM);
 771                         return;
 772                 }
 773
 774                 *skb_put(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN) = pipe;
 775
 776                 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
 777                         msg_len = frag_skb->len - NFC_HCI_HCP_PACKET_HEADER_LEN;
 778                         memcpy(skb_put(hcp_skb, msg_len),
 779                                frag_skb->data + NFC_HCI_HCP_PACKET_HEADER_LEN,
 780                                msg_len);
 781                 }
 782
 783                 skb_queue_purge(&hdev->rx_hcp_frags);
 784         } else {
 785                 packet->header &= NFC_HCI_FRAGMENT;
 786                 hcp_skb = skb;
 787         }
 788
 789         /* if this is a response, dispatch immediately to
 790          * unblock waiting cmd context. Otherwise, enqueue to dispatch
 791          * in separate context where handler can also execute command.
 792          */
 793         packet = (struct hcp_packet *)hcp_skb->data;
 794         type = HCP_MSG_GET_TYPE(packet->message.header);
 795         if (type == NFC_HCI_HCP_RESPONSE) {
 796                 pipe = packet->header;
 797                 instruction = HCP_MSG_GET_CMD(packet->message.header);
 798                 skb_pull(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN +
 799                          NFC_HCI_HCP_MESSAGE_HEADER_LEN);
 800                 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, hcp_skb);
 801         } else {
 802                 skb_queue_tail(&hdev->msg_rx_queue, hcp_skb);
 803                 schedule_work(&hdev->msg_rx_work);
 804         }
 805 }
 806
 807 static int hci_fw_download(struct nfc_dev *nfc_dev, const char *firmware_name)
 808 {
 809         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 810
 811         if (!hdev->ops->fw_download)
 812                 return -ENOTSUPP;
 813
 814         return hdev->ops->fw_download(hdev, firmware_name);
 815 }
 816
 817 static struct nfc_ops hci_nfc_ops = {
 818         .dev_up = hci_dev_up,
 819         .dev_down = hci_dev_down,
 820         .start_poll = hci_start_poll,
 821         .stop_poll = hci_stop_poll,
 822         .dep_link_up = hci_dep_link_up,
 823         .dep_link_down = hci_dep_link_down,
 824         .activate_target = hci_activate_target,
 825         .deactivate_target = hci_deactivate_target,
 826         .im_transceive = hci_transceive,
 827         .tm_send = hci_tm_send,
 828         .check_presence = hci_check_presence,
 829         .fw_download = hci_fw_download,
 830         .discover_se = hci_discover_se,
 831         .enable_se = hci_enable_se,
 832         .disable_se = hci_disable_se,
 833 };
 834
 835 struct nfc_hci_dev *nfc_hci_allocate_device(struct nfc_hci_ops *ops,
 836                                             struct nfc_hci_init_data *init_data,
 837                                             unsigned long quirks,
 838                                             u32 protocols,
 839                                             const char *llc_name,
 840                                             int tx_headroom,
 841                                             int tx_tailroom,
 842                                             int max_link_payload)
 843 {
 844         struct nfc_hci_dev *hdev;
 845
 846         if (ops->xmit == NULL)
 847                 return NULL;
 848
 849         if (protocols == 0)
 850                 return NULL;
 851
 852         hdev = kzalloc(sizeof(struct nfc_hci_dev), GFP_KERNEL);
 853         if (hdev == NULL)
 854                 return NULL;
 855
 856         hdev->llc = nfc_llc_allocate(llc_name, hdev, ops->xmit,
 857                                      nfc_hci_recv_from_llc, tx_headroom,
 858                                      tx_tailroom, nfc_hci_llc_failure);
 859         if (hdev->llc == NULL) {
 860                 kfree(hdev);
 861                 return NULL;
 862         }
 863
 864         hdev->ndev = nfc_allocate_device(&hci_nfc_ops, protocols,
 865                                          tx_headroom + HCI_CMDS_HEADROOM,
 866                                          tx_tailroom);
 867         if (!hdev->ndev) {
 868                 nfc_llc_free(hdev->llc);
 869                 kfree(hdev);
 870                 return NULL;
 871         }
 872
 873         hdev->ops = ops;
 874         hdev->max_data_link_payload = max_link_payload;
 875         hdev->init_data = *init_data;
 876
 877         nfc_set_drvdata(hdev->ndev, hdev);
 878
 879         memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
 880
 881         hdev->quirks = quirks;
 882
 883         return hdev;
 884 }
 885 EXPORT_SYMBOL(nfc_hci_allocate_device);
 886
 887 void nfc_hci_free_device(struct nfc_hci_dev *hdev)
 888 {
 889         nfc_free_device(hdev->ndev);
 890         nfc_llc_free(hdev->llc);
 891         kfree(hdev);
 892 }
 893 EXPORT_SYMBOL(nfc_hci_free_device);
 894
 895 int nfc_hci_register_device(struct nfc_hci_dev *hdev)
 896 {
 897         mutex_init(&hdev->msg_tx_mutex);
 898
 899         INIT_LIST_HEAD(&hdev->msg_tx_queue);
 900
 901         INIT_WORK(&hdev->msg_tx_work, nfc_hci_msg_tx_work);
 902
 903         init_timer(&hdev->cmd_timer);
 904         hdev->cmd_timer.data = (unsigned long)hdev;
 905         hdev->cmd_timer.function = nfc_hci_cmd_timeout;
 906
 907         skb_queue_head_init(&hdev->rx_hcp_frags);
 908
 909         INIT_WORK(&hdev->msg_rx_work, nfc_hci_msg_rx_work);
 910
 911         skb_queue_head_init(&hdev->msg_rx_queue);
 912
 913         return nfc_register_device(hdev->ndev);
 914 }
 915 EXPORT_SYMBOL(nfc_hci_register_device);
 916
 917 void nfc_hci_unregister_device(struct nfc_hci_dev *hdev)
 918 {
 919         struct hci_msg *msg, *n;
 920
 921         mutex_lock(&hdev->msg_tx_mutex);
 922
 923         if (hdev->cmd_pending_msg) {
 924                 if (hdev->cmd_pending_msg->cb)
 925                         hdev->cmd_pending_msg->cb(
 926                                              hdev->cmd_pending_msg->cb_context,
 927                                              NULL, -ESHUTDOWN);
 928                 kfree(hdev->cmd_pending_msg);
 929                 hdev->cmd_pending_msg = NULL;
 930         }
 931
 932         hdev->shutting_down = true;
 933
 934         mutex_unlock(&hdev->msg_tx_mutex);
 935
 936         del_timer_sync(&hdev->cmd_timer);
 937         cancel_work_sync(&hdev->msg_tx_work);
 938
 939         cancel_work_sync(&hdev->msg_rx_work);
 940
 941         nfc_unregister_device(hdev->ndev);
 942
 943         skb_queue_purge(&hdev->rx_hcp_frags);
 944         skb_queue_purge(&hdev->msg_rx_queue);
 945
 946         list_for_each_entry_safe(msg, n, &hdev->msg_tx_queue, msg_l) {
 947                 list_del(&msg->msg_l);
 948                 skb_queue_purge(&msg->msg_frags);
 949                 kfree(msg);
 950         }
 951 }
 952 EXPORT_SYMBOL(nfc_hci_unregister_device);
 953
 954 void nfc_hci_set_clientdata(struct nfc_hci_dev *hdev, void *clientdata)
 955 {
 956         hdev->clientdata = clientdata;
 957 }
 958 EXPORT_SYMBOL(nfc_hci_set_clientdata);
 959
 960 void *nfc_hci_get_clientdata(struct nfc_hci_dev *hdev)
 961 {
 962         return hdev->clientdata;
 963 }
 964 EXPORT_SYMBOL(nfc_hci_get_clientdata);
 965
 966 void nfc_hci_driver_failure(struct nfc_hci_dev *hdev, int err)
 967 {
 968         nfc_hci_failure(hdev, err);
 969 }
 970 EXPORT_SYMBOL(nfc_hci_driver_failure);
 971
 972 void nfc_hci_recv_frame(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 973 {
 974         nfc_llc_rcv_from_drv(hdev->llc, skb);
 975 }
 976 EXPORT_SYMBOL(nfc_hci_recv_frame);
 977
 978 static int __init nfc_hci_init(void)
 979 {
 980         return nfc_llc_init();
 981 }
 982
 983 static void __exit nfc_hci_exit(void)
 984 {
 985         nfc_llc_exit();
 986 }
 987
 988 subsys_initcall(nfc_hci_init);
 989 module_exit(nfc_hci_exit);
 990
 991 MODULE_LICENSE("GPL");
 992 MODULE_DESCRIPTION("NFC HCI Core");