blob: b7eb545394b1c0c2e3d01aa50d29829af90619e6 [file] [log] [blame]
J Freyensee0b61d2a2011-05-06 16:56:49 -07001/*
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>
Sergei Trofimovich06ed4622011-08-25 15:59:01 -070036#include <linux/slab.h>
37#include <linux/uaccess.h>
J Freyensee0b61d2a2011-05-06 16:56:49 -070038
39#define DRIVERNAME "pti"
40#define PCINAME "pciPTI"
41#define TTYNAME "ttyPTI"
42#define CHARNAME "pti"
43#define PTITTY_MINOR_START 0
44#define PTITTY_MINOR_NUM 2
45#define MAX_APP_IDS 16 /* 128 channel ids / u8 bit size */
46#define MAX_OS_IDS 16 /* 128 channel ids / u8 bit size */
47#define MAX_MODEM_IDS 16 /* 128 channel ids / u8 bit size */
48#define MODEM_BASE_ID 71 /* modem master ID address */
49#define CONTROL_ID 72 /* control master ID address */
50#define CONSOLE_ID 73 /* console master ID address */
51#define OS_BASE_ID 74 /* base OS master ID address */
52#define APP_BASE_ID 80 /* base App master ID address */
53#define CONTROL_FRAME_LEN 32 /* PTI control frame maximum size */
54#define USER_COPY_SIZE 8192 /* 8Kb buffer for user space copy */
55#define APERTURE_14 0x3800000 /* offset to first OS write addr */
56#define APERTURE_LEN 0x400000 /* address length */
57
58struct pti_tty {
59 struct pti_masterchannel *mc;
60};
61
62struct pti_dev {
63 struct tty_port port;
64 unsigned long pti_addr;
65 unsigned long aperture_base;
66 void __iomem *pti_ioaddr;
67 u8 ia_app[MAX_APP_IDS];
68 u8 ia_os[MAX_OS_IDS];
69 u8 ia_modem[MAX_MODEM_IDS];
70};
71
72/*
73 * This protects access to ia_app, ia_os, and ia_modem,
74 * which keeps track of channels allocated in
75 * an aperture write id.
76 */
77static DEFINE_MUTEX(alloclock);
78
79static struct pci_device_id pci_ids[] __devinitconst = {
80 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x82B)},
81 {0}
82};
83
84static struct tty_driver *pti_tty_driver;
85static struct pti_dev *drv_data;
86
87static unsigned int pti_console_channel;
88static unsigned int pti_control_channel;
89
90/**
91 * pti_write_to_aperture()- The private write function to PTI HW.
92 *
93 * @mc: The 'aperture'. It's part of a write address that holds
94 * a master and channel ID.
95 * @buf: Data being written to the HW that will ultimately be seen
96 * in a debugging tool (Fido, Lauterbach).
97 * @len: Size of buffer.
98 *
99 * Since each aperture is specified by a unique
100 * master/channel ID, no two processes will be writing
101 * to the same aperture at the same time so no lock is required. The
102 * PTI-Output agent will send these out in the order that they arrived, and
103 * thus, it will intermix these messages. The debug tool can then later
104 * regroup the appropriate message segments together reconstituting each
105 * message.
106 */
107static void pti_write_to_aperture(struct pti_masterchannel *mc,
108 u8 *buf,
109 int len)
110{
111 int dwordcnt;
112 int final;
113 int i;
114 u32 ptiword;
115 u32 __iomem *aperture;
116 u8 *p = buf;
117
118 /*
119 * calculate the aperture offset from the base using the master and
120 * channel id's.
121 */
122 aperture = drv_data->pti_ioaddr + (mc->master << 15)
123 + (mc->channel << 8);
124
125 dwordcnt = len >> 2;
126 final = len - (dwordcnt << 2); /* final = trailing bytes */
127 if (final == 0 && dwordcnt != 0) { /* always need a final dword */
128 final += 4;
129 dwordcnt--;
130 }
131
132 for (i = 0; i < dwordcnt; i++) {
133 ptiword = be32_to_cpu(*(u32 *)p);
134 p += 4;
135 iowrite32(ptiword, aperture);
136 }
137
138 aperture += PTI_LASTDWORD_DTS; /* adding DTS signals that is EOM */
139
140 ptiword = 0;
141 for (i = 0; i < final; i++)
142 ptiword |= *p++ << (24-(8*i));
143
144 iowrite32(ptiword, aperture);
145 return;
146}
147
148/**
149 * pti_control_frame_built_and_sent()- control frame build and send function.
150 *
J Freyensee8168e9c2011-06-17 15:09:53 -0700151 * @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.
J Freyensee0b61d2a2011-05-06 16:56:49 -0700155 *
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.
J Freyensee8168e9c2011-06-17 15:09:53 -0700159 * The thread name is retrieved from 'current' global variable if 'thread_name'
160 * is 'NULL', else it is retrieved from 'thread_name' parameter.
J Freyensee0b61d2a2011-05-06 16:56:49 -0700161 * 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 */
J Freyensee8168e9c2011-06-17 15:09:53 -0700165static void pti_control_frame_built_and_sent(struct pti_masterchannel *mc,
166 const char *thread_name)
J Freyensee0b61d2a2011-05-06 16:56:49 -0700167{
Jesper Juhl1ebe9da2011-09-14 16:22:12 -0700168 /*
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];
J Freyensee0b61d2a2011-05-06 16:56:49 -0700173 struct pti_masterchannel mccontrol = {.master = CONTROL_ID,
174 .channel = 0};
J Freyensee8168e9c2011-06-17 15:09:53 -0700175 const char *thread_name_p;
J Freyensee0b61d2a2011-05-06 16:56:49 -0700176 const char *control_format = "%3d %3d %s";
177 u8 control_frame[CONTROL_FRAME_LEN];
178
J Freyensee8168e9c2011-06-17 15:09:53 -0700179 if (!thread_name) {
J Freyensee8168e9c2011-06-17 15:09:53 -0700180 if (!in_interrupt())
181 get_task_comm(comm, current);
182 else
183 strncpy(comm, "Interrupt", TASK_COMM_LEN);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700184
J Freyensee8168e9c2011-06-17 15:09:53 -0700185 /* 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 }
J Freyensee0b61d2a2011-05-06 16:56:49 -0700191
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,
J Freyensee8168e9c2011-06-17 15:09:53 -0700196 mc->channel, thread_name_p);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700197 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{
J Freyensee8168e9c2011-06-17 15:09:53 -0700218 pti_control_frame_built_and_sent(mc, NULL);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700219 pti_write_to_aperture(mc, (u8 *)buf, len);
220}
221
222/**
223 * get_id()- Allocate a master and channel ID.
224 *
J Freyensee8168e9c2011-06-17 15:09:53 -0700225 * @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.
J Freyensee0b61d2a2011-05-06 16:56:49 -0700232 *
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 */
J Freyensee8168e9c2011-06-17 15:09:53 -0700241static struct pti_masterchannel *get_id(u8 *id_array,
242 int max_ids,
243 int base_id,
244 const char *thread_name)
J Freyensee0b61d2a2011-05-06 16:56:49 -0700245{
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 */
J Freyensee8168e9c2011-06-17 15:09:53 -0700274 pti_control_frame_built_and_sent(mc, thread_name);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700275 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 *
J Freyensee8168e9c2011-06-17 15:09:53 -0700290 * @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.
J Freyensee0b61d2a2011-05-06 16:56:49 -0700299 *
300 * Returns:
301 * pti_masterchannel struct
302 * 0 for error
303 */
J Freyensee8168e9c2011-06-17 15:09:53 -0700304struct pti_masterchannel *pti_request_masterchannel(u8 type,
305 const char *thread_name)
J Freyensee0b61d2a2011-05-06 16:56:49 -0700306{
307 struct pti_masterchannel *mc;
308
309 mutex_lock(&alloclock);
310
311 switch (type) {
312
313 case 0:
J Freyensee8168e9c2011-06-17 15:09:53 -0700314 mc = get_id(drv_data->ia_app, MAX_APP_IDS,
315 APP_BASE_ID, thread_name);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700316 break;
317
318 case 1:
J Freyensee8168e9c2011-06-17 15:09:53 -0700319 mc = get_id(drv_data->ia_os, MAX_OS_IDS,
320 OS_BASE_ID, thread_name);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700321 break;
322
323 case 2:
J Freyensee8168e9c2011-06-17 15:09:53 -0700324 mc = get_id(drv_data->ia_modem, MAX_MODEM_IDS,
325 MODEM_BASE_ID, thread_name);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700326 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 *
J Freyensee29021bcc2011-05-25 14:38:18 -0700341 * @mc: master, channel apeture ID address to be released. This
342 * will de-allocate the structure via kfree().
J Freyensee0b61d2a2011-05-06 16:56:49 -0700343 */
344void pti_release_masterchannel(struct pti_masterchannel *mc)
345{
346 u8 master, channel, i;
347
348 mutex_lock(&alloclock);
349
350 if (mc) {
351 master = mc->master;
352 channel = mc->channel;
353
354 if (master == APP_BASE_ID) {
355 i = channel >> 3;
356 drv_data->ia_app[i] &= ~(0x80>>(channel & 0x7));
357 } else if (master == OS_BASE_ID) {
358 i = channel >> 3;
359 drv_data->ia_os[i] &= ~(0x80>>(channel & 0x7));
360 } else {
361 i = channel >> 3;
362 drv_data->ia_modem[i] &= ~(0x80>>(channel & 0x7));
363 }
364
365 kfree(mc);
366 }
367
368 mutex_unlock(&alloclock);
369}
370EXPORT_SYMBOL_GPL(pti_release_masterchannel);
371
372/**
373 * pti_writedata()- Kernel API function used to write trace
374 * debugging data to PTI HW.
375 *
376 * @mc: Master, channel aperture ID address to write to.
377 * Null value will return with no write occurring.
378 * @buf: Trace debuging data to write to the PTI HW.
379 * Null value will return with no write occurring.
380 * @count: Size of buf. Value of 0 or a negative number will
381 * return with no write occuring.
382 */
383void pti_writedata(struct pti_masterchannel *mc, u8 *buf, int count)
384{
385 /*
386 * since this function is exported, this is treated like an
387 * API function, thus, all parameters should
388 * be checked for validity.
389 */
390 if ((mc != NULL) && (buf != NULL) && (count > 0))
391 pti_write_to_aperture(mc, buf, count);
392 return;
393}
394EXPORT_SYMBOL_GPL(pti_writedata);
395
396/**
397 * pti_pci_remove()- Driver exit method to remove PTI from
398 * PCI bus.
399 * @pdev: variable containing pci info of PTI.
400 */
401static void __devexit pti_pci_remove(struct pci_dev *pdev)
402{
403 struct pti_dev *drv_data;
404
405 drv_data = pci_get_drvdata(pdev);
406 if (drv_data != NULL) {
407 pci_iounmap(pdev, drv_data->pti_ioaddr);
408 pci_set_drvdata(pdev, NULL);
409 kfree(drv_data);
410 pci_release_region(pdev, 1);
411 pci_disable_device(pdev);
412 }
413}
414
415/*
416 * for the tty_driver_*() basic function descriptions, see tty_driver.h.
417 * Specific header comments made for PTI-related specifics.
418 */
419
420/**
421 * pti_tty_driver_open()- Open an Application master, channel aperture
422 * ID to the PTI device via tty device.
423 *
424 * @tty: tty interface.
425 * @filp: filp interface pased to tty_port_open() call.
426 *
427 * Returns:
428 * int, 0 for success
429 * otherwise, fail value
430 *
431 * The main purpose of using the tty device interface is for
432 * each tty port to have a unique PTI write aperture. In an
433 * example use case, ttyPTI0 gets syslogd and an APP aperture
434 * ID and ttyPTI1 is where the n_tracesink ldisc hooks to route
435 * modem messages into PTI. Modem trace data does not have to
436 * go to ttyPTI1, but ttyPTI0 and ttyPTI1 do need to be distinct
437 * master IDs. These messages go through the PTI HW and out of
438 * the handheld platform and to the Fido/Lauterbach device.
439 */
440static int pti_tty_driver_open(struct tty_struct *tty, struct file *filp)
441{
442 /*
443 * we actually want to allocate a new channel per open, per
444 * system arch. HW gives more than plenty channels for a single
445 * system task to have its own channel to write trace data. This
446 * also removes a locking requirement for the actual write
447 * procedure.
448 */
449 return tty_port_open(&drv_data->port, tty, filp);
450}
451
452/**
453 * pti_tty_driver_close()- close tty device and release Application
454 * master, channel aperture ID to the PTI device via tty device.
455 *
456 * @tty: tty interface.
457 * @filp: filp interface pased to tty_port_close() call.
458 *
459 * The main purpose of using the tty device interface is to route
460 * syslog daemon messages to the PTI HW and out of the handheld platform
461 * and to the Fido/Lauterbach device.
462 */
463static void pti_tty_driver_close(struct tty_struct *tty, struct file *filp)
464{
465 tty_port_close(&drv_data->port, tty, filp);
466}
467
468/**
J Freyenseee556b812011-05-25 14:50:26 -0700469 * pti_tty_install()- Used to set up specific master-channels
470 * to tty ports for organizational purposes when
471 * tracing viewed from debuging tools.
J Freyensee0b61d2a2011-05-06 16:56:49 -0700472 *
473 * @driver: tty driver information.
474 * @tty: tty struct containing pti information.
475 *
476 * Returns:
477 * 0 for success
478 * otherwise, error
479 */
480static int pti_tty_install(struct tty_driver *driver, struct tty_struct *tty)
481{
482 int idx = tty->index;
483 struct pti_tty *pti_tty_data;
Jiri Slaby81f58352012-01-30 21:14:30 +0100484 int ret = tty_standard_install(driver, tty);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700485
486 if (ret == 0) {
J Freyensee0b61d2a2011-05-06 16:56:49 -0700487 pti_tty_data = kmalloc(sizeof(struct pti_tty), GFP_KERNEL);
488 if (pti_tty_data == NULL)
489 return -ENOMEM;
490
491 if (idx == PTITTY_MINOR_START)
J Freyensee8168e9c2011-06-17 15:09:53 -0700492 pti_tty_data->mc = pti_request_masterchannel(0, NULL);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700493 else
J Freyensee8168e9c2011-06-17 15:09:53 -0700494 pti_tty_data->mc = pti_request_masterchannel(2, NULL);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700495
J Freyensee1dae42b2011-05-25 14:45:40 -0700496 if (pti_tty_data->mc == NULL) {
497 kfree(pti_tty_data);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700498 return -ENXIO;
J Freyensee1dae42b2011-05-25 14:45:40 -0700499 }
J Freyensee0b61d2a2011-05-06 16:56:49 -0700500 tty->driver_data = pti_tty_data;
501 }
502
503 return ret;
504}
505
506/**
507 * pti_tty_cleanup()- Used to de-allocate master-channel resources
508 * tied to tty's of this driver.
509 *
510 * @tty: tty struct containing pti information.
511 */
512static void pti_tty_cleanup(struct tty_struct *tty)
513{
514 struct pti_tty *pti_tty_data = tty->driver_data;
515 if (pti_tty_data == NULL)
516 return;
517 pti_release_masterchannel(pti_tty_data->mc);
J Freyensee1312ba42011-05-25 14:56:43 -0700518 kfree(pti_tty_data);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700519 tty->driver_data = NULL;
520}
521
522/**
523 * pti_tty_driver_write()- Write trace debugging data through the char
524 * interface to the PTI HW. Part of the misc device implementation.
525 *
526 * @filp: Contains private data which is used to obtain
527 * master, channel write ID.
528 * @data: trace data to be written.
529 * @len: # of byte to write.
530 *
531 * Returns:
532 * int, # of bytes written
533 * otherwise, error
534 */
535static int pti_tty_driver_write(struct tty_struct *tty,
536 const unsigned char *buf, int len)
537{
538 struct pti_tty *pti_tty_data = tty->driver_data;
539 if ((pti_tty_data != NULL) && (pti_tty_data->mc != NULL)) {
540 pti_write_to_aperture(pti_tty_data->mc, (u8 *)buf, len);
541 return len;
542 }
543 /*
544 * we can't write to the pti hardware if the private driver_data
545 * and the mc address is not there.
546 */
547 else
548 return -EFAULT;
549}
550
551/**
552 * pti_tty_write_room()- Always returns 2048.
553 *
554 * @tty: contains tty info of the pti driver.
555 */
556static int pti_tty_write_room(struct tty_struct *tty)
557{
558 return 2048;
559}
560
561/**
562 * pti_char_open()- Open an Application master, channel aperture
563 * ID to the PTI device. Part of the misc device implementation.
564 *
565 * @inode: not used.
566 * @filp: Output- will have a masterchannel struct set containing
567 * the allocated application PTI aperture write address.
568 *
569 * Returns:
570 * int, 0 for success
571 * otherwise, a fail value
572 */
573static int pti_char_open(struct inode *inode, struct file *filp)
574{
575 struct pti_masterchannel *mc;
576
577 /*
578 * We really do want to fail immediately if
579 * pti_request_masterchannel() fails,
580 * before assigning the value to filp->private_data.
581 * Slightly easier to debug if this driver needs debugging.
582 */
J Freyensee8168e9c2011-06-17 15:09:53 -0700583 mc = pti_request_masterchannel(0, NULL);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700584 if (mc == NULL)
585 return -ENOMEM;
586 filp->private_data = mc;
587 return 0;
588}
589
590/**
591 * pti_char_release()- Close a char channel to the PTI device. Part
592 * of the misc device implementation.
593 *
594 * @inode: Not used in this implementaiton.
595 * @filp: Contains private_data that contains the master, channel
596 * ID to be released by the PTI device.
597 *
598 * Returns:
599 * always 0
600 */
601static int pti_char_release(struct inode *inode, struct file *filp)
602{
603 pti_release_masterchannel(filp->private_data);
J Freyensee29021bcc2011-05-25 14:38:18 -0700604 filp->private_data = NULL;
J Freyensee0b61d2a2011-05-06 16:56:49 -0700605 return 0;
606}
607
608/**
609 * pti_char_write()- Write trace debugging data through the char
610 * interface to the PTI HW. Part of the misc device implementation.
611 *
612 * @filp: Contains private data which is used to obtain
613 * master, channel write ID.
614 * @data: trace data to be written.
615 * @len: # of byte to write.
616 * @ppose: Not used in this function implementation.
617 *
618 * Returns:
619 * int, # of bytes written
620 * otherwise, error value
621 *
622 * Notes: From side discussions with Alan Cox and experimenting
623 * with PTI debug HW like Nokia's Fido box and Lauterbach
624 * devices, 8192 byte write buffer used by USER_COPY_SIZE was
625 * deemed an appropriate size for this type of usage with
626 * debugging HW.
627 */
628static ssize_t pti_char_write(struct file *filp, const char __user *data,
629 size_t len, loff_t *ppose)
630{
631 struct pti_masterchannel *mc;
632 void *kbuf;
633 const char __user *tmp;
634 size_t size = USER_COPY_SIZE;
635 size_t n = 0;
636
637 tmp = data;
638 mc = filp->private_data;
639
640 kbuf = kmalloc(size, GFP_KERNEL);
641 if (kbuf == NULL) {
642 pr_err("%s(%d): buf allocation failed\n",
643 __func__, __LINE__);
644 return -ENOMEM;
645 }
646
647 do {
648 if (len - n > USER_COPY_SIZE)
649 size = USER_COPY_SIZE;
650 else
651 size = len - n;
652
653 if (copy_from_user(kbuf, tmp, size)) {
654 kfree(kbuf);
655 return n ? n : -EFAULT;
656 }
657
658 pti_write_to_aperture(mc, kbuf, size);
659 n += size;
660 tmp += size;
661
662 } while (len > n);
663
664 kfree(kbuf);
665 return len;
666}
667
668static const struct tty_operations pti_tty_driver_ops = {
669 .open = pti_tty_driver_open,
670 .close = pti_tty_driver_close,
671 .write = pti_tty_driver_write,
672 .write_room = pti_tty_write_room,
673 .install = pti_tty_install,
674 .cleanup = pti_tty_cleanup
675};
676
677static const struct file_operations pti_char_driver_ops = {
678 .owner = THIS_MODULE,
679 .write = pti_char_write,
680 .open = pti_char_open,
681 .release = pti_char_release,
682};
683
684static struct miscdevice pti_char_driver = {
685 .minor = MISC_DYNAMIC_MINOR,
686 .name = CHARNAME,
687 .fops = &pti_char_driver_ops
688};
689
690/**
691 * pti_console_write()- Write to the console that has been acquired.
692 *
693 * @c: Not used in this implementaiton.
694 * @buf: Data to be written.
695 * @len: Length of buf.
696 */
697static void pti_console_write(struct console *c, const char *buf, unsigned len)
698{
699 static struct pti_masterchannel mc = {.master = CONSOLE_ID,
700 .channel = 0};
701
702 mc.channel = pti_console_channel;
703 pti_console_channel = (pti_console_channel + 1) & 0x7f;
704
705 pti_write_full_frame_to_aperture(&mc, buf, len);
706}
707
708/**
709 * pti_console_device()- Return the driver tty structure and set the
710 * associated index implementation.
711 *
712 * @c: Console device of the driver.
713 * @index: index associated with c.
714 *
715 * Returns:
716 * always value of pti_tty_driver structure when this function
717 * is called.
718 */
719static struct tty_driver *pti_console_device(struct console *c, int *index)
720{
721 *index = c->index;
722 return pti_tty_driver;
723}
724
725/**
726 * pti_console_setup()- Initialize console variables used by the driver.
727 *
728 * @c: Not used.
729 * @opts: Not used.
730 *
731 * Returns:
732 * always 0.
733 */
734static int pti_console_setup(struct console *c, char *opts)
735{
736 pti_console_channel = 0;
737 pti_control_channel = 0;
738 return 0;
739}
740
741/*
742 * pti_console struct, used to capture OS printk()'s and shift
743 * out to the PTI device for debugging. This cannot be
744 * enabled upon boot because of the possibility of eating
745 * any serial console printk's (race condition discovered).
746 * The console should be enabled upon when the tty port is
747 * used for the first time. Since the primary purpose for
748 * the tty port is to hook up syslog to it, the tty port
749 * will be open for a really long time.
750 */
751static struct console pti_console = {
752 .name = TTYNAME,
753 .write = pti_console_write,
754 .device = pti_console_device,
755 .setup = pti_console_setup,
756 .flags = CON_PRINTBUFFER,
757 .index = 0,
758};
759
760/**
761 * pti_port_activate()- Used to start/initialize any items upon
762 * first opening of tty_port().
763 *
764 * @port- The tty port number of the PTI device.
765 * @tty- The tty struct associated with this device.
766 *
767 * Returns:
768 * always returns 0
769 *
770 * Notes: The primary purpose of the PTI tty port 0 is to hook
771 * the syslog daemon to it; thus this port will be open for a
772 * very long time.
773 */
774static int pti_port_activate(struct tty_port *port, struct tty_struct *tty)
775{
776 if (port->tty->index == PTITTY_MINOR_START)
777 console_start(&pti_console);
778 return 0;
779}
780
781/**
782 * pti_port_shutdown()- Used to stop/shutdown any items upon the
783 * last tty port close.
784 *
785 * @port- The tty port number of the PTI device.
786 *
787 * Notes: The primary purpose of the PTI tty port 0 is to hook
788 * the syslog daemon to it; thus this port will be open for a
789 * very long time.
790 */
791static void pti_port_shutdown(struct tty_port *port)
792{
793 if (port->tty->index == PTITTY_MINOR_START)
794 console_stop(&pti_console);
795}
796
797static const struct tty_port_operations tty_port_ops = {
798 .activate = pti_port_activate,
799 .shutdown = pti_port_shutdown,
800};
801
802/*
803 * Note the _probe() call sets everything up and ties the char and tty
804 * to successfully detecting the PTI device on the pci bus.
805 */
806
807/**
808 * pti_pci_probe()- Used to detect pti on the pci bus and set
809 * things up in the driver.
810 *
811 * @pdev- pci_dev struct values for pti.
812 * @ent- pci_device_id struct for pti driver.
813 *
814 * Returns:
815 * 0 for success
816 * otherwise, error
817 */
818static int __devinit pti_pci_probe(struct pci_dev *pdev,
819 const struct pci_device_id *ent)
820{
821 int retval = -EINVAL;
822 int pci_bar = 1;
823
824 dev_dbg(&pdev->dev, "%s %s(%d): PTI PCI ID %04x:%04x\n", __FILE__,
825 __func__, __LINE__, pdev->vendor, pdev->device);
826
827 retval = misc_register(&pti_char_driver);
828 if (retval) {
829 pr_err("%s(%d): CHAR registration failed of pti driver\n",
830 __func__, __LINE__);
831 pr_err("%s(%d): Error value returned: %d\n",
832 __func__, __LINE__, retval);
833 return retval;
834 }
835
836 retval = pci_enable_device(pdev);
837 if (retval != 0) {
838 dev_err(&pdev->dev,
839 "%s: pci_enable_device() returned error %d\n",
840 __func__, retval);
841 return retval;
842 }
843
844 drv_data = kzalloc(sizeof(*drv_data), GFP_KERNEL);
845
846 if (drv_data == NULL) {
847 retval = -ENOMEM;
848 dev_err(&pdev->dev,
849 "%s(%d): kmalloc() returned NULL memory.\n",
850 __func__, __LINE__);
851 return retval;
852 }
853 drv_data->pti_addr = pci_resource_start(pdev, pci_bar);
854
855 retval = pci_request_region(pdev, pci_bar, dev_name(&pdev->dev));
856 if (retval != 0) {
857 dev_err(&pdev->dev,
858 "%s(%d): pci_request_region() returned error %d\n",
859 __func__, __LINE__, retval);
860 kfree(drv_data);
861 return retval;
862 }
863 drv_data->aperture_base = drv_data->pti_addr+APERTURE_14;
864 drv_data->pti_ioaddr =
865 ioremap_nocache((u32)drv_data->aperture_base,
866 APERTURE_LEN);
867 if (!drv_data->pti_ioaddr) {
868 pci_release_region(pdev, pci_bar);
869 retval = -ENOMEM;
870 kfree(drv_data);
871 return retval;
872 }
873
874 pci_set_drvdata(pdev, drv_data);
875
876 tty_port_init(&drv_data->port);
877 drv_data->port.ops = &tty_port_ops;
878
879 tty_register_device(pti_tty_driver, 0, &pdev->dev);
880 tty_register_device(pti_tty_driver, 1, &pdev->dev);
881
882 register_console(&pti_console);
883
884 return retval;
885}
886
887static struct pci_driver pti_pci_driver = {
888 .name = PCINAME,
889 .id_table = pci_ids,
890 .probe = pti_pci_probe,
Arnd Bergmann2dc60c52012-04-14 10:25:03 -0600891 .remove = __devexit_p(pti_pci_remove),
J Freyensee0b61d2a2011-05-06 16:56:49 -0700892};
893
894/**
895 *
896 * pti_init()- Overall entry/init call to the pti driver.
897 * It starts the registration process with the kernel.
898 *
899 * Returns:
900 * int __init, 0 for success
901 * otherwise value is an error
902 *
903 */
904static int __init pti_init(void)
905{
906 int retval = -EINVAL;
907
908 /* First register module as tty device */
909
Jiri Slaby2f166692012-03-05 14:51:52 +0100910 pti_tty_driver = alloc_tty_driver(PTITTY_MINOR_NUM);
J Freyensee0b61d2a2011-05-06 16:56:49 -0700911 if (pti_tty_driver == NULL) {
912 pr_err("%s(%d): Memory allocation failed for ptiTTY driver\n",
913 __func__, __LINE__);
914 return -ENOMEM;
915 }
916
J Freyensee0b61d2a2011-05-06 16:56:49 -0700917 pti_tty_driver->driver_name = DRIVERNAME;
918 pti_tty_driver->name = TTYNAME;
919 pti_tty_driver->major = 0;
920 pti_tty_driver->minor_start = PTITTY_MINOR_START;
J Freyensee0b61d2a2011-05-06 16:56:49 -0700921 pti_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
922 pti_tty_driver->subtype = SYSTEM_TYPE_SYSCONS;
923 pti_tty_driver->flags = TTY_DRIVER_REAL_RAW |
924 TTY_DRIVER_DYNAMIC_DEV;
925 pti_tty_driver->init_termios = tty_std_termios;
926
927 tty_set_operations(pti_tty_driver, &pti_tty_driver_ops);
928
929 retval = tty_register_driver(pti_tty_driver);
930 if (retval) {
931 pr_err("%s(%d): TTY registration failed of pti driver\n",
932 __func__, __LINE__);
933 pr_err("%s(%d): Error value returned: %d\n",
934 __func__, __LINE__, retval);
935
936 pti_tty_driver = NULL;
937 return retval;
938 }
939
940 retval = pci_register_driver(&pti_pci_driver);
941
942 if (retval) {
943 pr_err("%s(%d): PCI registration failed of pti driver\n",
944 __func__, __LINE__);
945 pr_err("%s(%d): Error value returned: %d\n",
946 __func__, __LINE__, retval);
947
948 tty_unregister_driver(pti_tty_driver);
949 pr_err("%s(%d): Unregistering TTY part of pti driver\n",
950 __func__, __LINE__);
951 pti_tty_driver = NULL;
952 return retval;
953 }
954
955 return retval;
956}
957
958/**
959 * pti_exit()- Unregisters this module as a tty and pci driver.
960 */
961static void __exit pti_exit(void)
962{
963 int retval;
964
965 tty_unregister_device(pti_tty_driver, 0);
966 tty_unregister_device(pti_tty_driver, 1);
967
968 retval = tty_unregister_driver(pti_tty_driver);
969 if (retval) {
970 pr_err("%s(%d): TTY unregistration failed of pti driver\n",
971 __func__, __LINE__);
972 pr_err("%s(%d): Error value returned: %d\n",
973 __func__, __LINE__, retval);
974 }
975
976 pci_unregister_driver(&pti_pci_driver);
977
978 retval = misc_deregister(&pti_char_driver);
979 if (retval) {
980 pr_err("%s(%d): CHAR unregistration failed of pti driver\n",
981 __func__, __LINE__);
982 pr_err("%s(%d): Error value returned: %d\n",
983 __func__, __LINE__, retval);
984 }
985
986 unregister_console(&pti_console);
987 return;
988}
989
990module_init(pti_init);
991module_exit(pti_exit);
992
993MODULE_LICENSE("GPL");
994MODULE_AUTHOR("Ken Mills, Jay Freyensee");
995MODULE_DESCRIPTION("PTI Driver");
996