2 * pti.c - PTI driver for cJTAG data extration
4 * Copyright (C) Intel 2010
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.
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.
15 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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>
37 #define DRIVERNAME "pti"
38 #define PCINAME "pciPTI"
39 #define TTYNAME "ttyPTI"
40 #define CHARNAME "pti"
41 #define PTITTY_MINOR_START 0
42 #define PTITTY_MINOR_NUM 2
43 #define MAX_APP_IDS 16 /* 128 channel ids / u8 bit size */
44 #define MAX_OS_IDS 16 /* 128 channel ids / u8 bit size */
45 #define MAX_MODEM_IDS 16 /* 128 channel ids / u8 bit size */
46 #define MODEM_BASE_ID 71 /* modem master ID address */
47 #define CONTROL_ID 72 /* control master ID address */
48 #define CONSOLE_ID 73 /* console master ID address */
49 #define OS_BASE_ID 74 /* base OS master ID address */
50 #define APP_BASE_ID 80 /* base App master ID address */
51 #define CONTROL_FRAME_LEN 32 /* PTI control frame maximum size */
52 #define USER_COPY_SIZE 8192 /* 8Kb buffer for user space copy */
53 #define APERTURE_14 0x3800000 /* offset to first OS write addr */
54 #define APERTURE_LEN 0x400000 /* address length */
57 struct pti_masterchannel *mc;
62 unsigned long pti_addr;
63 unsigned long aperture_base;
64 void __iomem *pti_ioaddr;
65 u8 ia_app[MAX_APP_IDS];
67 u8 ia_modem[MAX_MODEM_IDS];
71 * This protects access to ia_app, ia_os, and ia_modem,
72 * which keeps track of channels allocated in
73 * an aperture write id.
75 static DEFINE_MUTEX(alloclock);
77 static struct pci_device_id pci_ids[] __devinitconst = {
78 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x82B)},
82 static struct tty_driver *pti_tty_driver;
83 static struct pti_dev *drv_data;
85 static unsigned int pti_console_channel;
86 static unsigned int pti_control_channel;
89 * pti_write_to_aperture()- The private write function to PTI HW.
91 * @mc: The 'aperture'. It's part of a write address that holds
92 * a master and channel ID.
93 * @buf: Data being written to the HW that will ultimately be seen
94 * in a debugging tool (Fido, Lauterbach).
95 * @len: Size of buffer.
97 * Since each aperture is specified by a unique
98 * master/channel ID, no two processes will be writing
99 * to the same aperture at the same time so no lock is required. The
100 * PTI-Output agent will send these out in the order that they arrived, and
101 * thus, it will intermix these messages. The debug tool can then later
102 * regroup the appropriate message segments together reconstituting each
105 static void pti_write_to_aperture(struct pti_masterchannel *mc,
113 u32 __iomem *aperture;
117 * calculate the aperture offset from the base using the master and
120 aperture = drv_data->pti_ioaddr + (mc->master << 15)
121 + (mc->channel << 8);
124 final = len - (dwordcnt << 2); /* final = trailing bytes */
125 if (final == 0 && dwordcnt != 0) { /* always need a final dword */
130 for (i = 0; i < dwordcnt; i++) {
131 ptiword = be32_to_cpu(*(u32 *)p);
133 iowrite32(ptiword, aperture);
136 aperture += PTI_LASTDWORD_DTS; /* adding DTS signals that is EOM */
139 for (i = 0; i < final; i++)
140 ptiword |= *p++ << (24-(8*i));
142 iowrite32(ptiword, aperture);
147 * pti_control_frame_built_and_sent()- control frame build and send function.
149 * @mc: The master / channel structure on which the function
150 * built a control frame.
152 * To be able to post process the PTI contents on host side, a control frame
153 * is added before sending any PTI content. So the host side knows on
154 * each PTI frame the name of the thread using a dedicated master / channel.
155 * The thread name is retrieved from the 'current' global variable.
156 * This function builds this frame and sends it to a master ID CONTROL_ID.
157 * The overhead is only 32 bytes since the driver only writes to HW
161 static void pti_control_frame_built_and_sent(struct pti_masterchannel *mc)
163 struct pti_masterchannel mccontrol = {.master = CONTROL_ID,
165 const char *control_format = "%3d %3d %s";
166 u8 control_frame[CONTROL_FRAME_LEN];
169 * Since we access the comm member in current's task_struct,
170 * we only need to be as large as what 'comm' in that
173 char comm[TASK_COMM_LEN];
176 get_task_comm(comm, current);
178 strncpy(comm, "Interrupt", TASK_COMM_LEN);
180 /* Absolutely ensure our buffer is zero terminated. */
181 comm[TASK_COMM_LEN-1] = 0;
183 mccontrol.channel = pti_control_channel;
184 pti_control_channel = (pti_control_channel + 1) & 0x7f;
186 snprintf(control_frame, CONTROL_FRAME_LEN, control_format, mc->master,
188 pti_write_to_aperture(&mccontrol, control_frame, strlen(control_frame));
192 * pti_write_full_frame_to_aperture()- high level function to
195 * @mc: The 'aperture'. It's part of a write address that holds
196 * a master and channel ID.
197 * @buf: Data being written to the HW that will ultimately be seen
198 * in a debugging tool (Fido, Lauterbach).
199 * @len: Size of buffer.
201 * All threads sending data (either console, user space application, ...)
202 * are calling the high level function to write to PTI meaning that it is
203 * possible to add a control frame before sending the content.
205 static void pti_write_full_frame_to_aperture(struct pti_masterchannel *mc,
206 const unsigned char *buf,
209 pti_control_frame_built_and_sent(mc);
210 pti_write_to_aperture(mc, (u8 *)buf, len);
214 * get_id()- Allocate a master and channel ID.
216 * @id_array: an array of bits representing what channel
217 * id's are allocated for writing.
218 * @max_ids: The max amount of available write IDs to use.
219 * @base_id: The starting SW channel ID, based on the Intel
223 * pti_masterchannel struct with master, channel ID address
226 * Each bit in the arrays ia_app and ia_os correspond to a master and
227 * channel id. The bit is one if the id is taken and 0 if free. For
228 * every master there are 128 channel id's.
230 static struct pti_masterchannel *get_id(u8 *id_array, int max_ids, int base_id)
232 struct pti_masterchannel *mc;
235 mc = kmalloc(sizeof(struct pti_masterchannel), GFP_KERNEL);
239 /* look for a byte with a free bit */
240 for (i = 0; i < max_ids; i++)
241 if (id_array[i] != 0xff)
247 /* find the bit in the 128 possible channel opportunities */
249 for (j = 0; j < 8; j++) {
250 if ((id_array[i] & mask) == 0)
257 mc->master = base_id;
258 mc->channel = ((i & 0xf)<<3) + j;
259 /* write new master Id / channel Id allocation to channel control */
260 pti_control_frame_built_and_sent(mc);
265 * The following three functions:
266 * pti_request_mastercahannel(), mipi_release_masterchannel()
267 * and pti_writedata() are an API for other kernel drivers to
272 * pti_request_masterchannel()- Kernel API function used to allocate
273 * a master, channel ID address
274 * to write to PTI HW.
276 * @type: 0- request Application master, channel aperture ID write address.
277 * 1- request OS master, channel aperture ID write
279 * 2- request Modem master, channel aperture ID
281 * Other values, error.
284 * pti_masterchannel struct
287 struct pti_masterchannel *pti_request_masterchannel(u8 type)
289 struct pti_masterchannel *mc;
291 mutex_lock(&alloclock);
296 mc = get_id(drv_data->ia_app, MAX_APP_IDS, APP_BASE_ID);
300 mc = get_id(drv_data->ia_os, MAX_OS_IDS, OS_BASE_ID);
304 mc = get_id(drv_data->ia_modem, MAX_MODEM_IDS, MODEM_BASE_ID);
310 mutex_unlock(&alloclock);
313 EXPORT_SYMBOL_GPL(pti_request_masterchannel);
316 * pti_release_masterchannel()- Kernel API function used to release
317 * a master, channel ID address
318 * used to write to PTI HW.
320 * @mc: master, channel apeture ID address to be released. This
321 * will de-allocate the structure via kfree().
323 void pti_release_masterchannel(struct pti_masterchannel *mc)
325 u8 master, channel, i;
327 mutex_lock(&alloclock);
331 channel = mc->channel;
333 if (master == APP_BASE_ID) {
335 drv_data->ia_app[i] &= ~(0x80>>(channel & 0x7));
336 } else if (master == OS_BASE_ID) {
338 drv_data->ia_os[i] &= ~(0x80>>(channel & 0x7));
341 drv_data->ia_modem[i] &= ~(0x80>>(channel & 0x7));
347 mutex_unlock(&alloclock);
349 EXPORT_SYMBOL_GPL(pti_release_masterchannel);
352 * pti_writedata()- Kernel API function used to write trace
353 * debugging data to PTI HW.
355 * @mc: Master, channel aperture ID address to write to.
356 * Null value will return with no write occurring.
357 * @buf: Trace debuging data to write to the PTI HW.
358 * Null value will return with no write occurring.
359 * @count: Size of buf. Value of 0 or a negative number will
360 * return with no write occuring.
362 void pti_writedata(struct pti_masterchannel *mc, u8 *buf, int count)
365 * since this function is exported, this is treated like an
366 * API function, thus, all parameters should
367 * be checked for validity.
369 if ((mc != NULL) && (buf != NULL) && (count > 0))
370 pti_write_to_aperture(mc, buf, count);
373 EXPORT_SYMBOL_GPL(pti_writedata);
376 * pti_pci_remove()- Driver exit method to remove PTI from
378 * @pdev: variable containing pci info of PTI.
380 static void __devexit pti_pci_remove(struct pci_dev *pdev)
382 struct pti_dev *drv_data;
384 drv_data = pci_get_drvdata(pdev);
385 if (drv_data != NULL) {
386 pci_iounmap(pdev, drv_data->pti_ioaddr);
387 pci_set_drvdata(pdev, NULL);
389 pci_release_region(pdev, 1);
390 pci_disable_device(pdev);
395 * for the tty_driver_*() basic function descriptions, see tty_driver.h.
396 * Specific header comments made for PTI-related specifics.
400 * pti_tty_driver_open()- Open an Application master, channel aperture
401 * ID to the PTI device via tty device.
403 * @tty: tty interface.
404 * @filp: filp interface pased to tty_port_open() call.
408 * otherwise, fail value
410 * The main purpose of using the tty device interface is for
411 * each tty port to have a unique PTI write aperture. In an
412 * example use case, ttyPTI0 gets syslogd and an APP aperture
413 * ID and ttyPTI1 is where the n_tracesink ldisc hooks to route
414 * modem messages into PTI. Modem trace data does not have to
415 * go to ttyPTI1, but ttyPTI0 and ttyPTI1 do need to be distinct
416 * master IDs. These messages go through the PTI HW and out of
417 * the handheld platform and to the Fido/Lauterbach device.
419 static int pti_tty_driver_open(struct tty_struct *tty, struct file *filp)
422 * we actually want to allocate a new channel per open, per
423 * system arch. HW gives more than plenty channels for a single
424 * system task to have its own channel to write trace data. This
425 * also removes a locking requirement for the actual write
428 return tty_port_open(&drv_data->port, tty, filp);
432 * pti_tty_driver_close()- close tty device and release Application
433 * master, channel aperture ID to the PTI device via tty device.
435 * @tty: tty interface.
436 * @filp: filp interface pased to tty_port_close() call.
438 * The main purpose of using the tty device interface is to route
439 * syslog daemon messages to the PTI HW and out of the handheld platform
440 * and to the Fido/Lauterbach device.
442 static void pti_tty_driver_close(struct tty_struct *tty, struct file *filp)
444 tty_port_close(&drv_data->port, tty, filp);
448 * pti_tty_intstall()- Used to set up specific master-channels
449 * to tty ports for organizational purposes when
450 * tracing viewed from debuging tools.
452 * @driver: tty driver information.
453 * @tty: tty struct containing pti information.
459 static int pti_tty_install(struct tty_driver *driver, struct tty_struct *tty)
461 int idx = tty->index;
462 struct pti_tty *pti_tty_data;
463 int ret = tty_init_termios(tty);
466 tty_driver_kref_get(driver);
468 driver->ttys[idx] = tty;
470 pti_tty_data = kmalloc(sizeof(struct pti_tty), GFP_KERNEL);
471 if (pti_tty_data == NULL)
474 if (idx == PTITTY_MINOR_START)
475 pti_tty_data->mc = pti_request_masterchannel(0);
477 pti_tty_data->mc = pti_request_masterchannel(2);
479 if (pti_tty_data->mc == NULL)
481 tty->driver_data = pti_tty_data;
488 * pti_tty_cleanup()- Used to de-allocate master-channel resources
489 * tied to tty's of this driver.
491 * @tty: tty struct containing pti information.
493 static void pti_tty_cleanup(struct tty_struct *tty)
495 struct pti_tty *pti_tty_data = tty->driver_data;
496 if (pti_tty_data == NULL)
498 pti_release_masterchannel(pti_tty_data->mc);
499 kfree(tty->driver_data);
500 tty->driver_data = NULL;
504 * pti_tty_driver_write()- Write trace debugging data through the char
505 * interface to the PTI HW. Part of the misc device implementation.
507 * @filp: Contains private data which is used to obtain
508 * master, channel write ID.
509 * @data: trace data to be written.
510 * @len: # of byte to write.
513 * int, # of bytes written
516 static int pti_tty_driver_write(struct tty_struct *tty,
517 const unsigned char *buf, int len)
519 struct pti_tty *pti_tty_data = tty->driver_data;
520 if ((pti_tty_data != NULL) && (pti_tty_data->mc != NULL)) {
521 pti_write_to_aperture(pti_tty_data->mc, (u8 *)buf, len);
525 * we can't write to the pti hardware if the private driver_data
526 * and the mc address is not there.
533 * pti_tty_write_room()- Always returns 2048.
535 * @tty: contains tty info of the pti driver.
537 static int pti_tty_write_room(struct tty_struct *tty)
543 * pti_char_open()- Open an Application master, channel aperture
544 * ID to the PTI device. Part of the misc device implementation.
547 * @filp: Output- will have a masterchannel struct set containing
548 * the allocated application PTI aperture write address.
552 * otherwise, a fail value
554 static int pti_char_open(struct inode *inode, struct file *filp)
556 struct pti_masterchannel *mc;
559 * We really do want to fail immediately if
560 * pti_request_masterchannel() fails,
561 * before assigning the value to filp->private_data.
562 * Slightly easier to debug if this driver needs debugging.
564 mc = pti_request_masterchannel(0);
567 filp->private_data = mc;
572 * pti_char_release()- Close a char channel to the PTI device. Part
573 * of the misc device implementation.
575 * @inode: Not used in this implementaiton.
576 * @filp: Contains private_data that contains the master, channel
577 * ID to be released by the PTI device.
582 static int pti_char_release(struct inode *inode, struct file *filp)
584 pti_release_masterchannel(filp->private_data);
585 filp->private_data = NULL;
590 * pti_char_write()- Write trace debugging data through the char
591 * interface to the PTI HW. Part of the misc device implementation.
593 * @filp: Contains private data which is used to obtain
594 * master, channel write ID.
595 * @data: trace data to be written.
596 * @len: # of byte to write.
597 * @ppose: Not used in this function implementation.
600 * int, # of bytes written
601 * otherwise, error value
603 * Notes: From side discussions with Alan Cox and experimenting
604 * with PTI debug HW like Nokia's Fido box and Lauterbach
605 * devices, 8192 byte write buffer used by USER_COPY_SIZE was
606 * deemed an appropriate size for this type of usage with
609 static ssize_t pti_char_write(struct file *filp, const char __user *data,
610 size_t len, loff_t *ppose)
612 struct pti_masterchannel *mc;
614 const char __user *tmp;
615 size_t size = USER_COPY_SIZE;
619 mc = filp->private_data;
621 kbuf = kmalloc(size, GFP_KERNEL);
623 pr_err("%s(%d): buf allocation failed\n",
629 if (len - n > USER_COPY_SIZE)
630 size = USER_COPY_SIZE;
634 if (copy_from_user(kbuf, tmp, size)) {
636 return n ? n : -EFAULT;
639 pti_write_to_aperture(mc, kbuf, size);
649 static const struct tty_operations pti_tty_driver_ops = {
650 .open = pti_tty_driver_open,
651 .close = pti_tty_driver_close,
652 .write = pti_tty_driver_write,
653 .write_room = pti_tty_write_room,
654 .install = pti_tty_install,
655 .cleanup = pti_tty_cleanup
658 static const struct file_operations pti_char_driver_ops = {
659 .owner = THIS_MODULE,
660 .write = pti_char_write,
661 .open = pti_char_open,
662 .release = pti_char_release,
665 static struct miscdevice pti_char_driver = {
666 .minor = MISC_DYNAMIC_MINOR,
668 .fops = &pti_char_driver_ops
672 * pti_console_write()- Write to the console that has been acquired.
674 * @c: Not used in this implementaiton.
675 * @buf: Data to be written.
676 * @len: Length of buf.
678 static void pti_console_write(struct console *c, const char *buf, unsigned len)
680 static struct pti_masterchannel mc = {.master = CONSOLE_ID,
683 mc.channel = pti_console_channel;
684 pti_console_channel = (pti_console_channel + 1) & 0x7f;
686 pti_write_full_frame_to_aperture(&mc, buf, len);
690 * pti_console_device()- Return the driver tty structure and set the
691 * associated index implementation.
693 * @c: Console device of the driver.
694 * @index: index associated with c.
697 * always value of pti_tty_driver structure when this function
700 static struct tty_driver *pti_console_device(struct console *c, int *index)
703 return pti_tty_driver;
707 * pti_console_setup()- Initialize console variables used by the driver.
715 static int pti_console_setup(struct console *c, char *opts)
717 pti_console_channel = 0;
718 pti_control_channel = 0;
723 * pti_console struct, used to capture OS printk()'s and shift
724 * out to the PTI device for debugging. This cannot be
725 * enabled upon boot because of the possibility of eating
726 * any serial console printk's (race condition discovered).
727 * The console should be enabled upon when the tty port is
728 * used for the first time. Since the primary purpose for
729 * the tty port is to hook up syslog to it, the tty port
730 * will be open for a really long time.
732 static struct console pti_console = {
734 .write = pti_console_write,
735 .device = pti_console_device,
736 .setup = pti_console_setup,
737 .flags = CON_PRINTBUFFER,
742 * pti_port_activate()- Used to start/initialize any items upon
743 * first opening of tty_port().
745 * @port- The tty port number of the PTI device.
746 * @tty- The tty struct associated with this device.
751 * Notes: The primary purpose of the PTI tty port 0 is to hook
752 * the syslog daemon to it; thus this port will be open for a
755 static int pti_port_activate(struct tty_port *port, struct tty_struct *tty)
757 if (port->tty->index == PTITTY_MINOR_START)
758 console_start(&pti_console);
763 * pti_port_shutdown()- Used to stop/shutdown any items upon the
764 * last tty port close.
766 * @port- The tty port number of the PTI device.
768 * Notes: The primary purpose of the PTI tty port 0 is to hook
769 * the syslog daemon to it; thus this port will be open for a
772 static void pti_port_shutdown(struct tty_port *port)
774 if (port->tty->index == PTITTY_MINOR_START)
775 console_stop(&pti_console);
778 static const struct tty_port_operations tty_port_ops = {
779 .activate = pti_port_activate,
780 .shutdown = pti_port_shutdown,
784 * Note the _probe() call sets everything up and ties the char and tty
785 * to successfully detecting the PTI device on the pci bus.
789 * pti_pci_probe()- Used to detect pti on the pci bus and set
790 * things up in the driver.
792 * @pdev- pci_dev struct values for pti.
793 * @ent- pci_device_id struct for pti driver.
799 static int __devinit pti_pci_probe(struct pci_dev *pdev,
800 const struct pci_device_id *ent)
802 int retval = -EINVAL;
805 dev_dbg(&pdev->dev, "%s %s(%d): PTI PCI ID %04x:%04x\n", __FILE__,
806 __func__, __LINE__, pdev->vendor, pdev->device);
808 retval = misc_register(&pti_char_driver);
810 pr_err("%s(%d): CHAR registration failed of pti driver\n",
812 pr_err("%s(%d): Error value returned: %d\n",
813 __func__, __LINE__, retval);
817 retval = pci_enable_device(pdev);
820 "%s: pci_enable_device() returned error %d\n",
825 drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL);
827 if (drv_data == NULL) {
830 "%s(%d): kmalloc() returned NULL memory.\n",
834 drv_data->pti_addr = pci_resource_start(pdev, pci_bar);
836 retval = pci_request_region(pdev, pci_bar, dev_name(&pdev->dev));
839 "%s(%d): pci_request_region() returned error %d\n",
840 __func__, __LINE__, retval);
844 drv_data->aperture_base = drv_data->pti_addr+APERTURE_14;
845 drv_data->pti_ioaddr =
846 ioremap_nocache((u32)drv_data->aperture_base,
848 if (!drv_data->pti_ioaddr) {
849 pci_release_region(pdev, pci_bar);
855 pci_set_drvdata(pdev, drv_data);
857 tty_port_init(&drv_data->port);
858 drv_data->port.ops = &tty_port_ops;
860 tty_register_device(pti_tty_driver, 0, &pdev->dev);
861 tty_register_device(pti_tty_driver, 1, &pdev->dev);
863 register_console(&pti_console);
868 static struct pci_driver pti_pci_driver = {
871 .probe = pti_pci_probe,
872 .remove = pti_pci_remove,
877 * pti_init()- Overall entry/init call to the pti driver.
878 * It starts the registration process with the kernel.
881 * int __init, 0 for success
882 * otherwise value is an error
885 static int __init pti_init(void)
887 int retval = -EINVAL;
889 /* First register module as tty device */
891 pti_tty_driver = alloc_tty_driver(1);
892 if (pti_tty_driver == NULL) {
893 pr_err("%s(%d): Memory allocation failed for ptiTTY driver\n",
898 pti_tty_driver->owner = THIS_MODULE;
899 pti_tty_driver->magic = TTY_DRIVER_MAGIC;
900 pti_tty_driver->driver_name = DRIVERNAME;
901 pti_tty_driver->name = TTYNAME;
902 pti_tty_driver->major = 0;
903 pti_tty_driver->minor_start = PTITTY_MINOR_START;
904 pti_tty_driver->minor_num = PTITTY_MINOR_NUM;
905 pti_tty_driver->num = PTITTY_MINOR_NUM;
906 pti_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
907 pti_tty_driver->subtype = SYSTEM_TYPE_SYSCONS;
908 pti_tty_driver->flags = TTY_DRIVER_REAL_RAW |
909 TTY_DRIVER_DYNAMIC_DEV;
910 pti_tty_driver->init_termios = tty_std_termios;
912 tty_set_operations(pti_tty_driver, &pti_tty_driver_ops);
914 retval = tty_register_driver(pti_tty_driver);
916 pr_err("%s(%d): TTY registration failed of pti driver\n",
918 pr_err("%s(%d): Error value returned: %d\n",
919 __func__, __LINE__, retval);
921 pti_tty_driver = NULL;
925 retval = pci_register_driver(&pti_pci_driver);
928 pr_err("%s(%d): PCI registration failed of pti driver\n",
930 pr_err("%s(%d): Error value returned: %d\n",
931 __func__, __LINE__, retval);
933 tty_unregister_driver(pti_tty_driver);
934 pr_err("%s(%d): Unregistering TTY part of pti driver\n",
936 pti_tty_driver = NULL;
944 * pti_exit()- Unregisters this module as a tty and pci driver.
946 static void __exit pti_exit(void)
950 tty_unregister_device(pti_tty_driver, 0);
951 tty_unregister_device(pti_tty_driver, 1);
953 retval = tty_unregister_driver(pti_tty_driver);
955 pr_err("%s(%d): TTY unregistration failed of pti driver\n",
957 pr_err("%s(%d): Error value returned: %d\n",
958 __func__, __LINE__, retval);
961 pci_unregister_driver(&pti_pci_driver);
963 retval = misc_deregister(&pti_char_driver);
965 pr_err("%s(%d): CHAR unregistration failed of pti driver\n",
967 pr_err("%s(%d): Error value returned: %d\n",
968 __func__, __LINE__, retval);
971 unregister_console(&pti_console);
975 module_init(pti_init);
976 module_exit(pti_exit);
978 MODULE_LICENSE("GPL");
979 MODULE_AUTHOR("Ken Mills, Jay Freyensee");
980 MODULE_DESCRIPTION("PTI Driver");