Root/
1 | /* |
2 | * Texas Instrument's Bluetooth Driver For Shared Transport. |
3 | * |
4 | * Bluetooth Driver acts as interface between HCI core and |
5 | * TI Shared Transport Layer. |
6 | * |
7 | * Copyright (C) 2009-2010 Texas Instruments |
8 | * Author: Raja Mani <raja_mani@ti.com> |
9 | * Pavan Savoy <pavan_savoy@ti.com> |
10 | * |
11 | * This program is free software; you can redistribute it and/or modify |
12 | * it under the terms of the GNU General Public License version 2 as |
13 | * published by the Free Software Foundation. |
14 | * |
15 | * This program is distributed in the hope that it will be useful, |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
18 | * GNU General Public License for more details. |
19 | * |
20 | * You should have received a copy of the GNU General Public License |
21 | * along with this program; if not, write to the Free Software |
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
23 | * |
24 | */ |
25 | #define DEBUG |
26 | #include <linux/platform_device.h> |
27 | #include <net/bluetooth/bluetooth.h> |
28 | #include <net/bluetooth/hci_core.h> |
29 | #include <net/bluetooth/hci.h> |
30 | |
31 | #include <linux/ti_wilink_st.h> |
32 | #include <linux/module.h> |
33 | |
34 | /* Bluetooth Driver Version */ |
35 | #define VERSION "1.0" |
36 | #define MAX_BT_CHNL_IDS 3 |
37 | |
38 | /* Number of seconds to wait for registration completion |
39 | * when ST returns PENDING status. |
40 | */ |
41 | #define BT_REGISTER_TIMEOUT 6000 /* 6 sec */ |
42 | |
43 | /** |
44 | * struct ti_st - driver operation structure |
45 | * @hdev: hci device pointer which binds to bt driver |
46 | * @reg_status: ST registration callback status |
47 | * @st_write: write function provided by the ST driver |
48 | * to be used by the driver during send_frame. |
49 | * @wait_reg_completion - completion sync between ti_st_open |
50 | * and st_reg_completion_cb. |
51 | */ |
52 | struct ti_st { |
53 | struct hci_dev *hdev; |
54 | char reg_status; |
55 | long (*st_write) (struct sk_buff *); |
56 | struct completion wait_reg_completion; |
57 | }; |
58 | |
59 | /* Increments HCI counters based on pocket ID (cmd,acl,sco) */ |
60 | static inline void ti_st_tx_complete(struct ti_st *hst, int pkt_type) |
61 | { |
62 | struct hci_dev *hdev = hst->hdev; |
63 | |
64 | /* Update HCI stat counters */ |
65 | switch (pkt_type) { |
66 | case HCI_COMMAND_PKT: |
67 | hdev->stat.cmd_tx++; |
68 | break; |
69 | |
70 | case HCI_ACLDATA_PKT: |
71 | hdev->stat.acl_tx++; |
72 | break; |
73 | |
74 | case HCI_SCODATA_PKT: |
75 | hdev->stat.sco_tx++; |
76 | break; |
77 | } |
78 | } |
79 | |
80 | /* ------- Interfaces to Shared Transport ------ */ |
81 | |
82 | /* Called by ST layer to indicate protocol registration completion |
83 | * status.ti_st_open() function will wait for signal from this |
84 | * API when st_register() function returns ST_PENDING. |
85 | */ |
86 | static void st_reg_completion_cb(void *priv_data, char data) |
87 | { |
88 | struct ti_st *lhst = priv_data; |
89 | |
90 | /* Save registration status for use in ti_st_open() */ |
91 | lhst->reg_status = data; |
92 | /* complete the wait in ti_st_open() */ |
93 | complete(&lhst->wait_reg_completion); |
94 | } |
95 | |
96 | /* Called by Shared Transport layer when receive data is |
97 | * available */ |
98 | static long st_receive(void *priv_data, struct sk_buff *skb) |
99 | { |
100 | struct ti_st *lhst = priv_data; |
101 | int err; |
102 | |
103 | if (!skb) |
104 | return -EFAULT; |
105 | |
106 | if (!lhst) { |
107 | kfree_skb(skb); |
108 | return -EFAULT; |
109 | } |
110 | |
111 | skb->dev = (void *) lhst->hdev; |
112 | |
113 | /* Forward skb to HCI core layer */ |
114 | err = hci_recv_frame(skb); |
115 | if (err < 0) { |
116 | BT_ERR("Unable to push skb to HCI core(%d)", err); |
117 | return err; |
118 | } |
119 | |
120 | lhst->hdev->stat.byte_rx += skb->len; |
121 | |
122 | return 0; |
123 | } |
124 | |
125 | /* ------- Interfaces to HCI layer ------ */ |
126 | /* protocol structure registered with shared transport */ |
127 | static struct st_proto_s ti_st_proto[MAX_BT_CHNL_IDS] = { |
128 | { |
129 | .chnl_id = HCI_EVENT_PKT, /* HCI Events */ |
130 | .hdr_len = sizeof(struct hci_event_hdr), |
131 | .offset_len_in_hdr = offsetof(struct hci_event_hdr, plen), |
132 | .len_size = 1, /* sizeof(plen) in struct hci_event_hdr */ |
133 | .reserve = 8, |
134 | }, |
135 | { |
136 | .chnl_id = HCI_ACLDATA_PKT, /* ACL */ |
137 | .hdr_len = sizeof(struct hci_acl_hdr), |
138 | .offset_len_in_hdr = offsetof(struct hci_acl_hdr, dlen), |
139 | .len_size = 2, /* sizeof(dlen) in struct hci_acl_hdr */ |
140 | .reserve = 8, |
141 | }, |
142 | { |
143 | .chnl_id = HCI_SCODATA_PKT, /* SCO */ |
144 | .hdr_len = sizeof(struct hci_sco_hdr), |
145 | .offset_len_in_hdr = offsetof(struct hci_sco_hdr, dlen), |
146 | .len_size = 1, /* sizeof(dlen) in struct hci_sco_hdr */ |
147 | .reserve = 8, |
148 | }, |
149 | }; |
150 | |
151 | /* Called from HCI core to initialize the device */ |
152 | static int ti_st_open(struct hci_dev *hdev) |
153 | { |
154 | unsigned long timeleft; |
155 | struct ti_st *hst; |
156 | int err, i; |
157 | |
158 | BT_DBG("%s %p", hdev->name, hdev); |
159 | |
160 | if (test_and_set_bit(HCI_RUNNING, &hdev->flags)) |
161 | return -EBUSY; |
162 | |
163 | /* provide contexts for callbacks from ST */ |
164 | hst = hci_get_drvdata(hdev); |
165 | |
166 | for (i = 0; i < MAX_BT_CHNL_IDS; i++) { |
167 | ti_st_proto[i].priv_data = hst; |
168 | ti_st_proto[i].max_frame_size = HCI_MAX_FRAME_SIZE; |
169 | ti_st_proto[i].recv = st_receive; |
170 | ti_st_proto[i].reg_complete_cb = st_reg_completion_cb; |
171 | |
172 | /* Prepare wait-for-completion handler */ |
173 | init_completion(&hst->wait_reg_completion); |
174 | /* Reset ST registration callback status flag, |
175 | * this value will be updated in |
176 | * st_reg_completion_cb() |
177 | * function whenever it called from ST driver. |
178 | */ |
179 | hst->reg_status = -EINPROGRESS; |
180 | |
181 | err = st_register(&ti_st_proto[i]); |
182 | if (!err) |
183 | goto done; |
184 | |
185 | if (err != -EINPROGRESS) { |
186 | clear_bit(HCI_RUNNING, &hdev->flags); |
187 | BT_ERR("st_register failed %d", err); |
188 | return err; |
189 | } |
190 | |
191 | /* ST is busy with either protocol |
192 | * registration or firmware download. |
193 | */ |
194 | BT_DBG("waiting for registration " |
195 | "completion signal from ST"); |
196 | timeleft = wait_for_completion_timeout |
197 | (&hst->wait_reg_completion, |
198 | msecs_to_jiffies(BT_REGISTER_TIMEOUT)); |
199 | if (!timeleft) { |
200 | clear_bit(HCI_RUNNING, &hdev->flags); |
201 | BT_ERR("Timeout(%d sec),didn't get reg " |
202 | "completion signal from ST", |
203 | BT_REGISTER_TIMEOUT / 1000); |
204 | return -ETIMEDOUT; |
205 | } |
206 | |
207 | /* Is ST registration callback |
208 | * called with ERROR status? */ |
209 | if (hst->reg_status != 0) { |
210 | clear_bit(HCI_RUNNING, &hdev->flags); |
211 | BT_ERR("ST registration completed with invalid " |
212 | "status %d", hst->reg_status); |
213 | return -EAGAIN; |
214 | } |
215 | |
216 | done: |
217 | hst->st_write = ti_st_proto[i].write; |
218 | if (!hst->st_write) { |
219 | BT_ERR("undefined ST write function"); |
220 | clear_bit(HCI_RUNNING, &hdev->flags); |
221 | for (i = 0; i < MAX_BT_CHNL_IDS; i++) { |
222 | /* Undo registration with ST */ |
223 | err = st_unregister(&ti_st_proto[i]); |
224 | if (err) |
225 | BT_ERR("st_unregister() failed with " |
226 | "error %d", err); |
227 | hst->st_write = NULL; |
228 | } |
229 | return -EIO; |
230 | } |
231 | } |
232 | return 0; |
233 | } |
234 | |
235 | /* Close device */ |
236 | static int ti_st_close(struct hci_dev *hdev) |
237 | { |
238 | int err, i; |
239 | struct ti_st *hst = hci_get_drvdata(hdev); |
240 | |
241 | if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags)) |
242 | return 0; |
243 | |
244 | for (i = MAX_BT_CHNL_IDS-1; i >= 0; i--) { |
245 | err = st_unregister(&ti_st_proto[i]); |
246 | if (err) |
247 | BT_ERR("st_unregister(%d) failed with error %d", |
248 | ti_st_proto[i].chnl_id, err); |
249 | } |
250 | |
251 | hst->st_write = NULL; |
252 | |
253 | return err; |
254 | } |
255 | |
256 | static int ti_st_send_frame(struct sk_buff *skb) |
257 | { |
258 | struct hci_dev *hdev; |
259 | struct ti_st *hst; |
260 | long len; |
261 | |
262 | hdev = (struct hci_dev *)skb->dev; |
263 | |
264 | if (!test_bit(HCI_RUNNING, &hdev->flags)) |
265 | return -EBUSY; |
266 | |
267 | hst = hci_get_drvdata(hdev); |
268 | |
269 | /* Prepend skb with frame type */ |
270 | memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); |
271 | |
272 | BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, |
273 | skb->len); |
274 | |
275 | /* Insert skb to shared transport layer's transmit queue. |
276 | * Freeing skb memory is taken care in shared transport layer, |
277 | * so don't free skb memory here. |
278 | */ |
279 | len = hst->st_write(skb); |
280 | if (len < 0) { |
281 | kfree_skb(skb); |
282 | BT_ERR("ST write failed (%ld)", len); |
283 | /* Try Again, would only fail if UART has gone bad */ |
284 | return -EAGAIN; |
285 | } |
286 | |
287 | /* ST accepted our skb. So, Go ahead and do rest */ |
288 | hdev->stat.byte_tx += len; |
289 | ti_st_tx_complete(hst, bt_cb(skb)->pkt_type); |
290 | |
291 | return 0; |
292 | } |
293 | |
294 | static int bt_ti_probe(struct platform_device *pdev) |
295 | { |
296 | static struct ti_st *hst; |
297 | struct hci_dev *hdev; |
298 | int err; |
299 | |
300 | hst = devm_kzalloc(&pdev->dev, sizeof(struct ti_st), GFP_KERNEL); |
301 | if (!hst) |
302 | return -ENOMEM; |
303 | |
304 | /* Expose "hciX" device to user space */ |
305 | hdev = hci_alloc_dev(); |
306 | if (!hdev) |
307 | return -ENOMEM; |
308 | |
309 | BT_DBG("hdev %p", hdev); |
310 | |
311 | hst->hdev = hdev; |
312 | hdev->bus = HCI_UART; |
313 | hci_set_drvdata(hdev, hst); |
314 | hdev->open = ti_st_open; |
315 | hdev->close = ti_st_close; |
316 | hdev->flush = NULL; |
317 | hdev->send = ti_st_send_frame; |
318 | |
319 | err = hci_register_dev(hdev); |
320 | if (err < 0) { |
321 | BT_ERR("Can't register HCI device error %d", err); |
322 | hci_free_dev(hdev); |
323 | return err; |
324 | } |
325 | |
326 | BT_DBG("HCI device registered (hdev %p)", hdev); |
327 | |
328 | dev_set_drvdata(&pdev->dev, hst); |
329 | return err; |
330 | } |
331 | |
332 | static int bt_ti_remove(struct platform_device *pdev) |
333 | { |
334 | struct hci_dev *hdev; |
335 | struct ti_st *hst = dev_get_drvdata(&pdev->dev); |
336 | |
337 | if (!hst) |
338 | return -EFAULT; |
339 | |
340 | BT_DBG("%s", hst->hdev->name); |
341 | |
342 | hdev = hst->hdev; |
343 | ti_st_close(hdev); |
344 | hci_unregister_dev(hdev); |
345 | |
346 | hci_free_dev(hdev); |
347 | |
348 | dev_set_drvdata(&pdev->dev, NULL); |
349 | return 0; |
350 | } |
351 | |
352 | static struct platform_driver btwilink_driver = { |
353 | .probe = bt_ti_probe, |
354 | .remove = bt_ti_remove, |
355 | .driver = { |
356 | .name = "btwilink", |
357 | .owner = THIS_MODULE, |
358 | }, |
359 | }; |
360 | |
361 | module_platform_driver(btwilink_driver); |
362 | |
363 | /* ------ Module Info ------ */ |
364 | |
365 | MODULE_AUTHOR("Raja Mani <raja_mani@ti.com>"); |
366 | MODULE_DESCRIPTION("Bluetooth Driver for TI Shared Transport" VERSION); |
367 | MODULE_VERSION(VERSION); |
368 | MODULE_LICENSE("GPL"); |
369 |
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