linux/drivers/misc/pti.c
<<
>>
Prefs
   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