Root/
1 | /* |
2 | BlueZ - Bluetooth protocol stack for Linux |
3 | Copyright (C) 2010 Nokia Corporation |
4 | |
5 | This program is free software; you can redistribute it and/or modify |
6 | it under the terms of the GNU General Public License version 2 as |
7 | published by the Free Software Foundation; |
8 | |
9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
10 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
11 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. |
12 | IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY |
13 | CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES |
14 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
15 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
16 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
17 | |
18 | ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, |
19 | COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS |
20 | SOFTWARE IS DISCLAIMED. |
21 | */ |
22 | |
23 | /* Bluetooth HCI Management interface */ |
24 | |
25 | #include <asm/uaccess.h> |
26 | #include <asm/unaligned.h> |
27 | |
28 | #include <net/bluetooth/bluetooth.h> |
29 | #include <net/bluetooth/hci_core.h> |
30 | #include <net/bluetooth/mgmt.h> |
31 | |
32 | #define MGMT_VERSION 0 |
33 | #define MGMT_REVISION 1 |
34 | |
35 | static int cmd_status(struct sock *sk, u16 cmd, u8 status) |
36 | { |
37 | struct sk_buff *skb; |
38 | struct mgmt_hdr *hdr; |
39 | struct mgmt_ev_cmd_status *ev; |
40 | |
41 | BT_DBG("sock %p", sk); |
42 | |
43 | skb = alloc_skb(sizeof(*hdr) + sizeof(*ev), GFP_ATOMIC); |
44 | if (!skb) |
45 | return -ENOMEM; |
46 | |
47 | hdr = (void *) skb_put(skb, sizeof(*hdr)); |
48 | |
49 | hdr->opcode = cpu_to_le16(MGMT_EV_CMD_STATUS); |
50 | hdr->len = cpu_to_le16(sizeof(*ev)); |
51 | |
52 | ev = (void *) skb_put(skb, sizeof(*ev)); |
53 | ev->status = status; |
54 | put_unaligned_le16(cmd, &ev->opcode); |
55 | |
56 | if (sock_queue_rcv_skb(sk, skb) < 0) |
57 | kfree_skb(skb); |
58 | |
59 | return 0; |
60 | } |
61 | |
62 | static int read_version(struct sock *sk) |
63 | { |
64 | struct sk_buff *skb; |
65 | struct mgmt_hdr *hdr; |
66 | struct mgmt_ev_cmd_complete *ev; |
67 | struct mgmt_rp_read_version *rp; |
68 | |
69 | BT_DBG("sock %p", sk); |
70 | |
71 | skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(*rp), GFP_ATOMIC); |
72 | if (!skb) |
73 | return -ENOMEM; |
74 | |
75 | hdr = (void *) skb_put(skb, sizeof(*hdr)); |
76 | hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE); |
77 | hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(*rp)); |
78 | |
79 | ev = (void *) skb_put(skb, sizeof(*ev)); |
80 | put_unaligned_le16(MGMT_OP_READ_VERSION, &ev->opcode); |
81 | |
82 | rp = (void *) skb_put(skb, sizeof(*rp)); |
83 | rp->version = MGMT_VERSION; |
84 | put_unaligned_le16(MGMT_REVISION, &rp->revision); |
85 | |
86 | if (sock_queue_rcv_skb(sk, skb) < 0) |
87 | kfree_skb(skb); |
88 | |
89 | return 0; |
90 | } |
91 | |
92 | static int read_index_list(struct sock *sk) |
93 | { |
94 | struct sk_buff *skb; |
95 | struct mgmt_hdr *hdr; |
96 | struct mgmt_ev_cmd_complete *ev; |
97 | struct mgmt_rp_read_index_list *rp; |
98 | struct list_head *p; |
99 | size_t body_len; |
100 | u16 count; |
101 | int i; |
102 | |
103 | BT_DBG("sock %p", sk); |
104 | |
105 | read_lock(&hci_dev_list_lock); |
106 | |
107 | count = 0; |
108 | list_for_each(p, &hci_dev_list) { |
109 | count++; |
110 | } |
111 | |
112 | body_len = sizeof(*ev) + sizeof(*rp) + (2 * count); |
113 | skb = alloc_skb(sizeof(*hdr) + body_len, GFP_ATOMIC); |
114 | if (!skb) |
115 | return -ENOMEM; |
116 | |
117 | hdr = (void *) skb_put(skb, sizeof(*hdr)); |
118 | hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE); |
119 | hdr->len = cpu_to_le16(body_len); |
120 | |
121 | ev = (void *) skb_put(skb, sizeof(*ev)); |
122 | put_unaligned_le16(MGMT_OP_READ_INDEX_LIST, &ev->opcode); |
123 | |
124 | rp = (void *) skb_put(skb, sizeof(*rp) + (2 * count)); |
125 | put_unaligned_le16(count, &rp->num_controllers); |
126 | |
127 | i = 0; |
128 | list_for_each(p, &hci_dev_list) { |
129 | struct hci_dev *d = list_entry(p, struct hci_dev, list); |
130 | put_unaligned_le16(d->id, &rp->index[i++]); |
131 | BT_DBG("Added hci%u", d->id); |
132 | } |
133 | |
134 | read_unlock(&hci_dev_list_lock); |
135 | |
136 | if (sock_queue_rcv_skb(sk, skb) < 0) |
137 | kfree_skb(skb); |
138 | |
139 | return 0; |
140 | } |
141 | |
142 | static int read_controller_info(struct sock *sk, unsigned char *data, u16 len) |
143 | { |
144 | struct sk_buff *skb; |
145 | struct mgmt_hdr *hdr; |
146 | struct mgmt_ev_cmd_complete *ev; |
147 | struct mgmt_rp_read_info *rp; |
148 | struct mgmt_cp_read_info *cp; |
149 | struct hci_dev *hdev; |
150 | u16 dev_id; |
151 | |
152 | BT_DBG("sock %p", sk); |
153 | |
154 | if (len != 2) |
155 | return cmd_status(sk, MGMT_OP_READ_INFO, EINVAL); |
156 | |
157 | skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(*rp), GFP_ATOMIC); |
158 | if (!skb) |
159 | return -ENOMEM; |
160 | |
161 | hdr = (void *) skb_put(skb, sizeof(*hdr)); |
162 | hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE); |
163 | hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(*rp)); |
164 | |
165 | ev = (void *) skb_put(skb, sizeof(*ev)); |
166 | put_unaligned_le16(MGMT_OP_READ_INFO, &ev->opcode); |
167 | |
168 | rp = (void *) skb_put(skb, sizeof(*rp)); |
169 | |
170 | cp = (void *) data; |
171 | dev_id = get_unaligned_le16(&cp->index); |
172 | |
173 | BT_DBG("request for hci%u", dev_id); |
174 | |
175 | hdev = hci_dev_get(dev_id); |
176 | if (!hdev) { |
177 | kfree_skb(skb); |
178 | return cmd_status(sk, MGMT_OP_READ_INFO, ENODEV); |
179 | } |
180 | |
181 | hci_dev_lock_bh(hdev); |
182 | |
183 | put_unaligned_le16(hdev->id, &rp->index); |
184 | rp->type = hdev->dev_type; |
185 | |
186 | rp->powered = test_bit(HCI_UP, &hdev->flags); |
187 | rp->discoverable = test_bit(HCI_ISCAN, &hdev->flags); |
188 | rp->pairable = test_bit(HCI_PSCAN, &hdev->flags); |
189 | |
190 | if (test_bit(HCI_AUTH, &hdev->flags)) |
191 | rp->sec_mode = 3; |
192 | else if (hdev->ssp_mode > 0) |
193 | rp->sec_mode = 4; |
194 | else |
195 | rp->sec_mode = 2; |
196 | |
197 | bacpy(&rp->bdaddr, &hdev->bdaddr); |
198 | memcpy(rp->features, hdev->features, 8); |
199 | memcpy(rp->dev_class, hdev->dev_class, 3); |
200 | put_unaligned_le16(hdev->manufacturer, &rp->manufacturer); |
201 | rp->hci_ver = hdev->hci_ver; |
202 | put_unaligned_le16(hdev->hci_rev, &rp->hci_rev); |
203 | |
204 | hci_dev_unlock_bh(hdev); |
205 | hci_dev_put(hdev); |
206 | |
207 | if (sock_queue_rcv_skb(sk, skb) < 0) |
208 | kfree_skb(skb); |
209 | |
210 | return 0; |
211 | } |
212 | |
213 | int mgmt_control(struct sock *sk, struct msghdr *msg, size_t msglen) |
214 | { |
215 | unsigned char *buf; |
216 | struct mgmt_hdr *hdr; |
217 | u16 opcode, len; |
218 | int err; |
219 | |
220 | BT_DBG("got %zu bytes", msglen); |
221 | |
222 | if (msglen < sizeof(*hdr)) |
223 | return -EINVAL; |
224 | |
225 | buf = kmalloc(msglen, GFP_ATOMIC); |
226 | if (!buf) |
227 | return -ENOMEM; |
228 | |
229 | if (memcpy_fromiovec(buf, msg->msg_iov, msglen)) { |
230 | err = -EFAULT; |
231 | goto done; |
232 | } |
233 | |
234 | hdr = (struct mgmt_hdr *) buf; |
235 | opcode = get_unaligned_le16(&hdr->opcode); |
236 | len = get_unaligned_le16(&hdr->len); |
237 | |
238 | if (len != msglen - sizeof(*hdr)) { |
239 | err = -EINVAL; |
240 | goto done; |
241 | } |
242 | |
243 | switch (opcode) { |
244 | case MGMT_OP_READ_VERSION: |
245 | err = read_version(sk); |
246 | break; |
247 | case MGMT_OP_READ_INDEX_LIST: |
248 | err = read_index_list(sk); |
249 | break; |
250 | case MGMT_OP_READ_INFO: |
251 | err = read_controller_info(sk, buf + sizeof(*hdr), len); |
252 | break; |
253 | default: |
254 | BT_DBG("Unknown op %u", opcode); |
255 | err = cmd_status(sk, opcode, 0x01); |
256 | break; |
257 | } |
258 | |
259 | if (err < 0) |
260 | goto done; |
261 | |
262 | err = msglen; |
263 | |
264 | done: |
265 | kfree(buf); |
266 | return err; |
267 | } |
268 | |
269 | static int mgmt_event(u16 event, void *data, u16 data_len) |
270 | { |
271 | struct sk_buff *skb; |
272 | struct mgmt_hdr *hdr; |
273 | |
274 | skb = alloc_skb(sizeof(*hdr) + data_len, GFP_ATOMIC); |
275 | if (!skb) |
276 | return -ENOMEM; |
277 | |
278 | bt_cb(skb)->channel = HCI_CHANNEL_CONTROL; |
279 | |
280 | hdr = (void *) skb_put(skb, sizeof(*hdr)); |
281 | hdr->opcode = cpu_to_le16(event); |
282 | hdr->len = cpu_to_le16(data_len); |
283 | |
284 | memcpy(skb_put(skb, data_len), data, data_len); |
285 | |
286 | hci_send_to_sock(NULL, skb); |
287 | kfree_skb(skb); |
288 | |
289 | return 0; |
290 | } |
291 | |
292 | int mgmt_index_added(u16 index) |
293 | { |
294 | struct mgmt_ev_index_added ev; |
295 | |
296 | put_unaligned_le16(index, &ev.index); |
297 | |
298 | return mgmt_event(MGMT_EV_INDEX_ADDED, &ev, sizeof(ev)); |
299 | } |
300 | |
301 | int mgmt_index_removed(u16 index) |
302 | { |
303 | struct mgmt_ev_index_added ev; |
304 | |
305 | put_unaligned_le16(index, &ev.index); |
306 | |
307 | return mgmt_event(MGMT_EV_INDEX_REMOVED, &ev, sizeof(ev)); |
308 | } |
309 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9