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[PTITTY_MINOR_NUM]; 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 const struct pci_device_id pci_ids[] = { 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 * for the tty_driver_*() basic function descriptions, see tty_driver.h. 398 * Specific header comments made for PTI-related specifics. 399 */ 400 401/** 402 * pti_tty_driver_open()- Open an Application master, channel aperture 403 * ID to the PTI device via tty device. 404 * 405 * @tty: tty interface. 406 * @filp: filp interface pased to tty_port_open() call. 407 * 408 * Returns: 409 * int, 0 for success 410 * otherwise, fail value 411 * 412 * The main purpose of using the tty device interface is for 413 * each tty port to have a unique PTI write aperture. In an 414 * example use case, ttyPTI0 gets syslogd and an APP aperture 415 * ID and ttyPTI1 is where the n_tracesink ldisc hooks to route 416 * modem messages into PTI. Modem trace data does not have to 417 * go to ttyPTI1, but ttyPTI0 and ttyPTI1 do need to be distinct 418 * master IDs. These messages go through the PTI HW and out of 419 * the handheld platform and to the Fido/Lauterbach device. 420 */ 421static int pti_tty_driver_open(struct tty_struct *tty, struct file *filp) 422{ 423 /* 424 * we actually want to allocate a new channel per open, per 425 * system arch. HW gives more than plenty channels for a single 426 * system task to have its own channel to write trace data. This 427 * also removes a locking requirement for the actual write 428 * procedure. 429 */ 430 return tty_port_open(tty->port, tty, filp); 431} 432 433/** 434 * pti_tty_driver_close()- close tty device and release Application 435 * master, channel aperture ID to the PTI device via tty device. 436 * 437 * @tty: tty interface. 438 * @filp: filp interface pased to tty_port_close() call. 439 * 440 * The main purpose of using the tty device interface is to route 441 * syslog daemon messages to the PTI HW and out of the handheld platform 442 * and to the Fido/Lauterbach device. 443 */ 444static void pti_tty_driver_close(struct tty_struct *tty, struct file *filp) 445{ 446 tty_port_close(tty->port, tty, filp); 447} 448 449/** 450 * pti_tty_install()- Used to set up specific master-channels 451 * to tty ports for organizational purposes when 452 * tracing viewed from debuging tools. 453 * 454 * @driver: tty driver information. 455 * @tty: tty struct containing pti information. 456 * 457 * Returns: 458 * 0 for success 459 * otherwise, error 460 */ 461static int pti_tty_install(struct tty_driver *driver, struct tty_struct *tty) 462{ 463 int idx = tty->index; 464 struct pti_tty *pti_tty_data; 465 int ret = tty_standard_install(driver, tty); 466 467 if (ret == 0) { 468 pti_tty_data = kmalloc(sizeof(struct pti_tty), GFP_KERNEL); 469 if (pti_tty_data == NULL) 470 return -ENOMEM; 471 472 if (idx == PTITTY_MINOR_START) 473 pti_tty_data->mc = pti_request_masterchannel(0, NULL); 474 else 475 pti_tty_data->mc = pti_request_masterchannel(2, NULL); 476 477 if (pti_tty_data->mc == NULL) { 478 kfree(pti_tty_data); 479 return -ENXIO; 480 } 481 tty->driver_data = pti_tty_data; 482 } 483 484 return ret; 485} 486 487/** 488 * pti_tty_cleanup()- Used to de-allocate master-channel resources 489 * tied to tty's of this driver. 490 * 491 * @tty: tty struct containing pti information. 492 */ 493static void pti_tty_cleanup(struct tty_struct *tty) 494{ 495 struct pti_tty *pti_tty_data = tty->driver_data; 496 if (pti_tty_data == NULL) 497 return; 498 pti_release_masterchannel(pti_tty_data->mc); 499 kfree(pti_tty_data); 500 tty->driver_data = NULL; 501} 502 503/** 504 * pti_tty_driver_write()- Write trace debugging data through the char 505 * interface to the PTI HW. Part of the misc device implementation. 506 * 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. 511 * 512 * Returns: 513 * int, # of bytes written 514 * otherwise, error 515 */ 516static int pti_tty_driver_write(struct tty_struct *tty, 517 const unsigned char *buf, int len) 518{ 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); 522 return len; 523 } 524 /* 525 * we can't write to the pti hardware if the private driver_data 526 * and the mc address is not there. 527 */ 528 else 529 return -EFAULT; 530} 531 532/** 533 * pti_tty_write_room()- Always returns 2048. 534 * 535 * @tty: contains tty info of the pti driver. 536 */ 537static int pti_tty_write_room(struct tty_struct *tty) 538{ 539 return 2048; 540} 541 542/** 543 * pti_char_open()- Open an Application master, channel aperture 544 * ID to the PTI device. Part of the misc device implementation. 545 * 546 * @inode: not used. 547 * @filp: Output- will have a masterchannel struct set containing 548 * the allocated application PTI aperture write address. 549 * 550 * Returns: 551 * int, 0 for success 552 * otherwise, a fail value 553 */ 554static int pti_char_open(struct inode *inode, struct file *filp) 555{ 556 struct pti_masterchannel *mc; 557 558 /* 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. 563 */ 564 mc = pti_request_masterchannel(0, NULL); 565 if (mc == NULL) 566 return -ENOMEM; 567 filp->private_data = mc; 568 return 0; 569} 570 571/** 572 * pti_char_release()- Close a char channel to the PTI device. Part 573 * of the misc device implementation. 574 * 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. 578 * 579 * Returns: 580 * always 0 581 */ 582static int pti_char_release(struct inode *inode, struct file *filp) 583{ 584 pti_release_masterchannel(filp->private_data); 585 filp->private_data = NULL; 586 return 0; 587} 588 589/** 590 * pti_char_write()- Write trace debugging data through the char 591 * interface to the PTI HW. Part of the misc device implementation. 592 * 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. 598 * 599 * Returns: 600 * int, # of bytes written 601 * otherwise, error value 602 * 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 607 * debugging HW. 608 */ 609static ssize_t pti_char_write(struct file *filp, const char __user *data, 610 size_t len, loff_t *ppose) 611{ 612 struct pti_masterchannel *mc; 613 void *kbuf; 614 const char __user *tmp; 615 size_t size = USER_COPY_SIZE; 616 size_t n = 0; 617 618 tmp = data; 619 mc = filp->private_data; 620 621 kbuf = kmalloc(size, GFP_KERNEL); 622 if (kbuf == NULL) { 623 pr_err("%s(%d): buf allocation failed\n", 624 __func__, __LINE__); 625 return -ENOMEM; 626 } 627 628 do { 629 if (len - n > USER_COPY_SIZE) 630 size = USER_COPY_SIZE; 631 else 632 size = len - n; 633 634 if (copy_from_user(kbuf, tmp, size)) { 635 kfree(kbuf); 636 return n ? n : -EFAULT; 637 } 638 639 pti_write_to_aperture(mc, kbuf, size); 640 n += size; 641 tmp += size; 642 643 } while (len > n); 644 645 kfree(kbuf); 646 return len; 647} 648 649static 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 656}; 657 658static 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, 663}; 664 665static struct miscdevice pti_char_driver = { 666 .minor = MISC_DYNAMIC_MINOR, 667 .name = CHARNAME, 668 .fops = &pti_char_driver_ops 669}; 670 671/** 672 * pti_console_write()- Write to the console that has been acquired. 673 * 674 * @c: Not used in this implementaiton. 675 * @buf: Data to be written. 676 * @len: Length of buf. 677 */ 678static void pti_console_write(struct console *c, const char *buf, unsigned len) 679{ 680 static struct pti_masterchannel mc = {.master = CONSOLE_ID, 681 .channel = 0}; 682 683 mc.channel = pti_console_channel; 684 pti_console_channel = (pti_console_channel + 1) & 0x7f; 685 686 pti_write_full_frame_to_aperture(&mc, buf, len); 687} 688 689/** 690 * pti_console_device()- Return the driver tty structure and set the 691 * associated index implementation. 692 * 693 * @c: Console device of the driver. 694 * @index: index associated with c. 695 * 696 * Returns: 697 * always value of pti_tty_driver structure when this function 698 * is called. 699 */ 700static struct tty_driver *pti_console_device(struct console *c, int *index) 701{ 702 *index = c->index; 703 return pti_tty_driver; 704} 705 706/** 707 * pti_console_setup()- Initialize console variables used by the driver. 708 * 709 * @c: Not used. 710 * @opts: Not used. 711 * 712 * Returns: 713 * always 0. 714 */ 715static int pti_console_setup(struct console *c, char *opts) 716{ 717 pti_console_channel = 0; 718 pti_control_channel = 0; 719 return 0; 720} 721 722/* 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. 731 */ 732static struct console pti_console = { 733 .name = TTYNAME, 734 .write = pti_console_write, 735 .device = pti_console_device, 736 .setup = pti_console_setup, 737 .flags = CON_PRINTBUFFER, 738 .index = 0, 739}; 740 741/** 742 * pti_port_activate()- Used to start/initialize any items upon 743 * first opening of tty_port(). 744 * 745 * @port- The tty port number of the PTI device. 746 * @tty- The tty struct associated with this device. 747 * 748 * Returns: 749 * always returns 0 750 * 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 753 * very long time. 754 */ 755static int pti_port_activate(struct tty_port *port, struct tty_struct *tty) 756{ 757 if (port->tty->index == PTITTY_MINOR_START) 758 console_start(&pti_console); 759 return 0; 760} 761 762/** 763 * pti_port_shutdown()- Used to stop/shutdown any items upon the 764 * last tty port close. 765 * 766 * @port- The tty port number of the PTI device. 767 * 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 770 * very long time. 771 */ 772static void pti_port_shutdown(struct tty_port *port) 773{ 774 if (port->tty->index == PTITTY_MINOR_START) 775 console_stop(&pti_console); 776} 777 778static const struct tty_port_operations tty_port_ops = { 779 .activate = pti_port_activate, 780 .shutdown = pti_port_shutdown, 781}; 782 783/* 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. 786 */ 787 788/** 789 * pti_pci_probe()- Used to detect pti on the pci bus and set 790 * things up in the driver. 791 * 792 * @pdev- pci_dev struct values for pti. 793 * @ent- pci_device_id struct for pti driver. 794 * 795 * Returns: 796 * 0 for success 797 * otherwise, error 798 */ 799static int pti_pci_probe(struct pci_dev *pdev, 800 const struct pci_device_id *ent) 801{ 802 unsigned int a; 803 int retval = -EINVAL; 804 int pci_bar = 1; 805 806 dev_dbg(&pdev->dev, "%s %s(%d): PTI PCI ID %04x:%04x\n", __FILE__, 807 __func__, __LINE__, pdev->vendor, pdev->device); 808 809 retval = misc_register(&pti_char_driver); 810 if (retval) { 811 pr_err("%s(%d): CHAR registration failed of pti driver\n", 812 __func__, __LINE__); 813 pr_err("%s(%d): Error value returned: %d\n", 814 __func__, __LINE__, retval); 815 goto err; 816 } 817 818 retval = pci_enable_device(pdev); 819 if (retval != 0) { 820 dev_err(&pdev->dev, 821 "%s: pci_enable_device() returned error %d\n", 822 __func__, retval); 823 goto err_unreg_misc; 824 } 825 826 drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL); 827 if (drv_data == NULL) { 828 retval = -ENOMEM; 829 dev_err(&pdev->dev, 830 "%s(%d): kmalloc() returned NULL memory.\n", 831 __func__, __LINE__); 832 goto err_disable_pci; 833 } 834 drv_data->pti_addr = pci_resource_start(pdev, pci_bar); 835 836 retval = pci_request_region(pdev, pci_bar, dev_name(&pdev->dev)); 837 if (retval != 0) { 838 dev_err(&pdev->dev, 839 "%s(%d): pci_request_region() returned error %d\n", 840 __func__, __LINE__, retval); 841 goto err_free_dd; 842 } 843 drv_data->aperture_base = drv_data->pti_addr+APERTURE_14; 844 drv_data->pti_ioaddr = 845 ioremap_nocache((u32)drv_data->aperture_base, 846 APERTURE_LEN); 847 if (!drv_data->pti_ioaddr) { 848 retval = -ENOMEM; 849 goto err_rel_reg; 850 } 851 852 pci_set_drvdata(pdev, drv_data); 853 854 for (a = 0; a < PTITTY_MINOR_NUM; a++) { 855 struct tty_port *port = &drv_data->port[a]; 856 tty_port_init(port); 857 port->ops = &tty_port_ops; 858 859 tty_port_register_device(port, pti_tty_driver, a, &pdev->dev); 860 } 861 862 register_console(&pti_console); 863 864 return 0; 865err_rel_reg: 866 pci_release_region(pdev, pci_bar); 867err_free_dd: 868 kfree(drv_data); 869err_disable_pci: 870 pci_disable_device(pdev); 871err_unreg_misc: 872 misc_deregister(&pti_char_driver); 873err: 874 return retval; 875} 876 877/** 878 * pti_pci_remove()- Driver exit method to remove PTI from 879 * PCI bus. 880 * @pdev: variable containing pci info of PTI. 881 */ 882static void pti_pci_remove(struct pci_dev *pdev) 883{ 884 struct pti_dev *drv_data = pci_get_drvdata(pdev); 885 unsigned int a; 886 887 unregister_console(&pti_console); 888 889 for (a = 0; a < PTITTY_MINOR_NUM; a++) { 890 tty_unregister_device(pti_tty_driver, a); 891 tty_port_destroy(&drv_data->port[a]); 892 } 893 894 iounmap(drv_data->pti_ioaddr); 895 kfree(drv_data); 896 pci_release_region(pdev, 1); 897 pci_disable_device(pdev); 898 899 misc_deregister(&pti_char_driver); 900} 901 902static struct pci_driver pti_pci_driver = { 903 .name = PCINAME, 904 .id_table = pci_ids, 905 .probe = pti_pci_probe, 906 .remove = pti_pci_remove, 907}; 908 909/** 910 * 911 * pti_init()- Overall entry/init call to the pti driver. 912 * It starts the registration process with the kernel. 913 * 914 * Returns: 915 * int __init, 0 for success 916 * otherwise value is an error 917 * 918 */ 919static int __init pti_init(void) 920{ 921 int retval = -EINVAL; 922 923 /* First register module as tty device */ 924 925 pti_tty_driver = alloc_tty_driver(PTITTY_MINOR_NUM); 926 if (pti_tty_driver == NULL) { 927 pr_err("%s(%d): Memory allocation failed for ptiTTY driver\n", 928 __func__, __LINE__); 929 return -ENOMEM; 930 } 931 932 pti_tty_driver->driver_name = DRIVERNAME; 933 pti_tty_driver->name = TTYNAME; 934 pti_tty_driver->major = 0; 935 pti_tty_driver->minor_start = PTITTY_MINOR_START; 936 pti_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM; 937 pti_tty_driver->subtype = SYSTEM_TYPE_SYSCONS; 938 pti_tty_driver->flags = TTY_DRIVER_REAL_RAW | 939 TTY_DRIVER_DYNAMIC_DEV; 940 pti_tty_driver->init_termios = tty_std_termios; 941 942 tty_set_operations(pti_tty_driver, &pti_tty_driver_ops); 943 944 retval = tty_register_driver(pti_tty_driver); 945 if (retval) { 946 pr_err("%s(%d): TTY registration failed of pti driver\n", 947 __func__, __LINE__); 948 pr_err("%s(%d): Error value returned: %d\n", 949 __func__, __LINE__, retval); 950 951 goto put_tty; 952 } 953 954 retval = pci_register_driver(&pti_pci_driver); 955 if (retval) { 956 pr_err("%s(%d): PCI registration failed of pti driver\n", 957 __func__, __LINE__); 958 pr_err("%s(%d): Error value returned: %d\n", 959 __func__, __LINE__, retval); 960 goto unreg_tty; 961 } 962 963 return 0; 964unreg_tty: 965 tty_unregister_driver(pti_tty_driver); 966put_tty: 967 put_tty_driver(pti_tty_driver); 968 pti_tty_driver = NULL; 969 return retval; 970} 971 972/** 973 * pti_exit()- Unregisters this module as a tty and pci driver. 974 */ 975static void __exit pti_exit(void) 976{ 977 tty_unregister_driver(pti_tty_driver); 978 pci_unregister_driver(&pti_pci_driver); 979 put_tty_driver(pti_tty_driver); 980} 981 982module_init(pti_init); 983module_exit(pti_exit); 984 985MODULE_LICENSE("GPL"); 986MODULE_AUTHOR("Ken Mills, Jay Freyensee"); 987MODULE_DESCRIPTION("PTI Driver"); 988 989