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, write to the
  16  * Free Software Foundation, Inc.,
  17  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #define pr_fmt(fmt) "hci: %s: " fmt, __func__
  21
  22 #include <linux/init.h>
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/nfc.h>
  26
  27 #include <net/nfc/nfc.h>
  28 #include <net/nfc/hci.h>
  29
  30 #include "hci.h"
  31
  32 /* Largest headroom needed for outgoing HCI commands */
  33 #define HCI_CMDS_HEADROOM 1
  34
  35 static void nfc_hci_msg_tx_work(struct work_struct *work)
  36 {
  37         struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
  38                                                 msg_tx_work);
  39         struct hci_msg *msg;
  40         struct sk_buff *skb;
  41         int r = 0;
  42
  43         mutex_lock(&hdev->msg_tx_mutex);
  44
  45         if (hdev->cmd_pending_msg) {
  46                 if (timer_pending(&hdev->cmd_timer) == 0) {
  47                         if (hdev->cmd_pending_msg->cb)
  48                                 hdev->cmd_pending_msg->cb(hdev,
  49                                                           NFC_HCI_ANY_E_TIMEOUT,
  50                                                           NULL,
  51                                                           hdev->
  52                                                           cmd_pending_msg->
  53                                                           cb_context);
  54                         kfree(hdev->cmd_pending_msg);
  55                         hdev->cmd_pending_msg = NULL;
  56                 } else
  57                         goto exit;
  58         }
  59
  60 next_msg:
  61         if (list_empty(&hdev->msg_tx_queue))
  62                 goto exit;
  63
  64         msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg, msg_l);
  65         list_del(&msg->msg_l);
  66
  67         pr_debug("msg_tx_queue has a cmd to send\n");
  68         while ((skb = skb_dequeue(&msg->msg_frags)) != NULL) {
  69                 r = hdev->ops->xmit(hdev, skb);
  70                 if (r < 0) {
  71                         kfree_skb(skb);
  72                         skb_queue_purge(&msg->msg_frags);
  73                         if (msg->cb)
  74                                 msg->cb(hdev, NFC_HCI_ANY_E_NOK, NULL,
  75                                         msg->cb_context);
  76                         kfree(msg);
  77                         break;
  78                 }
  79         }
  80
  81         if (r)
  82                 goto next_msg;
  83
  84         if (msg->wait_response == false) {
  85                 kfree(msg);
  86                 goto next_msg;
  87         }
  88
  89         hdev->cmd_pending_msg = msg;
  90         mod_timer(&hdev->cmd_timer, jiffies +
  91                   msecs_to_jiffies(hdev->cmd_pending_msg->completion_delay));
  92
  93 exit:
  94         mutex_unlock(&hdev->msg_tx_mutex);
  95 }
  96
  97 static void nfc_hci_msg_rx_work(struct work_struct *work)
  98 {
  99         struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
 100                                                 msg_rx_work);
 101         struct sk_buff *skb;
 102         struct hcp_message *message;
 103         u8 pipe;
 104         u8 type;
 105         u8 instruction;
 106
 107         while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) {
 108                 pipe = skb->data[0];
 109                 skb_pull(skb, NFC_HCI_HCP_PACKET_HEADER_LEN);
 110                 message = (struct hcp_message *)skb->data;
 111                 type = HCP_MSG_GET_TYPE(message->header);
 112                 instruction = HCP_MSG_GET_CMD(message->header);
 113                 skb_pull(skb, NFC_HCI_HCP_MESSAGE_HEADER_LEN);
 114
 115                 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, skb);
 116         }
 117 }
 118
 119 void nfc_hci_resp_received(struct nfc_hci_dev *hdev, u8 result,
 120                            struct sk_buff *skb)
 121 {
 122         mutex_lock(&hdev->msg_tx_mutex);
 123
 124         if (hdev->cmd_pending_msg == NULL) {
 125                 kfree_skb(skb);
 126                 goto exit;
 127         }
 128
 129         del_timer_sync(&hdev->cmd_timer);
 130
 131         if (hdev->cmd_pending_msg->cb)
 132                 hdev->cmd_pending_msg->cb(hdev, result, skb,
 133                                           hdev->cmd_pending_msg->cb_context);
 134         else
 135                 kfree_skb(skb);
 136
 137         kfree(hdev->cmd_pending_msg);
 138         hdev->cmd_pending_msg = NULL;
 139
 140         queue_work(hdev->msg_tx_wq, &hdev->msg_tx_work);
 141
 142 exit:
 143         mutex_unlock(&hdev->msg_tx_mutex);
 144 }
 145
 146 void nfc_hci_cmd_received(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd,
 147                           struct sk_buff *skb)
 148 {
 149         kfree_skb(skb);
 150 }
 151
 152 static u32 nfc_hci_sak_to_protocol(u8 sak)
 153 {
 154         switch (NFC_HCI_TYPE_A_SEL_PROT(sak)) {
 155         case NFC_HCI_TYPE_A_SEL_PROT_MIFARE:
 156                 return NFC_PROTO_MIFARE_MASK;
 157         case NFC_HCI_TYPE_A_SEL_PROT_ISO14443:
 158                 return NFC_PROTO_ISO14443_MASK;
 159         case NFC_HCI_TYPE_A_SEL_PROT_DEP:
 160                 return NFC_PROTO_NFC_DEP_MASK;
 161         case NFC_HCI_TYPE_A_SEL_PROT_ISO14443_DEP:
 162                 return NFC_PROTO_ISO14443_MASK | NFC_PROTO_NFC_DEP_MASK;
 163         default:
 164                 return 0xffffffff;
 165         }
 166 }
 167
 168 static int nfc_hci_target_discovered(struct nfc_hci_dev *hdev, u8 gate)
 169 {
 170         struct nfc_target *targets;
 171         struct sk_buff *atqa_skb = NULL;
 172         struct sk_buff *sak_skb = NULL;
 173         int r;
 174
 175         pr_debug("from gate %d\n", gate);
 176
 177         targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
 178         if (targets == NULL)
 179                 return -ENOMEM;
 180
 181         switch (gate) {
 182         case NFC_HCI_RF_READER_A_GATE:
 183                 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
 184                                       NFC_HCI_RF_READER_A_ATQA, &atqa_skb);
 185                 if (r < 0)
 186                         goto exit;
 187
 188                 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
 189                                       NFC_HCI_RF_READER_A_SAK, &sak_skb);
 190                 if (r < 0)
 191                         goto exit;
 192
 193                 if (atqa_skb->len != 2 || sak_skb->len != 1) {
 194                         r = -EPROTO;
 195                         goto exit;
 196                 }
 197
 198                 targets->supported_protocols =
 199                                 nfc_hci_sak_to_protocol(sak_skb->data[0]);
 200                 if (targets->supported_protocols == 0xffffffff) {
 201                         r = -EPROTO;
 202                         goto exit;
 203                 }
 204
 205                 targets->sens_res = be16_to_cpu(*(u16 *)atqa_skb->data);
 206                 targets->sel_res = sak_skb->data[0];
 207
 208                 if (hdev->ops->complete_target_discovered) {
 209                         r = hdev->ops->complete_target_discovered(hdev, gate,
 210                                                                   targets);
 211                         if (r < 0)
 212                                 goto exit;
 213                 }
 214                 break;
 215         case NFC_HCI_RF_READER_B_GATE:
 216                 targets->supported_protocols = NFC_PROTO_ISO14443_MASK;
 217                 break;
 218         default:
 219                 if (hdev->ops->target_from_gate)
 220                         r = hdev->ops->target_from_gate(hdev, gate, targets);
 221                 else
 222                         r = -EPROTO;
 223                 if (r < 0)
 224                         goto exit;
 225
 226                 if (hdev->ops->complete_target_discovered) {
 227                         r = hdev->ops->complete_target_discovered(hdev, gate,
 228                                                                   targets);
 229                         if (r < 0)
 230                                 goto exit;
 231                 }
 232                 break;
 233         }
 234
 235         targets->hci_reader_gate = gate;
 236
 237         r = nfc_targets_found(hdev->ndev, targets, 1);
 238         if (r < 0)
 239                 goto exit;
 240
 241         kfree(hdev->targets);
 242         hdev->targets = targets;
 243         targets = NULL;
 244         hdev->target_count = 1;
 245
 246 exit:
 247         kfree(targets);
 248         kfree_skb(atqa_skb);
 249         kfree_skb(sak_skb);
 250
 251         return r;
 252 }
 253
 254 void nfc_hci_event_received(struct nfc_hci_dev *hdev, u8 pipe, u8 event,
 255                             struct sk_buff *skb)
 256 {
 257         int r = 0;
 258
 259         switch (event) {
 260         case NFC_HCI_EVT_TARGET_DISCOVERED:
 261                 if (hdev->poll_started == false) {
 262                         r = -EPROTO;
 263                         goto exit;
 264                 }
 265
 266                 if (skb->len < 1) {     /* no status data? */
 267                         r = -EPROTO;
 268                         goto exit;
 269                 }
 270
 271                 if (skb->data[0] == 3) {
 272                         /* TODO: Multiple targets in field, none activated
 273                          * poll is supposedly stopped, but there is no
 274                          * single target to activate, so nothing to report
 275                          * up.
 276                          * if we need to restart poll, we must save the
 277                          * protocols from the initial poll and reuse here.
 278                          */
 279                 }
 280
 281                 if (skb->data[0] != 0) {
 282                         r = -EPROTO;
 283                         goto exit;
 284                 }
 285
 286                 r = nfc_hci_target_discovered(hdev,
 287                                               nfc_hci_pipe2gate(hdev, pipe));
 288                 break;
 289         default:
 290                 /* TODO: Unknown events are hardware specific
 291                  * pass them to the driver (needs a new hci_ops) */
 292                 break;
 293         }
 294
 295 exit:
 296         kfree_skb(skb);
 297
 298         if (r) {
 299                 /* TODO: There was an error dispatching the event,
 300                  * how to propagate up to nfc core?
 301                  */
 302         }
 303 }
 304
 305 static void nfc_hci_cmd_timeout(unsigned long data)
 306 {
 307         struct nfc_hci_dev *hdev = (struct nfc_hci_dev *)data;
 308
 309         queue_work(hdev->msg_tx_wq, &hdev->msg_tx_work);
 310 }
 311
 312 static int hci_dev_connect_gates(struct nfc_hci_dev *hdev, u8 gate_count,
 313                                  u8 gates[])
 314 {
 315         int r;
 316         u8 *p = gates;
 317         while (gate_count--) {
 318                 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID, *p);
 319                 if (r < 0)
 320                         return r;
 321                 p++;
 322         }
 323
 324         return 0;
 325 }
 326
 327 static int hci_dev_session_init(struct nfc_hci_dev *hdev)
 328 {
 329         struct sk_buff *skb = NULL;
 330         int r;
 331         u8 hci_gates[] = {      /* NFC_HCI_ADMIN_GATE MUST be first */
 332                 NFC_HCI_ADMIN_GATE, NFC_HCI_LOOPBACK_GATE,
 333                 NFC_HCI_ID_MGMT_GATE, NFC_HCI_LINK_MGMT_GATE,
 334                 NFC_HCI_RF_READER_B_GATE, NFC_HCI_RF_READER_A_GATE
 335         };
 336
 337         r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID,
 338                                  NFC_HCI_ADMIN_GATE);
 339         if (r < 0)
 340                 goto exit;
 341
 342         r = nfc_hci_get_param(hdev, NFC_HCI_ADMIN_GATE,
 343                               NFC_HCI_ADMIN_SESSION_IDENTITY, &skb);
 344         if (r < 0)
 345                 goto disconnect_all;
 346
 347         if (skb->len && skb->len == strlen(hdev->init_data.session_id))
 348                 if (memcmp(hdev->init_data.session_id, skb->data,
 349                            skb->len) == 0) {
 350                         /* TODO ELa: restore gate<->pipe table from
 351                          * some TBD location.
 352                          * note: it doesn't seem possible to get the chip
 353                          * currently open gate/pipe table.
 354                          * It is only possible to obtain the supported
 355                          * gate list.
 356                          */
 357
 358                         /* goto exit
 359                          * For now, always do a full initialization */
 360                 }
 361
 362         r = nfc_hci_disconnect_all_gates(hdev);
 363         if (r < 0)
 364                 goto exit;
 365
 366         r = hci_dev_connect_gates(hdev, sizeof(hci_gates), hci_gates);
 367         if (r < 0)
 368                 goto disconnect_all;
 369
 370         r = hci_dev_connect_gates(hdev, hdev->init_data.gate_count,
 371                                   hdev->init_data.gates);
 372         if (r < 0)
 373                 goto disconnect_all;
 374
 375         r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE,
 376                               NFC_HCI_ADMIN_SESSION_IDENTITY,
 377                               hdev->init_data.session_id,
 378                               strlen(hdev->init_data.session_id));
 379         if (r == 0)
 380                 goto exit;
 381
 382 disconnect_all:
 383         nfc_hci_disconnect_all_gates(hdev);
 384
 385 exit:
 386         if (skb)
 387                 kfree_skb(skb);
 388
 389         return r;
 390 }
 391
 392 static int hci_dev_version(struct nfc_hci_dev *hdev)
 393 {
 394         int r;
 395         struct sk_buff *skb;
 396
 397         r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
 398                               NFC_HCI_ID_MGMT_VERSION_SW, &skb);
 399         if (r < 0)
 400                 return r;
 401
 402         if (skb->len != 3) {
 403                 kfree_skb(skb);
 404                 return -EINVAL;
 405         }
 406
 407         hdev->sw_romlib = (skb->data[0] & 0xf0) >> 4;
 408         hdev->sw_patch = skb->data[0] & 0x0f;
 409         hdev->sw_flashlib_major = skb->data[1];
 410         hdev->sw_flashlib_minor = skb->data[2];
 411
 412         kfree_skb(skb);
 413
 414         r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
 415                               NFC_HCI_ID_MGMT_VERSION_HW, &skb);
 416         if (r < 0)
 417                 return r;
 418
 419         if (skb->len != 3) {
 420                 kfree_skb(skb);
 421                 return -EINVAL;
 422         }
 423
 424         hdev->hw_derivative = (skb->data[0] & 0xe0) >> 5;
 425         hdev->hw_version = skb->data[0] & 0x1f;
 426         hdev->hw_mpw = (skb->data[1] & 0xc0) >> 6;
 427         hdev->hw_software = skb->data[1] & 0x3f;
 428         hdev->hw_bsid = skb->data[2];
 429
 430         kfree_skb(skb);
 431
 432         pr_info("SOFTWARE INFO:\n");
 433         pr_info("RomLib         : %d\n", hdev->sw_romlib);
 434         pr_info("Patch          : %d\n", hdev->sw_patch);
 435         pr_info("FlashLib Major : %d\n", hdev->sw_flashlib_major);
 436         pr_info("FlashLib Minor : %d\n", hdev->sw_flashlib_minor);
 437         pr_info("HARDWARE INFO:\n");
 438         pr_info("Derivative     : %d\n", hdev->hw_derivative);
 439         pr_info("HW Version     : %d\n", hdev->hw_version);
 440         pr_info("#MPW           : %d\n", hdev->hw_mpw);
 441         pr_info("Software       : %d\n", hdev->hw_software);
 442         pr_info("BSID Version   : %d\n", hdev->hw_bsid);
 443
 444         return 0;
 445 }
 446
 447 static int hci_dev_up(struct nfc_dev *nfc_dev)
 448 {
 449         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 450         int r = 0;
 451
 452         if (hdev->ops->open) {
 453                 r = hdev->ops->open(hdev);
 454                 if (r < 0)
 455                         return r;
 456         }
 457
 458         r = hci_dev_session_init(hdev);
 459         if (r < 0)
 460                 goto exit;
 461
 462         r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 463                                NFC_HCI_EVT_END_OPERATION, NULL, 0);
 464         if (r < 0)
 465                 goto exit;
 466
 467         if (hdev->ops->hci_ready) {
 468                 r = hdev->ops->hci_ready(hdev);
 469                 if (r < 0)
 470                         goto exit;
 471         }
 472
 473         r = hci_dev_version(hdev);
 474         if (r < 0)
 475                 goto exit;
 476
 477 exit:
 478         if (r < 0)
 479                 if (hdev->ops->close)
 480                         hdev->ops->close(hdev);
 481         return r;
 482 }
 483
 484 static int hci_dev_down(struct nfc_dev *nfc_dev)
 485 {
 486         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 487
 488         if (hdev->ops->close)
 489                 hdev->ops->close(hdev);
 490
 491         memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
 492
 493         return 0;
 494 }
 495
 496 static int hci_start_poll(struct nfc_dev *nfc_dev, u32 protocols)
 497 {
 498         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 499         int r;
 500
 501         if (hdev->ops->start_poll)
 502                 r = hdev->ops->start_poll(hdev, protocols);
 503         else
 504                 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 505                                        NFC_HCI_EVT_READER_REQUESTED, NULL, 0);
 506         if (r == 0)
 507                 hdev->poll_started = true;
 508
 509         return r;
 510 }
 511
 512 static void hci_stop_poll(struct nfc_dev *nfc_dev)
 513 {
 514         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 515
 516         if (hdev->poll_started) {
 517                 nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
 518                                    NFC_HCI_EVT_END_OPERATION, NULL, 0);
 519                 hdev->poll_started = false;
 520         }
 521 }
 522
 523 static struct nfc_target *hci_find_target(struct nfc_hci_dev *hdev,
 524                                           u32 target_idx)
 525 {
 526         int i;
 527         if (hdev->poll_started == false || hdev->targets == NULL)
 528                 return NULL;
 529
 530         for (i = 0; i < hdev->target_count; i++) {
 531                 if (hdev->targets[i].idx == target_idx)
 532                         return &hdev->targets[i];
 533         }
 534
 535         return NULL;
 536 }
 537
 538 static int hci_activate_target(struct nfc_dev *nfc_dev, u32 target_idx,
 539                                u32 protocol)
 540 {
 541         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 542
 543         if (hci_find_target(hdev, target_idx) == NULL)
 544                 return -ENOMEDIUM;
 545
 546         return 0;
 547 }
 548
 549 static void hci_deactivate_target(struct nfc_dev *nfc_dev, u32 target_idx)
 550 {
 551 }
 552
 553 static int hci_data_exchange(struct nfc_dev *nfc_dev, u32 target_idx,
 554                              struct sk_buff *skb, data_exchange_cb_t cb,
 555                              void *cb_context)
 556 {
 557         struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
 558         int r;
 559         struct nfc_target *target;
 560         struct sk_buff *res_skb = NULL;
 561
 562         pr_debug("target_idx=%d\n", target_idx);
 563
 564         target = hci_find_target(hdev, target_idx);
 565         if (target == NULL)
 566                 return -ENOMEDIUM;
 567
 568         switch (target->hci_reader_gate) {
 569         case NFC_HCI_RF_READER_A_GATE:
 570         case NFC_HCI_RF_READER_B_GATE:
 571                 if (hdev->ops->data_exchange) {
 572                         r = hdev->ops->data_exchange(hdev, target, skb,
 573                                                      &res_skb);
 574                         if (r <= 0)     /* handled */
 575                                 break;
 576                 }
 577
 578                 *skb_push(skb, 1) = 0;  /* CTR, see spec:10.2.2.1 */
 579                 r = nfc_hci_send_cmd(hdev, target->hci_reader_gate,
 580                                      NFC_HCI_WR_XCHG_DATA,
 581                                      skb->data, skb->len, &res_skb);
 582                 /*
 583                  * TODO: Check RF Error indicator to make sure data is valid.
 584                  * It seems that HCI cmd can complete without error, but data
 585                  * can be invalid if an RF error occured? Ignore for now.
 586                  */
 587                 if (r == 0)
 588                         skb_trim(res_skb, res_skb->len - 1); /* RF Err ind */
 589                 break;
 590         default:
 591                 if (hdev->ops->data_exchange) {
 592                         r = hdev->ops->data_exchange(hdev, target, skb,
 593                                                      &res_skb);
 594                         if (r == 1)
 595                                 r = -ENOTSUPP;
 596                 }
 597                 else
 598                         r = -ENOTSUPP;
 599         }
 600
 601         kfree_skb(skb);
 602
 603         cb(cb_context, res_skb, r);
 604
 605         return 0;
 606 }
 607
 608 struct nfc_ops hci_nfc_ops = {
 609         .dev_up = hci_dev_up,
 610         .dev_down = hci_dev_down,
 611         .start_poll = hci_start_poll,
 612         .stop_poll = hci_stop_poll,
 613         .activate_target = hci_activate_target,
 614         .deactivate_target = hci_deactivate_target,
 615         .data_exchange = hci_data_exchange,
 616 };
 617
 618 struct nfc_hci_dev *nfc_hci_allocate_device(struct nfc_hci_ops *ops,
 619                                             struct nfc_hci_init_data *init_data,
 620                                             u32 protocols,
 621                                             int tx_headroom,
 622                                             int tx_tailroom,
 623                                             int max_link_payload)
 624 {
 625         struct nfc_hci_dev *hdev;
 626
 627         if (ops->xmit == NULL)
 628                 return NULL;
 629
 630         if (protocols == 0)
 631                 return NULL;
 632
 633         hdev = kzalloc(sizeof(struct nfc_hci_dev), GFP_KERNEL);
 634         if (hdev == NULL)
 635                 return NULL;
 636
 637         hdev->ndev = nfc_allocate_device(&hci_nfc_ops, protocols,
 638                                          tx_headroom + HCI_CMDS_HEADROOM,
 639                                          tx_tailroom);
 640         if (!hdev->ndev) {
 641                 kfree(hdev);
 642                 return NULL;
 643         }
 644
 645         hdev->ops = ops;
 646         hdev->max_data_link_payload = max_link_payload;
 647         hdev->init_data = *init_data;
 648
 649         nfc_set_drvdata(hdev->ndev, hdev);
 650
 651         memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
 652
 653         return hdev;
 654 }
 655 EXPORT_SYMBOL(nfc_hci_allocate_device);
 656
 657 void nfc_hci_free_device(struct nfc_hci_dev *hdev)
 658 {
 659         nfc_free_device(hdev->ndev);
 660         kfree(hdev);
 661 }
 662 EXPORT_SYMBOL(nfc_hci_free_device);
 663
 664 int nfc_hci_register_device(struct nfc_hci_dev *hdev)
 665 {
 666         struct device *dev = &hdev->ndev->dev;
 667         const char *devname = dev_name(dev);
 668         char name[32];
 669         int r = 0;
 670
 671         mutex_init(&hdev->msg_tx_mutex);
 672
 673         INIT_LIST_HEAD(&hdev->msg_tx_queue);
 674
 675         INIT_WORK(&hdev->msg_tx_work, nfc_hci_msg_tx_work);
 676         snprintf(name, sizeof(name), "%s_hci_msg_tx_wq", devname);
 677         hdev->msg_tx_wq = alloc_workqueue(name, WQ_NON_REENTRANT | WQ_UNBOUND |
 678                                           WQ_MEM_RECLAIM, 1);
 679         if (hdev->msg_tx_wq == NULL) {
 680                 r = -ENOMEM;
 681                 goto exit;
 682         }
 683
 684         init_timer(&hdev->cmd_timer);
 685         hdev->cmd_timer.data = (unsigned long)hdev;
 686         hdev->cmd_timer.function = nfc_hci_cmd_timeout;
 687
 688         skb_queue_head_init(&hdev->rx_hcp_frags);
 689
 690         INIT_WORK(&hdev->msg_rx_work, nfc_hci_msg_rx_work);
 691         snprintf(name, sizeof(name), "%s_hci_msg_rx_wq", devname);
 692         hdev->msg_rx_wq = alloc_workqueue(name, WQ_NON_REENTRANT | WQ_UNBOUND |
 693                                           WQ_MEM_RECLAIM, 1);
 694         if (hdev->msg_rx_wq == NULL) {
 695                 r = -ENOMEM;
 696                 goto exit;
 697         }
 698
 699         skb_queue_head_init(&hdev->msg_rx_queue);
 700
 701         r = nfc_register_device(hdev->ndev);
 702
 703 exit:
 704         if (r < 0) {
 705                 if (hdev->msg_tx_wq)
 706                         destroy_workqueue(hdev->msg_tx_wq);
 707                 if (hdev->msg_rx_wq)
 708                         destroy_workqueue(hdev->msg_rx_wq);
 709         }
 710
 711         return r;
 712 }
 713 EXPORT_SYMBOL(nfc_hci_register_device);
 714
 715 void nfc_hci_unregister_device(struct nfc_hci_dev *hdev)
 716 {
 717         struct hci_msg *msg;
 718
 719         skb_queue_purge(&hdev->rx_hcp_frags);
 720         skb_queue_purge(&hdev->msg_rx_queue);
 721
 722         while ((msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg,
 723                                        msg_l)) != NULL) {
 724                 list_del(&msg->msg_l);
 725                 skb_queue_purge(&msg->msg_frags);
 726                 kfree(msg);
 727         }
 728
 729         del_timer_sync(&hdev->cmd_timer);
 730
 731         nfc_unregister_device(hdev->ndev);
 732
 733         destroy_workqueue(hdev->msg_tx_wq);
 734
 735         destroy_workqueue(hdev->msg_rx_wq);
 736 }
 737 EXPORT_SYMBOL(nfc_hci_unregister_device);
 738
 739 void nfc_hci_set_clientdata(struct nfc_hci_dev *hdev, void *clientdata)
 740 {
 741         hdev->clientdata = clientdata;
 742 }
 743 EXPORT_SYMBOL(nfc_hci_set_clientdata);
 744
 745 void *nfc_hci_get_clientdata(struct nfc_hci_dev *hdev)
 746 {
 747         return hdev->clientdata;
 748 }
 749 EXPORT_SYMBOL(nfc_hci_get_clientdata);
 750
 751 void nfc_hci_recv_frame(struct nfc_hci_dev *hdev, struct sk_buff *skb)
 752 {
 753         struct hcp_packet *packet;
 754         u8 type;
 755         u8 instruction;
 756         struct sk_buff *hcp_skb;
 757         u8 pipe;
 758         struct sk_buff *frag_skb;
 759         int msg_len;
 760
 761         if (skb == NULL) {
 762                 /* TODO ELa: lower layer had permanent failure, need to
 763                  * propagate that up
 764                  */
 765
 766                 skb_queue_purge(&hdev->rx_hcp_frags);
 767
 768                 return;
 769         }
 770
 771         packet = (struct hcp_packet *)skb->data;
 772         if ((packet->header & ~NFC_HCI_FRAGMENT) == 0) {
 773                 skb_queue_tail(&hdev->rx_hcp_frags, skb);
 774                 return;
 775         }
 776
 777         /* it's the last fragment. Does it need re-aggregation? */
 778         if (skb_queue_len(&hdev->rx_hcp_frags)) {
 779                 pipe = packet->header & NFC_HCI_FRAGMENT;
 780                 skb_queue_tail(&hdev->rx_hcp_frags, skb);
 781
 782                 msg_len = 0;
 783                 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
 784                         msg_len += (frag_skb->len -
 785                                     NFC_HCI_HCP_PACKET_HEADER_LEN);
 786                 }
 787
 788                 hcp_skb = nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN +
 789                                              msg_len, GFP_KERNEL);
 790                 if (hcp_skb == NULL) {
 791                         /* TODO ELa: cannot deliver HCP message. How to
 792                          * propagate error up?
 793                          */
 794                 }
 795
 796                 *skb_put(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN) = pipe;
 797
 798                 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
 799                         msg_len = frag_skb->len - NFC_HCI_HCP_PACKET_HEADER_LEN;
 800                         memcpy(skb_put(hcp_skb, msg_len),
 801                                frag_skb->data + NFC_HCI_HCP_PACKET_HEADER_LEN,
 802                                msg_len);
 803                 }
 804
 805                 skb_queue_purge(&hdev->rx_hcp_frags);
 806         } else {
 807                 packet->header &= NFC_HCI_FRAGMENT;
 808                 hcp_skb = skb;
 809         }
 810
 811         /* if this is a response, dispatch immediately to
 812          * unblock waiting cmd context. Otherwise, enqueue to dispatch
 813          * in separate context where handler can also execute command.
 814          */
 815         packet = (struct hcp_packet *)hcp_skb->data;
 816         type = HCP_MSG_GET_TYPE(packet->message.header);
 817         if (type == NFC_HCI_HCP_RESPONSE) {
 818                 pipe = packet->header;
 819                 instruction = HCP_MSG_GET_CMD(packet->message.header);
 820                 skb_pull(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN +
 821                          NFC_HCI_HCP_MESSAGE_HEADER_LEN);
 822                 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, hcp_skb);
 823         } else {
 824                 skb_queue_tail(&hdev->msg_rx_queue, hcp_skb);
 825                 queue_work(hdev->msg_rx_wq, &hdev->msg_rx_work);
 826         }
 827 }
 828 EXPORT_SYMBOL(nfc_hci_recv_frame);
 829
 830 MODULE_LICENSE("GPL");