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