1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#define pr_fmt(fmt) "(stk) :" fmt
24#include <linux/platform_device.h>
25#include <linux/jiffies.h>
26#include <linux/firmware.h>
27#include <linux/delay.h>
28#include <linux/wait.h>
29#include <linux/gpio.h>
30#include <linux/debugfs.h>
31#include <linux/seq_file.h>
32#include <linux/sched.h>
33#include <linux/rfkill.h>
34
35
36#include <net/bluetooth/bluetooth.h>
37#include <net/bluetooth/hci_core.h>
38#include <net/bluetooth/hci.h>
39
40#include <linux/ti_wilink_st.h>
41
42
43static int kim_probe(struct platform_device *pdev);
44static int kim_remove(struct platform_device *pdev);
45
46
47static struct platform_driver kim_platform_driver = {
48 .probe = kim_probe,
49 .remove = kim_remove,
50
51
52#if 0
53 .suspend = kim_suspend,
54 .resume = kim_resume,
55#endif
56 .driver = {
57 .name = "kim",
58 .owner = THIS_MODULE,
59 },
60};
61
62static int kim_toggle_radio(void*, bool);
63static const struct rfkill_ops kim_rfkill_ops = {
64 .set_block = kim_toggle_radio,
65};
66
67
68
69
70#define PROTO_ENTRY(type, name) name
71const unsigned char *protocol_names[] = {
72 PROTO_ENTRY(ST_BT, "Bluetooth"),
73 PROTO_ENTRY(ST_FM, "FM"),
74 PROTO_ENTRY(ST_GPS, "GPS"),
75};
76
77#define MAX_ST_DEVICES 3
78static struct platform_device *st_kim_devices[MAX_ST_DEVICES];
79
80
81
82
83
84
85
86
87
88
89
90
91static struct platform_device *st_get_plat_device(int id)
92{
93 return st_kim_devices[id];
94}
95
96
97
98
99
100
101
102void validate_firmware_response(struct kim_data_s *kim_gdata)
103{
104 struct sk_buff *skb = kim_gdata->rx_skb;
105 if (unlikely(skb->data[5] != 0)) {
106 pr_err("no proper response during fw download");
107 pr_err("data6 %x", skb->data[5]);
108 return;
109 }
110
111 complete_all(&kim_gdata->kim_rcvd);
112 kfree_skb(skb);
113}
114
115
116
117
118static inline int kim_check_data_len(struct kim_data_s *kim_gdata, int len)
119{
120 register int room = skb_tailroom(kim_gdata->rx_skb);
121
122 pr_debug("len %d room %d", len, room);
123
124 if (!len) {
125 validate_firmware_response(kim_gdata);
126 } else if (len > room) {
127
128
129
130 pr_err("Data length is too large len %d room %d", len,
131 room);
132 kfree_skb(kim_gdata->rx_skb);
133 } else {
134
135
136
137 kim_gdata->rx_state = ST_BT_W4_DATA;
138 kim_gdata->rx_count = len;
139 return len;
140 }
141
142
143
144 kim_gdata->rx_state = ST_W4_PACKET_TYPE;
145 kim_gdata->rx_skb = NULL;
146 kim_gdata->rx_count = 0;
147
148 return 0;
149}
150
151
152
153
154
155
156
157void kim_int_recv(struct kim_data_s *kim_gdata,
158 const unsigned char *data, long count)
159{
160 const unsigned char *ptr;
161 struct hci_event_hdr *eh;
162 int len = 0, type = 0;
163
164 pr_debug("%s", __func__);
165
166 ptr = data;
167 if (unlikely(ptr == NULL)) {
168 pr_err(" received null from TTY ");
169 return;
170 }
171
172 while (count) {
173 if (kim_gdata->rx_count) {
174 len = min_t(unsigned int, kim_gdata->rx_count, count);
175 memcpy(skb_put(kim_gdata->rx_skb, len), ptr, len);
176 kim_gdata->rx_count -= len;
177 count -= len;
178 ptr += len;
179
180 if (kim_gdata->rx_count)
181 continue;
182
183
184 switch (kim_gdata->rx_state) {
185
186 case ST_BT_W4_DATA:
187 pr_debug("Complete pkt received");
188 validate_firmware_response(kim_gdata);
189 kim_gdata->rx_state = ST_W4_PACKET_TYPE;
190 kim_gdata->rx_skb = NULL;
191 continue;
192
193 case ST_BT_W4_EVENT_HDR:
194 eh = (struct hci_event_hdr *)kim_gdata->
195 rx_skb->data;
196 pr_debug("Event header: evt 0x%2.2x"
197 "plen %d", eh->evt, eh->plen);
198 kim_check_data_len(kim_gdata, eh->plen);
199 continue;
200 }
201 }
202 switch (*ptr) {
203
204 case HCI_EVENT_PKT:
205 pr_info("Event packet");
206 kim_gdata->rx_state = ST_BT_W4_EVENT_HDR;
207 kim_gdata->rx_count = HCI_EVENT_HDR_SIZE;
208 type = HCI_EVENT_PKT;
209 break;
210 default:
211 pr_info("unknown packet");
212 ptr++;
213 count--;
214 continue;
215 }
216 ptr++;
217 count--;
218 kim_gdata->rx_skb =
219 bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
220 if (!kim_gdata->rx_skb) {
221 pr_err("can't allocate mem for new packet");
222 kim_gdata->rx_state = ST_W4_PACKET_TYPE;
223 kim_gdata->rx_count = 0;
224 return;
225 }
226 bt_cb(kim_gdata->rx_skb)->pkt_type = type;
227 }
228 pr_info("done %s", __func__);
229 return;
230}
231
232static long read_local_version(struct kim_data_s *kim_gdata, char *bts_scr_name)
233{
234 unsigned short version = 0, chip = 0, min_ver = 0, maj_ver = 0;
235 const char read_ver_cmd[] = { 0x01, 0x01, 0x10, 0x00 };
236
237 pr_debug("%s", __func__);
238
239 INIT_COMPLETION(kim_gdata->kim_rcvd);
240 if (4 != st_int_write(kim_gdata->core_data, read_ver_cmd, 4)) {
241 pr_err("kim: couldn't write 4 bytes");
242 return -1;
243 }
244
245 if (!wait_for_completion_timeout
246 (&kim_gdata->kim_rcvd, msecs_to_jiffies(CMD_RESP_TIME))) {
247 pr_err(" waiting for ver info- timed out ");
248 return -1;
249 }
250
251 version =
252 MAKEWORD(kim_gdata->resp_buffer[13],
253 kim_gdata->resp_buffer[14]);
254 chip = (version & 0x7C00) >> 10;
255 min_ver = (version & 0x007F);
256 maj_ver = (version & 0x0380) >> 7;
257
258 if (version & 0x8000)
259 maj_ver |= 0x0008;
260
261 sprintf(bts_scr_name, "TIInit_%d.%d.%d.bts", chip, maj_ver, min_ver);
262
263
264 kim_gdata->version.full = version;
265 kim_gdata->version.chip = chip;
266 kim_gdata->version.maj_ver = maj_ver;
267 kim_gdata->version.min_ver = min_ver;
268
269 pr_info("%s", bts_scr_name);
270 return 0;
271}
272
273
274
275
276
277
278static long download_firmware(struct kim_data_s *kim_gdata)
279{
280 long err = 0;
281 long len = 0;
282 unsigned char *ptr = NULL;
283 unsigned char *action_ptr = NULL;
284 unsigned char bts_scr_name[30] = { 0 };
285
286 err = read_local_version(kim_gdata, bts_scr_name);
287 if (err != 0) {
288 pr_err("kim: failed to read local ver");
289 return err;
290 }
291 err =
292 request_firmware(&kim_gdata->fw_entry, bts_scr_name,
293 &kim_gdata->kim_pdev->dev);
294 if (unlikely((err != 0) || (kim_gdata->fw_entry->data == NULL) ||
295 (kim_gdata->fw_entry->size == 0))) {
296 pr_err(" request_firmware failed(errno %ld) for %s", err,
297 bts_scr_name);
298 return -1;
299 }
300 ptr = (void *)kim_gdata->fw_entry->data;
301 len = kim_gdata->fw_entry->size;
302
303
304
305 ptr += sizeof(struct bts_header);
306 len -= sizeof(struct bts_header);
307
308 while (len > 0 && ptr) {
309 pr_debug(" action size %d, type %d ",
310 ((struct bts_action *)ptr)->size,
311 ((struct bts_action *)ptr)->type);
312
313 switch (((struct bts_action *)ptr)->type) {
314 case ACTION_SEND_COMMAND:
315 action_ptr = &(((struct bts_action *)ptr)->data[0]);
316 if (unlikely
317 (((struct hci_command *)action_ptr)->opcode ==
318 0xFF36)) {
319
320
321 pr_err
322 (" change remote baud"
323 " rate command in firmware");
324 break;
325 }
326
327 INIT_COMPLETION(kim_gdata->kim_rcvd);
328 err = st_int_write(kim_gdata->core_data,
329 ((struct bts_action_send *)action_ptr)->data,
330 ((struct bts_action *)ptr)->size);
331 if (unlikely(err < 0)) {
332 release_firmware(kim_gdata->fw_entry);
333 return -1;
334 }
335 if (!wait_for_completion_timeout
336 (&kim_gdata->kim_rcvd,
337 msecs_to_jiffies(CMD_RESP_TIME))) {
338 pr_err
339 (" response timeout during fw download ");
340
341 release_firmware(kim_gdata->fw_entry);
342 return -1;
343 }
344 break;
345 case ACTION_DELAY:
346 pr_info("sleep command in scr");
347 action_ptr = &(((struct bts_action *)ptr)->data[0]);
348 mdelay(((struct bts_action_delay *)action_ptr)->msec);
349 break;
350 }
351 len =
352 len - (sizeof(struct bts_action) +
353 ((struct bts_action *)ptr)->size);
354 ptr =
355 ptr + sizeof(struct bts_action) +
356 ((struct bts_action *)ptr)->size;
357 }
358
359 release_firmware(kim_gdata->fw_entry);
360 return 0;
361}
362
363
364
365
366
367
368void st_kim_chip_toggle(enum proto_type type, enum kim_gpio_state state)
369{
370 struct platform_device *kim_pdev;
371 struct kim_data_s *kim_gdata;
372 pr_info(" %s ", __func__);
373
374 kim_pdev = st_get_plat_device(0);
375 kim_gdata = dev_get_drvdata(&kim_pdev->dev);
376
377 if (kim_gdata->gpios[type] == -1) {
378 pr_info(" gpio not requested for protocol %s",
379 protocol_names[type]);
380 return;
381 }
382 switch (type) {
383 case ST_BT:
384
385 break;
386
387 case ST_FM:
388 if (state == KIM_GPIO_ACTIVE)
389 gpio_set_value(kim_gdata->gpios[ST_FM], GPIO_LOW);
390 else
391 gpio_set_value(kim_gdata->gpios[ST_FM], GPIO_HIGH);
392 break;
393
394 case ST_GPS:
395 if (state == KIM_GPIO_ACTIVE)
396 gpio_set_value(kim_gdata->gpios[ST_GPS], GPIO_HIGH);
397 else
398 gpio_set_value(kim_gdata->gpios[ST_GPS], GPIO_LOW);
399 break;
400
401 case ST_MAX:
402 default:
403 break;
404 }
405
406 return;
407}
408
409
410
411
412
413
414void st_kim_recv(void *disc_data, const unsigned char *data, long count)
415{
416 struct st_data_s *st_gdata = (struct st_data_s *)disc_data;
417 struct kim_data_s *kim_gdata = st_gdata->kim_data;
418
419 pr_info(" %s ", __func__);
420
421 if (unlikely(data[4] == 0x01 && data[5] == 0x10 && data[0] == 0x04)) {
422
423 memcpy(kim_gdata->resp_buffer, data, count);
424 complete_all(&kim_gdata->kim_rcvd);
425 return;
426 } else {
427 kim_int_recv(kim_gdata, data, count);
428
429 }
430 return;
431}
432
433
434
435
436void st_kim_complete(void *kim_data)
437{
438 struct kim_data_s *kim_gdata = (struct kim_data_s *)kim_data;
439 complete(&kim_gdata->ldisc_installed);
440}
441
442
443
444
445
446
447
448
449long st_kim_start(void *kim_data)
450{
451 long err = 0;
452 long retry = POR_RETRY_COUNT;
453 struct kim_data_s *kim_gdata = (struct kim_data_s *)kim_data;
454
455 pr_info(" %s", __func__);
456
457 do {
458
459
460
461
462 rfkill_set_hw_state(kim_gdata->rfkill[ST_BT], 1);
463
464 gpio_set_value(kim_gdata->gpios[ST_BT], GPIO_LOW);
465 mdelay(5);
466 gpio_set_value(kim_gdata->gpios[ST_BT], GPIO_HIGH);
467 mdelay(100);
468
469 INIT_COMPLETION(kim_gdata->ldisc_installed);
470#if 0
471
472 err = kill_pid(find_get_pid(kim_gdata->uim_pid), SIGUSR2, 0);
473 if (err != 0) {
474 pr_info(" sending SIGUSR2 to uim failed %ld", err);
475 err = -1;
476 continue;
477 }
478#endif
479
480 rfkill_set_hw_state(kim_gdata->rfkill[ST_BT], 0);
481
482 err = wait_for_completion_timeout(&kim_gdata->ldisc_installed,
483 msecs_to_jiffies(LDISC_TIME));
484 if (!err) {
485 pr_err("line disc installation timed out ");
486 err = -1;
487 continue;
488 } else {
489
490 pr_info(" line discipline installed ");
491 err = download_firmware(kim_gdata);
492 if (err != 0) {
493 pr_err("download firmware failed");
494 continue;
495 } else {
496 break;
497 }
498 }
499 } while (retry--);
500 return err;
501}
502
503
504
505
506
507long st_kim_stop(void *kim_data)
508{
509 long err = 0;
510 struct kim_data_s *kim_gdata = (struct kim_data_s *)kim_data;
511
512 INIT_COMPLETION(kim_gdata->ldisc_installed);
513#if 0
514
515 err = kill_pid(find_get_pid(kim_gdata->uim_pid), SIGUSR2, 1);
516 if (err != 0) {
517 pr_err("sending SIGUSR2 to uim failed %ld", err);
518 return -1;
519 }
520#endif
521
522 err = rfkill_set_hw_state(kim_gdata->rfkill[ST_BT], 1);
523
524
525 err = wait_for_completion_timeout(&kim_gdata->ldisc_installed,
526 msecs_to_jiffies(LDISC_TIME));
527 if (!err) {
528 pr_err(" timed out waiting for ldisc to be un-installed");
529 return -1;
530 }
531
532
533 gpio_set_value(kim_gdata->gpios[ST_BT], GPIO_LOW);
534 mdelay(1);
535 gpio_set_value(kim_gdata->gpios[ST_BT], GPIO_HIGH);
536 mdelay(1);
537 gpio_set_value(kim_gdata->gpios[ST_BT], GPIO_LOW);
538 return err;
539}
540
541
542
543
544
545static int show_version(struct seq_file *s, void *unused)
546{
547 struct kim_data_s *kim_gdata = (struct kim_data_s *)s->private;
548 seq_printf(s, "%04X %d.%d.%d\n", kim_gdata->version.full,
549 kim_gdata->version.chip, kim_gdata->version.maj_ver,
550 kim_gdata->version.min_ver);
551 return 0;
552}
553
554static int show_list(struct seq_file *s, void *unused)
555{
556 struct kim_data_s *kim_gdata = (struct kim_data_s *)s->private;
557 kim_st_list_protocols(kim_gdata->core_data, s);
558 return 0;
559}
560
561
562
563
564
565static int kim_toggle_radio(void *data, bool blocked)
566{
567 enum proto_type type = *((enum proto_type *)data);
568 pr_debug(" %s: %d ", __func__, type);
569
570 switch (type) {
571 case ST_BT:
572
573 break;
574 case ST_FM:
575 case ST_GPS:
576 if (blocked)
577 st_kim_chip_toggle(type, KIM_GPIO_INACTIVE);
578 else
579 st_kim_chip_toggle(type, KIM_GPIO_ACTIVE);
580 break;
581 case ST_MAX:
582 pr_err(" wrong proto type ");
583 break;
584 }
585 return 0;
586}
587
588
589
590
591
592
593
594
595void st_kim_ref(struct st_data_s **core_data, int id)
596{
597 struct platform_device *pdev;
598 struct kim_data_s *kim_gdata;
599
600 pdev = st_get_plat_device(id);
601 kim_gdata = dev_get_drvdata(&pdev->dev);
602 *core_data = kim_gdata->core_data;
603}
604
605static int kim_version_open(struct inode *i, struct file *f)
606{
607 return single_open(f, show_version, i->i_private);
608}
609
610static int kim_list_open(struct inode *i, struct file *f)
611{
612 return single_open(f, show_list, i->i_private);
613}
614
615static const struct file_operations version_debugfs_fops = {
616
617 .open = kim_version_open,
618 .read = seq_read,
619 .llseek = seq_lseek,
620 .release = single_release,
621};
622static const struct file_operations list_debugfs_fops = {
623
624 .open = kim_list_open,
625 .read = seq_read,
626 .llseek = seq_lseek,
627 .release = single_release,
628};
629
630
631
632
633
634
635
636struct dentry *kim_debugfs_dir;
637static int kim_probe(struct platform_device *pdev)
638{
639 long status;
640 long proto;
641 long *gpios = pdev->dev.platform_data;
642 struct kim_data_s *kim_gdata;
643
644 if ((pdev->id != -1) && (pdev->id < MAX_ST_DEVICES)) {
645
646 st_kim_devices[pdev->id] = pdev;
647 } else {
648
649 st_kim_devices[0] = pdev;
650 }
651
652 kim_gdata = kzalloc(sizeof(struct kim_data_s), GFP_ATOMIC);
653 if (!kim_gdata) {
654 pr_err("no mem to allocate");
655 return -ENOMEM;
656 }
657 dev_set_drvdata(&pdev->dev, kim_gdata);
658
659 status = st_core_init(&kim_gdata->core_data);
660 if (status != 0) {
661 pr_err(" ST core init failed");
662 return -1;
663 }
664
665 kim_gdata->core_data->kim_data = kim_gdata;
666
667 for (proto = 0; proto < ST_MAX; proto++) {
668 kim_gdata->gpios[proto] = gpios[proto];
669 pr_info(" %ld gpio to be requested", gpios[proto]);
670 }
671
672 for (proto = 0; (proto < ST_MAX) && (gpios[proto] != -1); proto++) {
673
674
675
676 status = gpio_request(gpios[proto], "kim");
677 if (unlikely(status)) {
678 pr_err(" gpio %ld request failed ", gpios[proto]);
679 proto -= 1;
680 while (proto >= 0) {
681 if (gpios[proto] != -1)
682 gpio_free(gpios[proto]);
683 }
684 return status;
685 }
686
687
688 status =
689 gpio_direction_output(gpios[proto], 0);
690 if (unlikely(status)) {
691 pr_err(" unable to configure gpio %ld",
692 gpios[proto]);
693 proto -= 1;
694 while (proto >= 0) {
695 if (gpios[proto] != -1)
696 gpio_free(gpios[proto]);
697 }
698 return status;
699 }
700 }
701
702
703 kim_gdata->kim_pdev = pdev;
704 init_completion(&kim_gdata->kim_rcvd);
705 init_completion(&kim_gdata->ldisc_installed);
706
707 for (proto = 0; (proto < ST_MAX) && (gpios[proto] != -1); proto++) {
708
709 kim_gdata->rf_protos[proto] = proto;
710 kim_gdata->rfkill[proto] = rfkill_alloc(protocol_names[proto],
711 &pdev->dev, RFKILL_TYPE_BLUETOOTH,
712 &kim_rfkill_ops, &kim_gdata->rf_protos[proto]);
713 if (kim_gdata->rfkill[proto] == NULL) {
714 pr_err("cannot create rfkill entry for gpio %ld",
715 gpios[proto]);
716 continue;
717 }
718
719 rfkill_init_sw_state(kim_gdata->rfkill[proto], 1);
720 status = rfkill_register(kim_gdata->rfkill[proto]);
721 if (unlikely(status)) {
722 pr_err("rfkill registration failed for gpio %ld",
723 gpios[proto]);
724 rfkill_unregister(kim_gdata->rfkill[proto]);
725 continue;
726 }
727 pr_info("rfkill entry created for %ld", gpios[proto]);
728 }
729
730 kim_debugfs_dir = debugfs_create_dir("ti-st", NULL);
731 if (IS_ERR(kim_debugfs_dir)) {
732 pr_err(" debugfs entries creation failed ");
733 kim_debugfs_dir = NULL;
734 return -1;
735 }
736
737 debugfs_create_file("version", S_IRUGO, kim_debugfs_dir,
738 kim_gdata, &version_debugfs_fops);
739 debugfs_create_file("protocols", S_IRUGO, kim_debugfs_dir,
740 kim_gdata, &list_debugfs_fops);
741 pr_info(" debugfs entries created ");
742 return 0;
743}
744
745static int kim_remove(struct platform_device *pdev)
746{
747
748
749 long *gpios = pdev->dev.platform_data;
750 long proto;
751 struct kim_data_s *kim_gdata;
752
753 kim_gdata = dev_get_drvdata(&pdev->dev);
754
755 for (proto = 0; (proto < ST_MAX) && (gpios[proto] != -1); proto++) {
756
757
758
759 gpio_free(gpios[proto]);
760 rfkill_unregister(kim_gdata->rfkill[proto]);
761 rfkill_destroy(kim_gdata->rfkill[proto]);
762 kim_gdata->rfkill[proto] = NULL;
763 }
764 pr_info("kim: GPIO Freed");
765 debugfs_remove_recursive(kim_debugfs_dir);
766 kim_gdata->kim_pdev = NULL;
767 st_core_exit(kim_gdata->core_data);
768
769 kfree(kim_gdata);
770 kim_gdata = NULL;
771 return 0;
772}
773
774
775
776
777static int __init st_kim_init(void)
778{
779 long ret = 0;
780 ret = platform_driver_register(&kim_platform_driver);
781 if (ret != 0) {
782 pr_err("platform drv registration failed");
783 return -1;
784 }
785 return 0;
786}
787
788static void __exit st_kim_deinit(void)
789{
790
791 platform_driver_unregister(&kim_platform_driver);
792}
793
794
795module_init(st_kim_init);
796module_exit(st_kim_deinit);
797MODULE_AUTHOR("Pavan Savoy <pavan_savoy@ti.com>");
798MODULE_DESCRIPTION("Shared Transport Driver for TI BT/FM/GPS combo chips ");
799MODULE_LICENSE("GPL");
800