Lines Matching defs:hp
87 static int (*hvsi_wait)(struct hvsi_struct *hp, int state);
99 static inline int is_console(struct hvsi_struct *hp)
101 return hp->flags & HVSI_CONSOLE;
104 static inline int is_open(struct hvsi_struct *hp)
107 return (hp->state == HVSI_OPEN)
108 || (hp->state == HVSI_WAIT_FOR_MCTRL_RESPONSE);
111 static inline void print_state(struct hvsi_struct *hp)
122 const char *name = (hp->state < ARRAY_SIZE(state_names))
123 ? state_names[hp->state] : "UNKNOWN";
125 pr_debug("hvsi%i: state = %s\n", hp->index, name);
129 static inline void __set_state(struct hvsi_struct *hp, int state)
131 hp->state = state;
132 print_state(hp);
133 wake_up_all(&hp->stateq);
136 static inline void set_state(struct hvsi_struct *hp, int state)
140 spin_lock_irqsave(&hp->lock, flags);
141 __set_state(hp, state);
142 spin_unlock_irqrestore(&hp->lock, flags);
156 static inline int got_packet(const struct hvsi_struct *hp, uint8_t *packet)
158 if (hp->inbuf_end < packet + sizeof(struct hvsi_header))
161 if (hp->inbuf_end < (packet + len_packet(packet)))
168 static void compact_inbuf(struct hvsi_struct *hp, uint8_t *read_to)
170 int remaining = (int)(hp->inbuf_end - read_to);
174 if (read_to != hp->inbuf)
175 memmove(hp->inbuf, read_to, remaining);
177 hp->inbuf_end = hp->inbuf + remaining;
216 static int hvsi_read(struct hvsi_struct *hp, char *buf, int count)
220 got = hvc_get_chars(hp->vtermno, buf, count);
225 static void hvsi_recv_control(struct hvsi_struct *hp, uint8_t *packet,
234 pr_debug("hvsi%i: CD dropped\n", hp->index);
235 hp->mctrl &= TIOCM_CD;
241 pr_debug("hvsi%i: service processor came back\n", hp->index);
242 if (hp->state != HVSI_CLOSED) {
243 *to_handshake = hp;
248 hp->index);
254 static void hvsi_recv_response(struct hvsi_struct *hp, uint8_t *packet)
259 switch (hp->state) {
261 __set_state(hp, HVSI_WAIT_FOR_VER_QUERY);
264 hp->mctrl = 0;
267 hp->mctrl |= TIOCM_DTR;
269 hp->mctrl |= TIOCM_CD;
270 __set_state(hp, HVSI_OPEN);
273 printk(KERN_ERR "hvsi%i: unexpected query response: ", hp->index);
280 static int hvsi_version_respond(struct hvsi_struct *hp, uint16_t query_seqno)
287 packet.hdr.seqno = cpu_to_be16(atomic_inc_return(&hp->seqno));
295 wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
298 hp->index);
305 static void hvsi_recv_query(struct hvsi_struct *hp, uint8_t *packet)
309 switch (hp->state) {
311 hvsi_version_respond(hp, be16_to_cpu(query->hdr.seqno));
312 __set_state(hp, HVSI_OPEN);
315 printk(KERN_ERR "hvsi%i: unexpected query: ", hp->index);
321 static void hvsi_insert_chars(struct hvsi_struct *hp, const char *buf, int len)
329 hp->sysrq = 1;
331 } else if (hp->sysrq) {
333 hp->sysrq = 0;
337 tty_insert_flip_char(&hp->port, c, 0);
350 static bool hvsi_recv_data(struct hvsi_struct *hp, const uint8_t *packet)
367 hvsi_insert_chars(hp, data, datalen);
375 memcpy(hp->throttle_buf, data + TTY_THRESHOLD_THROTTLE, overflow);
376 hp->n_throttle = overflow;
388 static int hvsi_load_chunk(struct hvsi_struct *hp, struct tty_struct *tty,
391 uint8_t *packet = hp->inbuf;
397 chunklen = hvsi_read(hp, hp->inbuf_end, HVSI_MAX_READ);
404 dbg_dump_hex(hp->inbuf_end, chunklen);
406 hp->inbuf_end += chunklen;
409 while ((packet < hp->inbuf_end) && got_packet(hp, packet)) {
413 printk(KERN_ERR "hvsi%i: got malformed packet\n", hp->index);
415 while ((packet < hp->inbuf_end) && (!is_header(packet)))
426 if (!is_open(hp))
428 flip = hvsi_recv_data(hp, packet);
431 hvsi_recv_control(hp, packet, tty, handshake);
434 hvsi_recv_response(hp, packet);
437 hvsi_recv_query(hp, packet);
441 hp->index, header->type);
454 compact_inbuf(hp, packet);
457 tty_flip_buffer_push(&hp->port);
462 static void hvsi_send_overflow(struct hvsi_struct *hp)
465 hp->n_throttle);
467 hvsi_insert_chars(hp, hp->throttle_buf, hp->n_throttle);
468 hp->n_throttle = 0;
477 struct hvsi_struct *hp = (struct hvsi_struct *)arg;
485 tty = tty_port_tty_get(&hp->port);
488 spin_lock_irqsave(&hp->lock, flags);
489 again = hvsi_load_chunk(hp, tty, &handshake);
490 spin_unlock_irqrestore(&hp->lock, flags);
498 spin_lock_irqsave(&hp->lock, flags);
499 if (tty && hp->n_throttle && !tty_throttled(tty)) {
502 hvsi_send_overflow(hp);
503 tty_flip_buffer_push(&hp->port);
505 spin_unlock_irqrestore(&hp->lock, flags);
513 static int __init poll_for_state(struct hvsi_struct *hp, int state)
518 hvsi_interrupt(hp->virq, (void *)hp); /* get pending data */
520 if (hp->state == state)
530 static int wait_for_state(struct hvsi_struct *hp, int state)
534 if (!wait_event_timeout(hp->stateq, (hp->state == state), HVSI_TIMEOUT))
540 static int hvsi_query(struct hvsi_struct *hp, uint16_t verb)
547 packet.hdr.seqno = cpu_to_be16(atomic_inc_return(&hp->seqno));
553 wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
555 printk(KERN_ERR "hvsi%i: couldn't send query (%i)!\n", hp->index,
563 static int hvsi_get_mctrl(struct hvsi_struct *hp)
567 set_state(hp, HVSI_WAIT_FOR_MCTRL_RESPONSE);
568 hvsi_query(hp, VSV_SEND_MODEM_CTL_STATUS);
570 ret = hvsi_wait(hp, HVSI_OPEN);
572 printk(KERN_ERR "hvsi%i: didn't get modem flags\n", hp->index);
573 set_state(hp, HVSI_OPEN);
577 pr_debug("%s: mctrl 0x%x\n", __func__, hp->mctrl);
583 static int hvsi_set_mctrl(struct hvsi_struct *hp, uint16_t mctrl)
589 packet.hdr.seqno = cpu_to_be16(atomic_inc_return(&hp->seqno));
600 wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
602 printk(KERN_ERR "hvsi%i: couldn't set DTR!\n", hp->index);
609 static void hvsi_drain_input(struct hvsi_struct *hp)
615 if (0 == hvsi_read(hp, buf, HVSI_MAX_READ))
619 static int hvsi_handshake(struct hvsi_struct *hp)
630 hvsi_drain_input(hp);
632 set_state(hp, HVSI_WAIT_FOR_VER_RESPONSE);
633 ret = hvsi_query(hp, VSV_SEND_VERSION_NUMBER);
635 printk(KERN_ERR "hvsi%i: couldn't send version query\n", hp->index);
639 ret = hvsi_wait(hp, HVSI_OPEN);
648 struct hvsi_struct *hp =
651 if (hvsi_handshake(hp) >= 0)
654 printk(KERN_ERR "hvsi%i: re-handshaking failed\n", hp->index);
655 if (is_console(hp)) {
660 printk(KERN_ERR "hvsi%i: lost console!\n", hp->index);
664 static int hvsi_put_chars(struct hvsi_struct *hp, const char *buf, int count)
672 packet.hdr.seqno = cpu_to_be16(atomic_inc_return(&hp->seqno));
676 ret = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
684 static void hvsi_close_protocol(struct hvsi_struct *hp)
689 packet.hdr.seqno = cpu_to_be16(atomic_inc_return(&hp->seqno));
696 hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
701 struct hvsi_struct *hp;
707 hp = &hvsi_ports[tty->index];
709 tty->driver_data = hp;
712 if (hp->state == HVSI_FSP_DIED)
715 tty_port_tty_set(&hp->port, tty);
716 spin_lock_irqsave(&hp->lock, flags);
717 hp->port.count++;
718 atomic_set(&hp->seqno, 0);
719 h_vio_signal(hp->vtermno, VIO_IRQ_ENABLE);
720 spin_unlock_irqrestore(&hp->lock, flags);
722 if (is_console(hp))
725 ret = hvsi_handshake(hp);
731 ret = hvsi_get_mctrl(hp);
737 ret = hvsi_set_mctrl(hp, hp->mctrl | TIOCM_DTR);
746 /* wait for hvsi_write_worker to empty hp->outbuf */
747 static void hvsi_flush_output(struct hvsi_struct *hp)
749 wait_event_timeout(hp->emptyq, (hp->n_outbuf <= 0), HVSI_TIMEOUT);
752 cancel_delayed_work_sync(&hp->writer);
753 flush_work(&hp->handshaker);
759 hp->n_outbuf = 0;
764 struct hvsi_struct *hp = tty->driver_data;
772 spin_lock_irqsave(&hp->lock, flags);
774 if (--hp->port.count == 0) {
775 tty_port_tty_set(&hp->port, NULL);
776 hp->inbuf_end = hp->inbuf; /* discard remaining partial packets */
779 if (!is_console(hp)) {
780 h_vio_signal(hp->vtermno, VIO_IRQ_DISABLE); /* no more irqs */
781 __set_state(hp, HVSI_CLOSED);
788 spin_unlock_irqrestore(&hp->lock, flags);
791 synchronize_irq(hp->virq);
794 hvsi_flush_output(hp);
797 hvsi_close_protocol(hp);
803 hvsi_drain_input(hp);
805 spin_lock_irqsave(&hp->lock, flags);
807 } else if (hp->port.count < 0)
809 hp - hvsi_ports, hp->port.count);
811 spin_unlock_irqrestore(&hp->lock, flags);
816 struct hvsi_struct *hp = tty->driver_data;
821 tty_port_tty_set(&hp->port, NULL);
823 spin_lock_irqsave(&hp->lock, flags);
824 hp->port.count = 0;
825 hp->n_outbuf = 0;
826 spin_unlock_irqrestore(&hp->lock, flags);
829 /* called with hp->lock held */
830 static void hvsi_push(struct hvsi_struct *hp)
834 if (hp->n_outbuf <= 0)
837 n = hvsi_put_chars(hp, hp->outbuf, hp->n_outbuf);
841 hp->n_outbuf = 0;
843 __set_state(hp, HVSI_FSP_DIED);
844 printk(KERN_ERR "hvsi%i: service processor died\n", hp->index);
851 struct hvsi_struct *hp =
861 spin_lock_irqsave(&hp->lock, flags);
863 pr_debug("%s: %i chars in buffer\n", __func__, hp->n_outbuf);
865 if (!is_open(hp)) {
872 schedule_delayed_work(&hp->writer, HZ);
876 hvsi_push(hp);
877 if (hp->n_outbuf > 0)
878 schedule_delayed_work(&hp->writer, 10);
885 wake_up_all(&hp->emptyq);
886 tty_port_tty_wakeup(&hp->port);
890 spin_unlock_irqrestore(&hp->lock, flags);
895 struct hvsi_struct *hp = tty->driver_data;
897 return N_OUTBUF - hp->n_outbuf;
902 struct hvsi_struct *hp = tty->driver_data;
904 return hp->n_outbuf;
910 struct hvsi_struct *hp = tty->driver_data;
915 spin_lock_irqsave(&hp->lock, flags);
917 pr_debug("%s: %i chars in buffer\n", __func__, hp->n_outbuf);
919 if (!is_open(hp)) {
926 * when the hypervisor buffer (16K) fills, data will stay in hp->outbuf
933 BUG_ON(hp->n_outbuf < 0);
934 memcpy(hp->outbuf + hp->n_outbuf, source, chunksize);
935 hp->n_outbuf += chunksize;
940 hvsi_push(hp);
943 if (hp->n_outbuf > 0) {
948 schedule_delayed_work(&hp->writer, 10);
952 spin_unlock_irqrestore(&hp->lock, flags);
967 struct hvsi_struct *hp = tty->driver_data;
971 h_vio_signal(hp->vtermno, VIO_IRQ_DISABLE);
976 struct hvsi_struct *hp = tty->driver_data;
981 spin_lock_irqsave(&hp->lock, flags);
982 if (hp->n_throttle) {
983 hvsi_send_overflow(hp);
984 tty_flip_buffer_push(&hp->port);
986 spin_unlock_irqrestore(&hp->lock, flags);
989 h_vio_signal(hp->vtermno, VIO_IRQ_ENABLE);
994 struct hvsi_struct *hp = tty->driver_data;
996 hvsi_get_mctrl(hp);
997 return hp->mctrl;
1003 struct hvsi_struct *hp = tty->driver_data;
1011 spin_lock_irqsave(&hp->lock, flags);
1013 new_mctrl = (hp->mctrl & ~clear) | set;
1015 if (hp->mctrl != new_mctrl) {
1016 hvsi_set_mctrl(hp, new_mctrl);
1017 hp->mctrl = new_mctrl;
1019 spin_unlock_irqrestore(&hp->lock, flags);
1059 struct hvsi_struct *hp = &hvsi_ports[i];
1062 tty_port_link_device(&hp->port, driver, i);
1064 ret = request_irq(hp->virq, hvsi_interrupt, 0, "hvsi", hp);
1067 hp->virq, ret);
1085 struct hvsi_struct *hp = &hvsi_ports[i];
1087 free_irq(hp->virq, hp);
1100 struct hvsi_struct *hp = &hvsi_ports[console->index];
1106 if (!is_open(hp))
1124 ret = hvsi_put_chars(hp, c, i);
1141 struct hvsi_struct *hp;
1146 hp = &hvsi_ports[console->index];
1149 hvsi_close_protocol(hp);
1151 ret = hvsi_handshake(hp);
1155 ret = hvsi_get_mctrl(hp);
1159 ret = hvsi_set_mctrl(hp, hp->mctrl | TIOCM_DTR);
1163 hp->flags |= HVSI_CONSOLE;
1185 struct hvsi_struct *hp;
1198 hp = &hvsi_ports[hvsi_count];
1199 INIT_DELAYED_WORK(&hp->writer, hvsi_write_worker);
1200 INIT_WORK(&hp->handshaker, hvsi_handshaker);
1201 init_waitqueue_head(&hp->emptyq);
1202 init_waitqueue_head(&hp->stateq);
1203 spin_lock_init(&hp->lock);
1204 tty_port_init(&hp->port);
1205 hp->index = hvsi_count;
1206 hp->inbuf_end = hp->inbuf;
1207 hp->state = HVSI_CLOSED;
1208 hp->vtermno = be32_to_cpup(vtermno);
1209 hp->virq = irq_create_mapping(NULL, be32_to_cpup(irq));
1210 if (hp->virq == 0) {
1213 tty_port_destroy(&hp->port);