2 * Copyright (C) 2004 Hollis Blanchard <hollisb@us.ibm.com>, IBM
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 /* Host Virtual Serial Interface (HVSI) is a protocol between the hosted OS
20 * and the service processor on IBM pSeries servers. On these servers, there
21 * are no serial ports under the OS's control, and sometimes there is no other
22 * console available either. However, the service processor has two standard
23 * serial ports, so this over-complicated protocol allows the OS to control
24 * those ports by proxy.
26 * Besides data, the procotol supports the reading/writing of the serial
27 * port's DTR line, and the reading of the CD line. This is to allow the OS to
28 * control a modem attached to the service processor's serial port. Note that
29 * the OS cannot change the speed of the port through this protocol.
34 * add udbg support for xmon/kdb
39 #include <linux/console.h>
40 #include <linux/ctype.h>
41 #include <linux/delay.h>
42 #include <linux/init.h>
43 #include <linux/interrupt.h>
44 #include <linux/module.h>
45 #include <linux/major.h>
46 #include <linux/kernel.h>
47 #include <linux/sched.h>
48 #include <linux/spinlock.h>
49 #include <linux/sysrq.h>
50 #include <linux/tty.h>
51 #include <linux/tty_flip.h>
52 #include <asm/hvcall.h>
53 #include <asm/hvconsole.h>
55 #include <asm/uaccess.h>
58 #define HVSI_MAJOR 229
59 #define HVSI_MINOR 128
60 #define MAX_NR_HVSI_CONSOLES 4
62 #define HVSI_TIMEOUT (5*HZ)
63 #define HVSI_VERSION 1
64 #define HVSI_MAX_PACKET 256
65 #define HVSI_MAX_READ 16
66 #define HVSI_MAX_OUTGOING_DATA 12
70 * we pass data via two 8-byte registers, so we would like our char arrays
71 * properly aligned for those loads.
73 #define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
76 struct work_struct writer
;
77 wait_queue_head_t emptyq
; /* woken when outbuf is emptied */
78 wait_queue_head_t stateq
; /* woken when HVSI state changes */
81 struct tty_struct
*tty
;
83 uint8_t throttle_buf
[128];
84 uint8_t outbuf
[N_OUTBUF
]; /* to implement write_room and chars_in_buffer */
85 /* inbuf is for packet reassembly. leave a little room for leftovers. */
86 uint8_t inbuf
[HVSI_MAX_PACKET
+ HVSI_MAX_READ
];
92 atomic_t seqno
; /* HVSI packet sequence number */
94 uint8_t state
; /* HVSI protocol state */
96 #ifdef CONFIG_MAGIC_SYSRQ
98 #endif /* CONFIG_MAGIC_SYSRQ */
100 static struct hvsi_struct hvsi_ports
[MAX_NR_HVSI_CONSOLES
];
102 static struct tty_driver
*hvsi_driver
;
103 static int hvsi_count
;
104 static int (*hvsi_wait
)(struct hvsi_struct
*hp
, int state
);
106 enum HVSI_PROTOCOL_STATE
{
108 HVSI_WAIT_FOR_VER_RESPONSE
,
109 HVSI_WAIT_FOR_VER_QUERY
,
111 HVSI_WAIT_FOR_MCTRL_RESPONSE
,
113 #define HVSI_CONSOLE 0x1
115 #define VS_DATA_PACKET_HEADER 0xff
116 #define VS_CONTROL_PACKET_HEADER 0xfe
117 #define VS_QUERY_PACKET_HEADER 0xfd
118 #define VS_QUERY_RESPONSE_PACKET_HEADER 0xfc
121 #define VSV_SET_MODEM_CTL 1 /* to service processor only */
122 #define VSV_MODEM_CTL_UPDATE 2 /* from service processor only */
123 #define VSV_CLOSE_PROTOCOL 3
126 #define VSV_SEND_VERSION_NUMBER 1
127 #define VSV_SEND_MODEM_CTL_STATUS 2
129 /* yes, these masks are not consecutive. */
130 #define HVSI_TSDTR 0x01
131 #define HVSI_TSCD 0x20
137 } __attribute__((packed
));
143 uint8_t data
[HVSI_MAX_OUTGOING_DATA
];
144 } __attribute__((packed
));
146 struct hvsi_control
{
151 /* optional depending on verb: */
154 } __attribute__((packed
));
161 } __attribute__((packed
));
163 struct hvsi_query_response
{
168 uint16_t query_seqno
;
173 } __attribute__((packed
));
175 static inline int is_open(struct hvsi_struct
*hp
)
177 /* if we're waiting for an mctrl then we're already open */
178 return (hp
->state
== HVSI_OPEN
)
179 || (hp
->state
== HVSI_WAIT_FOR_MCTRL_RESPONSE
);
182 static inline void print_state(struct hvsi_struct
*hp
)
185 static const char *state_names
[] = {
187 "HVSI_WAIT_FOR_VER_RESPONSE",
188 "HVSI_WAIT_FOR_VER_QUERY",
190 "HVSI_WAIT_FOR_MCTRL_RESPONSE",
192 const char *name
= state_names
[hp
->state
];
194 if (hp
->state
> (sizeof(state_names
)/sizeof(char*)))
197 pr_debug("hvsi%i: state = %s\n", hp
->index
, name
);
201 static inline void __set_state(struct hvsi_struct
*hp
, int state
)
205 wake_up_all(&hp
->stateq
);
208 static inline void set_state(struct hvsi_struct
*hp
, int state
)
212 spin_lock_irqsave(&hp
->lock
, flags
);
213 __set_state(hp
, state
);
214 spin_unlock_irqrestore(&hp
->lock
, flags
);
217 static inline int len_packet(const uint8_t *packet
)
219 return (int)((struct hvsi_header
*)packet
)->len
;
222 static inline int is_header(const uint8_t *packet
)
224 struct hvsi_header
*header
= (struct hvsi_header
*)packet
;
225 return header
->type
>= VS_QUERY_RESPONSE_PACKET_HEADER
;
228 static inline int got_packet(const struct hvsi_struct
*hp
, uint8_t *packet
)
230 if (hp
->inbuf_end
< packet
+ sizeof(struct hvsi_header
))
231 return 0; /* don't even have the packet header */
233 if (hp
->inbuf_end
< (packet
+ len_packet(packet
)))
234 return 0; /* don't have the rest of the packet */
239 /* shift remaining bytes in packetbuf down */
240 static void compact_inbuf(struct hvsi_struct
*hp
, uint8_t *read_to
)
242 int remaining
= (int)(hp
->inbuf_end
- read_to
);
244 pr_debug("%s: %i chars remain\n", __FUNCTION__
, remaining
);
246 if (read_to
!= hp
->inbuf
)
247 memmove(hp
->inbuf
, read_to
, remaining
);
249 hp
->inbuf_end
= hp
->inbuf
+ remaining
;
253 #define dbg_dump_packet(packet) dump_packet(packet)
254 #define dbg_dump_hex(data, len) dump_hex(data, len)
256 #define dbg_dump_packet(packet) do { } while (0)
257 #define dbg_dump_hex(data, len) do { } while (0)
260 static void dump_hex(const uint8_t *data
, int len
)
265 for (i
=0; i
< len
; i
++)
266 printk("%.2x", data
[i
]);
269 for (i
=0; i
< len
; i
++) {
270 if (isprint(data
[i
]))
271 printk("%c", data
[i
]);
278 static void dump_packet(uint8_t *packet
)
280 struct hvsi_header
*header
= (struct hvsi_header
*)packet
;
282 printk("type 0x%x, len %i, seqno %i:\n", header
->type
, header
->len
,
285 dump_hex(packet
, header
->len
);
288 /* can't use hvc_get_chars because that strips CRs */
289 static int hvsi_read(struct hvsi_struct
*hp
, char *buf
, int count
)
293 if (plpar_hcall(H_GET_TERM_CHAR
, hp
->vtermno
, 0, 0, 0, &got
,
294 (unsigned long *)buf
, (unsigned long *)buf
+1) == H_Success
)
300 * we can't call tty_hangup() directly here because we need to call that
301 * outside of our lock
303 static struct tty_struct
*hvsi_recv_control(struct hvsi_struct
*hp
,
306 struct tty_struct
*to_hangup
= NULL
;
307 struct hvsi_control
*header
= (struct hvsi_control
*)packet
;
309 switch (header
->verb
) {
310 case VSV_MODEM_CTL_UPDATE
:
311 if ((header
->word
& HVSI_TSCD
) == 0) {
312 /* CD went away; no more connection */
313 pr_debug("hvsi%i: CD dropped\n", hp
->index
);
314 hp
->mctrl
&= TIOCM_CD
;
315 if (!(hp
->tty
->flags
& CLOCAL
))
319 case VSV_CLOSE_PROTOCOL
:
321 "hvsi%i: service processor closed connection!\n", hp
->index
);
322 __set_state(hp
, HVSI_CLOSED
);
327 printk(KERN_WARNING
"hvsi%i: unknown HVSI control packet: ",
336 static void hvsi_recv_response(struct hvsi_struct
*hp
, uint8_t *packet
)
338 struct hvsi_query_response
*resp
= (struct hvsi_query_response
*)packet
;
341 case HVSI_WAIT_FOR_VER_RESPONSE
:
342 __set_state(hp
, HVSI_WAIT_FOR_VER_QUERY
);
344 case HVSI_WAIT_FOR_MCTRL_RESPONSE
:
346 if (resp
->u
.mctrl_word
& HVSI_TSDTR
)
347 hp
->mctrl
|= TIOCM_DTR
;
348 if (resp
->u
.mctrl_word
& HVSI_TSCD
)
349 hp
->mctrl
|= TIOCM_CD
;
350 __set_state(hp
, HVSI_OPEN
);
353 printk(KERN_ERR
"hvsi%i: unexpected query response: ", hp
->index
);
359 /* respond to service processor's version query */
360 static int hvsi_version_respond(struct hvsi_struct
*hp
, uint16_t query_seqno
)
362 struct hvsi_query_response packet __ALIGNED__
;
365 packet
.type
= VS_QUERY_RESPONSE_PACKET_HEADER
;
366 packet
.len
= sizeof(struct hvsi_query_response
);
367 packet
.seqno
= atomic_inc_return(&hp
->seqno
);
368 packet
.verb
= VSV_SEND_VERSION_NUMBER
;
369 packet
.u
.version
= HVSI_VERSION
;
370 packet
.query_seqno
= query_seqno
+1;
372 pr_debug("%s: sending %i bytes\n", __FUNCTION__
, packet
.len
);
373 dbg_dump_hex((uint8_t*)&packet
, packet
.len
);
375 wrote
= hvc_put_chars(hp
->vtermno
, (char *)&packet
, packet
.len
);
376 if (wrote
!= packet
.len
) {
377 printk(KERN_ERR
"hvsi%i: couldn't send query response!\n",
385 static void hvsi_recv_query(struct hvsi_struct
*hp
, uint8_t *packet
)
387 struct hvsi_query
*query
= (struct hvsi_query
*)packet
;
390 case HVSI_WAIT_FOR_VER_QUERY
:
391 __set_state(hp
, HVSI_OPEN
);
392 hvsi_version_respond(hp
, query
->seqno
);
395 printk(KERN_ERR
"hvsi%i: unexpected query: ", hp
->index
);
401 static void hvsi_insert_chars(struct hvsi_struct
*hp
, const char *buf
, int len
)
405 for (i
=0; i
< len
; i
++) {
407 #ifdef CONFIG_MAGIC_SYSRQ
411 } else if (hp
->sysrq
) {
412 handle_sysrq(c
, NULL
, hp
->tty
);
416 #endif /* CONFIG_MAGIC_SYSRQ */
417 tty_insert_flip_char(hp
->tty
, c
, 0);
422 * We could get 252 bytes of data at once here. But the tty layer only
423 * throttles us at TTY_THRESHOLD_THROTTLE (128) bytes, so we could overflow
424 * it. Accordingly we won't send more than 128 bytes at a time to the flip
425 * buffer, which will give the tty buffer a chance to throttle us. Should the
426 * value of TTY_THRESHOLD_THROTTLE change in n_tty.c, this code should be
429 #define TTY_THRESHOLD_THROTTLE 128
430 static struct tty_struct
*hvsi_recv_data(struct hvsi_struct
*hp
,
431 const uint8_t *packet
)
433 const struct hvsi_header
*header
= (const struct hvsi_header
*)packet
;
434 const uint8_t *data
= packet
+ sizeof(struct hvsi_header
);
435 int datalen
= header
->len
- sizeof(struct hvsi_header
);
436 int overflow
= datalen
- TTY_THRESHOLD_THROTTLE
;
438 pr_debug("queueing %i chars '%.*s'\n", datalen
, datalen
, data
);
444 pr_debug("%s: got >TTY_THRESHOLD_THROTTLE bytes\n", __FUNCTION__
);
445 datalen
= TTY_THRESHOLD_THROTTLE
;
448 hvsi_insert_chars(hp
, data
, datalen
);
452 * we still have more data to deliver, so we need to save off the
453 * overflow and send it later
455 pr_debug("%s: deferring overflow\n", __FUNCTION__
);
456 memcpy(hp
->throttle_buf
, data
+ TTY_THRESHOLD_THROTTLE
, overflow
);
457 hp
->n_throttle
= overflow
;
464 * Returns true/false indicating data successfully read from hypervisor.
465 * Used both to get packets for tty connections and to advance the state
466 * machine during console handshaking (in which case tty = NULL and we ignore
469 static int hvsi_load_chunk(struct hvsi_struct
*hp
, struct tty_struct
**flip
,
470 struct tty_struct
**hangup
)
472 uint8_t *packet
= hp
->inbuf
;
478 chunklen
= hvsi_read(hp
, hp
->inbuf_end
, HVSI_MAX_READ
);
482 pr_debug("%s: got %i bytes\n", __FUNCTION__
, chunklen
);
483 dbg_dump_hex(hp
->inbuf_end
, chunklen
);
485 hp
->inbuf_end
+= chunklen
;
487 /* handle all completed packets */
488 while ((packet
< hp
->inbuf_end
) && got_packet(hp
, packet
)) {
489 struct hvsi_header
*header
= (struct hvsi_header
*)packet
;
491 if (!is_header(packet
)) {
492 printk(KERN_ERR
"hvsi%i: got malformed packet\n", hp
->index
);
493 /* skip bytes until we find a header or run out of data */
494 while ((packet
< hp
->inbuf_end
) && (!is_header(packet
)))
499 pr_debug("%s: handling %i-byte packet\n", __FUNCTION__
,
501 dbg_dump_packet(packet
);
503 switch (header
->type
) {
504 case VS_DATA_PACKET_HEADER
:
508 break; /* no tty buffer to put data in */
509 *flip
= hvsi_recv_data(hp
, packet
);
511 case VS_CONTROL_PACKET_HEADER
:
512 *hangup
= hvsi_recv_control(hp
, packet
);
514 case VS_QUERY_RESPONSE_PACKET_HEADER
:
515 hvsi_recv_response(hp
, packet
);
517 case VS_QUERY_PACKET_HEADER
:
518 hvsi_recv_query(hp
, packet
);
521 printk(KERN_ERR
"hvsi%i: unknown HVSI packet type 0x%x\n",
522 hp
->index
, header
->type
);
527 packet
+= len_packet(packet
);
530 pr_debug("%s: hangup\n", __FUNCTION__
);
532 * we need to send the hangup now before receiving any more data.
533 * If we get "data, hangup, data", we can't deliver the second
534 * data before the hangup.
540 compact_inbuf(hp
, packet
);
545 static void hvsi_send_overflow(struct hvsi_struct
*hp
)
547 pr_debug("%s: delivering %i bytes overflow\n", __FUNCTION__
,
550 hvsi_insert_chars(hp
, hp
->throttle_buf
, hp
->n_throttle
);
555 * must get all pending data because we only get an irq on empty->non-empty
558 static irqreturn_t
hvsi_interrupt(int irq
, void *arg
, struct pt_regs
*regs
)
560 struct hvsi_struct
*hp
= (struct hvsi_struct
*)arg
;
561 struct tty_struct
*flip
;
562 struct tty_struct
*hangup
;
564 irqreturn_t handled
= IRQ_NONE
;
567 pr_debug("%s\n", __FUNCTION__
);
570 spin_lock_irqsave(&hp
->lock
, flags
);
571 again
= hvsi_load_chunk(hp
, &flip
, &hangup
);
572 handled
= IRQ_HANDLED
;
573 spin_unlock_irqrestore(&hp
->lock
, flags
);
576 * we have to call tty_flip_buffer_push() and tty_hangup() outside our
577 * spinlock. But we also have to keep going until we've read all the
582 /* there was data put in the tty flip buffer */
583 tty_flip_buffer_push(flip
);
592 spin_lock_irqsave(&hp
->lock
, flags
);
593 if (hp
->tty
&& hp
->n_throttle
594 && (!test_bit(TTY_THROTTLED
, &hp
->tty
->flags
))) {
595 /* we weren't hung up and we weren't throttled, so we can deliver the
598 hvsi_send_overflow(hp
);
600 spin_unlock_irqrestore(&hp
->lock
, flags
);
603 tty_flip_buffer_push(flip
);
609 /* for boot console, before the irq handler is running */
610 static int __init
poll_for_state(struct hvsi_struct
*hp
, int state
)
612 unsigned long end_jiffies
= jiffies
+ HVSI_TIMEOUT
;
615 hvsi_interrupt(hp
->virq
, (void *)hp
, NULL
); /* get pending data */
617 if (hp
->state
== state
)
621 if (time_after(jiffies
, end_jiffies
))
626 /* wait for irq handler to change our state */
627 static int wait_for_state(struct hvsi_struct
*hp
, int state
)
629 unsigned long end_jiffies
= jiffies
+ HVSI_TIMEOUT
;
630 unsigned long timeout
;
633 DECLARE_WAITQUEUE(myself
, current
);
634 set_current_state(TASK_INTERRUPTIBLE
);
635 add_wait_queue(&hp
->stateq
, &myself
);
638 set_current_state(TASK_INTERRUPTIBLE
);
639 if (hp
->state
== state
)
641 timeout
= end_jiffies
- jiffies
;
642 if (time_after(jiffies
, end_jiffies
)) {
646 schedule_timeout(timeout
);
648 remove_wait_queue(&hp
->stateq
, &myself
);
649 set_current_state(TASK_RUNNING
);
654 static int hvsi_query(struct hvsi_struct
*hp
, uint16_t verb
)
656 struct hvsi_query packet __ALIGNED__
;
659 packet
.type
= VS_QUERY_PACKET_HEADER
;
660 packet
.len
= sizeof(struct hvsi_query
);
661 packet
.seqno
= atomic_inc_return(&hp
->seqno
);
664 pr_debug("%s: sending %i bytes\n", __FUNCTION__
, packet
.len
);
665 dbg_dump_hex((uint8_t*)&packet
, packet
.len
);
667 wrote
= hvc_put_chars(hp
->vtermno
, (char *)&packet
, packet
.len
);
668 if (wrote
!= packet
.len
) {
669 printk(KERN_ERR
"hvsi%i: couldn't send query (%i)!\n", hp
->index
,
677 static int hvsi_get_mctrl(struct hvsi_struct
*hp
)
681 set_state(hp
, HVSI_WAIT_FOR_MCTRL_RESPONSE
);
682 hvsi_query(hp
, VSV_SEND_MODEM_CTL_STATUS
);
684 ret
= hvsi_wait(hp
, HVSI_OPEN
);
686 printk(KERN_ERR
"hvsi%i: didn't get modem flags\n", hp
->index
);
687 set_state(hp
, HVSI_OPEN
);
691 pr_debug("%s: mctrl 0x%x\n", __FUNCTION__
, hp
->mctrl
);
696 /* note that we can only set DTR */
697 static int hvsi_set_mctrl(struct hvsi_struct
*hp
, uint16_t mctrl
)
699 struct hvsi_control packet __ALIGNED__
;
702 packet
.type
= VS_CONTROL_PACKET_HEADER
,
703 packet
.seqno
= atomic_inc_return(&hp
->seqno
);
704 packet
.len
= sizeof(struct hvsi_control
);
705 packet
.verb
= VSV_SET_MODEM_CTL
;
706 packet
.mask
= HVSI_TSDTR
;
708 if (mctrl
& TIOCM_DTR
)
709 packet
.word
= HVSI_TSDTR
;
711 pr_debug("%s: sending %i bytes\n", __FUNCTION__
, packet
.len
);
712 dbg_dump_hex((uint8_t*)&packet
, packet
.len
);
714 wrote
= hvc_put_chars(hp
->vtermno
, (char *)&packet
, packet
.len
);
715 if (wrote
!= packet
.len
) {
716 printk(KERN_ERR
"hvsi%i: couldn't set DTR!\n", hp
->index
);
723 static void hvsi_drain_input(struct hvsi_struct
*hp
)
725 uint8_t buf
[HVSI_MAX_READ
] __ALIGNED__
;
726 unsigned long end_jiffies
= jiffies
+ HVSI_TIMEOUT
;
728 while (time_before(end_jiffies
, jiffies
))
729 if (0 == hvsi_read(hp
, buf
, HVSI_MAX_READ
))
733 static int hvsi_handshake(struct hvsi_struct
*hp
)
738 * We could have a CLOSE or other data waiting for us before we even try
739 * to open; try to throw it all away so we don't get confused. (CLOSE
740 * is the first message sent up the pipe when the FSP comes online. We
741 * need to distinguish between "it came up a while ago and we're the first
742 * user" and "it was just reset before it saw our handshake packet".)
744 hvsi_drain_input(hp
);
746 set_state(hp
, HVSI_WAIT_FOR_VER_RESPONSE
);
747 ret
= hvsi_query(hp
, VSV_SEND_VERSION_NUMBER
);
749 printk(KERN_ERR
"hvsi%i: couldn't send version query\n", hp
->index
);
753 ret
= hvsi_wait(hp
, HVSI_OPEN
);
760 static int hvsi_put_chars(struct hvsi_struct
*hp
, const char *buf
, int count
)
762 struct hvsi_data packet __ALIGNED__
;
765 BUG_ON(count
> HVSI_MAX_OUTGOING_DATA
);
767 packet
.type
= VS_DATA_PACKET_HEADER
;
768 packet
.seqno
= atomic_inc_return(&hp
->seqno
);
769 packet
.len
= count
+ sizeof(struct hvsi_header
);
770 memcpy(&packet
.data
, buf
, count
);
772 ret
= hvc_put_chars(hp
->vtermno
, (char *)&packet
, packet
.len
);
773 if (ret
== packet
.len
) {
774 /* return the number of chars written, not the packet length */
777 return ret
; /* return any errors */
780 static void hvsi_close_protocol(struct hvsi_struct
*hp
)
782 struct hvsi_control packet __ALIGNED__
;
784 packet
.type
= VS_CONTROL_PACKET_HEADER
;
785 packet
.seqno
= atomic_inc_return(&hp
->seqno
);
787 packet
.verb
= VSV_CLOSE_PROTOCOL
;
789 pr_debug("%s: sending %i bytes\n", __FUNCTION__
, packet
.len
);
790 dbg_dump_hex((uint8_t*)&packet
, packet
.len
);
792 hvc_put_chars(hp
->vtermno
, (char *)&packet
, packet
.len
);
795 static int hvsi_open(struct tty_struct
*tty
, struct file
*filp
)
797 struct hvsi_struct
*hp
;
799 int line
= tty
->index
;
802 pr_debug("%s\n", __FUNCTION__
);
804 if (line
< 0 || line
>= hvsi_count
)
806 hp
= &hvsi_ports
[line
];
808 tty
->driver_data
= hp
;
809 tty
->low_latency
= 1; /* avoid throttle/tty_flip_buffer_push race */
811 spin_lock_irqsave(&hp
->lock
, flags
);
814 atomic_set(&hp
->seqno
, 0);
815 h_vio_signal(hp
->vtermno
, VIO_IRQ_ENABLE
);
816 spin_unlock_irqrestore(&hp
->lock
, flags
);
818 if (hp
->flags
& HVSI_CONSOLE
)
819 return 0; /* this has already been handshaked as the console */
821 ret
= hvsi_handshake(hp
);
823 printk(KERN_ERR
"%s: HVSI handshaking failed\n", tty
->name
);
827 ret
= hvsi_get_mctrl(hp
);
829 printk(KERN_ERR
"%s: couldn't get initial modem flags\n", tty
->name
);
833 ret
= hvsi_set_mctrl(hp
, hp
->mctrl
| TIOCM_DTR
);
835 printk(KERN_ERR
"%s: couldn't set DTR\n", tty
->name
);
842 /* wait for hvsi_write_worker to empty hp->outbuf */
843 static void hvsi_flush_output(struct hvsi_struct
*hp
)
845 unsigned long end_jiffies
= jiffies
+ HVSI_TIMEOUT
;
846 unsigned long timeout
;
848 DECLARE_WAITQUEUE(myself
, current
);
849 set_current_state(TASK_UNINTERRUPTIBLE
);
850 add_wait_queue(&hp
->emptyq
, &myself
);
853 set_current_state(TASK_UNINTERRUPTIBLE
);
854 if (hp
->n_outbuf
<= 0)
856 timeout
= end_jiffies
- jiffies
;
857 if (time_after(jiffies
, end_jiffies
))
859 schedule_timeout(timeout
);
861 remove_wait_queue(&hp
->emptyq
, &myself
);
862 set_current_state(TASK_RUNNING
);
864 /* 'writer' could still be pending if it didn't see n_outbuf = 0 yet */
865 cancel_delayed_work(&hp
->writer
);
866 flush_scheduled_work();
869 * it's also possible that our timeout expired and hvsi_write_worker
870 * didn't manage to push outbuf. poof.
875 static void hvsi_close(struct tty_struct
*tty
, struct file
*filp
)
877 struct hvsi_struct
*hp
= tty
->driver_data
;
880 pr_debug("%s\n", __FUNCTION__
);
882 if (tty_hung_up_p(filp
))
885 spin_lock_irqsave(&hp
->lock
, flags
);
887 if (--hp
->count
== 0) {
889 hp
->inbuf_end
= hp
->inbuf
; /* discard remaining partial packets */
891 /* only close down connection if it is not the console */
892 if (!(hp
->flags
& HVSI_CONSOLE
)) {
893 h_vio_signal(hp
->vtermno
, VIO_IRQ_DISABLE
); /* no more irqs */
894 __set_state(hp
, HVSI_CLOSED
);
896 * any data delivered to the tty layer after this will be
897 * discarded (except for XON/XOFF)
901 spin_unlock_irqrestore(&hp
->lock
, flags
);
903 /* let any existing irq handlers finish. no more will start. */
904 synchronize_irq(hp
->virq
);
906 /* hvsi_write_worker will re-schedule until outbuf is empty. */
907 hvsi_flush_output(hp
);
909 /* tell FSP to stop sending data */
910 hvsi_close_protocol(hp
);
913 * drain anything FSP is still in the middle of sending, and let
914 * hvsi_handshake drain the rest on the next open.
916 hvsi_drain_input(hp
);
918 spin_lock_irqsave(&hp
->lock
, flags
);
920 } else if (hp
->count
< 0)
921 printk(KERN_ERR
"hvsi_close %lu: oops, count is %d\n",
922 hp
- hvsi_ports
, hp
->count
);
924 spin_unlock_irqrestore(&hp
->lock
, flags
);
927 static void hvsi_hangup(struct tty_struct
*tty
)
929 struct hvsi_struct
*hp
= tty
->driver_data
;
931 pr_debug("%s\n", __FUNCTION__
);
937 /* called with hp->lock held */
938 static void hvsi_push(struct hvsi_struct
*hp
)
942 if (hp
->n_outbuf
<= 0)
945 n
= hvsi_put_chars(hp
, hp
->outbuf
, hp
->n_outbuf
);
948 * either all data was sent or there was an error, and we throw away
955 /* hvsi_write_worker will keep rescheduling itself until outbuf is empty */
956 static void hvsi_write_worker(void *arg
)
958 struct hvsi_struct
*hp
= (struct hvsi_struct
*)arg
;
961 static long start_j
= 0;
967 spin_lock_irqsave(&hp
->lock
, flags
);
970 if (hp
->n_outbuf
> 0)
971 schedule_delayed_work(&hp
->writer
, 10);
974 pr_debug("%s: outbuf emptied after %li jiffies\n", __FUNCTION__
,
978 wake_up_all(&hp
->emptyq
);
979 if (test_bit(TTY_DO_WRITE_WAKEUP
, &hp
->tty
->flags
)
980 && hp
->tty
->ldisc
.write_wakeup
)
981 hp
->tty
->ldisc
.write_wakeup(hp
->tty
);
982 wake_up_interruptible(&hp
->tty
->write_wait
);
985 spin_unlock_irqrestore(&hp
->lock
, flags
);
988 static int hvsi_write_room(struct tty_struct
*tty
)
990 struct hvsi_struct
*hp
= (struct hvsi_struct
*)tty
->driver_data
;
992 return N_OUTBUF
- hp
->n_outbuf
;
995 static int hvsi_chars_in_buffer(struct tty_struct
*tty
)
997 struct hvsi_struct
*hp
= (struct hvsi_struct
*)tty
->driver_data
;
1002 static int hvsi_write(struct tty_struct
*tty
, int from_user
,
1003 const unsigned char *buf
, int count
)
1005 struct hvsi_struct
*hp
= tty
->driver_data
;
1006 const char *source
= buf
;
1008 unsigned long flags
;
1010 int origcount
= count
;
1013 kbuf
= kmalloc(count
, GFP_KERNEL
);
1016 if (copy_from_user(kbuf
, buf
, count
)) {
1023 spin_lock_irqsave(&hp
->lock
, flags
);
1026 /* we're either closing or not yet open; don't accept data */
1027 pr_debug("%s: not open\n", __FUNCTION__
);
1032 * when the hypervisor buffer (16K) fills, data will stay in hp->outbuf
1033 * and hvsi_write_worker will be scheduled. subsequent hvsi_write() calls
1034 * will see there is no room in outbuf and return.
1036 while ((count
> 0) && (hvsi_write_room(hp
->tty
) > 0)) {
1037 int chunksize
= min(count
, hvsi_write_room(hp
->tty
));
1039 BUG_ON(hp
->n_outbuf
< 0);
1040 memcpy(hp
->outbuf
+ hp
->n_outbuf
, source
, chunksize
);
1041 hp
->n_outbuf
+= chunksize
;
1044 source
+= chunksize
;
1049 if (hp
->n_outbuf
> 0) {
1051 * we weren't able to write it all to the hypervisor.
1052 * schedule another push attempt.
1054 schedule_delayed_work(&hp
->writer
, 10);
1058 spin_unlock_irqrestore(&hp
->lock
, flags
);
1063 if (total
!= origcount
)
1064 pr_debug("%s: wanted %i, only wrote %i\n", __FUNCTION__
, origcount
,
1071 * I have never seen throttle or unthrottle called, so this little throttle
1072 * buffering scheme may or may not work.
1074 static void hvsi_throttle(struct tty_struct
*tty
)
1076 struct hvsi_struct
*hp
= (struct hvsi_struct
*)tty
->driver_data
;
1078 pr_debug("%s\n", __FUNCTION__
);
1080 h_vio_signal(hp
->vtermno
, VIO_IRQ_DISABLE
);
1083 static void hvsi_unthrottle(struct tty_struct
*tty
)
1085 struct hvsi_struct
*hp
= (struct hvsi_struct
*)tty
->driver_data
;
1086 unsigned long flags
;
1089 pr_debug("%s\n", __FUNCTION__
);
1091 spin_lock_irqsave(&hp
->lock
, flags
);
1092 if (hp
->n_throttle
) {
1093 hvsi_send_overflow(hp
);
1096 spin_unlock_irqrestore(&hp
->lock
, flags
);
1099 tty_flip_buffer_push(hp
->tty
);
1101 h_vio_signal(hp
->vtermno
, VIO_IRQ_ENABLE
);
1104 static int hvsi_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1106 struct hvsi_struct
*hp
= (struct hvsi_struct
*)tty
->driver_data
;
1112 static int hvsi_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1113 unsigned int set
, unsigned int clear
)
1115 struct hvsi_struct
*hp
= (struct hvsi_struct
*)tty
->driver_data
;
1116 unsigned long flags
;
1119 /* we can only alter DTR */
1123 spin_lock_irqsave(&hp
->lock
, flags
);
1125 new_mctrl
= (hp
->mctrl
& ~clear
) | set
;
1127 if (hp
->mctrl
!= new_mctrl
) {
1128 hvsi_set_mctrl(hp
, new_mctrl
);
1129 hp
->mctrl
= new_mctrl
;
1131 spin_unlock_irqrestore(&hp
->lock
, flags
);
1137 static struct tty_operations hvsi_ops
= {
1139 .close
= hvsi_close
,
1140 .write
= hvsi_write
,
1141 .hangup
= hvsi_hangup
,
1142 .write_room
= hvsi_write_room
,
1143 .chars_in_buffer
= hvsi_chars_in_buffer
,
1144 .throttle
= hvsi_throttle
,
1145 .unthrottle
= hvsi_unthrottle
,
1146 .tiocmget
= hvsi_tiocmget
,
1147 .tiocmset
= hvsi_tiocmset
,
1150 static int __init
hvsi_init(void)
1154 hvsi_driver
= alloc_tty_driver(hvsi_count
);
1158 hvsi_driver
->owner
= THIS_MODULE
;
1159 hvsi_driver
->devfs_name
= "hvsi/";
1160 hvsi_driver
->driver_name
= "hvsi";
1161 hvsi_driver
->name
= "hvsi";
1162 hvsi_driver
->major
= HVSI_MAJOR
;
1163 hvsi_driver
->minor_start
= HVSI_MINOR
;
1164 hvsi_driver
->type
= TTY_DRIVER_TYPE_SYSTEM
;
1165 hvsi_driver
->init_termios
= tty_std_termios
;
1166 hvsi_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
;
1167 hvsi_driver
->flags
= TTY_DRIVER_REAL_RAW
;
1168 tty_set_operations(hvsi_driver
, &hvsi_ops
);
1170 for (i
=0; i
< hvsi_count
; i
++) {
1171 struct hvsi_struct
*hp
= &hvsi_ports
[i
];
1174 ret
= request_irq(hp
->virq
, hvsi_interrupt
, SA_INTERRUPT
, "hvsi", hp
);
1176 printk(KERN_ERR
"HVSI: couldn't reserve irq 0x%x (error %i)\n",
1179 hvsi_wait
= wait_for_state
; /* irqs active now */
1181 if (tty_register_driver(hvsi_driver
))
1182 panic("Couldn't register hvsi console driver\n");
1184 printk(KERN_INFO
"HVSI: registered %i devices\n", hvsi_count
);
1188 device_initcall(hvsi_init
);
1190 /***** console (not tty) code: *****/
1192 static void hvsi_console_print(struct console
*console
, const char *buf
,
1195 struct hvsi_struct
*hp
= &hvsi_ports
[console
->index
];
1196 char c
[HVSI_MAX_OUTGOING_DATA
] __ALIGNED__
;
1197 unsigned int i
= 0, n
= 0;
1198 int ret
, donecr
= 0;
1205 * ugh, we have to translate LF -> CRLF ourselves, in place.
1206 * copied from hvc_console.c:
1208 while (count
> 0 || i
> 0) {
1209 if (count
> 0 && i
< sizeof(c
)) {
1210 if (buf
[n
] == '\n' && !donecr
) {
1219 ret
= hvsi_put_chars(hp
, c
, i
);
1227 static struct tty_driver
*hvsi_console_device(struct console
*console
,
1230 *index
= console
->index
;
1234 static int __init
hvsi_console_setup(struct console
*console
, char *options
)
1236 struct hvsi_struct
*hp
= &hvsi_ports
[console
->index
];
1239 if (console
->index
< 0 || console
->index
>= hvsi_count
)
1242 /* give the FSP a chance to change the baud rate when we re-open */
1243 hvsi_close_protocol(hp
);
1245 ret
= hvsi_handshake(hp
);
1249 ret
= hvsi_get_mctrl(hp
);
1253 ret
= hvsi_set_mctrl(hp
, hp
->mctrl
| TIOCM_DTR
);
1257 hp
->flags
|= HVSI_CONSOLE
;
1262 static struct console hvsi_con_driver
= {
1264 .write
= hvsi_console_print
,
1265 .device
= hvsi_console_device
,
1266 .setup
= hvsi_console_setup
,
1267 .flags
= CON_PRINTBUFFER
,
1271 static int __init
hvsi_console_init(void)
1273 struct device_node
*vty
;
1275 hvsi_wait
= poll_for_state
; /* no irqs yet; must poll */
1277 /* search device tree for vty nodes */
1278 for (vty
= of_find_compatible_node(NULL
, "serial", "hvterm-protocol");
1280 vty
= of_find_compatible_node(vty
, "serial", "hvterm-protocol")) {
1281 struct hvsi_struct
*hp
;
1285 vtermno
= (uint32_t *)get_property(vty
, "reg", NULL
);
1286 irq
= (uint32_t *)get_property(vty
, "interrupts", NULL
);
1287 if (!vtermno
|| !irq
)
1290 if (hvsi_count
>= MAX_NR_HVSI_CONSOLES
) {
1295 hp
= &hvsi_ports
[hvsi_count
];
1296 INIT_WORK(&hp
->writer
, hvsi_write_worker
, hp
);
1297 init_waitqueue_head(&hp
->emptyq
);
1298 init_waitqueue_head(&hp
->stateq
);
1299 hp
->lock
= SPIN_LOCK_UNLOCKED
;
1300 hp
->index
= hvsi_count
;
1301 hp
->inbuf_end
= hp
->inbuf
;
1302 hp
->state
= HVSI_CLOSED
;
1303 hp
->vtermno
= *vtermno
;
1304 hp
->virq
= virt_irq_create_mapping(irq
[0]);
1305 if (hp
->virq
== NO_IRQ
) {
1306 printk(KERN_ERR
"%s: couldn't create irq mapping for 0x%x\n",
1307 __FUNCTION__
, hp
->virq
);
1310 hp
->virq
= irq_offset_up(hp
->virq
);
1316 register_console(&hvsi_con_driver
);
1319 console_initcall(hvsi_console_init
);