Linux Audio

Check our new training course

Buildroot integration, development and maintenance

Need a Buildroot system for your embedded project?
Loading...
v3.1
 
  1/*
  2 * Copyright (C) 2011 Instituto Nokia de Tecnologia
  3 *
  4 * Authors:
  5 *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
  6 *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
  7 *
  8 * This program is free software; you can redistribute it and/or modify
  9 * it under the terms of the GNU General Public License as published by
 10 * the Free Software Foundation; either version 2 of the License, or
 11 * (at your option) any later version.
 12 *
 13 * This program is distributed in the hope that it will be useful,
 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 16 * GNU General Public License for more details.
 17 *
 18 * You should have received a copy of the GNU General Public License
 19 * along with this program; if not, write to the
 20 * Free Software Foundation, Inc.,
 21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 22 */
 23
 
 
 24#include <net/tcp_states.h>
 25#include <linux/nfc.h>
 
 
 26
 27#include "nfc.h"
 28
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 29static void rawsock_write_queue_purge(struct sock *sk)
 30{
 31	nfc_dbg("sk=%p", sk);
 32
 33	spin_lock_bh(&sk->sk_write_queue.lock);
 34	__skb_queue_purge(&sk->sk_write_queue);
 35	nfc_rawsock(sk)->tx_work_scheduled = false;
 36	spin_unlock_bh(&sk->sk_write_queue.lock);
 37}
 38
 39static void rawsock_report_error(struct sock *sk, int err)
 40{
 41	nfc_dbg("sk=%p err=%d", sk, err);
 42
 43	sk->sk_shutdown = SHUTDOWN_MASK;
 44	sk->sk_err = -err;
 45	sk->sk_error_report(sk);
 46
 47	rawsock_write_queue_purge(sk);
 48}
 49
 50static int rawsock_release(struct socket *sock)
 51{
 52	struct sock *sk = sock->sk;
 53
 54	nfc_dbg("sock=%p", sock);
 
 
 
 
 
 
 55
 56	sock_orphan(sk);
 57	sock_put(sk);
 58
 59	return 0;
 60}
 61
 62static int rawsock_connect(struct socket *sock, struct sockaddr *_addr,
 63							int len, int flags)
 64{
 65	struct sock *sk = sock->sk;
 66	struct sockaddr_nfc *addr = (struct sockaddr_nfc *)_addr;
 67	struct nfc_dev *dev;
 68	int rc = 0;
 69
 70	nfc_dbg("sock=%p sk=%p flags=%d", sock, sk, flags);
 71
 72	if (!addr || len < sizeof(struct sockaddr_nfc) ||
 73		addr->sa_family != AF_NFC)
 74		return -EINVAL;
 75
 76	nfc_dbg("addr dev_idx=%u target_idx=%u protocol=%u", addr->dev_idx,
 77					addr->target_idx, addr->nfc_protocol);
 78
 79	lock_sock(sk);
 80
 81	if (sock->state == SS_CONNECTED) {
 82		rc = -EISCONN;
 83		goto error;
 84	}
 85
 86	dev = nfc_get_device(addr->dev_idx);
 87	if (!dev) {
 88		rc = -ENODEV;
 89		goto error;
 90	}
 91
 92	if (addr->target_idx > dev->target_idx - 1 ||
 93		addr->target_idx < dev->target_idx - dev->n_targets) {
 94		rc = -EINVAL;
 95		goto error;
 96	}
 97
 98	if (addr->target_idx > dev->target_idx - 1 ||
 99		addr->target_idx < dev->target_idx - dev->n_targets) {
100		rc = -EINVAL;
101		goto error;
102	}
103
104	rc = nfc_activate_target(dev, addr->target_idx, addr->nfc_protocol);
105	if (rc)
106		goto put_dev;
107
108	nfc_rawsock(sk)->dev = dev;
109	nfc_rawsock(sk)->target_idx = addr->target_idx;
110	sock->state = SS_CONNECTED;
111	sk->sk_state = TCP_ESTABLISHED;
112	sk->sk_state_change(sk);
113
114	release_sock(sk);
115	return 0;
116
117put_dev:
118	nfc_put_device(dev);
119error:
120	release_sock(sk);
121	return rc;
122}
123
124static int rawsock_add_header(struct sk_buff *skb)
125{
126
127	if (skb_cow_head(skb, 1))
128		return -ENOMEM;
129
130	*skb_push(skb, 1) = 0;
131
132	return 0;
133}
134
135static void rawsock_data_exchange_complete(void *context, struct sk_buff *skb,
136								int err)
137{
138	struct sock *sk = (struct sock *) context;
139
140	BUG_ON(in_irq());
141
142	nfc_dbg("sk=%p err=%d", sk, err);
143
144	if (err)
145		goto error;
146
147	err = rawsock_add_header(skb);
148	if (err)
149		goto error;
150
151	err = sock_queue_rcv_skb(sk, skb);
152	if (err)
153		goto error;
154
155	spin_lock_bh(&sk->sk_write_queue.lock);
156	if (!skb_queue_empty(&sk->sk_write_queue))
157		schedule_work(&nfc_rawsock(sk)->tx_work);
158	else
159		nfc_rawsock(sk)->tx_work_scheduled = false;
160	spin_unlock_bh(&sk->sk_write_queue.lock);
161
162	sock_put(sk);
163	return;
164
 
 
 
165error:
166	rawsock_report_error(sk, err);
167	sock_put(sk);
168}
169
170static void rawsock_tx_work(struct work_struct *work)
171{
172	struct sock *sk = to_rawsock_sk(work);
173	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
174	u32 target_idx = nfc_rawsock(sk)->target_idx;
175	struct sk_buff *skb;
176	int rc;
177
178	nfc_dbg("sk=%p target_idx=%u", sk, target_idx);
179
180	if (sk->sk_shutdown & SEND_SHUTDOWN) {
181		rawsock_write_queue_purge(sk);
182		return;
183	}
184
185	skb = skb_dequeue(&sk->sk_write_queue);
 
186
187	sock_hold(sk);
188	rc = nfc_data_exchange(dev, target_idx, skb,
189				rawsock_data_exchange_complete, sk);
190	if (rc) {
191		rawsock_report_error(sk, rc);
192		sock_put(sk);
193	}
 
194}
195
196static int rawsock_sendmsg(struct kiocb *iocb, struct socket *sock,
197					struct msghdr *msg, size_t len)
198{
199	struct sock *sk = sock->sk;
 
200	struct sk_buff *skb;
201	int rc;
202
203	nfc_dbg("sock=%p sk=%p len=%zu", sock, sk, len);
204
205	if (msg->msg_namelen)
206		return -EOPNOTSUPP;
207
208	if (sock->state != SS_CONNECTED)
209		return -ENOTCONN;
210
211	skb = sock_alloc_send_skb(sk, len, msg->msg_flags & MSG_DONTWAIT,
212									&rc);
213	if (!skb)
214		return rc;
215
216	rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
217	if (rc < 0) {
218		kfree_skb(skb);
219		return rc;
220	}
221
222	spin_lock_bh(&sk->sk_write_queue.lock);
223	__skb_queue_tail(&sk->sk_write_queue, skb);
224	if (!nfc_rawsock(sk)->tx_work_scheduled) {
225		schedule_work(&nfc_rawsock(sk)->tx_work);
226		nfc_rawsock(sk)->tx_work_scheduled = true;
227	}
228	spin_unlock_bh(&sk->sk_write_queue.lock);
229
230	return len;
231}
232
233static int rawsock_recvmsg(struct kiocb *iocb, struct socket *sock,
234				struct msghdr *msg, size_t len, int flags)
235{
236	int noblock = flags & MSG_DONTWAIT;
237	struct sock *sk = sock->sk;
238	struct sk_buff *skb;
239	int copied;
240	int rc;
241
242	nfc_dbg("sock=%p sk=%p len=%zu flags=%d", sock, sk, len, flags);
243
244	skb = skb_recv_datagram(sk, flags, noblock, &rc);
245	if (!skb)
246		return rc;
247
248	msg->msg_namelen = 0;
249
250	copied = skb->len;
251	if (len < copied) {
252		msg->msg_flags |= MSG_TRUNC;
253		copied = len;
254	}
255
256	rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
257
258	skb_free_datagram(sk, skb);
259
260	return rc ? : copied;
261}
262
263
264static const struct proto_ops rawsock_ops = {
265	.family         = PF_NFC,
266	.owner          = THIS_MODULE,
267	.release        = rawsock_release,
268	.bind           = sock_no_bind,
269	.connect        = rawsock_connect,
270	.socketpair     = sock_no_socketpair,
271	.accept         = sock_no_accept,
272	.getname        = sock_no_getname,
273	.poll           = datagram_poll,
274	.ioctl          = sock_no_ioctl,
275	.listen         = sock_no_listen,
276	.shutdown       = sock_no_shutdown,
277	.setsockopt     = sock_no_setsockopt,
278	.getsockopt     = sock_no_getsockopt,
279	.sendmsg        = rawsock_sendmsg,
280	.recvmsg        = rawsock_recvmsg,
281	.mmap           = sock_no_mmap,
282};
283
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
284static void rawsock_destruct(struct sock *sk)
285{
286	nfc_dbg("sk=%p", sk);
287
288	if (sk->sk_state == TCP_ESTABLISHED) {
289		nfc_deactivate_target(nfc_rawsock(sk)->dev,
290					nfc_rawsock(sk)->target_idx);
 
291		nfc_put_device(nfc_rawsock(sk)->dev);
292	}
293
294	skb_queue_purge(&sk->sk_receive_queue);
295
296	if (!sock_flag(sk, SOCK_DEAD)) {
297		nfc_err("Freeing alive NFC raw socket %p", sk);
298		return;
299	}
300}
301
302static int rawsock_create(struct net *net, struct socket *sock,
303				const struct nfc_protocol *nfc_proto)
304{
305	struct sock *sk;
306
307	nfc_dbg("sock=%p", sock);
308
309	if (sock->type != SOCK_SEQPACKET)
310		return -ESOCKTNOSUPPORT;
311
312	sock->ops = &rawsock_ops;
 
 
 
 
 
 
313
314	sk = sk_alloc(net, PF_NFC, GFP_KERNEL, nfc_proto->proto);
315	if (!sk)
316		return -ENOMEM;
317
318	sock_init_data(sock, sk);
319	sk->sk_protocol = nfc_proto->id;
320	sk->sk_destruct = rawsock_destruct;
321	sock->state = SS_UNCONNECTED;
322
323	INIT_WORK(&nfc_rawsock(sk)->tx_work, rawsock_tx_work);
324	nfc_rawsock(sk)->tx_work_scheduled = false;
 
 
 
325
326	return 0;
327}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
328
329static struct proto rawsock_proto = {
330	.name     = "NFC_RAW",
331	.owner    = THIS_MODULE,
332	.obj_size = sizeof(struct nfc_rawsock),
333};
334
335static const struct nfc_protocol rawsock_nfc_proto = {
336	.id	  = NFC_SOCKPROTO_RAW,
337	.proto    = &rawsock_proto,
338	.owner    = THIS_MODULE,
339	.create   = rawsock_create
340};
341
342int __init rawsock_init(void)
343{
344	int rc;
345
346	rc = nfc_proto_register(&rawsock_nfc_proto);
347
348	return rc;
349}
350
351void rawsock_exit(void)
352{
353	nfc_proto_unregister(&rawsock_nfc_proto);
354}
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Copyright (C) 2011 Instituto Nokia de Tecnologia
  4 *
  5 * Authors:
  6 *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
  7 *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  8 */
  9
 10#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
 11
 12#include <net/tcp_states.h>
 13#include <linux/nfc.h>
 14#include <linux/export.h>
 15#include <linux/kcov.h>
 16
 17#include "nfc.h"
 18
 19static struct nfc_sock_list raw_sk_list = {
 20	.lock = __RW_LOCK_UNLOCKED(raw_sk_list.lock)
 21};
 22
 23static void nfc_sock_link(struct nfc_sock_list *l, struct sock *sk)
 24{
 25	write_lock(&l->lock);
 26	sk_add_node(sk, &l->head);
 27	write_unlock(&l->lock);
 28}
 29
 30static void nfc_sock_unlink(struct nfc_sock_list *l, struct sock *sk)
 31{
 32	write_lock(&l->lock);
 33	sk_del_node_init(sk);
 34	write_unlock(&l->lock);
 35}
 36
 37static void rawsock_write_queue_purge(struct sock *sk)
 38{
 39	pr_debug("sk=%p\n", sk);
 40
 41	spin_lock_bh(&sk->sk_write_queue.lock);
 42	__skb_queue_purge(&sk->sk_write_queue);
 43	nfc_rawsock(sk)->tx_work_scheduled = false;
 44	spin_unlock_bh(&sk->sk_write_queue.lock);
 45}
 46
 47static void rawsock_report_error(struct sock *sk, int err)
 48{
 49	pr_debug("sk=%p err=%d\n", sk, err);
 50
 51	sk->sk_shutdown = SHUTDOWN_MASK;
 52	sk->sk_err = -err;
 53	sk_error_report(sk);
 54
 55	rawsock_write_queue_purge(sk);
 56}
 57
 58static int rawsock_release(struct socket *sock)
 59{
 60	struct sock *sk = sock->sk;
 61
 62	pr_debug("sock=%p sk=%p\n", sock, sk);
 63
 64	if (!sk)
 65		return 0;
 66
 67	if (sock->type == SOCK_RAW)
 68		nfc_sock_unlink(&raw_sk_list, sk);
 69
 70	sock_orphan(sk);
 71	sock_put(sk);
 72
 73	return 0;
 74}
 75
 76static int rawsock_connect(struct socket *sock, struct sockaddr *_addr,
 77			   int len, int flags)
 78{
 79	struct sock *sk = sock->sk;
 80	struct sockaddr_nfc *addr = (struct sockaddr_nfc *)_addr;
 81	struct nfc_dev *dev;
 82	int rc = 0;
 83
 84	pr_debug("sock=%p sk=%p flags=%d\n", sock, sk, flags);
 85
 86	if (!addr || len < sizeof(struct sockaddr_nfc) ||
 87	    addr->sa_family != AF_NFC)
 88		return -EINVAL;
 89
 90	pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n",
 91		 addr->dev_idx, addr->target_idx, addr->nfc_protocol);
 92
 93	lock_sock(sk);
 94
 95	if (sock->state == SS_CONNECTED) {
 96		rc = -EISCONN;
 97		goto error;
 98	}
 99
