OpenCores
URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [net/] [bluetooth/] [af_bluetooth.c] - Blame information for rev 3

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 3 xianfeng 
/*
2 
   BlueZ - Bluetooth protocol stack for Linux
3 
   Copyright (C) 2000-2001 Qualcomm Incorporated
4 
 
5 
   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6 
 
7 
   This program is free software; you can redistribute it and/or modify
8 
   it under the terms of the GNU General Public License version 2 as
9 
   published by the Free Software Foundation;
10 
 
11 
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 
 
20 
   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 
   SOFTWARE IS DISCLAIMED.
23 
*/
24 
 
25 
/* Bluetooth address family and sockets. */
26 
 
27 
#include <linux/module.h>
28 
 
29 
#include <linux/types.h>
30 
#include <linux/list.h>
31 
#include <linux/errno.h>
32 
#include <linux/kernel.h>
33 
#include <linux/sched.h>
34 
#include <linux/slab.h>
35 
#include <linux/skbuff.h>
36 
#include <linux/init.h>
37 
#include <linux/poll.h>
38 
#include <net/sock.h>
39 
 
40 
#if defined(CONFIG_KMOD)
41 
#include <linux/kmod.h>
42 
#endif
43 
 
44 
#include <net/bluetooth/bluetooth.h>
45 
 
46 
#ifndef CONFIG_BT_SOCK_DEBUG
47 
#undef  BT_DBG
48 
#define BT_DBG(D...)
49 
#endif
50 
 
51 
#define VERSION "2.11"
52 
 
53 
/* Bluetooth sockets */
54 
#define BT_MAX_PROTO    8
55 
static struct net_proto_family *bt_proto[BT_MAX_PROTO];
56 
static DEFINE_RWLOCK(bt_proto_lock);
57 
 
58 
int bt_sock_register(int proto, struct net_proto_family *ops)
59 
{
60 
        int err = 0;
61 
 
62 
        if (proto < 0 || proto >= BT_MAX_PROTO)
63 
                return -EINVAL;
64 
 
65 
        write_lock(&bt_proto_lock);
66 
 
67 
        if (bt_proto[proto])
68 
                err = -EEXIST;
69 
        else
70 
                bt_proto[proto] = ops;
71 
 
72 
        write_unlock(&bt_proto_lock);
73 
 
74 
        return err;
75 
}
76 
EXPORT_SYMBOL(bt_sock_register);
77 
 
78 
int bt_sock_unregister(int proto)
79 
{
80 
        int err = 0;
81 
 
82 
        if (proto < 0 || proto >= BT_MAX_PROTO)
83 
                return -EINVAL;
84 
 
85 
        write_lock(&bt_proto_lock);
86 
 
87 
        if (!bt_proto[proto])
88 
                err = -ENOENT;
89 
        else
90 
                bt_proto[proto] = NULL;
91 
 
92 
        write_unlock(&bt_proto_lock);
93 
 
94 
        return err;
95 
}
96 
EXPORT_SYMBOL(bt_sock_unregister);
97 
 
98 
static int bt_sock_create(struct net *net, struct socket *sock, int proto)
99 
{
100 
        int err;
101 
 
102 
        if (net != &init_net)
103 
                return -EAFNOSUPPORT;
104 
 
105 
        if (proto < 0 || proto >= BT_MAX_PROTO)
106 
                return -EINVAL;
107 
 
108 
#if defined(CONFIG_KMOD)
109 
        if (!bt_proto[proto]) {
110 
                request_module("bt-proto-%d", proto);
111 
        }
112 
#endif
113 
 
114 
        err = -EPROTONOSUPPORT;
115 
 
116 
        read_lock(&bt_proto_lock);
117 
 
118 
        if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
119 
                err = bt_proto[proto]->create(net, sock, proto);
120 
                module_put(bt_proto[proto]->owner);
121 
        }
122 
 
123 
        read_unlock(&bt_proto_lock);
124 
 
125 
        return err;
126 
}
127 
 
