2 * iSeries vio driver interface to hvc_console.c
4 * This code is based heavily on hvc_vio.c and viocons.c
6 * Copyright (C) 2006 Stephen Rothwell, IBM Corporation
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/types.h>
24 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/spinlock.h>
27 #include <linux/console.h>
29 #include <asm/hvconsole.h>
32 #include <asm/iseries/vio.h>
33 #include <asm/iseries/hv_call.h>
34 #include <asm/iseries/hv_lp_config.h>
35 #include <asm/iseries/hv_lp_event.h>
37 #include "hvc_console.h"
41 static DEFINE_SPINLOCK(consolelock
);
42 static DEFINE_SPINLOCK(consoleloglock
);
44 static const char hvc_driver_name
[] = "hvc_console";
46 #define IN_BUF_SIZE 200
49 * Our port information.
51 static struct port_info
{
53 u64 seq
; /* sequence number of last HV send */
54 u64 ack
; /* last ack from HV */
55 struct hvc_struct
*hp
;
58 unsigned char in_buf
[IN_BUF_SIZE
];
59 } port_info
[VTTY_PORTS
] = {
60 [ 0 ... VTTY_PORTS
- 1 ] = {
61 .lp
= HvLpIndexInvalid
65 #define viochar_is_console(pi) ((pi) == &port_info[0])
67 static struct vio_device_id hvc_driver_table
[] __devinitdata
= {
68 {"serial", "IBM,iSeries-vty"},
71 MODULE_DEVICE_TABLE(vio
, hvc_driver_table
);
73 static void hvlog(char *fmt
, ...)
80 spin_lock_irqsave(&consoleloglock
, flags
);
82 i
= vscnprintf(buf
, sizeof(buf
) - 1, fmt
, args
);
85 HvCall_writeLogBuffer(buf
, i
);
86 spin_unlock_irqrestore(&consoleloglock
, flags
);
90 * Initialize the common fields in a charLpEvent
92 static void init_data_event(struct viocharlpevent
*viochar
, HvLpIndex lp
)
94 struct HvLpEvent
*hev
= &viochar
->event
;
96 memset(viochar
, 0, sizeof(struct viocharlpevent
));
98 hev
->flags
= HV_LP_EVENT_VALID
| HV_LP_EVENT_DEFERRED_ACK
|
100 hev
->xType
= HvLpEvent_Type_VirtualIo
;
101 hev
->xSubtype
= viomajorsubtype_chario
| viochardata
;
102 hev
->xSourceLp
= HvLpConfig_getLpIndex();
104 hev
->xSizeMinus1
= sizeof(struct viocharlpevent
);
105 hev
->xSourceInstanceId
= viopath_sourceinst(lp
);
106 hev
->xTargetInstanceId
= viopath_targetinst(lp
);
109 static int get_chars(uint32_t vtermno
, char *buf
, int count
)
111 struct port_info
*pi
;
115 if (vtermno
>= VTTY_PORTS
)
120 pi
= &port_info
[vtermno
];
121 spin_lock_irqsave(&consolelock
, flags
);
126 n
= pi
->in_end
- pi
->in_start
;
129 memcpy(buf
, &pi
->in_buf
[pi
->in_start
], n
);
131 if (pi
->in_start
== pi
->in_end
) {
136 spin_unlock_irqrestore(&consolelock
, flags
);
140 static int put_chars(uint32_t vtermno
, const char *buf
, int count
)
142 struct viocharlpevent
*viochar
;
143 struct port_info
*pi
;
148 if (vtermno
>= VTTY_PORTS
)
151 pi
= &port_info
[vtermno
];
153 spin_lock_irqsave(&consolelock
, flags
);
155 if (viochar_is_console(pi
) && !viopath_isactive(pi
->lp
)) {
156 HvCall_writeLogBuffer(buf
, count
);
161 viochar
= vio_get_event_buffer(viomajorsubtype_chario
);
162 if (viochar
== NULL
) {
163 hvlog("\n\rviocons: Can't get viochar buffer.");
167 while ((count
> 0) && ((pi
->seq
- pi
->ack
) < VIOCHAR_WINDOW
)) {
170 len
= (count
> VIOCHAR_MAX_DATA
) ? VIOCHAR_MAX_DATA
: count
;
172 if (viochar_is_console(pi
))
173 HvCall_writeLogBuffer(buf
, len
);
175 init_data_event(viochar
, pi
->lp
);
178 viochar
->event
.xCorrelationToken
= pi
->seq
++;
179 viochar
->event
.xSizeMinus1
=
180 offsetof(struct viocharlpevent
, data
) + len
;
182 memcpy(viochar
->data
, buf
, len
);
184 hvrc
= HvCallEvent_signalLpEvent(&viochar
->event
);
186 hvlog("\n\rerror sending event! return code %d\n\r",
193 vio_free_event_buffer(viomajorsubtype_chario
, viochar
);
195 spin_unlock_irqrestore(&consolelock
, flags
);
199 static struct hv_ops hvc_get_put_ops
= {
200 .get_chars
= get_chars
,
201 .put_chars
= put_chars
,
204 static int __devinit
hvc_vio_probe(struct vio_dev
*vdev
,
205 const struct vio_device_id
*id
)
207 struct hvc_struct
*hp
;
208 struct port_info
*pi
;
210 /* probed with invalid parameters. */
214 if (vdev
->unit_address
>= VTTY_PORTS
)
217 pi
= &port_info
[vdev
->unit_address
];
219 hp
= hvc_alloc(vdev
->unit_address
, vdev
->irq
, &hvc_get_put_ops
,
224 dev_set_drvdata(&vdev
->dev
, pi
);
229 static int __devexit
hvc_vio_remove(struct vio_dev
*vdev
)
231 struct port_info
*pi
= dev_get_drvdata(&vdev
->dev
);
232 struct hvc_struct
*hp
= pi
->hp
;
234 return hvc_remove(hp
);
237 static struct vio_driver hvc_vio_driver
= {
238 .id_table
= hvc_driver_table
,
239 .probe
= hvc_vio_probe
,
240 .remove
= hvc_vio_remove
,
242 .name
= hvc_driver_name
,
243 .owner
= THIS_MODULE
,
247 static void hvc_open_event(struct HvLpEvent
*event
)
250 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
251 u8 port
= cevent
->virtual_device
;
252 struct port_info
*pi
;
255 if (hvlpevent_is_ack(event
)) {
256 if (port
>= VTTY_PORTS
)
259 spin_lock_irqsave(&consolelock
, flags
);
261 pi
= &port_info
[port
];
262 if (event
->xRc
== HvLpEvent_Rc_Good
) {
263 pi
->seq
= pi
->ack
= 0;
265 * This line allows connections from the primary
266 * partition but once one is connected from the
267 * primary partition nothing short of a reboot
268 * of linux will allow access from the hosting
269 * partition again without a required iSeries fix.
271 pi
->lp
= event
->xTargetLp
;
274 spin_unlock_irqrestore(&consolelock
, flags
);
275 if (event
->xRc
!= HvLpEvent_Rc_Good
)
277 "hvc: handle_open_event: event->xRc == (%d).\n",
280 if (event
->xCorrelationToken
!= 0) {
281 atomic_t
*aptr
= (atomic_t
*)event
->xCorrelationToken
;
285 "hvc: weird...got open ack without atomic\n");
289 /* This had better require an ack, otherwise complain */
290 if (!hvlpevent_need_ack(event
)) {
291 printk(KERN_WARNING
"hvc: viocharopen without ack bit!\n");
295 spin_lock_irqsave(&consolelock
, flags
);
297 /* Make sure this is a good virtual tty */
298 if (port
>= VTTY_PORTS
) {
299 event
->xRc
= HvLpEvent_Rc_SubtypeError
;
300 cevent
->subtype_result_code
= viorc_openRejected
;
302 * Flag state here since we can't printk while holding
303 * the consolelock spinlock.
307 pi
= &port_info
[port
];
308 if ((pi
->lp
!= HvLpIndexInvalid
) &&
309 (pi
->lp
!= event
->xSourceLp
)) {
311 * If this is tty is already connected to a different
314 event
->xRc
= HvLpEvent_Rc_SubtypeError
;
315 cevent
->subtype_result_code
= viorc_openRejected
;
318 pi
->lp
= event
->xSourceLp
;
319 event
->xRc
= HvLpEvent_Rc_Good
;
320 cevent
->subtype_result_code
= viorc_good
;
321 pi
->seq
= pi
->ack
= 0;
325 spin_unlock_irqrestore(&consolelock
, flags
);
328 printk(KERN_WARNING
"hvc: open rejected: bad virtual tty.\n");
329 else if (reject
== 2)
330 printk(KERN_WARNING
"hvc: open rejected: console in exclusive "
331 "use by another partition.\n");
333 /* Return the acknowledgement */
334 HvCallEvent_ackLpEvent(event
);
338 * Handle a close charLpEvent. This should ONLY be an Interrupt because the
339 * virtual console should never actually issue a close event to the hypervisor
340 * because the virtual console never goes away. A close event coming from the
341 * hypervisor simply means that there are no client consoles connected to the
344 static void hvc_close_event(struct HvLpEvent
*event
)
347 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
348 u8 port
= cevent
->virtual_device
;
350 if (!hvlpevent_is_int(event
)) {
352 "hvc: got unexpected close acknowlegement\n");
356 if (port
>= VTTY_PORTS
) {
358 "hvc: close message from invalid virtual device.\n");
362 /* For closes, just mark the console partition invalid */
363 spin_lock_irqsave(&consolelock
, flags
);
365 if (port_info
[port
].lp
== event
->xSourceLp
)
366 port_info
[port
].lp
= HvLpIndexInvalid
;
368 spin_unlock_irqrestore(&consolelock
, flags
);
371 static void hvc_data_event(struct HvLpEvent
*event
)
374 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
375 struct port_info
*pi
;
377 u8 port
= cevent
->virtual_device
;
379 if (port
>= VTTY_PORTS
) {
380 printk(KERN_WARNING
"hvc: data on invalid virtual device %d\n",
384 if (cevent
->len
== 0)
388 * Change 05/01/2003 - Ryan Arnold: If a partition other than
389 * the current exclusive partition tries to send us data
390 * events then just drop them on the floor because we don't
391 * want his stinking data. He isn't authorized to receive
392 * data because he wasn't the first one to get the console,
393 * therefore he shouldn't be allowed to send data either.
394 * This will work without an iSeries fix.
396 pi
= &port_info
[port
];
397 if (pi
->lp
!= event
->xSourceLp
)
400 spin_lock_irqsave(&consolelock
, flags
);
402 n
= IN_BUF_SIZE
- pi
->in_end
;
406 memcpy(&pi
->in_buf
[pi
->in_end
], cevent
->data
, n
);
409 spin_unlock_irqrestore(&consolelock
, flags
);
411 printk(KERN_WARNING
"hvc: input buffer overflow\n");
414 static void hvc_ack_event(struct HvLpEvent
*event
)
416 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
418 u8 port
= cevent
->virtual_device
;
420 if (port
>= VTTY_PORTS
) {
421 printk(KERN_WARNING
"hvc: data on invalid virtual device\n");
425 spin_lock_irqsave(&consolelock
, flags
);
426 port_info
[port
].ack
= event
->xCorrelationToken
;
427 spin_unlock_irqrestore(&consolelock
, flags
);
430 static void hvc_config_event(struct HvLpEvent
*event
)
432 struct viocharlpevent
*cevent
= (struct viocharlpevent
*)event
;
434 if (cevent
->data
[0] == 0x01)
435 printk(KERN_INFO
"hvc: window resized to %d: %d: %d: %d\n",
436 cevent
->data
[1], cevent
->data
[2],
437 cevent
->data
[3], cevent
->data
[4]);
439 printk(KERN_WARNING
"hvc: unknown config event\n");
442 static void hvc_handle_event(struct HvLpEvent
*event
)
449 charminor
= event
->xSubtype
& VIOMINOR_SUBTYPE_MASK
;
452 hvc_open_event(event
);
455 hvc_close_event(event
);
458 hvc_data_event(event
);
461 hvc_ack_event(event
);
464 hvc_config_event(event
);
467 if (hvlpevent_is_int(event
) && hvlpevent_need_ack(event
)) {
468 event
->xRc
= HvLpEvent_Rc_InvalidSubtype
;
469 HvCallEvent_ackLpEvent(event
);
474 static int send_open(HvLpIndex remoteLp
, void *sem
)
476 return HvCallEvent_signalLpEventFast(remoteLp
,
477 HvLpEvent_Type_VirtualIo
,
478 viomajorsubtype_chario
| viocharopen
,
479 HvLpEvent_AckInd_DoAck
, HvLpEvent_AckType_ImmediateAck
,
480 viopath_sourceinst(remoteLp
),
481 viopath_targetinst(remoteLp
),
482 (u64
)(unsigned long)sem
, VIOVERSION
<< 16,
486 static int hvc_vio_init(void)
492 rc
= viopath_open(HvLpConfig_getPrimaryLpIndex(),
493 viomajorsubtype_chario
, VIOCHAR_WINDOW
+ 2);
495 printk(KERN_WARNING
"hvc: error opening to primary %d\n", rc
);
497 if (viopath_hostLp
== HvLpIndexInvalid
)
501 * And if the primary is not the same as the hosting LP, open to the
504 if ((viopath_hostLp
!= HvLpIndexInvalid
) &&
505 (viopath_hostLp
!= HvLpConfig_getPrimaryLpIndex())) {
506 printk(KERN_INFO
"hvc: open path to hosting (%d)\n",
508 rc
= viopath_open(viopath_hostLp
, viomajorsubtype_chario
,
509 VIOCHAR_WINDOW
+ 2); /* +2 for fudge */
512 "error opening to partition %d: %d\n",
516 if (vio_setHandler(viomajorsubtype_chario
, hvc_handle_event
) < 0)
518 "hvc: error seting handler for console events!\n");
521 * First, try to open the console to the hosting lp.
522 * Wait on a semaphore for the response.
524 atomic_set(&wait_flag
, 0);
525 if ((viopath_isactive(viopath_hostLp
)) &&
526 (send_open(viopath_hostLp
, &wait_flag
) == 0)) {
527 printk(KERN_INFO
"hvc: hosting partition %d\n", viopath_hostLp
);
528 while (atomic_read(&wait_flag
) == 0)
530 atomic_set(&wait_flag
, 0);
534 * If we don't have an active console, try the primary
536 if ((!viopath_isactive(port_info
[0].lp
)) &&
537 (viopath_isactive(HvLpConfig_getPrimaryLpIndex())) &&
538 (send_open(HvLpConfig_getPrimaryLpIndex(), &wait_flag
) == 0)) {
539 printk(KERN_INFO
"hvc: opening console to primary partition\n");
540 while (atomic_read(&wait_flag
) == 0)
544 /* Register as a vio device to receive callbacks */
545 rc
= vio_register_driver(&hvc_vio_driver
);
549 module_init(hvc_vio_init
); /* after drivers/char/hvc_console.c */
551 static void hvc_vio_exit(void)
553 vio_unregister_driver(&hvc_vio_driver
);
555 module_exit(hvc_vio_exit
);
557 /* the device tree order defines our numbering */
558 static int hvc_find_vtys(void)
560 struct device_node
*vty
;
563 for (vty
= of_find_node_by_name(NULL
, "vty"); vty
!= NULL
;
564 vty
= of_find_node_by_name(vty
, "vty")) {
567 /* We have statically defined space for only a certain number
568 * of console adapters.
570 if ((num_found
>= MAX_NR_HVC_CONSOLES
) ||
571 (num_found
>= VTTY_PORTS
))
574 vtermno
= (uint32_t *)get_property(vty
, "reg", NULL
);
578 if (!device_is_compatible(vty
, "IBM,iSeries-vty"))
582 add_preferred_console("hvc", 0, NULL
);
583 hvc_instantiate(*vtermno
, num_found
, &hvc_get_put_ops
);
589 console_initcall(hvc_find_vtys
);