xref: /openbmc/linux/drivers/bluetooth/btsdio.c (revision 82e6fdd6) 
1 /*
2  *
3  *  Generic Bluetooth SDIO driver
4  *
5  *  Copyright (C) 2007  Cambridge Silicon Radio Ltd.
6  *  Copyright (C) 2007  Marcel Holtmann <marcel@holtmann.org>
7  *
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  *
23  */
24 
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/errno.h>
32 #include <linux/skbuff.h>
33 
34 #include <linux/mmc/host.h>
35 #include <linux/mmc/sdio_ids.h>
36 #include <linux/mmc/sdio_func.h>
37 
38 #include <net/bluetooth/bluetooth.h>
39 #include <net/bluetooth/hci_core.h>
40 
41 #define VERSION "0.1"
42 
43 static const struct sdio_device_id btsdio_table[] = {
44 	/* Generic Bluetooth Type-A SDIO device */
45 	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_A) },
46 
47 	/* Generic Bluetooth Type-B SDIO device */
48 	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_B) },
49 
50 	/* Generic Bluetooth AMP controller */
51 	{ SDIO_DEVICE_CLASS(SDIO_CLASS_BT_AMP) },
52 
53 	{ }	/* Terminating entry */
54 };
55 
56 MODULE_DEVICE_TABLE(sdio, btsdio_table);
57 
58 struct btsdio_data {
59 	struct hci_dev   *hdev;
60 	struct sdio_func *func;
61 
62 	struct work_struct work;
63 
64 	struct sk_buff_head txq;
65 };
66 
67 #define REG_RDAT     0x00	/* Receiver Data */
68 #define REG_TDAT     0x00	/* Transmitter Data */
69 #define REG_PC_RRT   0x10	/* Read Packet Control */
70 #define REG_PC_WRT   0x11	/* Write Packet Control */
71 #define REG_RTC_STAT 0x12	/* Retry Control Status */
72 #define REG_RTC_SET  0x12	/* Retry Control Set */
73 #define REG_INTRD    0x13	/* Interrupt Indication */
74 #define REG_CL_INTRD 0x13	/* Interrupt Clear */
75 #define REG_EN_INTRD 0x14	/* Interrupt Enable */
76 #define REG_MD_STAT  0x20	/* Bluetooth Mode Status */
77 #define REG_MD_SET   0x20	/* Bluetooth Mode Set */
78 
79 static int btsdio_tx_packet(struct btsdio_data *data, struct sk_buff *skb)
80 {
81 	int err;
82 
83 	BT_DBG("%s", data->hdev->name);
84 
85 	/* Prepend Type-A header */
86 	skb_push(skb, 4);
87 	skb->data[0] = (skb->len & 0x0000ff);
88 	skb->data[1] = (skb->len & 0x00ff00) >> 8;
89 	skb->data[2] = (skb->len & 0xff0000) >> 16;
90 	skb->data[3] = hci_skb_pkt_type(skb);
91 
92 	err = sdio_writesb(data->func, REG_TDAT, skb->data, skb->len);
93 	if (err < 0) {
94 		skb_pull(skb, 4);
95 		sdio_writeb(data->func, 0x01, REG_PC_WRT, NULL);
96 		return err;
97 	}
98 
99 	data->hdev->stat.byte_tx += skb->len;
100 
101 	kfree_skb(skb);
102 
103 	return 0;
104 }
105 
106 static void btsdio_work(struct work_struct *work)
107 {
108 	struct btsdio_data *data = container_of(work, struct btsdio_data, work);
109 	struct sk_buff *skb;
110 	int err;
111 
112 	BT_DBG("%s", data->hdev->name);
113 
114 	sdio_claim_host(data->func);
115 
116 	while ((skb = skb_dequeue(&data->txq))) {
117 		err = btsdio_tx_packet(data, skb);
118 		if (err < 0) {
119 			data->hdev->stat.err_tx++;
120 			skb_queue_head(&data->txq, skb);
121 			break;
122 		}
123 	}
124 
125 	sdio_release_host(data->func);
126 }
127 
128 static int btsdio_rx_packet(struct btsdio_data *data)
129 {
130 	u8 hdr[4] __attribute__ ((aligned(4)));
131 	struct sk_buff *skb;
132 	int err, len;
133 
134 	BT_DBG("%s", data->hdev->name);
135 
136 	err = sdio_readsb(data->func, hdr, REG_RDAT, 4);
137 	if (err < 0)
138 		return err;
139 
140 	len = hdr[0] | (hdr[1] << 8) | (hdr[2] << 16);
141 	if (len < 4 || len > 65543)
142 		return -EILSEQ;
143 
144 	skb = bt_skb_alloc(len - 4, GFP_KERNEL);
145 	if (!skb) {
146 		/* Out of memory. Prepare a read retry and just
147 		 * return with the expectation that the next time
148 		 * we're called we'll have more memory.
149 		 */
150 		return -ENOMEM;
151 	}
152 
153 	skb_put(skb, len - 4);
154 
155 	err = sdio_readsb(data->func, skb->data, REG_RDAT, len - 4);
156 	if (err < 0) {
157 		kfree_skb(skb);
158 		return err;
159 	}
160 
161 	data->hdev->stat.byte_rx += len;
162 
163 	hci_skb_pkt_type(skb) = hdr[3];
164 
165 	err = hci_recv_frame(data->hdev, skb);
166 	if (err < 0)
167 		return err;
168 
169 	sdio_writeb(data->func, 0x00, REG_PC_RRT, NULL);
170 
171 	return 0;
172 }
173 
174 static void btsdio_interrupt(struct sdio_func *func)
175 {
176 	struct btsdio_data *data = sdio_get_drvdata(func);
177 	int intrd;
178 
179 	BT_DBG("%s", data->hdev->name);
180 
181 	intrd = sdio_readb(func, REG_INTRD, NULL);
182 	if (intrd & 0x01) {
183 		sdio_writeb(func, 0x01, REG_CL_INTRD, NULL);
184 
185 		if (btsdio_rx_packet(data) < 0) {
186 			data->hdev->stat.err_rx++;
187 			sdio_writeb(data->func, 0x01, REG_PC_RRT, NULL);
188 		}
189 	}
190 }
191 
192 static int btsdio_open(struct hci_dev *hdev)
193 {
194 	struct btsdio_data *data = hci_get_drvdata(hdev);
195 	int err;
196 
197 	BT_DBG("%s", hdev->name);
198 
199 	sdio_claim_host(data->func);
200 
201 	err = sdio_enable_func(data->func);
202 	if (err < 0)
203 		goto release;
204 
205 	err = sdio_claim_irq(data->func, btsdio_interrupt);
206 	if (err < 0) {
207 		sdio_disable_func(data->func);
208 		goto release;
209 	}
210 
211 	if (data->func->class == SDIO_CLASS_BT_B)
212 		sdio_writeb(data->func, 0x00, REG_MD_SET, NULL);
213 
214 	sdio_writeb(data->func, 0x01, REG_EN_INTRD, NULL);
215 
216 release:
217 	sdio_release_host(data->func);
218 
219 	return err;
220 }
221 
222 static int btsdio_close(struct hci_dev *hdev)
223 {
224 	struct btsdio_data *data = hci_get_drvdata(hdev);
225 
226 	BT_DBG("%s", hdev->name);
227 
228 	sdio_claim_host(data->func);
229 
230 	sdio_writeb(data->func, 0x00, REG_EN_INTRD, NULL);
231 
232 	sdio_release_irq(data->func);
233 	sdio_disable_func(data->func);
234 
235 	sdio_release_host(data->func);
236 
237 	return 0;
238 }
239 
240 static int btsdio_flush(struct hci_dev *hdev)
241 {
242 	struct btsdio_data *data = hci_get_drvdata(hdev);
243 
244 	BT_DBG("%s", hdev->name);
245 
246 	skb_queue_purge(&data->txq);
247 
248 	return 0;
249 }
250 
251 static int btsdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
252 {
253 	struct btsdio_data *data = hci_get_drvdata(hdev);
254 
255 	BT_DBG("%s", hdev->name);
256 
257 	switch (hci_skb_pkt_type(skb)) {
258 	case HCI_COMMAND_PKT:
259 		hdev->stat.cmd_tx++;
260 		break;
261 
262 	case HCI_ACLDATA_PKT:
263 		hdev->stat.acl_tx++;
264 		break;
265 
266 	case HCI_SCODATA_PKT:
267 		hdev->stat.sco_tx++;
268 		break;
269 
270 	default:
271 		return -EILSEQ;
272 	}
273 
274 	skb_queue_tail(&data->txq, skb);
275 
276 	schedule_work(&data->work);
277 
278 	return 0;
279 }
280 
281 static int btsdio_probe(struct sdio_func *func,
282 				const struct sdio_device_id *id)
283 {
284 	struct btsdio_data *data;
285 	struct hci_dev *hdev;
286 	struct sdio_func_tuple *tuple = func->tuples;
287 	int err;
288 
289 	BT_DBG("func %p id %p class 0x%04x", func, id, func->class);
290 
291 	while (tuple) {
292 		BT_DBG("code 0x%x size %d", tuple->code, tuple->size);
293 		tuple = tuple->next;
294 	}
295 
296 	/* BCM43341 devices soldered onto the PCB (non-removable) use an
297 	 * uart connection for bluetooth, ignore the BT SDIO interface.
298 	 */
299 	if (func->vendor == SDIO_VENDOR_ID_BROADCOM &&
300 	    func->device == SDIO_DEVICE_ID_BROADCOM_43341 &&
301 	    !mmc_card_is_removable(func->card->host))
302 		return -ENODEV;
303 
304 	data = devm_kzalloc(&func->dev, sizeof(*data), GFP_KERNEL);
305 	if (!data)
306 		return -ENOMEM;
307 
308 	data->func = func;
309 
310 	INIT_WORK(&data->work, btsdio_work);
311 
312 	skb_queue_head_init(&data->txq);
313 
314 	hdev = hci_alloc_dev();
315 	if (!hdev)
316 		return -ENOMEM;
317 
318 	hdev->bus = HCI_SDIO;
319 	hci_set_drvdata(hdev, data);
320 
321 	if (id->class == SDIO_CLASS_BT_AMP)
322 		hdev->dev_type = HCI_AMP;
323 	else
324 		hdev->dev_type = HCI_PRIMARY;
325 
326 	data->hdev = hdev;
327 
328 	SET_HCIDEV_DEV(hdev, &func->dev);
329 
330 	hdev->open     = btsdio_open;
331 	hdev->close    = btsdio_close;
332 	hdev->flush    = btsdio_flush;
333 	hdev->send     = btsdio_send_frame;
334 
335 	if (func->vendor == 0x0104 && func->device == 0x00c5)
336 		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
337 
338 	err = hci_register_dev(hdev);
339 	if (err < 0) {
340 		hci_free_dev(hdev);
341 		return err;
342 	}
343 
344 	sdio_set_drvdata(func, data);
345 
346 	return 0;
347 }
348 
349 static void btsdio_remove(struct sdio_func *func)
350 {
351 	struct btsdio_data *data = sdio_get_drvdata(func);
352 	struct hci_dev *hdev;
353 
354 	BT_DBG("func %p", func);
355 
356 	if (!data)
357 		return;
358 
359 	hdev = data->hdev;
360 
361 	sdio_set_drvdata(func, NULL);
362 
363 	hci_unregister_dev(hdev);
364 
365 	hci_free_dev(hdev);
366 }
367 
368 static struct sdio_driver btsdio_driver = {
369 	.name		= "btsdio",
370 	.probe		= btsdio_probe,
371 	.remove		= btsdio_remove,
372 	.id_table	= btsdio_table,
373 };
374 
375 static int __init btsdio_init(void)
376 {
377 	BT_INFO("Generic Bluetooth SDIO driver ver %s", VERSION);
378 
379 	return sdio_register_driver(&btsdio_driver);
380 }
381 
382 static void __exit btsdio_exit(void)
383 {
384 	sdio_unregister_driver(&btsdio_driver);
385 }
386 
387 module_init(btsdio_init);
388 module_exit(btsdio_exit);
389 
390 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
391 MODULE_DESCRIPTION("Generic Bluetooth SDIO driver ver " VERSION);
392 MODULE_VERSION(VERSION);
393 MODULE_LICENSE("GPL");
394