Pileus Git - ~andy/linux/blob - net/nfc/llcp/sock.c

   1 /*
   2  * Copyright (C) 2011  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) "llcp: %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 "../nfc.h"
  28 #include "llcp.h"
  29
  30 static struct proto llcp_sock_proto = {
  31         .name     = "NFC_LLCP",
  32         .owner    = THIS_MODULE,
  33         .obj_size = sizeof(struct nfc_llcp_sock),
  34 };
  35
  36 static int llcp_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
  37 {
  38         struct sock *sk = sock->sk;
  39         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  40         struct nfc_llcp_local *local;
  41         struct nfc_dev *dev;
  42         struct sockaddr_nfc_llcp llcp_addr;
  43         int len, ret = 0;
  44
  45         pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family);
  46
  47         if (!addr || addr->sa_family != AF_NFC)
  48                 return -EINVAL;
  49
  50         memset(&llcp_addr, 0, sizeof(llcp_addr));
  51         len = min_t(unsigned int, sizeof(llcp_addr), alen);
  52         memcpy(&llcp_addr, addr, len);
  53
  54         /* This is going to be a listening socket, dsap must be 0 */
  55         if (llcp_addr.dsap != 0)
  56                 return -EINVAL;
  57
  58         lock_sock(sk);
  59
  60         if (sk->sk_state != LLCP_CLOSED) {
  61                 ret = -EBADFD;
  62                 goto error;
  63         }
  64
  65         dev = nfc_get_device(llcp_addr.dev_idx);
  66         if (dev == NULL) {
  67                 ret = -ENODEV;
  68                 goto error;
  69         }
  70
  71         local = nfc_llcp_find_local(dev);
  72         if (local == NULL) {
  73                 ret = -ENODEV;
  74                 goto put_dev;
  75         }
  76
  77         llcp_sock->dev = dev;
  78         llcp_sock->local = local;
  79         llcp_sock->nfc_protocol = llcp_addr.nfc_protocol;
  80         llcp_sock->service_name_len = min_t(unsigned int,
  81                                             llcp_addr.service_name_len,
  82                                             NFC_LLCP_MAX_SERVICE_NAME);
  83         llcp_sock->service_name = kmemdup(llcp_addr.service_name,
  84                                           llcp_sock->service_name_len,
  85                                           GFP_KERNEL);
  86
  87         llcp_sock->ssap = nfc_llcp_get_sdp_ssap(local, llcp_sock);
  88         if (llcp_sock->ssap == LLCP_MAX_SAP)
  89                 goto put_dev;
  90
  91         local->sockets[llcp_sock->ssap] = llcp_sock;
  92
  93         pr_debug("Socket bound to SAP %d\n", llcp_sock->ssap);
  94
  95         sk->sk_state = LLCP_BOUND;
  96
  97 put_dev:
  98         nfc_put_device(dev);
  99
 100 error:
 101         release_sock(sk);
 102         return ret;
 103 }
 104
 105 static int llcp_sock_listen(struct socket *sock, int backlog)
 106 {
 107         struct sock *sk = sock->sk;
 108         int ret = 0;
 109
 110         pr_debug("sk %p backlog %d\n", sk, backlog);
 111
 112         lock_sock(sk);
 113
 114         if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
 115             || sk->sk_state != LLCP_BOUND) {
 116                 ret = -EBADFD;
 117                 goto error;
 118         }
 119
 120         sk->sk_max_ack_backlog = backlog;
 121         sk->sk_ack_backlog = 0;
 122
 123         pr_debug("Socket listening\n");
 124         sk->sk_state = LLCP_LISTEN;
 125
 126 error:
 127         release_sock(sk);
 128
 129         return ret;
 130 }
 131
 132 void nfc_llcp_accept_unlink(struct sock *sk)
 133 {
 134         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 135
 136         pr_debug("state %d\n", sk->sk_state);
 137
 138         list_del_init(&llcp_sock->accept_queue);
 139         sk_acceptq_removed(llcp_sock->parent);
 140         llcp_sock->parent = NULL;
 141
 142         sock_put(sk);
 143 }
 144
 145 void nfc_llcp_accept_enqueue(struct sock *parent, struct sock *sk)
 146 {
 147         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 148         struct nfc_llcp_sock *llcp_sock_parent = nfc_llcp_sock(parent);
 149
 150         /* Lock will be free from unlink */
 151         sock_hold(sk);
 152
 153         list_add_tail(&llcp_sock->accept_queue,
 154                       &llcp_sock_parent->accept_queue);
 155         llcp_sock->parent = parent;
 156         sk_acceptq_added(parent);
 157 }
 158
 159 struct sock *nfc_llcp_accept_dequeue(struct sock *parent,
 160                                      struct socket *newsock)
 161 {
 162         struct nfc_llcp_sock *lsk, *n, *llcp_parent;
 163         struct sock *sk;
 164
 165         llcp_parent = nfc_llcp_sock(parent);
 166
 167         list_for_each_entry_safe(lsk, n, &llcp_parent->accept_queue,
 168                                  accept_queue) {
 169                 sk = &lsk->sk;
 170                 lock_sock(sk);
 171
 172                 if (sk->sk_state == LLCP_CLOSED) {
 173                         release_sock(sk);
 174                         nfc_llcp_accept_unlink(sk);
 175                         continue;
 176                 }
 177
 178                 if (sk->sk_state == LLCP_CONNECTED || !newsock) {
 179                         nfc_llcp_accept_unlink(sk);
 180                         if (newsock)
 181                                 sock_graft(sk, newsock);
 182
 183                         release_sock(sk);
 184
 185                         pr_debug("Returning sk state %d\n", sk->sk_state);
 186
 187                         return sk;
 188                 }
 189
 190                 release_sock(sk);
 191         }
 192
 193         return NULL;
 194 }
 195
 196 static int llcp_sock_accept(struct socket *sock, struct socket *newsock,
 197                             int flags)
 198 {
 199         DECLARE_WAITQUEUE(wait, current);
 200         struct sock *sk = sock->sk, *new_sk;
 201         long timeo;
 202         int ret = 0;
 203
 204         pr_debug("parent %p\n", sk);
 205
 206         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 207
 208         if (sk->sk_state != LLCP_LISTEN) {
 209                 ret = -EBADFD;
 210                 goto error;
 211         }
 212
 213         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 214
 215         /* Wait for an incoming connection. */
 216         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 217         while (!(new_sk = nfc_llcp_accept_dequeue(sk, newsock))) {
 218                 set_current_state(TASK_INTERRUPTIBLE);
 219
 220                 if (!timeo) {
 221                         ret = -EAGAIN;
 222                         break;
 223                 }
 224
 225                 if (signal_pending(current)) {
 226                         ret = sock_intr_errno(timeo);
 227                         break;
 228                 }
 229
 230                 release_sock(sk);
 231                 timeo = schedule_timeout(timeo);
 232                 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 233         }
 234         __set_current_state(TASK_RUNNING);
 235         remove_wait_queue(sk_sleep(sk), &wait);
 236
 237         if (ret)
 238                 goto error;
 239
 240         newsock->state = SS_CONNECTED;
 241
 242         pr_debug("new socket %p\n", new_sk);
 243
 244 error:
 245         release_sock(sk);
 246
 247         return ret;
 248 }
 249
 250 static int llcp_sock_getname(struct socket *sock, struct sockaddr *addr,
 251                              int *len, int peer)
 252 {
 253         struct sockaddr_nfc_llcp *llcp_addr = (struct sockaddr_nfc_llcp *)addr;
 254         struct sock *sk = sock->sk;
 255         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 256
 257         pr_debug("%p\n", sk);
 258
 259         addr->sa_family = AF_NFC;
 260         *len = sizeof(struct sockaddr_nfc_llcp);
 261
 262         llcp_addr->dev_idx = llcp_sock->dev->idx;
 263         llcp_addr->dsap = llcp_sock->dsap;
 264         llcp_addr->ssap = llcp_sock->ssap;
 265         llcp_addr->service_name_len = llcp_sock->service_name_len;
 266         memcpy(llcp_addr->service_name, llcp_sock->service_name,
 267                llcp_addr->service_name_len);
 268
 269         return 0;
 270 }
 271
 272 static inline unsigned int llcp_accept_poll(struct sock *parent)
 273 {
 274         struct nfc_llcp_sock *llcp_sock, *n, *parent_sock;
 275         struct sock *sk;
 276
 277         parent_sock = nfc_llcp_sock(parent);
 278
 279         list_for_each_entry_safe(llcp_sock, n, &parent_sock->accept_queue,
 280                                  accept_queue) {
 281                 sk = &llcp_sock->sk;
 282
 283                 if (sk->sk_state == LLCP_CONNECTED)
 284                         return POLLIN | POLLRDNORM;
 285         }
 286
 287         return 0;
 288 }
 289
 290 static unsigned int llcp_sock_poll(struct file *file, struct socket *sock,
 291                                    poll_table *wait)
 292 {
 293         struct sock *sk = sock->sk;
 294         unsigned int mask = 0;
 295
 296         pr_debug("%p\n", sk);
 297
 298         sock_poll_wait(file, sk_sleep(sk), wait);
 299
 300         if (sk->sk_state == LLCP_LISTEN)
 301                 return llcp_accept_poll(sk);
 302
 303         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 304                 mask |= POLLERR;
 305
 306         if (!skb_queue_empty(&sk->sk_receive_queue))
 307                 mask |= POLLIN;
 308
 309         if (sk->sk_state == LLCP_CLOSED)
 310                 mask |= POLLHUP;
 311
 312         return mask;
 313 }
 314
 315 static int llcp_sock_release(struct socket *sock)
 316 {
 317         struct sock *sk = sock->sk;
 318         struct nfc_llcp_local *local;
 319         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 320         int err = 0;
 321
 322         if (!sk)
 323                 return 0;
 324
 325         pr_debug("%p\n", sk);
 326
 327         local = llcp_sock->local;
 328         if (local == NULL) {
 329                 err = -ENODEV;
 330                 goto out;
 331         }
 332
 333         mutex_lock(&local->socket_lock);
 334
 335         if (llcp_sock == local->sockets[llcp_sock->ssap])
 336                 local->sockets[llcp_sock->ssap] = NULL;
 337         else
 338                 list_del_init(&llcp_sock->list);
 339
 340         mutex_unlock(&local->socket_lock);
 341
 342         lock_sock(sk);
 343
 344         /* Send a DISC */
 345         if (sk->sk_state == LLCP_CONNECTED)
 346                 nfc_llcp_disconnect(llcp_sock);
 347
 348         if (sk->sk_state == LLCP_LISTEN) {
 349                 struct nfc_llcp_sock *lsk, *n;
 350                 struct sock *accept_sk;
 351
 352                 list_for_each_entry_safe(lsk, n, &llcp_sock->accept_queue,
 353                                          accept_queue) {
 354                         accept_sk = &lsk->sk;
 355                         lock_sock(accept_sk);
 356
 357                         nfc_llcp_disconnect(lsk);
 358                         nfc_llcp_accept_unlink(accept_sk);
 359
 360                         release_sock(accept_sk);
 361
 362                         sock_orphan(accept_sk);
 363                 }
 364         }
 365
 366         /* Freeing the SAP */
 367         if ((sk->sk_state == LLCP_CONNECTED
 368              && llcp_sock->ssap > LLCP_LOCAL_SAP_OFFSET) ||
 369             sk->sk_state == LLCP_BOUND || sk->sk_state == LLCP_LISTEN)
 370                 nfc_llcp_put_ssap(llcp_sock->local, llcp_sock->ssap);
 371
 372         release_sock(sk);
 373
 374 out:
 375         sock_orphan(sk);
 376         sock_put(sk);
 377
 378         return err;
 379 }
 380
 381 static int llcp_sock_connect(struct socket *sock, struct sockaddr *_addr,
 382                              int len, int flags)
 383 {
 384         struct sock *sk = sock->sk;
 385         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 386         struct sockaddr_nfc_llcp *addr = (struct sockaddr_nfc_llcp *)_addr;
 387         struct nfc_dev *dev;
 388         struct nfc_llcp_local *local;
 389         int ret = 0;
 390
 391         pr_debug("sock %p sk %p flags 0x%x\n", sock, sk, flags);
 392
 393         if (!addr || len < sizeof(struct sockaddr_nfc) ||
 394             addr->sa_family != AF_NFC) {
 395                 pr_err("Invalid socket\n");
 396                 return -EINVAL;
 397         }
 398
 399         if (addr->service_name_len == 0 && addr->dsap == 0) {
 400                 pr_err("Missing service name or dsap\n");
 401                 return -EINVAL;
 402         }
 403
 404         pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n", addr->dev_idx,
 405                  addr->target_idx, addr->nfc_protocol);
 406
 407         lock_sock(sk);
 408
 409         if (sk->sk_state == LLCP_CONNECTED) {
 410                 ret = -EISCONN;
 411                 goto error;
 412         }
 413
 414         dev = nfc_get_device(addr->dev_idx);
 415         if (dev == NULL) {
 416                 ret = -ENODEV;
 417                 goto error;
 418         }
 419
 420         local = nfc_llcp_find_local(dev);
 421         if (local == NULL) {
 422                 ret = -ENODEV;
 423                 goto put_dev;
 424         }
 425
 426         device_lock(&dev->dev);
 427         if (dev->dep_link_up == false) {
 428                 ret = -ENOLINK;
 429                 device_unlock(&dev->dev);
 430                 goto put_dev;
 431         }
 432         device_unlock(&dev->dev);
 433
 434         if (local->rf_mode == NFC_RF_INITIATOR &&
 435             addr->target_idx != local->target_idx) {
 436                 ret = -ENOLINK;
 437                 goto put_dev;
 438         }
 439
 440         llcp_sock->dev = dev;
 441         llcp_sock->local = local;
 442         llcp_sock->ssap = nfc_llcp_get_local_ssap(local);
 443         if (llcp_sock->ssap == LLCP_SAP_MAX) {
 444                 ret = -ENOMEM;
 445                 goto put_dev;
 446         }
 447         if (addr->service_name_len == 0)
 448                 llcp_sock->dsap = addr->dsap;
 449         else
 450                 llcp_sock->dsap = LLCP_SAP_SDP;
 451         llcp_sock->nfc_protocol = addr->nfc_protocol;
 452         llcp_sock->service_name_len = min_t(unsigned int,
 453                                             addr->service_name_len,
 454                                             NFC_LLCP_MAX_SERVICE_NAME);
 455         llcp_sock->service_name = kmemdup(addr->service_name,
 456                                           llcp_sock->service_name_len,
 457                                           GFP_KERNEL);
 458
 459         local->sockets[llcp_sock->ssap] = llcp_sock;
 460
 461         ret = nfc_llcp_send_connect(llcp_sock);
 462         if (ret)
 463                 goto put_dev;
 464
 465         sk->sk_state = LLCP_CONNECTED;
 466
 467         release_sock(sk);
 468         return 0;
 469
 470 put_dev:
 471         nfc_put_device(dev);
 472
 473 error:
 474         release_sock(sk);
 475         return ret;
 476 }
 477
 478 static int llcp_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 479                              struct msghdr *msg, size_t len)
 480 {
 481         struct sock *sk = sock->sk;
 482         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 483         int ret;
 484
 485         pr_debug("sock %p sk %p", sock, sk);
 486
 487         ret = sock_error(sk);
 488         if (ret)
 489                 return ret;
 490
 491         if (msg->msg_flags & MSG_OOB)
 492                 return -EOPNOTSUPP;
 493
 494         lock_sock(sk);
 495
 496         if (sk->sk_state != LLCP_CONNECTED) {
 497                 release_sock(sk);
 498                 return -ENOTCONN;
 499         }
 500
 501         release_sock(sk);
 502
 503         return nfc_llcp_send_i_frame(llcp_sock, msg, len);
 504 }
 505
 506 static int llcp_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 507                              struct msghdr *msg, size_t len, int flags)
 508 {
 509         int noblock = flags & MSG_DONTWAIT;
 510         struct sock *sk = sock->sk;
 511         unsigned int copied, rlen;
 512         struct sk_buff *skb, *cskb;
 513         int err = 0;
 514
 515         pr_debug("%p %zu\n", sk, len);
 516
 517         lock_sock(sk);
 518
 519         if (sk->sk_state == LLCP_CLOSED &&
 520             skb_queue_empty(&sk->sk_receive_queue)) {
 521                 release_sock(sk);
 522                 return 0;
 523         }
 524
 525         release_sock(sk);
 526
 527         if (flags & (MSG_OOB))
 528                 return -EOPNOTSUPP;
 529
 530         skb = skb_recv_datagram(sk, flags, noblock, &err);
 531         if (!skb) {
 532                 pr_err("Recv datagram failed state %d %d %d",
 533                        sk->sk_state, err, sock_error(sk));
 534
 535                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 536                         return 0;
 537
 538                 return err;
 539         }
 540
 541         rlen = skb->len;                /* real length of skb */
 542         copied = min_t(unsigned int, rlen, len);
 543
 544         cskb = skb;
 545         if (memcpy_toiovec(msg->msg_iov, cskb->data, copied)) {
 546                 if (!(flags & MSG_PEEK))
 547                         skb_queue_head(&sk->sk_receive_queue, skb);
 548                 return -EFAULT;
 549         }
 550
 551         /* Mark read part of skb as used */
 552         if (!(flags & MSG_PEEK)) {
 553
 554                 /* SOCK_STREAM: re-queue skb if it contains unreceived data */
 555                 if (sk->sk_type == SOCK_STREAM) {
 556                         skb_pull(skb, copied);
 557                         if (skb->len) {
 558                                 skb_queue_head(&sk->sk_receive_queue, skb);
 559                                 goto done;
 560                         }
 561                 }
 562
 563                 kfree_skb(skb);
 564         }
 565
 566         /* XXX Queue backlogged skbs */
 567
 568 done:
 569         /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
 570         if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
 571                 copied = rlen;
 572
 573         return copied;
 574 }
 575
 576 static const struct proto_ops llcp_sock_ops = {
 577         .family         = PF_NFC,
 578         .owner          = THIS_MODULE,
 579         .bind           = llcp_sock_bind,
 580         .connect        = llcp_sock_connect,
 581         .release        = llcp_sock_release,
 582         .socketpair     = sock_no_socketpair,
 583         .accept         = llcp_sock_accept,
 584         .getname        = llcp_sock_getname,
 585         .poll           = llcp_sock_poll,
 586         .ioctl          = sock_no_ioctl,
 587         .listen         = llcp_sock_listen,
 588         .shutdown       = sock_no_shutdown,
 589         .setsockopt     = sock_no_setsockopt,
 590         .getsockopt     = sock_no_getsockopt,
 591         .sendmsg        = llcp_sock_sendmsg,
 592         .recvmsg        = llcp_sock_recvmsg,
 593         .mmap           = sock_no_mmap,
 594 };
 595
 596 static void llcp_sock_destruct(struct sock *sk)
 597 {
 598         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 599
 600         pr_debug("%p\n", sk);
 601
 602         if (sk->sk_state == LLCP_CONNECTED)
 603                 nfc_put_device(llcp_sock->dev);
 604
 605         skb_queue_purge(&sk->sk_receive_queue);
 606
 607         nfc_llcp_sock_free(llcp_sock);
 608
 609         if (!sock_flag(sk, SOCK_DEAD)) {
 610                 pr_err("Freeing alive NFC LLCP socket %p\n", sk);
 611                 return;
 612         }
 613 }
 614
 615 struct sock *nfc_llcp_sock_alloc(struct socket *sock, int type, gfp_t gfp)
 616 {
 617         struct sock *sk;
 618         struct nfc_llcp_sock *llcp_sock;
 619
 620         sk = sk_alloc(&init_net, PF_NFC, gfp, &llcp_sock_proto);
 621         if (!sk)
 622                 return NULL;
 623
 624         llcp_sock = nfc_llcp_sock(sk);
 625
 626         sock_init_data(sock, sk);
 627         sk->sk_state = LLCP_CLOSED;
 628         sk->sk_protocol = NFC_SOCKPROTO_LLCP;
 629         sk->sk_type = type;
 630         sk->sk_destruct = llcp_sock_destruct;
 631
 632         llcp_sock->ssap = 0;
 633         llcp_sock->dsap = LLCP_SAP_SDP;
 634         llcp_sock->send_n = llcp_sock->send_ack_n = 0;
 635         llcp_sock->recv_n = llcp_sock->recv_ack_n = 0;
 636         llcp_sock->remote_ready = 1;
 637         skb_queue_head_init(&llcp_sock->tx_queue);
 638         skb_queue_head_init(&llcp_sock->tx_pending_queue);
 639         skb_queue_head_init(&llcp_sock->tx_backlog_queue);
 640         INIT_LIST_HEAD(&llcp_sock->list);
 641         INIT_LIST_HEAD(&llcp_sock->accept_queue);
 642
 643         if (sock != NULL)
 644                 sock->state = SS_UNCONNECTED;
 645
 646         return sk;
 647 }
 648
 649 void nfc_llcp_sock_free(struct nfc_llcp_sock *sock)
 650 {
 651         struct nfc_llcp_local *local = sock->local;
 652
 653         kfree(sock->service_name);
 654
 655         skb_queue_purge(&sock->tx_queue);
 656         skb_queue_purge(&sock->tx_pending_queue);
 657         skb_queue_purge(&sock->tx_backlog_queue);
 658
 659         list_del_init(&sock->accept_queue);
 660
 661         if (local != NULL && sock == local->sockets[sock->ssap])
 662                 local->sockets[sock->ssap] = NULL;
 663         else
 664                 list_del_init(&sock->list);
 665
 666         sock->parent = NULL;
 667 }
 668
 669 static int llcp_sock_create(struct net *net, struct socket *sock,
 670                             const struct nfc_protocol *nfc_proto)
 671 {
 672         struct sock *sk;
 673
 674         pr_debug("%p\n", sock);
 675
 676         if (sock->type != SOCK_STREAM && sock->type != SOCK_DGRAM)
 677                 return -ESOCKTNOSUPPORT;
 678
 679         sock->ops = &llcp_sock_ops;
 680
 681         sk = nfc_llcp_sock_alloc(sock, sock->type, GFP_ATOMIC);
 682         if (sk == NULL)
 683                 return -ENOMEM;
 684
 685         return 0;
 686 }
 687
 688 static const struct nfc_protocol llcp_nfc_proto = {
 689         .id       = NFC_SOCKPROTO_LLCP,
 690         .proto    = &llcp_sock_proto,
 691         .owner    = THIS_MODULE,
 692         .create   = llcp_sock_create
 693 };
 694
 695 int __init nfc_llcp_sock_init(void)
 696 {
 697         return nfc_proto_register(&llcp_nfc_proto);
 698 }
 699
 700 void nfc_llcp_sock_exit(void)
 701 {
 702         nfc_proto_unregister(&llcp_nfc_proto);
 703 }