100	dev = nfc_get_device(addr->dev_idx);
101	if (!dev) {
102		rc = -ENODEV;
103		goto error;
104	}
105
106	if (addr->target_idx > dev->target_next_idx - 1 ||
107	    addr->target_idx < dev->target_next_idx - dev->n_targets) {
 
 
 
 
 
 
108		rc = -EINVAL;
109		goto put_dev;
110	}
111
112	rc = nfc_activate_target(dev, addr->target_idx, addr->nfc_protocol);
113	if (rc)
114		goto put_dev;
115
116	nfc_rawsock(sk)->dev = dev;
117	nfc_rawsock(sk)->target_idx = addr->target_idx;
118	sock->state = SS_CONNECTED;
119	sk->sk_state = TCP_ESTABLISHED;
120	sk->sk_state_change(sk);
121
122	release_sock(sk);
123	return 0;
124
125put_dev:
126	nfc_put_device(dev);
127error:
128	release_sock(sk);
129	return rc;
130}
131
132static int rawsock_add_header(struct sk_buff *skb)
133{
134	*(u8 *)skb_push(skb, NFC_HEADER_SIZE) = 0;
 
 
 
 
135
136	return 0;
137}
138
139static void rawsock_data_exchange_complete(void *context, struct sk_buff *skb,
140					   int err)
141{
142	struct sock *sk = (struct sock *) context;
143
144	BUG_ON(in_hardirq());
145
146	pr_debug("sk=%p err=%d\n", sk, err);
147
148	if (err)
149		goto error;
150
151	err = rawsock_add_header(skb);
152	if (err)
153		goto error_skb;
154
155	err = sock_queue_rcv_skb(sk, skb);
156	if (err)
157		goto error_skb;
158
159	spin_lock_bh(&sk->sk_write_queue.lock);
160	if (!skb_queue_empty(&sk->sk_write_queue))
161		schedule_work(&nfc_rawsock(sk)->tx_work);
162	else
163		nfc_rawsock(sk)->tx_work_scheduled = false;
164	spin_unlock_bh(&sk->sk_write_queue.lock);
165
166	sock_put(sk);
167	return;
168
169error_skb:
170	kfree_skb(skb);
171
172error:
173	rawsock_report_error(sk, err);
174	sock_put(sk);
175}
176
177static void rawsock_tx_work(struct work_struct *work)
178{
179	struct sock *sk = to_rawsock_sk(work);
180	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
181	u32 target_idx = nfc_rawsock(sk)->target_idx;
182	struct sk_buff *skb;
183	int rc;
184
185	pr_debug("sk=%p target_idx=%u\n", sk, target_idx);
186
187	if (sk->sk_shutdown & SEND_SHUTDOWN) {
188		rawsock_write_queue_purge(sk);
189		return;
190	}
191
192	skb = skb_dequeue(&sk->sk_write_queue);
193	kcov_remote_start_common(skb_get_kcov_handle(skb));
194
195	sock_hold(sk);
196	rc = nfc_data_exchange(dev, target_idx, skb,
197			       rawsock_data_exchange_complete, sk);
198	if (rc) {
199		rawsock_report_error(sk, rc);
200		sock_put(sk);
201	}
202	kcov_remote_stop();
203}
204
205static int rawsock_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
 
