1 /* 2 * Shared Transport Line discipline driver Core 3 * Init Manager module responsible for GPIO control 4 * and firmware download 5 * Copyright (C) 2009-2010 Texas Instruments 6 * Author: Pavan Savoy <pavan_savoy@ti.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 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/sysfs.h> 34 #include <linux/tty.h> 35 36 #include <linux/skbuff.h> 37 #include <linux/ti_wilink_st.h> 38 #include <linux/module.h> 39 40 41 #define MAX_ST_DEVICES 3 /* Imagine 1 on each UART for now */ 42 static struct platform_device *st_kim_devices[MAX_ST_DEVICES]; 43 44 /**********************************************************************/ 45 /* internal functions */ 46 47 /** 48 * st_get_plat_device - 49 * function which returns the reference to the platform device 50 * requested by id. As of now only 1 such device exists (id=0) 51 * the context requesting for reference can get the id to be 52 * requested by a. The protocol driver which is registering or 53 * b. the tty device which is opened. 54 */ 55 static struct platform_device *st_get_plat_device(int id) 56 { 57 return st_kim_devices[id]; 58 } 59 60 /** 61 * validate_firmware_response - 62 * function to return whether the firmware response was proper 63 * in case of error don't complete so that waiting for proper 64 * response times out 65 */ 66 static void validate_firmware_response(struct kim_data_s *kim_gdata) 67 { 68 struct sk_buff *skb = kim_gdata->rx_skb; 69 if (!skb) 70 return; 71 72 /* these magic numbers are the position in the response buffer which 73 * allows us to distinguish whether the response is for the read 74 * version info. command 75 */ 76 if (skb->data[2] == 0x01 && skb->data[3] == 0x01 && 77 skb->data[4] == 0x10 && skb->data[5] == 0x00) { 78 /* fw version response */ 79 memcpy(kim_gdata->resp_buffer, 80 kim_gdata->rx_skb->data, 81 kim_gdata->rx_skb->len); 82 complete_all(&kim_gdata->kim_rcvd); 83 kim_gdata->rx_state = ST_W4_PACKET_TYPE; 84 kim_gdata->rx_skb = NULL; 85 kim_gdata->rx_count = 0; 86 } else if (unlikely(skb->data[5] != 0)) { 87 pr_err("no proper response during fw download"); 88 pr_err("data6 %x", skb->data[5]); 89 kfree_skb(skb); 90 return; /* keep waiting for the proper response */ 91 } 92 /* becos of all the script being downloaded */ 93 complete_all(&kim_gdata->kim_rcvd); 94 kfree_skb(skb); 95 } 96 97 /* check for data len received inside kim_int_recv 98 * most often hit the last case to update state to waiting for data 99 */ 100 static inline int kim_check_data_len(struct kim_data_s *kim_gdata, int len) 101 { 102 register int room = skb_tailroom(kim_gdata->rx_skb); 103 104 pr_debug("len %d room %d", len, room); 105 106 if (!len) { 107 validate_firmware_response(kim_gdata); 108 } else if (len > room) { 109 /* Received packet's payload length is larger. 110 * We can't accommodate it in created skb. 111 */ 112 pr_err("Data length is too large len %d room %d", len, 113 room); 114 kfree_skb(kim_gdata->rx_skb); 115 } else { 116 /* Packet header has non-zero payload length and 117 * we have enough space in created skb. Lets read 118 * payload data */ 119 kim_gdata->rx_state = ST_W4_DATA; 120 kim_gdata->rx_count = len; 121 return len; 122 } 123 124 /* Change ST LL state to continue to process next 125 * packet */ 126 kim_gdata->rx_state = ST_W4_PACKET_TYPE; 127 kim_gdata->rx_skb = NULL; 128 kim_gdata->rx_count = 0; 129 130 return 0; 131 } 132 133 /** 134 * kim_int_recv - receive function called during firmware download 135 * firmware download responses on different UART drivers 136 * have been observed to come in bursts of different 137 * tty_receive and hence the logic 138 */ 139 static void kim_int_recv(struct kim_data_s *kim_gdata, 140 const unsigned char *data, long count) 141 { 142 const unsigned char *ptr; 143 int len = 0, type = 0; 144 unsigned char *plen; 145 146 pr_debug("%s", __func__); 147 /* Decode received bytes here */ 148 ptr = data; 149 if (unlikely(ptr == NULL)) { 150 pr_err(" received null from TTY "); 151 return; 152 } 153 154 while (count) { 155 if (kim_gdata->rx_count) { 156 len = min_t(unsigned int, kim_gdata->rx_count, count); 157 memcpy(skb_put(kim_gdata->rx_skb, len), ptr, len); 158 kim_gdata->rx_count -= len; 159 count -= len; 160 ptr += len; 161 162 if (kim_gdata->rx_count) 163 continue; 164 165 /* Check ST RX state machine , where are we? */ 166 switch (kim_gdata->rx_state) { 167 /* Waiting for complete packet ? */ 168 case ST_W4_DATA: 169 pr_debug("Complete pkt received"); 170 validate_firmware_response(kim_gdata); 171 kim_gdata->rx_state = ST_W4_PACKET_TYPE; 172 kim_gdata->rx_skb = NULL; 173 continue; 174 /* Waiting for Bluetooth event header ? */ 175 case ST_W4_HEADER: 176 plen = 177 (unsigned char *)&kim_gdata->rx_skb->data[1]; 178 pr_debug("event hdr: plen 0x%02x\n", *plen); 179 kim_check_data_len(kim_gdata, *plen); 180 continue; 181 } /* end of switch */ 182 } /* end of if rx_state */ 183 switch (*ptr) { 184 /* Bluetooth event packet? */ 185 case 0x04: 186 kim_gdata->rx_state = ST_W4_HEADER; 187 kim_gdata->rx_count = 2; 188 type = *ptr; 189 break; 190 default: 191 pr_info("unknown packet"); 192 ptr++; 193 count--; 194 continue; 195 } 196 ptr++; 197 count--; 198 kim_gdata->rx_skb = 199 alloc_skb(1024+8, GFP_ATOMIC); 200 if (!kim_gdata->rx_skb) { 201 pr_err("can't allocate mem for new packet"); 202 kim_gdata->rx_state = ST_W4_PACKET_TYPE; 203 kim_gdata->rx_count = 0; 204 return; 205 } 206 skb_reserve(kim_gdata->rx_skb, 8); 207 kim_gdata->rx_skb->cb[0] = 4; 208 kim_gdata->rx_skb->cb[1] = 0; 209 210 } 211 return; 212 } 213 214 static long read_local_version(struct kim_data_s *kim_gdata, char *bts_scr_name) 215 { 216 unsigned short version = 0, chip = 0, min_ver = 0, maj_ver = 0; 217 const char read_ver_cmd[] = { 0x01, 0x01, 0x10, 0x00 }; 218 219 pr_debug("%s", __func__); 220 221 reinit_completion(&kim_gdata->kim_rcvd); 222 if (4 != st_int_write(kim_gdata->core_data, read_ver_cmd, 4)) { 223 pr_err("kim: couldn't write 4 bytes"); 224 return -EIO; 225 } 226 227 if (!wait_for_completion_interruptible_timeout( 228 &kim_gdata->kim_rcvd, msecs_to_jiffies(CMD_RESP_TIME))) { 229 pr_err(" waiting for ver info- timed out "); 230 return -ETIMEDOUT; 231 } 232 reinit_completion(&kim_gdata->kim_rcvd); 233 /* the positions 12 & 13 in the response buffer provide with the 234 * chip, major & minor numbers 235 */ 236 237 version = 238 MAKEWORD(kim_gdata->resp_buffer[12], 239 kim_gdata->resp_buffer[13]); 240 chip = (version & 0x7C00) >> 10; 241 min_ver = (version & 0x007F); 242 maj_ver = (version & 0x0380) >> 7; 243 244 if (version & 0x8000) 245 maj_ver |= 0x0008; 246 247 sprintf(bts_scr_name, "TIInit_%d.%d.%d.bts", chip, maj_ver, min_ver); 248 249 /* to be accessed later via sysfs entry */ 250 kim_gdata->version.full = version; 251 kim_gdata->version.chip = chip; 252 kim_gdata->version.maj_ver = maj_ver; 253 kim_gdata->version.min_ver = min_ver; 254 255 pr_info("%s", bts_scr_name); 256 return 0; 257 } 258 259 static void skip_change_remote_baud(unsigned char **ptr, long *len) 260 { 261 unsigned char *nxt_action, *cur_action; 262 cur_action = *ptr; 263 264 nxt_action = cur_action + sizeof(struct bts_action) + 265 ((struct bts_action *) cur_action)->size; 266 267 if (((struct bts_action *) nxt_action)->type != ACTION_WAIT_EVENT) { 268 pr_err("invalid action after change remote baud command"); 269 } else { 270 *ptr = *ptr + sizeof(struct bts_action) + 271 ((struct bts_action *)cur_action)->size; 272 *len = *len - (sizeof(struct bts_action) + 273 ((struct bts_action *)cur_action)->size); 274 /* warn user on not commenting these in firmware */ 275 pr_warn("skipping the wait event of change remote baud"); 276 } 277 } 278 279 /** 280 * download_firmware - 281 * internal function which parses through the .bts firmware 282 * script file intreprets SEND, DELAY actions only as of now 283 */ 284 static long download_firmware(struct kim_data_s *kim_gdata) 285 { 286 long err = 0; 287 long len = 0; 288 unsigned char *ptr = NULL; 289 unsigned char *action_ptr = NULL; 290 unsigned char bts_scr_name[30] = { 0 }; /* 30 char long bts scr name? */ 291 int wr_room_space; 292 int cmd_size; 293 unsigned long timeout; 294 295 err = read_local_version(kim_gdata, bts_scr_name); 296 if (err != 0) { 297 pr_err("kim: failed to read local ver"); 298 return err; 299 } 300 err = 301 request_firmware(&kim_gdata->fw_entry, bts_scr_name, 302 &kim_gdata->kim_pdev->dev); 303 if (unlikely((err != 0) || (kim_gdata->fw_entry->data == NULL) || 304 (kim_gdata->fw_entry->size == 0))) { 305 pr_err(" request_firmware failed(errno %ld) for %s", err, 306 bts_scr_name); 307 return -EINVAL; 308 } 309 ptr = (void *)kim_gdata->fw_entry->data; 310 len = kim_gdata->fw_entry->size; 311 /* bts_header to remove out magic number and 312 * version 313 */ 314 ptr += sizeof(struct bts_header); 315 len -= sizeof(struct bts_header); 316 317 while (len > 0 && ptr) { 318 pr_debug(" action size %d, type %d ", 319 ((struct bts_action *)ptr)->size, 320 ((struct bts_action *)ptr)->type); 321 322 switch (((struct bts_action *)ptr)->type) { 323 case ACTION_SEND_COMMAND: /* action send */ 324 pr_debug("S"); 325 action_ptr = &(((struct bts_action *)ptr)->data[0]); 326 if (unlikely 327 (((struct hci_command *)action_ptr)->opcode == 328 0xFF36)) { 329 /* ignore remote change 330 * baud rate HCI VS command */ 331 pr_warn("change remote baud" 332 " rate command in firmware"); 333 skip_change_remote_baud(&ptr, &len); 334 break; 335 } 336 /* 337 * Make sure we have enough free space in uart 338 * tx buffer to write current firmware command 339 */ 340 cmd_size = ((struct bts_action *)ptr)->size; 341 timeout = jiffies + msecs_to_jiffies(CMD_WR_TIME); 342 do { 343 wr_room_space = 344 st_get_uart_wr_room(kim_gdata->core_data); 345 if (wr_room_space < 0) { 346 pr_err("Unable to get free " 347 "space info from uart tx buffer"); 348 release_firmware(kim_gdata->fw_entry); 349 return wr_room_space; 350 } 351 mdelay(1); /* wait 1ms before checking room */ 352 } while ((wr_room_space < cmd_size) && 353 time_before(jiffies, timeout)); 354 355 /* Timeout happened ? */ 356 if (time_after_eq(jiffies, timeout)) { 357 pr_err("Timeout while waiting for free " 358 "free space in uart tx buffer"); 359 release_firmware(kim_gdata->fw_entry); 360 return -ETIMEDOUT; 361 } 362 /* reinit completion before sending for the 363 * relevant wait 364 */ 365 reinit_completion(&kim_gdata->kim_rcvd); 366 367 /* 368 * Free space found in uart buffer, call st_int_write 369 * to send current firmware command to the uart tx 370 * buffer. 371 */ 372 err = st_int_write(kim_gdata->core_data, 373 ((struct bts_action_send *)action_ptr)->data, 374 ((struct bts_action *)ptr)->size); 375 if (unlikely(err < 0)) { 376 release_firmware(kim_gdata->fw_entry); 377 return err; 378 } 379 /* 380 * Check number of bytes written to the uart tx buffer 381 * and requested command write size 382 */ 383 if (err != cmd_size) { 384 pr_err("Number of bytes written to uart " 385 "tx buffer are not matching with " 386 "requested cmd write size"); 387 release_firmware(kim_gdata->fw_entry); 388 return -EIO; 389 } 390 break; 391 case ACTION_WAIT_EVENT: /* wait */ 392 pr_debug("W"); 393 if (!wait_for_completion_interruptible_timeout( 394 &kim_gdata->kim_rcvd, 395 msecs_to_jiffies(CMD_RESP_TIME))) { 396 pr_err("response timeout during fw download "); 397 /* timed out */ 398 release_firmware(kim_gdata->fw_entry); 399 return -ETIMEDOUT; 400 } 401 reinit_completion(&kim_gdata->kim_rcvd); 402 break; 403 case ACTION_DELAY: /* sleep */ 404 pr_info("sleep command in scr"); 405 action_ptr = &(((struct bts_action *)ptr)->data[0]); 406 mdelay(((struct bts_action_delay *)action_ptr)->msec); 407 break; 408 } 409 len = 410 len - (sizeof(struct bts_action) + 411 ((struct bts_action *)ptr)->size); 412 ptr = 413 ptr + sizeof(struct bts_action) + 414 ((struct bts_action *)ptr)->size; 415 } 416 /* fw download complete */ 417 release_firmware(kim_gdata->fw_entry); 418 return 0; 419 } 420 421 /**********************************************************************/ 422 /* functions called from ST core */ 423 /* called from ST Core, when REG_IN_PROGRESS (registration in progress) 424 * can be because of 425 * 1. response to read local version 426 * 2. during send/recv's of firmware download 427 */ 428 void st_kim_recv(void *disc_data, const unsigned char *data, long count) 429 { 430 struct st_data_s *st_gdata = (struct st_data_s *)disc_data; 431 struct kim_data_s *kim_gdata = st_gdata->kim_data; 432 433 /* proceed to gather all data and distinguish read fw version response 434 * from other fw responses when data gathering is complete 435 */ 436 kim_int_recv(kim_gdata, data, count); 437 return; 438 } 439 440 /* to signal completion of line discipline installation 441 * called from ST Core, upon tty_open 442 */ 443 void st_kim_complete(void *kim_data) 444 { 445 struct kim_data_s *kim_gdata = (struct kim_data_s *)kim_data; 446 complete(&kim_gdata->ldisc_installed); 447 } 448 449 /** 450 * st_kim_start - called from ST Core upon 1st registration 451 * This involves toggling the chip enable gpio, reading 452 * the firmware version from chip, forming the fw file name 453 * based on the chip version, requesting the fw, parsing it 454 * and perform download(send/recv). 455 */ 456 long st_kim_start(void *kim_data) 457 { 458 long err = 0; 459 long retry = POR_RETRY_COUNT; 460 struct ti_st_plat_data *pdata; 461 struct kim_data_s *kim_gdata = (struct kim_data_s *)kim_data; 462 463 pr_info(" %s", __func__); 464 pdata = kim_gdata->kim_pdev->dev.platform_data; 465 466 do { 467 /* platform specific enabling code here */ 468 if (pdata->chip_enable) 469 pdata->chip_enable(kim_gdata); 470 471 /* Configure BT nShutdown to HIGH state */ 472 gpio_set_value(kim_gdata->nshutdown, GPIO_LOW); 473 mdelay(5); /* FIXME: a proper toggle */ 474 gpio_set_value(kim_gdata->nshutdown, GPIO_HIGH); 475 mdelay(100); 476 /* re-initialize the completion */ 477 reinit_completion(&kim_gdata->ldisc_installed); 478 /* send notification to UIM */ 479 kim_gdata->ldisc_install = 1; 480 pr_info("ldisc_install = 1"); 481 sysfs_notify(&kim_gdata->kim_pdev->dev.kobj, 482 NULL, "install"); 483 /* wait for ldisc to be installed */ 484 err = wait_for_completion_interruptible_timeout( 485 &kim_gdata->ldisc_installed, msecs_to_jiffies(LDISC_TIME)); 486 if (!err) { 487 /* ldisc installation timeout, 488 * flush uart, power cycle BT_EN */ 489 pr_err("ldisc installation timeout"); 490 err = st_kim_stop(kim_gdata); 491 continue; 492 } else { 493 /* ldisc installed now */ 494 pr_info("line discipline installed"); 495 err = download_firmware(kim_gdata); 496 if (err != 0) { 497 /* ldisc installed but fw download failed, 498 * flush uart & power cycle BT_EN */ 499 pr_err("download firmware failed"); 500 err = st_kim_stop(kim_gdata); 501 continue; 502 } else { /* on success don't retry */ 503 break; 504 } 505 } 506 } while (retry--); 507 return err; 508 } 509 510 /** 511 * st_kim_stop - stop communication with chip. 512 * This can be called from ST Core/KIM, on the- 513 * (a) last un-register when chip need not be powered there-after, 514 * (b) upon failure to either install ldisc or download firmware. 515 * The function is responsible to (a) notify UIM about un-installation, 516 * (b) flush UART if the ldisc was installed. 517 * (c) reset BT_EN - pull down nshutdown at the end. 518 * (d) invoke platform's chip disabling routine. 519 */ 520 long st_kim_stop(void *kim_data) 521 { 522 long err = 0; 523 struct kim_data_s *kim_gdata = (struct kim_data_s *)kim_data; 524 struct ti_st_plat_data *pdata = 525 kim_gdata->kim_pdev->dev.platform_data; 526 struct tty_struct *tty = kim_gdata->core_data->tty; 527 528 reinit_completion(&kim_gdata->ldisc_installed); 529 530 if (tty) { /* can be called before ldisc is installed */ 531 /* Flush any pending characters in the driver and discipline. */ 532 tty_ldisc_flush(tty); 533 tty_driver_flush_buffer(tty); 534 tty->ops->flush_buffer(tty); 535 } 536 537 /* send uninstall notification to UIM */ 538 pr_info("ldisc_install = 0"); 539 kim_gdata->ldisc_install = 0; 540 sysfs_notify(&kim_gdata->kim_pdev->dev.kobj, NULL, "install"); 541 542 /* wait for ldisc to be un-installed */ 543 err = wait_for_completion_interruptible_timeout( 544 &kim_gdata->ldisc_installed, msecs_to_jiffies(LDISC_TIME)); 545 if (!err) { /* timeout */ 546 pr_err(" timed out waiting for ldisc to be un-installed"); 547 err = -ETIMEDOUT; 548 } 549 550 /* By default configure BT nShutdown to LOW state */ 551 gpio_set_value(kim_gdata->nshutdown, GPIO_LOW); 552 mdelay(1); 553 gpio_set_value(kim_gdata->nshutdown, GPIO_HIGH); 554 mdelay(1); 555 gpio_set_value(kim_gdata->nshutdown, GPIO_LOW); 556 557 /* platform specific disable */ 558 if (pdata->chip_disable) 559 pdata->chip_disable(kim_gdata); 560 return err; 561 } 562 563 /**********************************************************************/ 564 /* functions called from subsystems */ 565 /* called when debugfs entry is read from */ 566 567 static int show_version(struct seq_file *s, void *unused) 568 { 569 struct kim_data_s *kim_gdata = (struct kim_data_s *)s->private; 570 seq_printf(s, "%04X %d.%d.%d\n", kim_gdata->version.full, 571 kim_gdata->version.chip, kim_gdata->version.maj_ver, 572 kim_gdata->version.min_ver); 573 return 0; 574 } 575 576 static int show_list(struct seq_file *s, void *unused) 577 { 578 struct kim_data_s *kim_gdata = (struct kim_data_s *)s->private; 579 kim_st_list_protocols(kim_gdata->core_data, s); 580 return 0; 581 } 582 583 static ssize_t show_install(struct device *dev, 584 struct device_attribute *attr, char *buf) 585 { 586 struct kim_data_s *kim_data = dev_get_drvdata(dev); 587 return sprintf(buf, "%d\n", kim_data->ldisc_install); 588 } 589 590 #ifdef DEBUG 591 static ssize_t store_dev_name(struct device *dev, 592 struct device_attribute *attr, const char *buf, size_t count) 593 { 594 struct kim_data_s *kim_data = dev_get_drvdata(dev); 595 pr_debug("storing dev name >%s<", buf); 596 strncpy(kim_data->dev_name, buf, count); 597 pr_debug("stored dev name >%s<", kim_data->dev_name); 598 return count; 599 } 600 601 static ssize_t store_baud_rate(struct device *dev, 602 struct device_attribute *attr, const char *buf, size_t count) 603 { 604 struct kim_data_s *kim_data = dev_get_drvdata(dev); 605 pr_debug("storing baud rate >%s<", buf); 606 sscanf(buf, "%ld", &kim_data->baud_rate); 607 pr_debug("stored baud rate >%ld<", kim_data->baud_rate); 608 return count; 609 } 610 #endif /* if DEBUG */ 611 612 static ssize_t show_dev_name(struct device *dev, 613 struct device_attribute *attr, char *buf) 614 { 615 struct kim_data_s *kim_data = dev_get_drvdata(dev); 616 return sprintf(buf, "%s\n", kim_data->dev_name); 617 } 618 619 static ssize_t show_baud_rate(struct device *dev, 620 struct device_attribute *attr, char *buf) 621 { 622 struct kim_data_s *kim_data = dev_get_drvdata(dev); 623 return sprintf(buf, "%ld\n", kim_data->baud_rate); 624 } 625 626 static ssize_t show_flow_cntrl(struct device *dev, 627 struct device_attribute *attr, char *buf) 628 { 629 struct kim_data_s *kim_data = dev_get_drvdata(dev); 630 return sprintf(buf, "%d\n", kim_data->flow_cntrl); 631 } 632 633 /* structures specific for sysfs entries */ 634 static struct kobj_attribute ldisc_install = 635 __ATTR(install, 0444, (void *)show_install, NULL); 636 637 static struct kobj_attribute uart_dev_name = 638 #ifdef DEBUG /* TODO: move this to debug-fs if possible */ 639 __ATTR(dev_name, 0644, (void *)show_dev_name, (void *)store_dev_name); 640 #else 641 __ATTR(dev_name, 0444, (void *)show_dev_name, NULL); 642 #endif 643 644 static struct kobj_attribute uart_baud_rate = 645 #ifdef DEBUG /* TODO: move to debugfs */ 646 __ATTR(baud_rate, 0644, (void *)show_baud_rate, (void *)store_baud_rate); 647 #else 648 __ATTR(baud_rate, 0444, (void *)show_baud_rate, NULL); 649 #endif 650 651 static struct kobj_attribute uart_flow_cntrl = 652 __ATTR(flow_cntrl, 0444, (void *)show_flow_cntrl, NULL); 653 654 static struct attribute *uim_attrs[] = { 655 &ldisc_install.attr, 656 &uart_dev_name.attr, 657 &uart_baud_rate.attr, 658 &uart_flow_cntrl.attr, 659 NULL, 660 }; 661 662 static struct attribute_group uim_attr_grp = { 663 .attrs = uim_attrs, 664 }; 665 666 /** 667 * st_kim_ref - reference the core's data 668 * This references the per-ST platform device in the arch/xx/ 669 * board-xx.c file. 670 * This would enable multiple such platform devices to exist 671 * on a given platform 672 */ 673 void st_kim_ref(struct st_data_s **core_data, int id) 674 { 675 struct platform_device *pdev; 676 struct kim_data_s *kim_gdata; 677 /* get kim_gdata reference from platform device */ 678 pdev = st_get_plat_device(id); 679 if (!pdev) { 680 *core_data = NULL; 681 return; 682 } 683 kim_gdata = platform_get_drvdata(pdev); 684 *core_data = kim_gdata->core_data; 685 } 686 687 static int kim_version_open(struct inode *i, struct file *f) 688 { 689 return single_open(f, show_version, i->i_private); 690 } 691 692 static int kim_list_open(struct inode *i, struct file *f) 693 { 694 return single_open(f, show_list, i->i_private); 695 } 696 697 static const struct file_operations version_debugfs_fops = { 698 /* version info */ 699 .open = kim_version_open, 700 .read = seq_read, 701 .llseek = seq_lseek, 702 .release = single_release, 703 }; 704 static const struct file_operations list_debugfs_fops = { 705 /* protocols info */ 706 .open = kim_list_open, 707 .read = seq_read, 708 .llseek = seq_lseek, 709 .release = single_release, 710 }; 711 712 /**********************************************************************/ 713 /* functions called from platform device driver subsystem 714 * need to have a relevant platform device entry in the platform's 715 * board-*.c file 716 */ 717 718 static struct dentry *kim_debugfs_dir; 719 static int kim_probe(struct platform_device *pdev) 720 { 721 struct kim_data_s *kim_gdata; 722 struct ti_st_plat_data *pdata = pdev->dev.platform_data; 723 int err; 724 725 if ((pdev->id != -1) && (pdev->id < MAX_ST_DEVICES)) { 726 /* multiple devices could exist */ 727 st_kim_devices[pdev->id] = pdev; 728 } else { 729 /* platform's sure about existence of 1 device */ 730 st_kim_devices[0] = pdev; 731 } 732 733 kim_gdata = kzalloc(sizeof(struct kim_data_s), GFP_ATOMIC); 734 if (!kim_gdata) { 735 pr_err("no mem to allocate"); 736 return -ENOMEM; 737 } 738 platform_set_drvdata(pdev, kim_gdata); 739 740 err = st_core_init(&kim_gdata->core_data); 741 if (err != 0) { 742 pr_err(" ST core init failed"); 743 err = -EIO; 744 goto err_core_init; 745 } 746 /* refer to itself */ 747 kim_gdata->core_data->kim_data = kim_gdata; 748 749 /* Claim the chip enable nShutdown gpio from the system */ 750 kim_gdata->nshutdown = pdata->nshutdown_gpio; 751 err = gpio_request(kim_gdata->nshutdown, "kim"); 752 if (unlikely(err)) { 753 pr_err(" gpio %ld request failed ", kim_gdata->nshutdown); 754 return err; 755 } 756 757 /* Configure nShutdown GPIO as output=0 */ 758 err = gpio_direction_output(kim_gdata->nshutdown, 0); 759 if (unlikely(err)) { 760 pr_err(" unable to configure gpio %ld", kim_gdata->nshutdown); 761 return err; 762 } 763 /* get reference of pdev for request_firmware 764 */ 765 kim_gdata->kim_pdev = pdev; 766 init_completion(&kim_gdata->kim_rcvd); 767 init_completion(&kim_gdata->ldisc_installed); 768 769 err = sysfs_create_group(&pdev->dev.kobj, &uim_attr_grp); 770 if (err) { 771 pr_err("failed to create sysfs entries"); 772 goto err_sysfs_group; 773 } 774 775 /* copying platform data */ 776 strncpy(kim_gdata->dev_name, pdata->dev_name, UART_DEV_NAME_LEN); 777 kim_gdata->flow_cntrl = pdata->flow_cntrl; 778 kim_gdata->baud_rate = pdata->baud_rate; 779 pr_info("sysfs entries created\n"); 780 781 kim_debugfs_dir = debugfs_create_dir("ti-st", NULL); 782 if (IS_ERR(kim_debugfs_dir)) { 783 pr_err(" debugfs entries creation failed "); 784 err = -EIO; 785 goto err_debugfs_dir; 786 } 787 788 debugfs_create_file("version", S_IRUGO, kim_debugfs_dir, 789 kim_gdata, &version_debugfs_fops); 790 debugfs_create_file("protocols", S_IRUGO, kim_debugfs_dir, 791 kim_gdata, &list_debugfs_fops); 792 pr_info(" debugfs entries created "); 793 return 0; 794 795 err_debugfs_dir: 796 sysfs_remove_group(&pdev->dev.kobj, &uim_attr_grp); 797 798 err_sysfs_group: 799 st_core_exit(kim_gdata->core_data); 800 801 err_core_init: 802 kfree(kim_gdata); 803 804 return err; 805 } 806 807 static int kim_remove(struct platform_device *pdev) 808 { 809 /* free the GPIOs requested */ 810 struct ti_st_plat_data *pdata = pdev->dev.platform_data; 811 struct kim_data_s *kim_gdata; 812 813 kim_gdata = platform_get_drvdata(pdev); 814 815 /* Free the Bluetooth/FM/GPIO 816 * nShutdown gpio from the system 817 */ 818 gpio_free(pdata->nshutdown_gpio); 819 pr_info("nshutdown GPIO Freed"); 820 821 debugfs_remove_recursive(kim_debugfs_dir); 822 sysfs_remove_group(&pdev->dev.kobj, &uim_attr_grp); 823 pr_info("sysfs entries removed"); 824 825 kim_gdata->kim_pdev = NULL; 826 st_core_exit(kim_gdata->core_data); 827 828 kfree(kim_gdata); 829 kim_gdata = NULL; 830 return 0; 831 } 832 833 static int kim_suspend(struct platform_device *pdev, pm_message_t state) 834 { 835 struct ti_st_plat_data *pdata = pdev->dev.platform_data; 836 837 if (pdata->suspend) 838 return pdata->suspend(pdev, state); 839 840 return -EOPNOTSUPP; 841 } 842 843 static int kim_resume(struct platform_device *pdev) 844 { 845 struct ti_st_plat_data *pdata = pdev->dev.platform_data; 846 847 if (pdata->resume) 848 return pdata->resume(pdev); 849 850 return -EOPNOTSUPP; 851 } 852 853 /**********************************************************************/ 854 /* entry point for ST KIM module, called in from ST Core */ 855 static struct platform_driver kim_platform_driver = { 856 .probe = kim_probe, 857 .remove = kim_remove, 858 .suspend = kim_suspend, 859 .resume = kim_resume, 860 .driver = { 861 .name = "kim", 862 .owner = THIS_MODULE, 863 }, 864 }; 865 866 module_platform_driver(kim_platform_driver); 867 868 MODULE_AUTHOR("Pavan Savoy <pavan_savoy@ti.com>"); 869 MODULE_DESCRIPTION("Shared Transport Driver for TI BT/FM/GPS combo chips "); 870 MODULE_LICENSE("GPL"); 871