~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/ia64/hp/sim/simserial.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Simulated Serial Driver (fake serial)
  3  *
  4  * This driver is mostly used for bringup purposes and will go away.
  5  * It has a strong dependency on the system console. All outputs
  6  * are rerouted to the same facility as the one used by printk which, in our
  7  * case means sys_sim.c console (goes via the simulator).
  8  *
  9  * Copyright (C) 1999-2000, 2002-2003 Hewlett-Packard Co
 10  *      Stephane Eranian <eranian@hpl.hp.com>
 11  *      David Mosberger-Tang <davidm@hpl.hp.com>
 12  */
 13 
 14 #include <linux/init.h>
 15 #include <linux/errno.h>
 16 #include <linux/sched.h>
 17 #include <linux/tty.h>
 18 #include <linux/tty_flip.h>
 19 #include <linux/major.h>
 20 #include <linux/fcntl.h>
 21 #include <linux/mm.h>
 22 #include <linux/seq_file.h>
 23 #include <linux/slab.h>
 24 #include <linux/capability.h>
 25 #include <linux/circ_buf.h>
 26 #include <linux/console.h>
 27 #include <linux/irq.h>
 28 #include <linux/module.h>
 29 #include <linux/serial.h>
 30 #include <linux/sysrq.h>
 31 #include <linux/uaccess.h>
 32 
 33 #include <asm/hpsim.h>
 34 
 35 #include "hpsim_ssc.h"
 36 
 37 #undef SIMSERIAL_DEBUG  /* define this to get some debug information */
 38 
 39 #define KEYBOARD_INTR   3       /* must match with simulator! */
 40 
 41 #define NR_PORTS        1       /* only one port for now */
 42 
 43 struct serial_state {
 44         struct tty_port port;
 45         struct circ_buf xmit;
 46         int irq;
 47         int x_char;
 48 };
 49 
 50 static struct serial_state rs_table[NR_PORTS];
 51 
 52 struct tty_driver *hp_simserial_driver;
 53 
 54 static struct console *console;
 55 
 56 static void receive_chars(struct tty_port *port)
 57 {
 58         unsigned char ch;
 59         static unsigned char seen_esc = 0;
 60 
 61         while ( (ch = ia64_ssc(0, 0, 0, 0, SSC_GETCHAR)) ) {
 62                 if (ch == 27 && seen_esc == 0) {
 63                         seen_esc = 1;
 64                         continue;
 65                 } else if (seen_esc == 1 && ch == 'O') {
 66                         seen_esc = 2;
 67                         continue;
 68                 } else if (seen_esc == 2) {
 69                         if (ch == 'P') /* F1 */
 70                                 show_state();
 71 #ifdef CONFIG_MAGIC_SYSRQ
 72                         if (ch == 'S') { /* F4 */
 73                                 do {
 74                                         ch = ia64_ssc(0, 0, 0, 0, SSC_GETCHAR);
 75                                 } while (!ch);
 76                                 handle_sysrq(ch);
 77                         }
 78 #endif
 79                         seen_esc = 0;
 80                         continue;
 81                 }
 82                 seen_esc = 0;
 83 
 84                 if (tty_insert_flip_char(port, ch, TTY_NORMAL) == 0)
 85                         break;
 86         }
 87         tty_flip_buffer_push(port);
 88 }
 89 
 90 /*
 91  * This is the serial driver's interrupt routine for a single port
 92  */
 93 static irqreturn_t rs_interrupt_single(int irq, void *dev_id)
 94 {
 95         struct serial_state *info = dev_id;
 96 
 97         receive_chars(&info->port);
 98 
 99         return IRQ_HANDLED;
100 }
101 
102 /*
103  * -------------------------------------------------------------------
104  * Here ends the serial interrupt routines.
105  * -------------------------------------------------------------------
106  */
107 
108 static int rs_put_char(struct tty_struct *tty, unsigned char ch)
109 {
110         struct serial_state *info = tty->driver_data;
111         unsigned long flags;
112 
113         if (!info->xmit.buf)
114                 return 0;
115 
116         local_irq_save(flags);
117         if (CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE) == 0) {
118                 local_irq_restore(flags);
119                 return 0;
120         }
121         info->xmit.buf[info->xmit.head] = ch;
122         info->xmit.head = (info->xmit.head + 1) & (SERIAL_XMIT_SIZE-1);
123         local_irq_restore(flags);
124         return 1;
125 }
126 
127 static void transmit_chars(struct tty_struct *tty, struct serial_state *info,
128                 int *intr_done)
129 {
130         int count;
131         unsigned long flags;
132 
133         local_irq_save(flags);
134 
135         if (info->x_char) {
136                 char c = info->x_char;
137 
138                 console->write(console, &c, 1);
139 
140                 info->x_char = 0;
141 
142                 goto out;
143         }
144 
145         if (info->xmit.head == info->xmit.tail || tty->stopped) {
146 #ifdef SIMSERIAL_DEBUG
147                 printk("transmit_chars: head=%d, tail=%d, stopped=%d\n",
148                        info->xmit.head, info->xmit.tail, tty->stopped);
149 #endif
150                 goto out;
151         }
152         /*
153          * We removed the loop and try to do it in to chunks. We need
154          * 2 operations maximum because it's a ring buffer.
155          *
156          * First from current to tail if possible.
157          * Then from the beginning of the buffer until necessary
158          */
159 
160         count = min(CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE),
161                     SERIAL_XMIT_SIZE - info->xmit.tail);
162         console->write(console, info->xmit.buf+info->xmit.tail, count);
163 
164         info->xmit.tail = (info->xmit.tail+count) & (SERIAL_XMIT_SIZE-1);
165 
166         /*
167          * We have more at the beginning of the buffer
168          */
169         count = CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
170         if (count) {
171                 console->write(console, info->xmit.buf, count);
172                 info->xmit.tail += count;
173         }
174 out:
175         local_irq_restore(flags);
176 }
177 
178 static void rs_flush_chars(struct tty_struct *tty)
179 {
180         struct serial_state *info = tty->driver_data;
181 
182         if (info->xmit.head == info->xmit.tail || tty->stopped ||
183                         !info->xmit.buf)
184                 return;
185 
186         transmit_chars(tty, info, NULL);
187 }
188 
189 static int rs_write(struct tty_struct * tty,
190                     const unsigned char *buf, int count)
191 {
192         struct serial_state *info = tty->driver_data;
193         int     c, ret = 0;
194         unsigned long flags;
195 
196         if (!info->xmit.buf)
197                 return 0;
198 
199         local_irq_save(flags);
200         while (1) {
201                 c = CIRC_SPACE_TO_END(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
202                 if (count < c)
203                         c = count;
204                 if (c <= 0) {
205                         break;
206                 }
207                 memcpy(info->xmit.buf + info->xmit.head, buf, c);
208                 info->xmit.head = ((info->xmit.head + c) &
209                                    (SERIAL_XMIT_SIZE-1));
210                 buf += c;
211                 count -= c;
212                 ret += c;
213         }
214         local_irq_restore(flags);
215         /*
216          * Hey, we transmit directly from here in our case
217          */
218         if (CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE) &&
219                         !tty->stopped)
220                 transmit_chars(tty, info, NULL);
221 
222         return ret;
223 }
224 
225 static int rs_write_room(struct tty_struct *tty)
226 {
227         struct serial_state *info = tty->driver_data;
228 
229         return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
230 }
231 
232 static int rs_chars_in_buffer(struct tty_struct *tty)
233 {
234         struct serial_state *info = tty->driver_data;
235 
236         return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
237 }
238 
239 static void rs_flush_buffer(struct tty_struct *tty)
240 {
241         struct serial_state *info = tty->driver_data;
242         unsigned long flags;
243 
244         local_irq_save(flags);
245         info->xmit.head = info->xmit.tail = 0;
246         local_irq_restore(flags);
247 
248         tty_wakeup(tty);
249 }
250 
251 /*
252  * This function is used to send a high-priority XON/XOFF character to
253  * the device
254  */
255 static void rs_send_xchar(struct tty_struct *tty, char ch)
256 {
257         struct serial_state *info = tty->driver_data;
258 
259         info->x_char = ch;
260         if (ch) {
261                 /*
262                  * I guess we could call console->write() directly but
263                  * let's do that for now.
264                  */
265                 transmit_chars(tty, info, NULL);
266         }
267 }
268 
269 /*
270  * ------------------------------------------------------------
271  * rs_throttle()
272  *
273  * This routine is called by the upper-layer tty layer to signal that
274  * incoming characters should be throttled.
275  * ------------------------------------------------------------
276  */
277 static void rs_throttle(struct tty_struct * tty)
278 {
279         if (I_IXOFF(tty))
280                 rs_send_xchar(tty, STOP_CHAR(tty));
281 
282         printk(KERN_INFO "simrs_throttle called\n");
283 }
284 
285 static void rs_unthrottle(struct tty_struct * tty)
286 {
287         struct serial_state *info = tty->driver_data;
288 
289         if (I_IXOFF(tty)) {
290                 if (info->x_char)
291                         info->x_char = 0;
292                 else
293                         rs_send_xchar(tty, START_CHAR(tty));
294         }
295         printk(KERN_INFO "simrs_unthrottle called\n");
296 }
297 
298 static int rs_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
299 {
300         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
301             (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
302             (cmd != TIOCMIWAIT)) {
303                 if (tty->flags & (1 << TTY_IO_ERROR))
304                     return -EIO;
305         }
306 
307         switch (cmd) {
308         case TIOCGSERIAL:
309         case TIOCSSERIAL:
310         case TIOCSERGSTRUCT:
311         case TIOCMIWAIT:
312                 return 0;
313         case TIOCSERCONFIG:
314         case TIOCSERGETLSR: /* Get line status register */
315                 return -EINVAL;
316         case TIOCSERGWILD:
317         case TIOCSERSWILD:
318                 /* "setserial -W" is called in Debian boot */
319                 printk (KERN_INFO "TIOCSER?WILD ioctl obsolete, ignored.\n");
320                 return 0;
321         }
322         return -ENOIOCTLCMD;
323 }
324 
325 #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
326 
327 /*
328  * This routine will shutdown a serial port; interrupts are disabled, and
329  * DTR is dropped if the hangup on close termio flag is on.
330  */
331 static void shutdown(struct tty_port *port)
332 {
333         struct serial_state *info = container_of(port, struct serial_state,
334                         port);
335         unsigned long flags;
336 
337         local_irq_save(flags);
338         if (info->irq)
339                 free_irq(info->irq, info);
340 
341         if (info->xmit.buf) {
342                 free_page((unsigned long) info->xmit.buf);
343                 info->xmit.buf = NULL;
344         }
345         local_irq_restore(flags);
346 }
347 
348 static void rs_close(struct tty_struct *tty, struct file * filp)
349 {
350         struct serial_state *info = tty->driver_data;
351 
352         tty_port_close(&info->port, tty, filp);
353 }
354 
355 static void rs_hangup(struct tty_struct *tty)
356 {
357         struct serial_state *info = tty->driver_data;
358 
359         rs_flush_buffer(tty);
360         tty_port_hangup(&info->port);
361 }
362 
363 static int activate(struct tty_port *port, struct tty_struct *tty)
364 {
365         struct serial_state *state = container_of(port, struct serial_state,
366                         port);
367         unsigned long flags, page;
368         int retval = 0;
369 
370         page = get_zeroed_page(GFP_KERNEL);
371         if (!page)
372                 return -ENOMEM;
373 
374         local_irq_save(flags);
375 
376         if (state->xmit.buf)
377                 free_page(page);
378         else
379                 state->xmit.buf = (unsigned char *) page;
380 
381         if (state->irq) {
382                 retval = request_irq(state->irq, rs_interrupt_single, 0,
383                                 "simserial", state);
384                 if (retval)
385                         goto errout;
386         }
387 
388         state->xmit.head = state->xmit.tail = 0;
389 
390         /*
391          * Set up the tty->alt_speed kludge
392          */
393         if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
394                 tty->alt_speed = 57600;
395         if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
396                 tty->alt_speed = 115200;
397         if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
398                 tty->alt_speed = 230400;
399         if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
400                 tty->alt_speed = 460800;
401 
402 errout:
403         local_irq_restore(flags);
404         return retval;
405 }
406 
407 
408 /*
409  * This routine is called whenever a serial port is opened.  It
410  * enables interrupts for a serial port, linking in its async structure into
411  * the IRQ chain.   It also performs the serial-specific
412  * initialization for the tty structure.
413  */
414 static int rs_open(struct tty_struct *tty, struct file * filp)
415 {
416         struct serial_state *info = rs_table + tty->index;
417         struct tty_port *port = &info->port;
418 
419         tty->driver_data = info;
420         port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
421 
422         /*
423          * figure out which console to use (should be one already)
424          */
425         console = console_drivers;
426         while (console) {
427                 if ((console->flags & CON_ENABLED) && console->write) break;
428                 console = console->next;
429         }
430 
431         return tty_port_open(port, tty, filp);
432 }
433 
434 /*
435  * /proc fs routines....
436  */
437 
438 static int rs_proc_show(struct seq_file *m, void *v)
439 {
440         int i;
441 
442         seq_printf(m, "simserinfo:1.0\n");
443         for (i = 0; i < NR_PORTS; i++)
444                 seq_printf(m, "%d: uart:16550 port:3F8 irq:%d\n",
445                        i, rs_table[i].irq);
446         return 0;
447 }
448 
449 static int rs_proc_open(struct inode *inode, struct file *file)
450 {
451         return single_open(file, rs_proc_show, NULL);
452 }
453 
454 static const struct file_operations rs_proc_fops = {
455         .owner          = THIS_MODULE,
456         .open           = rs_proc_open,
457         .read           = seq_read,
458         .llseek         = seq_lseek,
459         .release        = single_release,
460 };
461 
462 static const struct tty_operations hp_ops = {
463         .open = rs_open,
464         .close = rs_close,
465         .write = rs_write,
466         .put_char = rs_put_char,
467         .flush_chars = rs_flush_chars,
468         .write_room = rs_write_room,
469         .chars_in_buffer = rs_chars_in_buffer,
470         .flush_buffer = rs_flush_buffer,
471         .ioctl = rs_ioctl,
472         .throttle = rs_throttle,
473         .unthrottle = rs_unthrottle,
474         .send_xchar = rs_send_xchar,
475         .hangup = rs_hangup,
476         .proc_fops = &rs_proc_fops,
477 };
478 
479 static const struct tty_port_operations hp_port_ops = {
480         .activate = activate,
481         .shutdown = shutdown,
482 };
483 
484 static int __init simrs_init(void)
485 {
486         struct serial_state *state;
487         int retval;
488 
489         if (!ia64_platform_is("hpsim"))
490                 return -ENODEV;
491 
492         hp_simserial_driver = alloc_tty_driver(NR_PORTS);
493         if (!hp_simserial_driver)
494                 return -ENOMEM;
495 
496         printk(KERN_INFO "SimSerial driver with no serial options enabled\n");
497 
498         /* Initialize the tty_driver structure */
499 
500         hp_simserial_driver->driver_name = "simserial";
501         hp_simserial_driver->name = "ttyS";
502         hp_simserial_driver->major = TTY_MAJOR;
503         hp_simserial_driver->minor_start = 64;
504         hp_simserial_driver->type = TTY_DRIVER_TYPE_SERIAL;
505         hp_simserial_driver->subtype = SERIAL_TYPE_NORMAL;
506         hp_simserial_driver->init_termios = tty_std_termios;
507         hp_simserial_driver->init_termios.c_cflag =
508                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
509         hp_simserial_driver->flags = TTY_DRIVER_REAL_RAW;
510         tty_set_operations(hp_simserial_driver, &hp_ops);
511 
512         state = rs_table;
513         tty_port_init(&state->port);
514         state->port.ops = &hp_port_ops;
515         state->port.close_delay = 0; /* XXX really 0? */
516 
517         retval = hpsim_get_irq(KEYBOARD_INTR);
518         if (retval < 0) {
519                 printk(KERN_ERR "%s: out of interrupt vectors!\n",
520                                 __func__);
521                 goto err_free_tty;
522         }
523 
524         state->irq = retval;
525 
526         /* the port is imaginary */
527         printk(KERN_INFO "ttyS0 at 0x03f8 (irq = %d) is a 16550\n", state->irq);
528 
529         tty_port_link_device(&state->port, hp_simserial_driver, 0);
530         retval = tty_register_driver(hp_simserial_driver);
531         if (retval) {
532                 printk(KERN_ERR "Couldn't register simserial driver\n");
533                 goto err_free_tty;
534         }
535 
536         return 0;
537 err_free_tty:
538         put_tty_driver(hp_simserial_driver);
539         tty_port_destroy(&state->port);
540         return retval;
541 }
542 
543 #ifndef MODULE
544 __initcall(simrs_init);
545 #endif
546 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp