xref: /openbmc/linux/drivers/misc/ti-st/st_kim.c (revision bc000245)
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