128 
void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
129 
{
130 
        write_lock_bh(&l->lock);
131 
        sk_add_node(sk, &l->head);
132 
        write_unlock_bh(&l->lock);
133 
}
134 
EXPORT_SYMBOL(bt_sock_link);
135 
 
136 
void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
137 
{
138 
        write_lock_bh(&l->lock);
139 
        sk_del_node_init(sk);
140 
        write_unlock_bh(&l->lock);
141 
}
142 
EXPORT_SYMBOL(bt_sock_unlink);
143 
 
144 
void bt_accept_enqueue(struct sock *parent, struct sock *sk)
145 
{
146 
        BT_DBG("parent %p, sk %p", parent, sk);
147 
 
148 
        sock_hold(sk);
149 
        list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
150 
        bt_sk(sk)->parent = parent;
151 
        parent->sk_ack_backlog++;
152 
}
153 
EXPORT_SYMBOL(bt_accept_enqueue);
154 
 
155 
void bt_accept_unlink(struct sock *sk)
156 
{
157 
        BT_DBG("sk %p state %d", sk, sk->sk_state);
158 
 
159 
        list_del_init(&bt_sk(sk)->accept_q);
160 
        bt_sk(sk)->parent->sk_ack_backlog--;
161 
        bt_sk(sk)->parent = NULL;
162 
        sock_put(sk);
163 
}
164 
EXPORT_SYMBOL(bt_accept_unlink);
165 
 
166 
struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
167 
{
168 
        struct list_head *p, *n;
169 
        struct sock *sk;
170 
 
171 
        BT_DBG("parent %p", parent);
172 
 
173 
        list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
174 
                sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
175 
 
176 
                lock_sock(sk);
177 
 
178 
                /* FIXME: Is this check still needed */
179 
                if (sk->sk_state == BT_CLOSED) {
180 
                        release_sock(sk);
181 
                        bt_accept_unlink(sk);
182 
                        continue;
183 
                }
184 
 
185 
                if (sk->sk_state == BT_CONNECTED || !newsock) {
186 
                        bt_accept_unlink(sk);
187 
                        if (newsock)
188 
                                sock_graft(sk, newsock);
189 
                        release_sock(sk);
190 
                        return sk;
191 
                }
192 
 
193 
                release_sock(sk);
194 
        }
195 
        return NULL;
196 
}
197 
EXPORT_SYMBOL(bt_accept_dequeue);
198 
 
199 
int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
200 
        struct msghdr *msg, size_t len, int flags)
201 
{
202 
        int noblock = flags & MSG_DONTWAIT;
203 
        struct sock *sk = sock->sk;
204 
        struct sk_buff *skb;
205 
        size_t copied;
206 
        int err;
207 
 
208 
        BT_DBG("sock %p sk %p len %d", sock, sk, len);
209 
 
210 
        if (flags & (MSG_OOB))
211 
                return -EOPNOTSUPP;
212 
 
213 
        if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
214 
                if (sk->sk_shutdown & RCV_SHUTDOWN)
215 
                        return 0;
216 
                return err;
217 
        }
218 
 
219 
        msg->msg_namelen = 0;
220 
 
221 
        copied = skb->len;
222 
        if (len < copied) {
223 
                msg->msg_flags |= MSG_TRUNC;
224 
                copied = len;
225 
        }
226 
 
227 
        skb_reset_transport_header(skb);
228 
        err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
229 
 
230 
        skb_free_datagram(sk, skb);
231 
 
232 
        return err ? : copied;
233 
}
234 
EXPORT_SYMBOL(bt_sock_recvmsg);
235 
 
236 
static inline unsigned int bt_accept_poll(struct sock *parent)
237 
{
238 
        struct list_head *p, *n;
239 
        struct sock *sk;
240 
 
241 
        list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
242 
                sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
243 
                if (sk->sk_state == BT_CONNECTED)
244 
                        return POLLIN | POLLRDNORM;
245 
        }
246 
 
247 
        return 0;
248 
}
249 
 
