/* * pti.c - PTI driver for cJTAG data extration * * Copyright (C) Intel 2010 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * The PTI (Parallel Trace Interface) driver directs trace data routed from * various parts in the system out through the Intel Penwell PTI port and * out of the mobile device for analysis with a debugging tool * (Lauterbach, Fido). This is part of a solution for the MIPI P1149.7, * compact JTAG, standard. */ #include <linux/init.h> #include <linux/sched.h> #include <linux/interrupt.h> #include <linux/console.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/tty.h> #include <linux/tty_driver.h> #include <linux/pci.h> #include <linux/mutex.h> #include <linux/miscdevice.h> #include <linux/pti.h> #include <linux/slab.h> #include <linux/uaccess.h> #define DRIVERNAME "pti" #define PCINAME "pciPTI" #define TTYNAME "ttyPTI" #define CHARNAME "pti" #define PTITTY_MINOR_START 0 #define PTITTY_MINOR_NUM 2 #define MAX_APP_IDS 16 /* 128 channel ids / u8 bit size */ #define MAX_OS_IDS 16 /* 128 channel ids / u8 bit size */ #define MAX_MODEM_IDS 16 /* 128 channel ids / u8 bit size */ #define MODEM_BASE_ID 71 /* modem master ID address */ #define CONTROL_ID 72 /* control master ID address */ #define CONSOLE_ID 73 /* console master ID address */ #define OS_BASE_ID 74 /* base OS master ID address */ #define APP_BASE_ID 80 /* base App master ID address */ #define CONTROL_FRAME_LEN 32 /* PTI control frame maximum size */ #define USER_COPY_SIZE 8192 /* 8Kb buffer for user space copy */ #define APERTURE_14 0x3800000 /* offset to first OS write addr */ #define APERTURE_LEN 0x400000 /* address length */ struct pti_tty { struct pti_masterchannel *mc; }; struct pti_dev { struct tty_port port[PTITTY_MINOR_NUM]; unsigned long pti_addr; unsigned long aperture_base; void __iomem *pti_ioaddr; u8 ia_app[MAX_APP_IDS]; u8 ia_os[MAX_OS_IDS]; u8 ia_modem[MAX_MODEM_IDS]; }; /* * This protects access to ia_app, ia_os, and ia_modem, * which keeps track of channels allocated in * an aperture write id. */ static DEFINE_MUTEX(alloclock); static const struct pci_device_id pci_ids[] = { {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x82B)}, {0} }; static struct tty_driver *pti_tty_driver; static struct pti_dev *drv_data; static unsigned int pti_console_channel; static unsigned int pti_control_channel; /** * pti_write_to_aperture()- The private write function to PTI HW. * * @mc: The 'aperture'. It's part of a write address that holds * a master and channel ID. * @buf: Data being written to the HW that will ultimately be seen * in a debugging tool (Fido, Lauterbach). * @len: Size of buffer. * * Since each aperture is specified by a unique * master/channel ID, no two processes will be writing * to the same aperture at the same time so no lock is required. The * PTI-Output agent will send these out in the order that they arrived, and * thus, it will intermix these messages. The debug tool can then later * regroup the appropriate message segments together reconstituting each * message. */ static void pti_write_to_aperture(struct pti_masterchannel *mc, u8 *buf, int len) { int dwordcnt; int final; int i; u32 ptiword; u32 __iomem *aperture; u8 *p = buf; /* * calculate the aperture offset from the base using the master and * channel id's. */ aperture = drv_data->pti_ioaddr + (mc->master << 15) + (mc->channel << 8); dwordcnt = len >> 2; final = len - (dwordcnt << 2); /* final = trailing bytes */ if (final == 0 && dwordcnt != 0) { /* always need a final dword */ final += 4; dwordcnt--; } for (i = 0; i < dwordcnt; i++) { ptiword = be32_to_cpu(*(u32 *)p); p += 4; iowrite32(ptiword, aperture); } aperture += PTI_LASTDWORD_DTS; /* adding DTS signals that is EOM */ ptiword = 0; for (i = 0; i < final; i++) ptiword |= *p++ << (24-(8*i)); iowrite32(ptiword, aperture); return; } /** * pti_control_frame_built_and_sent()- control frame build and send function. * * @mc: The master / channel structure on which the function * built a control frame. * @thread_name: The thread name associated with the master / channel or * 'NULL' if using the 'current' global variable. * * To be able to post process the PTI contents on host side, a control frame * is added before sending any PTI content. So the host side knows on * each PTI frame the name of the thread using a dedicated master / channel. * The thread name is retrieved from 'current' global variable if 'thread_name' * is 'NULL', else it is retrieved from 'thread_name' parameter. * This function builds this frame and sends it to a master ID CONTROL_ID. * The overhead is only 32 bytes since the driver only writes to HW * in 32 byte chunks. */ static void pti_control_frame_built_and_sent(struct pti_masterchannel *mc, const char *thread_name) { /* * Since we access the comm member in current's task_struct, we only * need to be as large as what 'comm' in that structure is. */ char comm[TASK_COMM_LEN]; struct pti_masterchannel mccontrol = {.master = CONTROL_ID, .channel = 0}; const char *thread_name_p; const char *control_format = "%3d %3d %s"; u8 control_frame[CONTROL_FRAME_LEN]; if (!thread_name) { if (!in_interrupt()) get_task_comm(comm, current); else strncpy(comm, "Interrupt", TASK_COMM_LEN); /* Absolutely ensure our buffer is zero terminated. */ comm[TASK_COMM_LEN-1] = 0; thread_name_p = comm; } else { thread_name_p = thread_name; } mccontrol.channel = pti_control_channel; pti_control_channel = (pti_control_channel + 1) & 0x7f; snprintf(control_frame, CONTROL_FRAME_LEN, control_format, mc->master, mc->channel, thread_name_p); pti_write_to_aperture(&mccontrol, control_frame, strlen(control_frame)); } /** * pti_write_full_frame_to_aperture()- high level function to * write to PTI. * * @mc: The 'aperture'. It's part of a write address that holds * a master and channel ID. * @buf: Data being written to the HW that will ultimately be seen * in a debugging tool (Fido, Lauterbach). * @len: Size of buffer. * * All threads sending data (either console, user space application, ...) * are calling the high level function to write to PTI meaning that it is * possible to add a control frame before sending the content. */ static void pti_write_full_frame_to_aperture(struct pti_masterchannel *mc, const unsigned char *buf, int len) { pti_control_frame_built_and_sent(mc, NULL); pti_write_to_aperture(mc, (u8 *)buf, len); } /** * get_id()- Allocate a master and channel ID. * * @id_array: an array of bits representing what channel * id's are allocated for writing. * @max_ids: The max amount of available write IDs to use. * @base_id: The starting SW channel ID, based on the Intel * PTI arch. * @thread_name: The thread name associated with the master / channel or * 'NULL' if using the 'current' global variable. * * Returns: * pti_masterchannel struct with master, channel ID address * 0 for error * * Each bit in the arrays ia_app and ia_os correspond to a master and * channel id. The bit is one if the id is taken and 0 if free. For * every master there are 128 channel id's. */ static struct pti_masterchannel *get_id(u8 *id_array, int max_ids, int base_id, const char *thread_name) { struct pti_masterchannel *mc; int i, j, mask; mc = kmalloc(sizeof(struct pti_masterchannel), GFP_KERNEL); if (mc == NULL) return NULL; /* look for a byte with a free bit */ for (i = 0; i < max_ids; i++) if (id_array[i] != 0xff) break; if (i == max_ids) { kfree(mc); return NULL; } /* find the bit in the 128 possible channel opportunities */ mask = 0x80; for (j = 0; j < 8; j++) { if ((id_array[i] & mask) == 0) break; mask >>= 1; } /* grab it */ id_array[i] |= mask; mc->master = base_id; mc->channel = ((i & 0xf)<<3) + j; /* write new master Id / channel Id allocation to channel control */ pti_control_frame_built_and_sent(mc, thread_name); return mc; } /* * The following three functions: * pti_request_mastercahannel(), mipi_release_masterchannel() * and pti_writedata() are an API for other kernel drivers to * access PTI. */ /** * pti_request_masterchannel()- Kernel API function used to allocate * a master, channel ID address * to write to PTI HW. * * @type: 0- request Application master, channel aperture ID * write address. * 1- request OS master, channel aperture ID write * address. * 2- request Modem master, channel aperture ID * write address. * Other values, error. * @thread_name: The thread name associated with the master / channel or * 'NULL' if using the 'current' global variable. * * Returns: * pti_masterchannel struct * 0 for error */ struct pti_masterchannel *pti_request_masterchannel(u8 type, const char *thread_name) { struct pti_masterchannel *mc; mutex_lock(&alloclock); switch (type) { case 0: mc = get_id(drv_data->ia_app, MAX_APP_IDS, APP_BASE_ID, thread_name); break; case 1: mc = get_id(drv_data->ia_os, MAX_OS_IDS, OS_BASE_ID, thread_name); break; case 2: mc = get_id(drv_data->ia_modem, MAX_MODEM_IDS, MODEM_BASE_ID, thread_name); break; default: mc = NULL; } mutex_unlock(&alloclock); return mc; } EXPORT_SYMBOL_GPL(pti_request_masterchannel); /** * pti_release_masterchannel()- Kernel API function used to release * a master, channel ID address * used to write to PTI HW. * * @mc: master, channel apeture ID address to be released. This * will de-allocate the structure via kfree(). */ void pti_release_masterchannel(struct pti_masterchannel *mc) { u8 master, channel, i; mutex_lock(&alloclock); if (mc) { master = mc->master; channel = mc->channel; if (master == APP_BASE_ID) { i = channel >> 3; drv_data->ia_app[i] &= ~(0x80>>(channel & 0x7)); } else if (master == OS_BASE_ID) { i = channel >> 3; drv_data->ia_os[i] &= ~(0x80>>(channel & 0x7)); } else { i = channel >> 3; drv_data->ia_modem[i] &= ~(0x80>>(channel & 0x7)); } kfree(mc); } mutex_unlock(&alloclock); } EXPORT_SYMBOL_GPL(pti_release_masterchannel); /** * pti_writedata()- Kernel API function used to write trace * debugging data to PTI HW. * * @mc: Master, channel aperture ID address to write to. * Null value will return with no write occurring. * @buf: Trace debuging data to write to the PTI HW. * Null value will return with no write occurring. * @count: Size of buf. Value of 0 or a negative number will * return with no write occuring. */ void pti_writedata(struct pti_masterchannel *mc, u8 *buf, int count) { /* * since this function is exported, this is treated like an * API function, thus, all parameters should * be checked for validity. */ if ((mc != NULL) && (buf != NULL) && (count > 0)) pti_write_to_aperture(mc, buf, count); return; } EXPORT_SYMBOL_GPL(pti_writedata); /* * for the tty_driver_*() basic function descriptions, see tty_driver.h. * Specific header comments made for PTI-related specifics. */ /** * pti_tty_driver_open()- Open an Application master, channel aperture * ID to the PTI device via tty device. * * @tty: tty interface. * @filp: filp interface pased to tty_port_open() call. * * Returns: * int, 0 for success * otherwise, fail value * * The main purpose of using the tty device interface is for * each tty port to have a unique PTI write aperture. In an * example use case, ttyPTI0 gets syslogd and an APP aperture * ID and ttyPTI1 is where the n_tracesink ldisc hooks to route * modem messages into PTI. Modem trace data does not have to * go to ttyPTI1, but ttyPTI0 and ttyPTI1 do need to be distinct * master IDs. These messages go through the PTI HW and out of * the handheld platform and to the Fido/Lauterbach device. */ static int pti_tty_driver_open(struct tty_struct *tty, struct file *filp) { /* * we actually want to allocate a new channel per open, per * system arch. HW gives more than plenty channels for a single * system task to have its own channel to write trace data. This * also removes a locking requirement for the actual write * procedure. */ return tty_port_open(tty->port, tty, filp); } /** * pti_tty_driver_close()- close tty device and release Application * master, channel aperture ID to the PTI device via tty device. * * @tty: tty interface. * @filp: filp interface pased to tty_port_close() call. * * The main purpose of using the tty device interface is to route * syslog daemon messages to the PTI HW and out of the handheld platform * and to the Fido/Lauterbach device. */ static void pti_tty_driver_close(struct tty_struct *tty, struct file *filp) { tty_port_close(tty->port, tty, filp); } /** * pti_tty_install()- Used to set up specific master-channels * to tty ports for organizational purposes when * tracing viewed from debuging tools. * * @driver: tty driver information. * @tty: tty struct containing pti information. * * Returns: * 0 for success * otherwise, error */ static int pti_tty_install(struct tty_driver *driver, struct tty_struct *tty) { int idx = tty->index; struct pti_tty *pti_tty_data; int ret = tty_standard_install(driver, tty); if (ret == 0) { pti_tty_data = kmalloc(sizeof(struct pti_tty), GFP_KERNEL); if (pti_tty_data == NULL) return -ENOMEM; if (idx == PTITTY_MINOR_START) pti_tty_data->mc = pti_request_masterchannel(0, NULL); else pti_tty_data->mc = pti_request_masterchannel(2, NULL); if (pti_tty_data->mc == NULL) { kfree(pti_tty_data); return -ENXIO; } tty->driver_data = pti_tty_data; } return ret; } /** * pti_tty_cleanup()- Used to de-allocate master-channel resources * tied to tty's of this driver. * * @tty: tty struct containing pti information. */ static void pti_tty_cleanup(struct tty_struct *tty) { struct pti_tty *pti_tty_data = tty->driver_data; if (pti_tty_data == NULL) return; pti_release_masterchannel(pti_tty_data->mc); kfree(pti_tty_data); tty->driver_data = NULL; } /** * pti_tty_driver_write()- Write trace debugging data through the char * interface to the PTI HW. Part of the misc device implementation. * * @filp: Contains private data which is used to obtain * master, channel write ID. * @data: trace data to be written. * @len: # of byte to write. * * Returns: * int, # of bytes written * otherwise, error */ static int pti_tty_driver_write(struct tty_struct *tty, const unsigned char *buf, int len) { struct pti_tty *pti_tty_data = tty->driver_data; if ((pti_tty_data != NULL) && (pti_tty_data->mc != NULL)) { pti_write_to_aperture(pti_tty_data->mc, (u8 *)buf, len); return len; } /* * we can't write to the pti hardware if the private driver_data * and the mc address is not there. */ else return -EFAULT; } /** * pti_tty_write_room()- Always returns 2048. * * @tty: contains tty info of the pti driver. */ static int pti_tty_write_room(struct tty_struct *tty) { return 2048; } /** * pti_char_open()- Open an Application master, channel aperture * ID to the PTI device. Part of the misc device implementation. * * @inode: not used. * @filp: Output- will have a masterchannel struct set containing * the allocated application PTI aperture write address. * * Returns: * int, 0 for success * otherwise, a fail value */ static int pti_char_open(struct inode *inode, struct file *filp) { struct pti_masterchannel *mc; /* * We really do want to fail immediately if * pti_request_masterchannel() fails, * before assigning the value to filp->private_data. * Slightly easier to debug if this driver needs debugging. */ mc = pti_request_masterchannel(0, NULL); if (mc == NULL) return -ENOMEM; filp->private_data = mc; return 0; } /** * pti_char_release()- Close a char channel to the PTI device. Part * of the misc device implementation. * * @inode: Not used in this implementaiton. * @filp: Contains private_data that contains the master, channel * ID to be released by the PTI device. * * Returns: * always 0 */ static int pti_char_release(struct inode *inode, struct file *filp) { pti_release_masterchannel(filp->private_data); filp->private_data = NULL; return 0; } /** * pti_char_write()- Write trace debugging data through the char * interface to the PTI HW. Part of the misc device implementation. * * @filp: Contains private data which is used to obtain * master, channel write ID. * @data: trace data to be written. * @len: # of byte to write. * @ppose: Not used in this function implementation. * * Returns: * int, # of bytes written * otherwise, error value * * Notes: From side discussions with Alan Cox and experimenting * with PTI debug HW like Nokia's Fido box and Lauterbach * devices, 8192 byte write buffer used by USER_COPY_SIZE was * deemed an appropriate size for this type of usage with * debugging HW. */ static ssize_t pti_char_write(struct file *filp, const char __user *data, size_t len, loff_t *ppose) { struct pti_masterchannel *mc; void *kbuf; const char __user *tmp; size_t size = USER_COPY_SIZE; size_t n = 0; tmp = data; mc = filp->private_data; kbuf = kmalloc(size, GFP_KERNEL); if (kbuf == NULL) { pr_err("%s(%d): buf allocation failed\n", __func__, __LINE__); return -ENOMEM; } do { if (len - n > USER_COPY_SIZE) size = USER_COPY_SIZE; else size = len - n; if (copy_from_user(kbuf, tmp, size)) { kfree(kbuf); return n ? n : -EFAULT; } pti_write_to_aperture(mc, kbuf, size); n += size; tmp += size; } while (len > n); kfree(kbuf); return len; } static const struct tty_operations pti_tty_driver_ops = { .open = pti_tty_driver_open, .close = pti_tty_driver_close, .write = pti_tty_driver_write, .write_room = pti_tty_write_room, .install = pti_tty_install, .cleanup = pti_tty_cleanup }; static const struct file_operations pti_char_driver_ops = { .owner = THIS_MODULE, .write = pti_char_write, .open = pti_char_open, .release = pti_char_release, }; static struct miscdevice pti_char_driver = { .minor = MISC_DYNAMIC_MINOR, .name = CHARNAME, .fops = &pti_char_driver_ops }; /** * pti_console_write()- Write to the console that has been acquired. * * @c: Not used in this implementaiton. * @buf: Data to be written. * @len: Length of buf. */ static void pti_console_write(struct console *c, const char *buf, unsigned len) { static struct pti_masterchannel mc = {.master = CONSOLE_ID, .channel = 0}; mc.channel = pti_console_channel; pti_console_channel = (pti_console_channel + 1) & 0x7f; pti_write_full_frame_to_aperture(&mc, buf, len); } /** * pti_console_device()- Return the driver tty structure and set the * associated index implementation. * * @c: Console device of the driver. * @index: index associated with c. * * Returns: * always value of pti_tty_driver structure when this function * is called. */ static struct tty_driver *pti_console_device(struct console *c, int *index) { *index = c->index; return pti_tty_driver; } /** * pti_console_setup()- Initialize console variables used by the driver. * * @c: Not used. * @opts: Not used. * * Returns: * always 0. */ static int pti_console_setup(struct console *c, char *opts) { pti_console_channel = 0; pti_control_channel = 0; return 0; } /* * pti_console struct, used to capture OS printk()'s and shift * out to the PTI device for debugging. This cannot be * enabled upon boot because of the possibility of eating * any serial console printk's (race condition discovered). * The console should be enabled upon when the tty port is * used for the first time. Since the primary purpose for * the tty port is to hook up syslog to it, the tty port * will be open for a really long time. */ static struct console pti_console = { .name = TTYNAME, .write = pti_console_write, .device = pti_console_device, .setup = pti_console_setup, .flags = CON_PRINTBUFFER, .index = 0, }; /** * pti_port_activate()- Used to start/initialize any items upon * first opening of tty_port(). * * @port- The tty port number of the PTI device. * @tty- The tty struct associated with this device. * * Returns: * always returns 0 * * Notes: The primary purpose of the PTI tty port 0 is to hook * the syslog daemon to it; thus this port will be open for a * very long time. */ static int pti_port_activate(struct tty_port *port, struct tty_struct *tty) { if (port->tty->index == PTITTY_MINOR_START) console_start(&pti_console); return 0; } /** * pti_port_shutdown()- Used to stop/shutdown any items upon the * last tty port close. * * @port- The tty port number of the PTI device. * * Notes: The primary purpose of the PTI tty port 0 is to hook * the syslog daemon to it; thus this port will be open for a * very long time. */ static void pti_port_shutdown(struct tty_port *port) { if (port->tty->index == PTITTY_MINOR_START) console_stop(&pti_console); } static const struct tty_port_operations tty_port_ops = { .activate = pti_port_activate, .shutdown = pti_port_shutdown, }; /* * Note the _probe() call sets everything up and ties the char and tty * to successfully detecting the PTI device on the pci bus. */ /** * pti_pci_probe()- Used to detect pti on the pci bus and set * things up in the driver. * * @pdev- pci_dev struct values for pti. * @ent- pci_device_id struct for pti driver. * * Returns: * 0 for success * otherwise, error */ static int pti_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { unsigned int a; int retval = -EINVAL; int pci_bar = 1; dev_dbg(&pdev->dev, "%s %s(%d): PTI PCI ID %04x:%04x\n", __FILE__, __func__, __LINE__, pdev->vendor, pdev->device); retval = misc_register(&pti_char_driver); if (retval) { pr_err("%s(%d): CHAR registration failed of pti driver\n", __func__, __LINE__); pr_err("%s(%d): Error value returned: %d\n", __func__, __LINE__, retval); goto err; } retval = pci_enable_device(pdev); if (retval != 0) { dev_err(&pdev->dev, "%s: pci_enable_device() returned error %d\n", __func__, retval); goto err_unreg_misc; } drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL); if (drv_data == NULL) { retval = -ENOMEM; dev_err(&pdev->dev, "%s(%d): kmalloc() returned NULL memory.\n", __func__, __LINE__); goto err_disable_pci; } drv_data->pti_addr = pci_resource_start(pdev, pci_bar); retval = pci_request_region(pdev, pci_bar, dev_name(&pdev->dev)); if (retval != 0) { dev_err(&pdev->dev, "%s(%d): pci_request_region() returned error %d\n", __func__, __LINE__, retval); goto err_free_dd; } drv_data->aperture_base = drv_data->pti_addr+APERTURE_14; drv_data->pti_ioaddr = ioremap_nocache((u32)drv_data->aperture_base, APERTURE_LEN); if (!drv_data->pti_ioaddr) { retval = -ENOMEM; goto err_rel_reg; } pci_set_drvdata(pdev, drv_data); for (a = 0; a < PTITTY_MINOR_NUM; a++) { struct tty_port *port = &drv_data->port[a]; tty_port_init(port); port->ops = &tty_port_ops; tty_port_register_device(port, pti_tty_driver, a, &pdev->dev); } register_console(&pti_console); return 0; err_rel_reg: pci_release_region(pdev, pci_bar); err_free_dd: kfree(drv_data); err_disable_pci: pci_disable_device(pdev); err_unreg_misc: misc_deregister(&pti_char_driver); err: return retval; } /** * pti_pci_remove()- Driver exit method to remove PTI from * PCI bus. * @pdev: variable containing pci info of PTI. */ static void pti_pci_remove(struct pci_dev *pdev) { struct pti_dev *drv_data = pci_get_drvdata(pdev); unsigned int a; unregister_console(&pti_console); for (a = 0; a < PTITTY_MINOR_NUM; a++) { tty_unregister_device(pti_tty_driver, a); tty_port_destroy(&drv_data->port[a]); } iounmap(drv_data->pti_ioaddr); kfree(drv_data); pci_release_region(pdev, 1); pci_disable_device(pdev); misc_deregister(&pti_char_driver); } static struct pci_driver pti_pci_driver = { .name = PCINAME, .id_table = pci_ids, .probe = pti_pci_probe, .remove = pti_pci_remove, }; /** * * pti_init()- Overall entry/init call to the pti driver. * It starts the registration process with the kernel. * * Returns: * int __init, 0 for success * otherwise value is an error * */ static int __init pti_init(void) { int retval = -EINVAL; /* First register module as tty device */ pti_tty_driver = alloc_tty_driver(PTITTY_MINOR_NUM); if (pti_tty_driver == NULL) { pr_err("%s(%d): Memory allocation failed for ptiTTY driver\n", __func__, __LINE__); return -ENOMEM; } pti_tty_driver->driver_name = DRIVERNAME; pti_tty_driver->name = TTYNAME; pti_tty_driver->major = 0; pti_tty_driver->minor_start = PTITTY_MINOR_START; pti_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM; pti_tty_driver->subtype = SYSTEM_TYPE_SYSCONS; pti_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; pti_tty_driver->init_termios = tty_std_termios; tty_set_operations(pti_tty_driver, &pti_tty_driver_ops); retval = tty_register_driver(pti_tty_driver); if (retval) { pr_err("%s(%d): TTY registration failed of pti driver\n", __func__, __LINE__); pr_err("%s(%d): Error value returned: %d\n", __func__, __LINE__, retval); goto put_tty; } retval = pci_register_driver(&pti_pci_driver); if (retval) { pr_err("%s(%d): PCI registration failed of pti driver\n", __func__, __LINE__); pr_err("%s(%d): Error value returned: %d\n", __func__, __LINE__, retval); goto unreg_tty; } return 0; unreg_tty: tty_unregister_driver(pti_tty_driver); put_tty: put_tty_driver(pti_tty_driver); pti_tty_driver = NULL; return retval; } /** * pti_exit()- Unregisters this module as a tty and pci driver. */ static void __exit pti_exit(void) { tty_unregister_driver(pti_tty_driver); pci_unregister_driver(&pti_pci_driver); put_tty_driver(pti_tty_driver); } module_init(pti_init); module_exit(pti_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Ken Mills, Jay Freyensee"); MODULE_DESCRIPTION("PTI Driver");