← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/misc/pti.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/misc/pti.c
 
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
 
 
58
struct pti_tty {
 
59
        struct pti_masterchannel *mc;
 
60
};
 
61
 
 
62
struct 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
 */
 
77
static DEFINE_MUTEX(alloclock);
 
78
 
 
79
static struct pci_device_id pci_ids[] __devinitconst = {
 
80
                {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x82B)},
 
81
                {0}
 
82
};
 
83
 
 
84
static struct tty_driver *pti_tty_driver;
 
85
static struct pti_dev *drv_data;
 
86
 
 
87
static unsigned int pti_console_channel;
 
88
static 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
 */
 
107
static 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
 */
 
165
static 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
 */
 
214
static 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
 */
 
241
static 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
 */
 
304
struct 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
}
 
334
EXPORT_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
 */
 
344
void 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
}
 
370
EXPORT_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
 */
 
383
void 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
}
 
394
EXPORT_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
 */
 
401
static 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
 */
 
440
static 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
 */
 
463
static 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
 */
 
480
static 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
 */
 
516
static 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
 */
 
539
static 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
 */
 
560
static 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
 */
 
577
static 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
 */
 
605
static 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
 */
 
632
static 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
 
 
672
static 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
 
 
681
static 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
 
 
688
static 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
 */
 
701
static 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
 */
 
723
static 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
 */
 
738
static 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
 */
 
755
static 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
 */
 
778
static 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
 */
 
795
static void pti_port_shutdown(struct tty_port *port)
 
796
{
 
797
        if (port->tty->index == PTITTY_MINOR_START)
 
798
                console_stop(&pti_console);
 
799
}
 
800
 
 
801
static 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
 */
 
822
static 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
 
 
891
static 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
 */
 
908
static 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
 */
 
969
static 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
 
 
998
module_init(pti_init);
 
999
module_exit(pti_exit);
 
1000
 
 
1001
MODULE_LICENSE("GPL");
 
1002
MODULE_AUTHOR("Ken Mills, Jay Freyensee");
 
1003
MODULE_DESCRIPTION("PTI Driver");
 
1004