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
  58struct pti_tty {
  59	struct pti_masterchannel *mc;
  60};
  61
  62struct 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 */
  77static DEFINE_MUTEX(alloclock);
  78
  79static struct pci_device_id pci_ids[] __devinitconst = {
  80		{PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x82B)},
  81		{0}
  82};
  83
  84static struct tty_driver *pti_tty_driver;
  85static struct pti_dev *drv_data;
  86
  87static unsigned int pti_console_channel;
  88static 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 */
 107static 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-(8*i));
 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 */
 165static 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 */
 214static 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 */
 241static 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 */
 304struct 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}
 334EXPORT_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 */
 344void 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}
 370EXPORT_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 */
 383void 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}
 394EXPORT_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 */
 401static 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 */
 440static 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 */
 463static 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 */
 480static 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_init_termios(tty);
 485
 486	if (ret == 0) {
 487		tty_driver_kref_get(driver);
 488		tty->count++;
 489		driver->ttys[idx] = tty;
 490
 491		pti_tty_data = kmalloc(sizeof(struct pti_tty), GFP_KERNEL);
 492		if (pti_tty_data == NULL)
 493			return -ENOMEM;
 494
 495		if (idx == PTITTY_MINOR_START)
 496			pti_tty_data->mc = pti_request_masterchannel(0, NULL);
 497		else
 498			pti_tty_data->mc = pti_request_masterchannel(2, NULL);
 499
 500		if (pti_tty_data->mc == NULL) {
 501			kfree(pti_tty_data);
 502			return -ENXIO;
 503		}
 504		tty->driver_data = pti_tty_data;
 505	}
 506
 507	return ret;
 508}
 509
 510/**
 511 * pti_tty_cleanup()- Used to de-allocate master-channel resources
 512 *		      tied to tty's of this driver.
 513 *
 514 * @tty: tty struct containing pti information.
 515 */
 516static void pti_tty_cleanup(struct tty_struct *tty)
 517{
 518	struct pti_tty *pti_tty_data = tty->driver_data;
 519	if (pti_tty_data == NULL)
 520		return;
 521	pti_release_masterchannel(pti_tty_data->mc);
 522	kfree(pti_tty_data);
 523	tty->driver_data = NULL;
 524}
 525
 526/**
 527 * pti_tty_driver_write()-  Write trace debugging data through the char
 528 * interface to the PTI HW.  Part of the misc device implementation.
 529 *
 530 * @filp: Contains private data which is used to obtain
 531 *        master, channel write ID.
 532 * @data: trace data to be written.
 533 * @len:  # of byte to write.
 534 *
 535 * Returns:
 536 *	int, # of bytes written
 537 *	otherwise, error
 538 */
 539static int pti_tty_driver_write(struct tty_struct *tty,
 540	const unsigned char *buf, int len)
 541{
 542	struct pti_tty *pti_tty_data = tty->driver_data;
 543	if ((pti_tty_data != NULL) && (pti_tty_data->mc != NULL)) {
 544		pti_write_to_aperture(pti_tty_data->mc, (u8 *)buf, len);
 545		return len;
 546	}
 547	/*
 548	 * we can't write to the pti hardware if the private driver_data
 549	 * and the mc address is not there.
 550	 */
 551	else
 552		return -EFAULT;
 553}
 554
 555/**
 556 * pti_tty_write_room()- Always returns 2048.
 557 *
 558 * @tty: contains tty info of the pti driver.
 559 */
 560static int pti_tty_write_room(struct tty_struct *tty)
 561{
 562	return 2048;
 563}
 564
 565/**
 566 * pti_char_open()- Open an Application master, channel aperture
 567 * ID to the PTI device. Part of the misc device implementation.
 568 *
 569 * @inode: not used.
 570 * @filp:  Output- will have a masterchannel struct set containing
 571 *                 the allocated application PTI aperture write address.
 572 *
 573 * Returns:
 574 *	int, 0 for success
 575 *	otherwise, a fail value
 576 */
 577static int pti_char_open(struct inode *inode, struct file *filp)
 578{
 579	struct pti_masterchannel *mc;
 580
 581	/*
 582	 * We really do want to fail immediately if
 583	 * pti_request_masterchannel() fails,
 584	 * before assigning the value to filp->private_data.
 585	 * Slightly easier to debug if this driver needs debugging.
 586	 */
 587	mc = pti_request_masterchannel(0, NULL);
 588	if (mc == NULL)
 589		return -ENOMEM;
 590	filp->private_data = mc;
 591	return 0;
 592}
 593
 594/**
 595 * pti_char_release()-  Close a char channel to the PTI device. Part
 596 * of the misc device implementation.
 597 *
 598 * @inode: Not used in this implementaiton.
 599 * @filp:  Contains private_data that contains the master, channel
 600 *         ID to be released by the PTI device.
 601 *
 602 * Returns:
 603 *	always 0
 604 */
 605static int pti_char_release(struct inode *inode, struct file *filp)
 606{
 607	pti_release_masterchannel(filp->private_data);
 608	filp->private_data = NULL;
 609	return 0;
 610}
 611
 612/**
 613 * pti_char_write()-  Write trace debugging data through the char
 614 * interface to the PTI HW.  Part of the misc device implementation.
 615 *
 616 * @filp:  Contains private data which is used to obtain
 617 *         master, channel write ID.
 618 * @data:  trace data to be written.
 619 * @len:   # of byte to write.
 620 * @ppose: Not used in this function implementation.
 621 *
 622 * Returns:
 623 *	int, # of bytes written
 624 *	otherwise, error value
 625 *
 626 * Notes: From side discussions with Alan Cox and experimenting
 627 * with PTI debug HW like Nokia's Fido box and Lauterbach
 628 * devices, 8192 byte write buffer used by USER_COPY_SIZE was
 629 * deemed an appropriate size for this type of usage with
 630 * debugging HW.
 631 */
 632static ssize_t pti_char_write(struct file *filp, const char __user *data,
 633			      size_t len, loff_t *ppose)
 634{
 635	struct pti_masterchannel *mc;
 636	void *kbuf;
 637	const char __user *tmp;
 638	size_t size = USER_COPY_SIZE;
 639	size_t n = 0;
 640
 641	tmp = data;
 642	mc = filp->private_data;
 643
 644	kbuf = kmalloc(size, GFP_KERNEL);
 645	if (kbuf == NULL)  {
 646		pr_err("%s(%d): buf allocation failed\n",
 647			__func__, __LINE__);
 648		return -ENOMEM;
 649	}
 650
 651	do {
 652		if (len - n > USER_COPY_SIZE)
 653			size = USER_COPY_SIZE;
 654		else
 655			size = len - n;
 656
 657		if (copy_from_user(kbuf, tmp, size)) {
 658			kfree(kbuf);
 659			return n ? n : -EFAULT;
 660		}
 661
 662		pti_write_to_aperture(mc, kbuf, size);
 663		n  += size;
 664		tmp += size;
 665
 666	} while (len > n);
 667
 668	kfree(kbuf);
 669	return len;
 670}
 671
 672static const struct tty_operations pti_tty_driver_ops = {
 673	.open		= pti_tty_driver_open,
 674	.close		= pti_tty_driver_close,
 675	.write		= pti_tty_driver_write,
 676	.write_room	= pti_tty_write_room,
 677	.install	= pti_tty_install,
 678	.cleanup	= pti_tty_cleanup
 679};
 680
 681static const struct file_operations pti_char_driver_ops = {
 682	.owner		= THIS_MODULE,
 683	.write		= pti_char_write,
 684	.open		= pti_char_open,
 685	.release	= pti_char_release,
 686};
 687
 688static struct miscdevice pti_char_driver = {
 689	.minor		= MISC_DYNAMIC_MINOR,
 690	.name		= CHARNAME,
 691	.fops		= &pti_char_driver_ops
 692};
 693
 694/**
 695 * pti_console_write()-  Write to the console that has been acquired.
 696 *
 697 * @c:   Not used in this implementaiton.
 698 * @buf: Data to be written.
 699 * @len: Length of buf.
 700 */
 701static void pti_console_write(struct console *c, const char *buf, unsigned len)
 702{
 703	static struct pti_masterchannel mc = {.master  = CONSOLE_ID,
 704					      .channel = 0};
 705
 706	mc.channel = pti_console_channel;
 707	pti_console_channel = (pti_console_channel + 1) & 0x7f;
 708
 709	pti_write_full_frame_to_aperture(&mc, buf, len);
 710}
 711
 712/**
 713 * pti_console_device()-  Return the driver tty structure and set the
 714 *			  associated index implementation.
 715 *
 716 * @c:     Console device of the driver.
 717 * @index: index associated with c.
 718 *
 719 * Returns:
 720 *	always value of pti_tty_driver structure when this function
 721 *	is called.
 722 */
 723static struct tty_driver *pti_console_device(struct console *c, int *index)
 724{
 725	*index = c->index;
 726	return pti_tty_driver;
 727}
 728
 729/**
 730 * pti_console_setup()-  Initialize console variables used by the driver.
 731 *
 732 * @c:     Not used.
 733 * @opts:  Not used.
 734 *
 735 * Returns:
 736 *	always 0.
 737 */
 738static int pti_console_setup(struct console *c, char *opts)
 739{
 740	pti_console_channel = 0;
 741	pti_control_channel = 0;
 742	return 0;
 743}
 744
 745/*
 746 * pti_console struct, used to capture OS printk()'s and shift
 747 * out to the PTI device for debugging.  This cannot be
 748 * enabled upon boot because of the possibility of eating
 749 * any serial console printk's (race condition discovered).
 750 * The console should be enabled upon when the tty port is
 751 * used for the first time.  Since the primary purpose for
 752 * the tty port is to hook up syslog to it, the tty port
 753 * will be open for a really long time.
 754 */
 755static struct console pti_console = {
 756	.name		= TTYNAME,
 757	.write		= pti_console_write,
 758	.device		= pti_console_device,
 759	.setup		= pti_console_setup,
 760	.flags		= CON_PRINTBUFFER,
 761	.index		= 0,
 762};
 763
 764/**
 765 * pti_port_activate()- Used to start/initialize any items upon
 766 * first opening of tty_port().
 767 *
 768 * @port- The tty port number of the PTI device.
 769 * @tty-  The tty struct associated with this device.
 770 *
 771 * Returns:
 772 *	always returns 0
 773 *
 774 * Notes: The primary purpose of the PTI tty port 0 is to hook
 775 * the syslog daemon to it; thus this port will be open for a
 776 * very long time.
 777 */
 778static int pti_port_activate(struct tty_port *port, struct tty_struct *tty)
 779{
 780	if (port->tty->index == PTITTY_MINOR_START)
 781		console_start(&pti_console);
 782	return 0;
 783}
 784
 785/**
 786 * pti_port_shutdown()- Used to stop/shutdown any items upon the
 787 * last tty port close.
 788 *
 789 * @port- The tty port number of the PTI device.
 790 *
 791 * Notes: The primary purpose of the PTI tty port 0 is to hook
 792 * the syslog daemon to it; thus this port will be open for a
 793 * very long time.
 794 */
 795static void pti_port_shutdown(struct tty_port *port)
 796{
 797	if (port->tty->index == PTITTY_MINOR_START)
 798		console_stop(&pti_console);
 799}
 800
 801static const struct tty_port_operations tty_port_ops = {
 802	.activate = pti_port_activate,
 803	.shutdown = pti_port_shutdown,
 804};
 805
 806/*
 807 * Note the _probe() call sets everything up and ties the char and tty
 808 * to successfully detecting the PTI device on the pci bus.
 809 */
 810
 811/**
 812 * pti_pci_probe()- Used to detect pti on the pci bus and set
 813 *		    things up in the driver.
 814 *
 815 * @pdev- pci_dev struct values for pti.
 816 * @ent-  pci_device_id struct for pti driver.
 817 *
 818 * Returns:
 819 *	0 for success
 820 *	otherwise, error
 821 */
 822static int __devinit pti_pci_probe(struct pci_dev *pdev,
 823		const struct pci_device_id *ent)
 824{
 
 825	int retval = -EINVAL;
 826	int pci_bar = 1;
 827
 828	dev_dbg(&pdev->dev, "%s %s(%d): PTI PCI ID %04x:%04x\n", __FILE__,
 829			__func__, __LINE__, pdev->vendor, pdev->device);
 830
 831	retval = misc_register(&pti_char_driver);
 832	if (retval) {
 833		pr_err("%s(%d): CHAR registration failed of pti driver\n",
 834			__func__, __LINE__);
 835		pr_err("%s(%d): Error value returned: %d\n",
 836			__func__, __LINE__, retval);
 837		return retval;
 838	}
 839
 840	retval = pci_enable_device(pdev);
 841	if (retval != 0) {
 842		dev_err(&pdev->dev,
 843			"%s: pci_enable_device() returned error %d\n",
 844			__func__, retval);
 845		return retval;
 846	}
 847
 848	drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL);
 849
 850	if (drv_data == NULL) {
 851		retval = -ENOMEM;
 852		dev_err(&pdev->dev,
 853			"%s(%d): kmalloc() returned NULL memory.\n",
 854			__func__, __LINE__);
 855		return retval;
 856	}
 857	drv_data->pti_addr = pci_resource_start(pdev, pci_bar);
 858
 859	retval = pci_request_region(pdev, pci_bar, dev_name(&pdev->dev));
 860	if (retval != 0) {
 861		dev_err(&pdev->dev,
 862			"%s(%d): pci_request_region() returned error %d\n",
 863			__func__, __LINE__, retval);
 864		kfree(drv_data);
 865		return retval;
 866	}
 867	drv_data->aperture_base = drv_data->pti_addr+APERTURE_14;
 868	drv_data->pti_ioaddr =
 869		ioremap_nocache((u32)drv_data->aperture_base,
 870		APERTURE_LEN);
 871	if (!drv_data->pti_ioaddr) {
 872		pci_release_region(pdev, pci_bar);
 873		retval = -ENOMEM;
 874		kfree(drv_data);
 875		return retval;
 876	}
 877
 878	pci_set_drvdata(pdev, drv_data);
 879
 880	tty_port_init(&drv_data->port);
 881	drv_data->port.ops = &tty_port_ops;
 
 
 882
 883	tty_register_device(pti_tty_driver, 0, &pdev->dev);
 884	tty_register_device(pti_tty_driver, 1, &pdev->dev);
 885
 886	register_console(&pti_console);
 887
 
 
 
 
 
 
 
 
 
 
 888	return retval;
 889}
 890
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 891static struct pci_driver pti_pci_driver = {
 892	.name		= PCINAME,
 893	.id_table	= pci_ids,
 894	.probe		= pti_pci_probe,
 895	.remove		= pti_pci_remove,
 896};
 897
 898/**
 899 *
 900 * pti_init()- Overall entry/init call to the pti driver.
 901 *             It starts the registration process with the kernel.
 902 *
 903 * Returns:
 904 *	int __init, 0 for success
 905 *	otherwise value is an error
 906 *
 907 */
 908static int __init pti_init(void)
 909{
 910	int retval = -EINVAL;
 911
 912	/* First register module as tty device */
 913
 914	pti_tty_driver = alloc_tty_driver(1);
 915	if (pti_tty_driver == NULL) {
 916		pr_err("%s(%d): Memory allocation failed for ptiTTY driver\n",
 917			__func__, __LINE__);
 918		return -ENOMEM;
 919	}
 920
 921	pti_tty_driver->owner			= THIS_MODULE;
 922	pti_tty_driver->magic			= TTY_DRIVER_MAGIC;
 923	pti_tty_driver->driver_name		= DRIVERNAME;
 924	pti_tty_driver->name			= TTYNAME;
 925	pti_tty_driver->major			= 0;
 926	pti_tty_driver->minor_start		= PTITTY_MINOR_START;
 927	pti_tty_driver->minor_num		= PTITTY_MINOR_NUM;
 928	pti_tty_driver->num			= PTITTY_MINOR_NUM;
 929	pti_tty_driver->type			= TTY_DRIVER_TYPE_SYSTEM;
 930	pti_tty_driver->subtype			= SYSTEM_TYPE_SYSCONS;
 931	pti_tty_driver->flags			= TTY_DRIVER_REAL_RAW |
 932						  TTY_DRIVER_DYNAMIC_DEV;
 933	pti_tty_driver->init_termios		= tty_std_termios;
 934
 935	tty_set_operations(pti_tty_driver, &pti_tty_driver_ops);
 936
 937	retval = tty_register_driver(pti_tty_driver);
 938	if (retval) {
 939		pr_err("%s(%d): TTY registration failed of pti driver\n",
 940			__func__, __LINE__);
 941		pr_err("%s(%d): Error value returned: %d\n",
 942			__func__, __LINE__, retval);
 943
 944		pti_tty_driver = NULL;
 945		return retval;
 946	}
 947
 948	retval = pci_register_driver(&pti_pci_driver);
 949
 950	if (retval) {
 951		pr_err("%s(%d): PCI registration failed of pti driver\n",
 952			__func__, __LINE__);
 953		pr_err("%s(%d): Error value returned: %d\n",
 954			__func__, __LINE__, retval);
 955
 956		tty_unregister_driver(pti_tty_driver);
 957		pr_err("%s(%d): Unregistering TTY part of pti driver\n",
 958			__func__, __LINE__);
 959		pti_tty_driver = NULL;
 960		return retval;
 961	}
 962
 
 
 
 
 
 
 963	return retval;
 964}
 965
 966/**
 967 * pti_exit()- Unregisters this module as a tty and pci driver.
 968 */
 969static void __exit pti_exit(void)
 970{
 971	int retval;
 972
 973	tty_unregister_device(pti_tty_driver, 0);
 974	tty_unregister_device(pti_tty_driver, 1);
 975
 976	retval = tty_unregister_driver(pti_tty_driver);
 977	if (retval) {
 978		pr_err("%s(%d): TTY unregistration failed of pti driver\n",
 979			__func__, __LINE__);
 980		pr_err("%s(%d): Error value returned: %d\n",
 981			__func__, __LINE__, retval);
 982	}
 983
 984	pci_unregister_driver(&pti_pci_driver);
 985
 986	retval = misc_deregister(&pti_char_driver);
 987	if (retval) {
 988		pr_err("%s(%d): CHAR unregistration failed of pti driver\n",
 989			__func__, __LINE__);
 990		pr_err("%s(%d): Error value returned: %d\n",
 991			__func__, __LINE__, retval);
 992	}
 993
 994	unregister_console(&pti_console);
 995	return;
 996}
 997
 998module_init(pti_init);
 999module_exit(pti_exit);
1000
1001MODULE_LICENSE("GPL");
1002MODULE_AUTHOR("Ken Mills, Jay Freyensee");
1003MODULE_DESCRIPTION("PTI Driver");
1004