st_kim.c 24 KB

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