206{
207	struct sock *sk = sock->sk;
208	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
209	struct sk_buff *skb;
210	int rc;
211
212	pr_debug("sock=%p sk=%p len=%zu\n", sock, sk, len);
213
214	if (msg->msg_namelen)
215		return -EOPNOTSUPP;
216
217	if (sock->state != SS_CONNECTED)
218		return -ENOTCONN;
219
220	skb = nfc_alloc_send_skb(dev, sk, msg->msg_flags, len, &rc);
221	if (skb == NULL)
 
222		return rc;
223
224	rc = memcpy_from_msg(skb_put(skb, len), msg, len);
225	if (rc < 0) {
226		kfree_skb(skb);
227		return rc;
228	}
229
230	spin_lock_bh(&sk->sk_write_queue.lock);
231	__skb_queue_tail(&sk->sk_write_queue, skb);
232	if (!nfc_rawsock(sk)->tx_work_scheduled) {
233		schedule_work(&nfc_rawsock(sk)->tx_work);
234		nfc_rawsock(sk)->tx_work_scheduled = true;
235	}
236	spin_unlock_bh(&sk->sk_write_queue.lock);
237
238	return len;
239}
240
241static int rawsock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
242			   int flags)
243{
 
244	struct sock *sk = sock->sk;
245	struct sk_buff *skb;
246	int copied;
247	int rc;
248
249	pr_debug("sock=%p sk=%p len=%zu flags=%d\n", sock, sk, len, flags);
250
251	skb = skb_recv_datagram(sk, flags, &rc);
252	if (!skb)
253		return rc;
254
 
 
255	copied = skb->len;
256	if (len < copied) {
257		msg->msg_flags |= MSG_TRUNC;
258		copied = len;
259	}
260
261	rc = skb_copy_datagram_msg(skb, 0, msg, copied);
262
263	skb_free_datagram(sk, skb);
264
265	return rc ? : copied;
266}
267
 