250 
unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
251 
{
252 
        struct sock *sk = sock->sk;
253 
        unsigned int mask = 0;
254 
 
255 
        BT_DBG("sock %p, sk %p", sock, sk);
256 
 
257 
        poll_wait(file, sk->sk_sleep, wait);
258 
 
259 
        if (sk->sk_state == BT_LISTEN)
260 
                return bt_accept_poll(sk);
261 
 
262 
        if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
263 
                mask |= POLLERR;
264 
 
265 
        if (sk->sk_shutdown & RCV_SHUTDOWN)
266 
                mask |= POLLRDHUP;
267 
 
268 
        if (sk->sk_shutdown == SHUTDOWN_MASK)
269 
                mask |= POLLHUP;
270 
 
271 
        if (!skb_queue_empty(&sk->sk_receive_queue) ||
272 
                        (sk->sk_shutdown & RCV_SHUTDOWN))
273 
                mask |= POLLIN | POLLRDNORM;
274 
 
275 
        if (sk->sk_state == BT_CLOSED)
276 
                mask |= POLLHUP;
277 
 
278 
        if (sk->sk_state == BT_CONNECT ||
279 
                        sk->sk_state == BT_CONNECT2 ||
280 
                        sk->sk_state == BT_CONFIG)
281 
                return mask;
282 
 
283 
        if (sock_writeable(sk))
284 
                mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
285 
        else
286 
                set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
287 
 
288 
        return mask;
289 
}
290 
EXPORT_SYMBOL(bt_sock_poll);
291 
 
292 
int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
293 
{
294 
        DECLARE_WAITQUEUE(wait, current);
295 
        int err = 0;
296 
 
297 
        BT_DBG("sk %p", sk);
298 
 
299 
        add_wait_queue(sk->sk_sleep, &wait);
300 
        while (sk->sk_state != state) {
301 
                set_current_state(TASK_INTERRUPTIBLE);
302 
 
303 
                if (!timeo) {
304 
                        err = -EINPROGRESS;
305 
                        break;
306 
                }
307 
 
308 
                if (signal_pending(current)) {
309 
                        err = sock_intr_errno(timeo);
310 
                        break;
311 
                }
312 
 
313 
                release_sock(sk);
314 
                timeo = schedule_timeout(timeo);
315 
                lock_sock(sk);
316 
 
317 
                err = sock_error(sk);
318 
                if (err)
319 
                        break;
320 
        }
321 
        set_current_state(TASK_RUNNING);
322 
        remove_wait_queue(sk->sk_sleep, &wait);
323 
        return err;
324 
}
325 
EXPORT_SYMBOL(bt_sock_wait_state);
326 
 
327 
static struct net_proto_family bt_sock_family_ops = {
328 
        .owner  = THIS_MODULE,
329 
        .family = PF_BLUETOOTH,
330 
        .create = bt_sock_create,
331 
};
332 
 
333 
static int __init bt_init(void)
334 
{
335 
        int err;
336 
 
337 
        BT_INFO("Core ver %s", VERSION);
338 
 
339 
        err = bt_sysfs_init();
340 
        if (err < 0)
341 
                return err;
342 
 
343 
        err = sock_register(&bt_sock_family_ops);
344 
        if (err < 0) {
345 
                bt_sysfs_cleanup();
346 
                return err;
347 
        }
348 
 
349 
        BT_INFO("HCI device and connection manager initialized");
350 
 
351 
        hci_sock_init();
352 
 
353 
        return 0;
354 
}
355 
 
356 
static void __exit bt_exit(void)
357 
{
358 
        hci_sock_cleanup();
359 
 
360 
        sock_unregister(PF_BLUETOOTH);
361 
 
362 
        bt_sysfs_cleanup();
363 
}
364 
 
365 
subsys_initcall(bt_init);
366 
module_exit(bt_exit);
367 
 
368 
MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
369 
MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
370 
MODULE_VERSION(VERSION);
371 
MODULE_LICENSE("GPL");
372 
MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.