/*
   *  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
  ",
  			__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
  ", __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
  ",
  			__func__, __LINE__);
  		pr_err("%s(%d): Error value returned: %d
  ",
  			__func__, __LINE__, retval);
  		goto err;
  	}
  
  	retval = pci_enable_device(pdev);
  	if (retval != 0) {
  		dev_err(&pdev->dev,
  			"%s: pci_enable_device() returned error %d
  ",
  			__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.
  ",
  			__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
  ",
  			__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
  ",
  			__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
  ",
  			__func__, __LINE__);
  		pr_err("%s(%d): Error value returned: %d
  ",
  			__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
  ",
  			__func__, __LINE__);
  		pr_err("%s(%d): Error value returned: %d
  ",
  			__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");