268static const struct proto_ops rawsock_ops = {
269	.family         = PF_NFC,
270	.owner          = THIS_MODULE,
271	.release        = rawsock_release,
272	.bind           = sock_no_bind,
273	.connect        = rawsock_connect,
274	.socketpair     = sock_no_socketpair,
275	.accept         = sock_no_accept,
276	.getname        = sock_no_getname,
277	.poll           = datagram_poll,
278	.ioctl          = sock_no_ioctl,
279	.listen         = sock_no_listen,
280	.shutdown       = sock_no_shutdown,
 
 
281	.sendmsg        = rawsock_sendmsg,
282	.recvmsg        = rawsock_recvmsg,
283	.mmap           = sock_no_mmap,
284};
285
286static const struct proto_ops rawsock_raw_ops = {
287	.family         = PF_NFC,
288	.owner          = THIS_MODULE,
289	.release        = rawsock_release,
290	.bind           = sock_no_bind,
291	.connect        = sock_no_connect,
292	.socketpair     = sock_no_socketpair,
293	.accept         = sock_no_accept,
294	.getname        = sock_no_getname,
295	.poll           = datagram_poll,
296	.ioctl          = sock_no_ioctl,
297	.listen         = sock_no_listen,
298	.shutdown       = sock_no_shutdown,
299	.sendmsg        = sock_no_sendmsg,
300	.recvmsg        = rawsock_recvmsg,
301	.mmap           = sock_no_mmap,
302};
303
304static void rawsock_destruct(struct sock *sk)
305{
306	pr_debug("sk=%p\n", sk);
307
308	if (sk->sk_state == TCP_ESTABLISHED) {
309		nfc_deactivate_target(nfc_rawsock(sk)->dev,
310				      nfc_rawsock(sk)->target_idx,
311				      NFC_TARGET_MODE_IDLE);
312		nfc_put_device(nfc_rawsock(sk)->dev);
313	}
314
315	skb_queue_purge(&sk->sk_receive_queue);
316
317	if (!sock_flag(sk, SOCK_DEAD)) {
318		pr_err("Freeing alive NFC raw socket %p\n", sk);
319		return;
320	}
321}
322
323static int rawsock_create(struct net *net, struct socket *sock,
324			  const struct nfc_protocol *nfc_proto, int kern)
325{
326	struct sock *sk;
327
328	pr_debug("sock=%p\n", sock);
329
330	if ((sock->type != SOCK_SEQPACKET) && (sock->type != SOCK_RAW))
331		return -ESOCKTNOSUPPORT;
332
333	if (sock->type == SOCK_RAW) {
334		if (!ns_capable(net->user_ns, CAP_NET_RAW))
335			return -EPERM;
336		sock->ops = &rawsock_raw_ops;
337	} else {
338		sock->ops = &rawsock_ops;
339	}
340
341	sk = sk_alloc(net, PF_NFC, GFP_ATOMIC, nfc_proto->proto, kern);
342	if (!sk)
343		return -ENOMEM;
344
345	sock_init_data(sock, sk);
346	sk->sk_protocol = nfc_proto->id;
347	sk->sk_destruct = rawsock_destruct;
348	sock->state = SS_UNCONNECTED;
349	if (sock->type == SOCK_RAW)
350		nfc_sock_link(&raw_sk_list, sk);
351	else {
352		INIT_WORK(&nfc_rawsock(sk)->tx_work, rawsock_tx_work);
353		nfc_rawsock(sk)->tx_work_scheduled = false;
354	}
355
356	return 0;
357}
358
359void nfc_send_to_raw_sock(struct nfc_dev *dev, struct sk_buff *skb,
360			  u8 payload_type, u8 direction)
361{
362	struct sk_buff *skb_copy = NULL, *nskb;
363	struct sock *sk;
364	u8 *data;
365
366	read_lock(&raw_sk_list.lock);
367
368	sk_for_each(sk, &raw_sk_list.head) {
369		if (!skb_copy) {
370			skb_copy = __pskb_copy_fclone(skb, NFC_RAW_HEADER_SIZE,
371						      GFP_ATOMIC, true);
372			if (!skb_copy)
373				continue;
374
375			data = skb_push(skb_copy, NFC_RAW_HEADER_SIZE);
376
377			data[0] = dev ? dev->idx : 0xFF;
378			data[1] = direction & 0x01;
379			data[1] |= (payload_type << 1);
380		}
381
382		nskb = skb_clone(skb_copy, GFP_ATOMIC);
383		if (!nskb)
384			continue;
385
386		if (sock_queue_rcv_skb(sk, nskb))
387			kfree_skb(nskb);
388	}
389
390	read_unlock(&raw_sk_list.lock);
391
392	kfree_skb(skb_copy);
393}
394EXPORT_SYMBOL(nfc_send_to_raw_sock);
395
396static struct proto rawsock_proto = {
397	.name     = "NFC_RAW",
398	.owner    = THIS_MODULE,
399	.obj_size = sizeof(struct nfc_rawsock),
400};
401
402static const struct nfc_protocol rawsock_nfc_proto = {
403	.id	  = NFC_SOCKPROTO_RAW,
404	.proto    = &rawsock_proto,
405	.owner    = THIS_MODULE,
406	.create   = rawsock_create
407};
408
409int __init rawsock_init(void)
410{
411	int rc;
412
413	rc = nfc_proto_register(&rawsock_nfc_proto);
414
415	return rc;
416}
417
418void rawsock_exit(void)
419{
420	nfc_proto_unregister(&rawsock_nfc_proto);
421}