Kernel

Kernel Git Source Tree

Root/drivers/misc/pti.c

1	/*
2	* pti.c - PTI driver for cJTAG data extration
3	*
4	* Copyright (C) Intel 2010
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License version 2 as
8	* published by the Free Software Foundation.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
16	*
17	* The PTI (Parallel Trace Interface) driver directs trace data routed from
18	* various parts in the system out through the Intel Penwell PTI port and
19	* out of the mobile device for analysis with a debugging tool
20	* (Lauterbach, Fido). This is part of a solution for the MIPI P1149.7,
21	* compact JTAG, standard.
22	*/
23
24	#include <linux/init.h>
25	#include <linux/sched.h>
26	#include <linux/interrupt.h>
27	#include <linux/console.h>
28	#include <linux/kernel.h>
29	#include <linux/module.h>
30	#include <linux/tty.h>
31	#include <linux/tty_driver.h>
32	#include <linux/pci.h>
33	#include <linux/mutex.h>
34	#include <linux/miscdevice.h>
35	#include <linux/pti.h>
36	#include <linux/slab.h>
37	#include <linux/uaccess.h>
38
39	#define DRIVERNAME "pti"
40	#define PCINAME "pciPTI"
41	#define TTYNAME "ttyPTI"
42	#define CHARNAME "pti"
43	#define PTITTY_MINOR_START 0
44	#define PTITTY_MINOR_NUM 2
45	#define MAX_APP_IDS 16 /* 128 channel ids / u8 bit size */
46	#define MAX_OS_IDS 16 /* 128 channel ids / u8 bit size */
47	#define MAX_MODEM_IDS 16 /* 128 channel ids / u8 bit size */
48	#define MODEM_BASE_ID 71 /* modem master ID address */
49	#define CONTROL_ID 72 /* control master ID address */
50	#define CONSOLE_ID 73 /* console master ID address */
51	#define OS_BASE_ID 74 /* base OS master ID address */
52	#define APP_BASE_ID 80 /* base App master ID address */
53	#define CONTROL_FRAME_LEN 32 /* PTI control frame maximum size */
54	#define USER_COPY_SIZE 8192 /* 8Kb buffer for user space copy */
55	#define APERTURE_14 0x3800000 /* offset to first OS write addr */
56	#define APERTURE_LEN 0x400000 /* address length */
57
58	struct pti_tty {
59	struct pti_masterchannel *mc;
60	};
61
62	struct pti_dev {
63	struct tty_port port;
64	unsigned long pti_addr;
65	unsigned long aperture_base;
66	void __iomem *pti_ioaddr;
67	u8 ia_app[MAX_APP_IDS];
68	u8 ia_os[MAX_OS_IDS];
69	u8 ia_modem[MAX_MODEM_IDS];
70	};
71
72	/*
73	* This protects access to ia_app, ia_os, and ia_modem,
74	* which keeps track of channels allocated in
75	* an aperture write id.
76	*/
77	static DEFINE_MUTEX(alloclock);
78
79	static struct pci_device_id pci_ids[] __devinitconst = {
80	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x82B)},
81	{0}
82	};
83
84	static struct tty_driver *pti_tty_driver;
85	static struct pti_dev *drv_data;
86
87	static unsigned int pti_console_channel;
88	static unsigned int pti_control_channel;
89
90	/**
91	* pti_write_to_aperture()- The private write function to PTI HW.
92	*
93	* @mc: The 'aperture'. It's part of a write address that holds
94	* a master and channel ID.
95	* @buf: Data being written to the HW that will ultimately be seen
96	* in a debugging tool (Fido, Lauterbach).
97	* @len: Size of buffer.
98	*
99	* Since each aperture is specified by a unique
100	* master/channel ID, no two processes will be writing
101	* to the same aperture at the same time so no lock is required. The
102	* PTI-Output agent will send these out in the order that they arrived, and
103	* thus, it will intermix these messages. The debug tool can then later
104	* regroup the appropriate message segments together reconstituting each
105	* message.
106	*/
107	static void pti_write_to_aperture(struct pti_masterchannel *mc,
108	u8 *buf,
109	int len)
110	{
111	int dwordcnt;
112	int final;
113	int i;
114	u32 ptiword;
115	u32 __iomem *aperture;
116	u8 *p = buf;
117
118	/*
119	* calculate the aperture offset from the base using the master and
120	* channel id's.
121	*/
122	aperture = drv_data->pti_ioaddr + (mc->master << 15)
123	+ (mc->channel << 8);
124
125	dwordcnt = len >> 2;
126	final = len - (dwordcnt << 2); /* final = trailing bytes */
127	if (final == 0 && dwordcnt != 0) { /* always need a final dword */
128	final += 4;
129	dwordcnt--;
130	}
131
132	for (i = 0; i < dwordcnt; i++) {
133	ptiword = be32_to_cpu((u32 )p);
134	p += 4;
135	iowrite32(ptiword, aperture);
136	}
137
138	aperture += PTI_LASTDWORD_DTS; /* adding DTS signals that is EOM */
139
140	ptiword = 0;
141	for (i = 0; i < final; i++)
142	ptiword \|= p++ << (24-(8i));
143
144	iowrite32(ptiword, aperture);
145	return;
146	}
147
148	/**
149	* pti_control_frame_built_and_sent()- control frame build and send function.
150	*
151	* @mc: The master / channel structure on which the function
152	* built a control frame.
153	* @thread_name: The thread name associated with the master / channel or
154	* 'NULL' if using the 'current' global variable.
155	*
156	* To be able to post process the PTI contents on host side, a control frame
157	* is added before sending any PTI content. So the host side knows on
158	* each PTI frame the name of the thread using a dedicated master / channel.
159	* The thread name is retrieved from 'current' global variable if 'thread_name'
160	* is 'NULL', else it is retrieved from 'thread_name' parameter.
161	* This function builds this frame and sends it to a master ID CONTROL_ID.
162	* The overhead is only 32 bytes since the driver only writes to HW
163	* in 32 byte chunks.
164	*/
165	static void pti_control_frame_built_and_sent(struct pti_masterchannel *mc,
166	const char *thread_name)
167	{
168	/*
169	* Since we access the comm member in current's task_struct, we only
170	* need to be as large as what 'comm' in that structure is.
171	*/
172	char comm[TASK_COMM_LEN];
173	struct pti_masterchannel mccontrol = {.master = CONTROL_ID,
174	.channel = 0};
175	const char *thread_name_p;
176	const char *control_format = "%3d %3d %s";
177	u8 control_frame[CONTROL_FRAME_LEN];
178
179	if (!thread_name) {
180	if (!in_interrupt())
181	get_task_comm(comm, current);
182	else
183	strncpy(comm, "Interrupt", TASK_COMM_LEN);
184
185	/* Absolutely ensure our buffer is zero terminated. */
186	comm[TASK_COMM_LEN-1] = 0;
187	thread_name_p = comm;
188	} else {
189	thread_name_p = thread_name;
190	}
191
192	mccontrol.channel = pti_control_channel;
193	pti_control_channel = (pti_control_channel + 1) & 0x7f;
194
195	snprintf(control_frame, CONTROL_FRAME_LEN, control_format, mc->master,
196	mc->channel, thread_name_p);
197	pti_write_to_aperture(&mccontrol, control_frame, strlen(control_frame));
198	}
199
200	/**
201	* pti_write_full_frame_to_aperture()- high level function to
202	* write to PTI.
203	*
204	* @mc: The 'aperture'. It's part of a write address that holds
205	* a master and channel ID.
206	* @buf: Data being written to the HW that will ultimately be seen
207	* in a debugging tool (Fido, Lauterbach).
208	* @len: Size of buffer.
209	*
210	* All threads sending data (either console, user space application, ...)
211	* are calling the high level function to write to PTI meaning that it is
212	* possible to add a control frame before sending the content.
213	*/
214	static void pti_write_full_frame_to_aperture(struct pti_masterchannel *mc,
215	const unsigned char *buf,
216	int len)
217	{
218	pti_control_frame_built_and_sent(mc, NULL);
219	pti_write_to_aperture(mc, (u8 *)buf, len);
220	}
221
222	/**
223	* get_id()- Allocate a master and channel ID.
224	*
225	* @id_array: an array of bits representing what channel
226	* id's are allocated for writing.
227	* @max_ids: The max amount of available write IDs to use.
228	* @base_id: The starting SW channel ID, based on the Intel
229	* PTI arch.
230	* @thread_name: The thread name associated with the master / channel or
231	* 'NULL' if using the 'current' global variable.
232	*
233	* Returns:
234	* pti_masterchannel struct with master, channel ID address
235	* 0 for error
236	*
237	* Each bit in the arrays ia_app and ia_os correspond to a master and
238	* channel id. The bit is one if the id is taken and 0 if free. For
239	* every master there are 128 channel id's.
240	*/
241	static struct pti_masterchannel get_id(u8 id_array,
242	int max_ids,
243	int base_id,
244	const char *thread_name)
245	{
246	struct pti_masterchannel *mc;
247	int i, j, mask;
248
249	mc = kmalloc(sizeof(struct pti_masterchannel), GFP_KERNEL);
250	if (mc == NULL)
251	return NULL;
252
253	/* look for a byte with a free bit */
254	for (i = 0; i < max_ids; i++)
255	if (id_array[i] != 0xff)
256	break;
257	if (i == max_ids) {
258	kfree(mc);
259	return NULL;
260	}
261	/* find the bit in the 128 possible channel opportunities */
262	mask = 0x80;
263	for (j = 0; j < 8; j++) {
264	if ((id_array[i] & mask) == 0)
265	break;
266	mask >>= 1;
267	}
268
269	/* grab it */
270	id_array[i] \|= mask;
271	mc->master = base_id;
272	mc->channel = ((i & 0xf)<<3) + j;
273	/* write new master Id / channel Id allocation to channel control */
274	pti_control_frame_built_and_sent(mc, thread_name);
275	return mc;
276	}
277
278	/*
279	* The following three functions:
280	* pti_request_mastercahannel(), mipi_release_masterchannel()
281	* and pti_writedata() are an API for other kernel drivers to
282	* access PTI.
283	*/
284
285	/**
286	* pti_request_masterchannel()- Kernel API function used to allocate
287	* a master, channel ID address
288	* to write to PTI HW.
289	*
290	* @type: 0- request Application master, channel aperture ID
291	* write address.
292	* 1- request OS master, channel aperture ID write
293	* address.
294	* 2- request Modem master, channel aperture ID
295	* write address.
296	* Other values, error.
297	* @thread_name: The thread name associated with the master / channel or
298	* 'NULL' if using the 'current' global variable.
299	*
300	* Returns:
301	* pti_masterchannel struct
302	* 0 for error
303	*/
304	struct pti_masterchannel *pti_request_masterchannel(u8 type,
305	const char *thread_name)
306	{
307	struct pti_masterchannel *mc;
308
309	mutex_lock(&alloclock);
310
311	switch (type) {
312
313	case 0:
314	mc = get_id(drv_data->ia_app, MAX_APP_IDS,
315	APP_BASE_ID, thread_name);
316	break;
317
318	case 1:
319	mc = get_id(drv_data->ia_os, MAX_OS_IDS,
320	OS_BASE_ID, thread_name);
321	break;
322
323	case 2:
324	mc = get_id(drv_data->ia_modem, MAX_MODEM_IDS,
325	MODEM_BASE_ID, thread_name);
326	break;
327	default:
328	mc = NULL;
329	}
330
331	mutex_unlock(&alloclock);
332	return mc;
333	}
334	EXPORT_SYMBOL_GPL(pti_request_masterchannel);
335
336	/**
337	* pti_release_masterchannel()- Kernel API function used to release
338	* a master, channel ID address
339	* used to write to PTI HW.
340	*
341	* @mc: master, channel apeture ID address to be released. This
342	* will de-allocate the structure via kfree().
343	*/
344	void pti_release_masterchannel(struct pti_masterchannel *mc)
345	{
346	u8 master, channel, i;
347
348	mutex_lock(&alloclock);
349
350	if (mc) {
351	master = mc->master;
352	channel = mc->channel;
353
354	if (master == APP_BASE_ID) {
355	i = channel >> 3;
356	drv_data->ia_app[i] &= ~(0x80>>(channel & 0x7));
357	} else if (master == OS_BASE_ID) {
358	i = channel >> 3;
359	drv_data->ia_os[i] &= ~(0x80>>(channel & 0x7));
360	} else {
361	i = channel >> 3;
362	drv_data->ia_modem[i] &= ~(0x80>>(channel & 0x7));
363	}
364
365	kfree(mc);
366	}
367
368	mutex_unlock(&alloclock);
369	}
370	EXPORT_SYMBOL_GPL(pti_release_masterchannel);
371
372	/**
373	* pti_writedata()- Kernel API function used to write trace
374	* debugging data to PTI HW.
375	*
376	* @mc: Master, channel aperture ID address to write to.
377	* Null value will return with no write occurring.
378	* @buf: Trace debuging data to write to the PTI HW.
379	* Null value will return with no write occurring.
380	* @count: Size of buf. Value of 0 or a negative number will
381	* return with no write occuring.
382	*/
383	void pti_writedata(struct pti_masterchannel mc, u8 buf, int count)
384	{
385	/*
386	* since this function is exported, this is treated like an
387	* API function, thus, all parameters should
388	* be checked for validity.
389	*/
390	if ((mc != NULL) && (buf != NULL) && (count > 0))
391	pti_write_to_aperture(mc, buf, count);
392	return;
393	}
394	EXPORT_SYMBOL_GPL(pti_writedata);
395
396	/**
397	* pti_pci_remove()- Driver exit method to remove PTI from
398	* PCI bus.
399	* @pdev: variable containing pci info of PTI.
400	*/
401	static void __devexit pti_pci_remove(struct pci_dev *pdev)
402	{
403	struct pti_dev *drv_data;
404
405	drv_data = pci_get_drvdata(pdev);
406	if (drv_data != NULL) {
407	pci_iounmap(pdev, drv_data->pti_ioaddr);
408	pci_set_drvdata(pdev, NULL);
409	kfree(drv_data);
410	pci_release_region(pdev, 1);
411	pci_disable_device(pdev);
412	}
413	}
414
415	/*
416	* for the tty_driver_*() basic function descriptions, see tty_driver.h.
417	* Specific header comments made for PTI-related specifics.
418	*/
419
420	/**
421	* pti_tty_driver_open()- Open an Application master, channel aperture
422	* ID to the PTI device via tty device.
423	*
424	* @tty: tty interface.
425	* @filp: filp interface pased to tty_port_open() call.
426	*
427	* Returns:
428	* int, 0 for success
429	* otherwise, fail value
430	*
431	* The main purpose of using the tty device interface is for
432	* each tty port to have a unique PTI write aperture. In an
433	* example use case, ttyPTI0 gets syslogd and an APP aperture
434	* ID and ttyPTI1 is where the n_tracesink ldisc hooks to route
435	* modem messages into PTI. Modem trace data does not have to
436	* go to ttyPTI1, but ttyPTI0 and ttyPTI1 do need to be distinct
437	* master IDs. These messages go through the PTI HW and out of
438	* the handheld platform and to the Fido/Lauterbach device.
439	*/
440	static int pti_tty_driver_open(struct tty_struct tty, struct file filp)
441	{
442	/*
443	* we actually want to allocate a new channel per open, per
444	* system arch. HW gives more than plenty channels for a single
445	* system task to have its own channel to write trace data. This
446	* also removes a locking requirement for the actual write
447	* procedure.
448	*/
449	return tty_port_open(&drv_data->port, tty, filp);
450	}
451
452	/**
453	* pti_tty_driver_close()- close tty device and release Application
454	* master, channel aperture ID to the PTI device via tty device.
455	*
456	* @tty: tty interface.
457	* @filp: filp interface pased to tty_port_close() call.
458	*
459	* The main purpose of using the tty device interface is to route
460	* syslog daemon messages to the PTI HW and out of the handheld platform
461	* and to the Fido/Lauterbach device.
462	*/
463	static void pti_tty_driver_close(struct tty_struct tty, struct file filp)
464	{
465	tty_port_close(&drv_data->port, tty, filp);
466	}
467
468	/**
469	* pti_tty_install()- Used to set up specific master-channels
470	* to tty ports for organizational purposes when
471	* tracing viewed from debuging tools.
472	*
473	* @driver: tty driver information.
474	* @tty: tty struct containing pti information.
475	*
476	* Returns:
477	* 0 for success
478	* otherwise, error
479	*/
480	static int pti_tty_install(struct tty_driver driver, struct tty_struct tty)
481	{
482	int idx = tty->index;
483	struct pti_tty *pti_tty_data;
484	int ret = tty_standard_install(driver, tty);
485
486	if (ret == 0) {
487	pti_tty_data = kmalloc(sizeof(struct pti_tty), GFP_KERNEL);
488	if (pti_tty_data == NULL)
489	return -ENOMEM;
490
491	if (idx == PTITTY_MINOR_START)
492	pti_tty_data->mc = pti_request_masterchannel(0, NULL);
493	else
494	pti_tty_data->mc = pti_request_masterchannel(2, NULL);
495
496	if (pti_tty_data->mc == NULL) {
497	kfree(pti_tty_data);
498	return -ENXIO;
499	}
500	tty->driver_data = pti_tty_data;
501	}
502
503	return ret;
504	}
505
506	/**
507	* pti_tty_cleanup()- Used to de-allocate master-channel resources
508	* tied to tty's of this driver.
509	*
510	* @tty: tty struct containing pti information.
511	*/
512	static void pti_tty_cleanup(struct tty_struct *tty)
513	{
514	struct pti_tty *pti_tty_data = tty->driver_data;
515	if (pti_tty_data == NULL)
516	return;
517	pti_release_masterchannel(pti_tty_data->mc);
518	kfree(pti_tty_data);
519	tty->driver_data = NULL;
520	}
521
522	/**
523	* pti_tty_driver_write()- Write trace debugging data through the char
524	* interface to the PTI HW. Part of the misc device implementation.
525	*
526	* @filp: Contains private data which is used to obtain
527	* master, channel write ID.
528	* @data: trace data to be written.
529	* @len: # of byte to write.
530	*
531	* Returns:
532	* int, # of bytes written
533	* otherwise, error
534	*/
535	static int pti_tty_driver_write(struct tty_struct *tty,
536	const unsigned char *buf, int len)
537	{
538	struct pti_tty *pti_tty_data = tty->driver_data;
539	if ((pti_tty_data != NULL) && (pti_tty_data->mc != NULL)) {
540	pti_write_to_aperture(pti_tty_data->mc, (u8 *)buf, len);
541	return len;
542	}
543	/*
544	* we can't write to the pti hardware if the private driver_data
545	* and the mc address is not there.
546	*/
547	else
548	return -EFAULT;
549	}
550
551	/**
552	* pti_tty_write_room()- Always returns 2048.
553	*
554	* @tty: contains tty info of the pti driver.
555	*/
556	static int pti_tty_write_room(struct tty_struct *tty)
557	{
558	return 2048;
559	}
560
561	/**
562	* pti_char_open()- Open an Application master, channel aperture
563	* ID to the PTI device. Part of the misc device implementation.
564	*
565	* @inode: not used.
566	* @filp: Output- will have a masterchannel struct set containing
567	* the allocated application PTI aperture write address.
568	*
569	* Returns:
570	* int, 0 for success
571	* otherwise, a fail value
572	*/
573	static int pti_char_open(struct inode inode, struct file filp)
574	{
575	struct pti_masterchannel *mc;
576
577	/*
578	* We really do want to fail immediately if
579	* pti_request_masterchannel() fails,
580	* before assigning the value to filp->private_data.
581	* Slightly easier to debug if this driver needs debugging.
582	*/
583	mc = pti_request_masterchannel(0, NULL);
584	if (mc == NULL)
585	return -ENOMEM;
586	filp->private_data = mc;
587	return 0;
588	}
589
590	/**
591	* pti_char_release()- Close a char channel to the PTI device. Part
592	* of the misc device implementation.
593	*
594	* @inode: Not used in this implementaiton.
595	* @filp: Contains private_data that contains the master, channel
596	* ID to be released by the PTI device.
597	*
598	* Returns:
599	* always 0
600	*/
601	static int pti_char_release(struct inode inode, struct file filp)
602	{
603	pti_release_masterchannel(filp->private_data);
604	filp->private_data = NULL;
605	return 0;
606	}
607
608	/**
609	* pti_char_write()- Write trace debugging data through the char
610	* interface to the PTI HW. Part of the misc device implementation.
611	*
612	* @filp: Contains private data which is used to obtain
613	* master, channel write ID.
614	* @data: trace data to be written.
615	* @len: # of byte to write.
616	* @ppose: Not used in this function implementation.
617	*
618	* Returns:
619	* int, # of bytes written
620	* otherwise, error value
621	*
622	* Notes: From side discussions with Alan Cox and experimenting
623	* with PTI debug HW like Nokia's Fido box and Lauterbach
624	* devices, 8192 byte write buffer used by USER_COPY_SIZE was
625	* deemed an appropriate size for this type of usage with
626	* debugging HW.
627	*/
628	static ssize_t pti_char_write(struct file filp, const char __user data,
629	size_t len, loff_t *ppose)
630	{
631	struct pti_masterchannel *mc;
632	void *kbuf;
633	const char __user *tmp;
634	size_t size = USER_COPY_SIZE;
635	size_t n = 0;
636
637	tmp = data;
638	mc = filp->private_data;
639
640	kbuf = kmalloc(size, GFP_KERNEL);
641	if (kbuf == NULL) {
642	pr_err("%s(%d): buf allocation failed\n",
643	__func__, __LINE__);
644	return -ENOMEM;
645	}
646
647	do {
648	if (len - n > USER_COPY_SIZE)
649	size = USER_COPY_SIZE;
650	else
651	size = len - n;
652
653	if (copy_from_user(kbuf, tmp, size)) {
654	kfree(kbuf);
655	return n ? n : -EFAULT;
656	}
657
658	pti_write_to_aperture(mc, kbuf, size);
659	n += size;
660	tmp += size;
661
662	} while (len > n);
663
664	kfree(kbuf);
665	return len;
666	}
667
668	static const struct tty_operations pti_tty_driver_ops = {
669	.open = pti_tty_driver_open,
670	.close = pti_tty_driver_close,
671	.write = pti_tty_driver_write,
672	.write_room = pti_tty_write_room,
673	.install = pti_tty_install,
674	.cleanup = pti_tty_cleanup
675	};
676
677	static const struct file_operations pti_char_driver_ops = {
678	.owner = THIS_MODULE,
679	.write = pti_char_write,
680	.open = pti_char_open,
681	.release = pti_char_release,
682	};
683
684	static struct miscdevice pti_char_driver = {
685	.minor = MISC_DYNAMIC_MINOR,
686	.name = CHARNAME,
687	.fops = &pti_char_driver_ops
688	};
689
690	/**
691	* pti_console_write()- Write to the console that has been acquired.
692	*
693	* @c: Not used in this implementaiton.
694	* @buf: Data to be written.
695	* @len: Length of buf.
696	*/
697	static void pti_console_write(struct console c, const char buf, unsigned len)
698	{
699	static struct pti_masterchannel mc = {.master = CONSOLE_ID,
700	.channel = 0};
701
702	mc.channel = pti_console_channel;
703	pti_console_channel = (pti_console_channel + 1) & 0x7f;
704
705	pti_write_full_frame_to_aperture(&mc, buf, len);
706	}
707
708	/**
709	* pti_console_device()- Return the driver tty structure and set the
710	* associated index implementation.
711	*
712	* @c: Console device of the driver.
713	* @index: index associated with c.
714	*
715	* Returns:
716	* always value of pti_tty_driver structure when this function
717	* is called.
718	*/
719	static struct tty_driver pti_console_device(struct console c, int *index)
720	{
721	*index = c->index;
722	return pti_tty_driver;
723	}
724
725	/**
726	* pti_console_setup()- Initialize console variables used by the driver.
727	*
728	* @c: Not used.
729	* @opts: Not used.
730	*
731	* Returns:
732	* always 0.
733	*/
734	static int pti_console_setup(struct console c, char opts)
735	{
736	pti_console_channel = 0;
737	pti_control_channel = 0;
738	return 0;
739	}
740
741	/*
742	* pti_console struct, used to capture OS printk()'s and shift
743	* out to the PTI device for debugging. This cannot be
744	* enabled upon boot because of the possibility of eating
745	* any serial console printk's (race condition discovered).
746	* The console should be enabled upon when the tty port is
747	* used for the first time. Since the primary purpose for
748	* the tty port is to hook up syslog to it, the tty port
749	* will be open for a really long time.
750	*/
751	static struct console pti_console = {
752	.name = TTYNAME,
753	.write = pti_console_write,
754	.device = pti_console_device,
755	.setup = pti_console_setup,
756	.flags = CON_PRINTBUFFER,
757	.index = 0,
758	};
759
760	/**
761	* pti_port_activate()- Used to start/initialize any items upon
762	* first opening of tty_port().
763	*
764	* @port- The tty port number of the PTI device.
765	* @tty- The tty struct associated with this device.
766	*
767	* Returns:
768	* always returns 0
769	*
770	* Notes: The primary purpose of the PTI tty port 0 is to hook
771	* the syslog daemon to it; thus this port will be open for a
772	* very long time.
773	*/
774	static int pti_port_activate(struct tty_port port, struct tty_struct tty)
775	{
776	if (port->tty->index == PTITTY_MINOR_START)
777	console_start(&pti_console);
778	return 0;
779	}
780
781	/**
782	* pti_port_shutdown()- Used to stop/shutdown any items upon the
783	* last tty port close.
784	*
785	* @port- The tty port number of the PTI device.
786	*
787	* Notes: The primary purpose of the PTI tty port 0 is to hook
788	* the syslog daemon to it; thus this port will be open for a
789	* very long time.
790	*/
791	static void pti_port_shutdown(struct tty_port *port)
792	{
793	if (port->tty->index == PTITTY_MINOR_START)
794	console_stop(&pti_console);
795	}
796
797	static const struct tty_port_operations tty_port_ops = {
798	.activate = pti_port_activate,
799	.shutdown = pti_port_shutdown,
800	};
801
802	/*
803	* Note the _probe() call sets everything up and ties the char and tty
804	* to successfully detecting the PTI device on the pci bus.
805	*/
806
807	/**
808	* pti_pci_probe()- Used to detect pti on the pci bus and set
809	* things up in the driver.
810	*
811	* @pdev- pci_dev struct values for pti.
812	* @ent- pci_device_id struct for pti driver.
813	*
814	* Returns:
815	* 0 for success
816	* otherwise, error
817	*/
818	static int __devinit pti_pci_probe(struct pci_dev *pdev,
819	const struct pci_device_id *ent)
820	{
821	int retval = -EINVAL;
822	int pci_bar = 1;
823
824	dev_dbg(&pdev->dev, "%s %s(%d): PTI PCI ID %04x:%04x\n", __FILE__,
825	__func__, __LINE__, pdev->vendor, pdev->device);
826
827	retval = misc_register(&pti_char_driver);
828	if (retval) {
829	pr_err("%s(%d): CHAR registration failed of pti driver\n",
830	__func__, __LINE__);
831	pr_err("%s(%d): Error value returned: %d\n",
832	__func__, __LINE__, retval);
833	return retval;
834	}
835
836	retval = pci_enable_device(pdev);
837	if (retval != 0) {
838	dev_err(&pdev->dev,
839	"%s: pci_enable_device() returned error %d\n",
840	__func__, retval);
841	return retval;
842	}
843
844	drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL);
845
846	if (drv_data == NULL) {
847	retval = -ENOMEM;
848	dev_err(&pdev->dev,
849	"%s(%d): kmalloc() returned NULL memory.\n",
850	__func__, __LINE__);
851	return retval;
852	}
853	drv_data->pti_addr = pci_resource_start(pdev, pci_bar);
854
855	retval = pci_request_region(pdev, pci_bar, dev_name(&pdev->dev));
856	if (retval != 0) {
857	dev_err(&pdev->dev,
858	"%s(%d): pci_request_region() returned error %d\n",
859	__func__, __LINE__, retval);
860	kfree(drv_data);
861	return retval;
862	}
863	drv_data->aperture_base = drv_data->pti_addr+APERTURE_14;
864	drv_data->pti_ioaddr =
865	ioremap_nocache((u32)drv_data->aperture_base,
866	APERTURE_LEN);
867	if (!drv_data->pti_ioaddr) {
868	pci_release_region(pdev, pci_bar);
869	retval = -ENOMEM;
870	kfree(drv_data);
871	return retval;
872	}
873
874	pci_set_drvdata(pdev, drv_data);
875
876	tty_port_init(&drv_data->port);
877	drv_data->port.ops = &tty_port_ops;
878
879	tty_register_device(pti_tty_driver, 0, &pdev->dev);
880	tty_register_device(pti_tty_driver, 1, &pdev->dev);
881
882	register_console(&pti_console);
883
884	return retval;
885	}
886
887	static struct pci_driver pti_pci_driver = {
888	.name = PCINAME,
889	.id_table = pci_ids,
890	.probe = pti_pci_probe,
891	.remove = __devexit_p(pti_pci_remove),
892	};
893
894	/**
895	*
896	* pti_init()- Overall entry/init call to the pti driver.
897	* It starts the registration process with the kernel.
898	*
899	* Returns:
900	* int __init, 0 for success
901	* otherwise value is an error
902	*
903	*/
904	static int __init pti_init(void)
905	{
906	int retval = -EINVAL;
907
908	/* First register module as tty device */
909
910	pti_tty_driver = alloc_tty_driver(PTITTY_MINOR_NUM);
911	if (pti_tty_driver == NULL) {
912	pr_err("%s(%d): Memory allocation failed for ptiTTY driver\n",
913	__func__, __LINE__);
914	return -ENOMEM;
915	}
916
917	pti_tty_driver->driver_name = DRIVERNAME;
918	pti_tty_driver->name = TTYNAME;
919	pti_tty_driver->major = 0;
920	pti_tty_driver->minor_start = PTITTY_MINOR_START;
921	pti_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
922	pti_tty_driver->subtype = SYSTEM_TYPE_SYSCONS;
923	pti_tty_driver->flags = TTY_DRIVER_REAL_RAW \|
924	TTY_DRIVER_DYNAMIC_DEV;
925	pti_tty_driver->init_termios = tty_std_termios;
926
927	tty_set_operations(pti_tty_driver, &pti_tty_driver_ops);
928
929	retval = tty_register_driver(pti_tty_driver);
930	if (retval) {
931	pr_err("%s(%d): TTY registration failed of pti driver\n",
932	__func__, __LINE__);
933	pr_err("%s(%d): Error value returned: %d\n",
934	__func__, __LINE__, retval);
935
936	pti_tty_driver = NULL;
937	return retval;
938	}
939
940	retval = pci_register_driver(&pti_pci_driver);
941
942	if (retval) {
943	pr_err("%s(%d): PCI registration failed of pti driver\n",
944	__func__, __LINE__);
945	pr_err("%s(%d): Error value returned: %d\n",
946	__func__, __LINE__, retval);
947
948	tty_unregister_driver(pti_tty_driver);
949	pr_err("%s(%d): Unregistering TTY part of pti driver\n",
950	__func__, __LINE__);
951	pti_tty_driver = NULL;
952	return retval;
953	}
954
955	return retval;
956	}
957
958	/**
959	* pti_exit()- Unregisters this module as a tty and pci driver.
960	*/
961	static void __exit pti_exit(void)
962	{
963	int retval;
964
965	tty_unregister_device(pti_tty_driver, 0);
966	tty_unregister_device(pti_tty_driver, 1);
967
968	retval = tty_unregister_driver(pti_tty_driver);
969	if (retval) {
970	pr_err("%s(%d): TTY unregistration failed of pti driver\n",
971	__func__, __LINE__);
972	pr_err("%s(%d): Error value returned: %d\n",
973	__func__, __LINE__, retval);
974	}
975
976	pci_unregister_driver(&pti_pci_driver);
977
978	retval = misc_deregister(&pti_char_driver);
979	if (retval) {
980	pr_err("%s(%d): CHAR unregistration failed of pti driver\n",
981	__func__, __LINE__);
982	pr_err("%s(%d): Error value returned: %d\n",
983	__func__, __LINE__, retval);
984	}
985
986	unregister_console(&pti_console);
987	return;
988	}
989
990	module_init(pti_init);
991	module_exit(pti_exit);
992
993	MODULE_LICENSE("GPL");
994	MODULE_AUTHOR("Ken Mills, Jay Freyensee");
995	MODULE_DESCRIPTION("PTI Driver");
996
997

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/misc/pti.c

interactive