// SPDX-License-Identifier: GPL-2.0/* ePAPR hypervisor byte channel device driver * * Copyright 2009-2011 Freescale Semiconductor, Inc. * * Author: Timur Tabi <timur@freescale.com> * * This driver support three distinct interfaces, all of which are related to * ePAPR hypervisor byte channels. * * 1) An early-console (udbg) driver.  This provides early console output * through a byte channel.  The byte channel handle must be specified in a * Kconfig option. * * 2) A normal console driver.  Output is sent to the byte channel designated * for stdout in the device tree.  The console driver is for handling kernel * printk calls. * * 3) A tty driver, which is used to handle user-space input and output.  The * byte channel used for the console is designated as the default tty. */ #include <linux/init.h>#include <linux/slab.h>#include <linux/err.h>#include <linux/interrupt.h>#include <linux/fs.h>#include <linux/poll.h>#include <asm/epapr_hcalls.h>#include <linux/of.h>#include <linux/of_irq.h>#include <linux/platform_device.h>#include <linux/cdev.h>#include <linux/console.h>#include <linux/tty.h>#include <linux/tty_flip.h>#include <linux/circ_buf.h>#include <asm/udbg.h> /* The size of the transmit circular buffer.  This must be a power of two. */#define BUF_SIZE	2048 /* Per-byte channel private data */struct ehv_bc_data {	struct device *dev;	struct tty_port port;	uint32_t handle;	unsigned int rx_irq;	unsigned int tx_irq; 	spinlock_t lock;	/* lock for transmit buffer */	u8 buf[BUF_SIZE];	/* transmit circular buffer */	unsigned int head;	/* circular buffer head */	unsigned int tail;	/* circular buffer tail */ 	int tx_irq_enabled;	/* true == TX interrupt is enabled */}; /* Array of byte channel objects */static struct ehv_bc_data *bcs; /* Byte channel handle for stdout (and stdin), taken from device tree */static unsigned int stdout_bc; /* Virtual IRQ for the byte channel handle for stdin, taken from device tree */static unsigned int stdout_irq; /**************************** SUPPORT FUNCTIONS ****************************/ /* * Enable the transmit interrupt * * Unlike a serial device, byte channels have no mechanism for disabling their * own receive or transmit interrupts.  To emulate that feature, we toggle * the IRQ in the kernel. * * We cannot just blindly call enable_irq() or disable_irq(), because these * calls are reference counted.  This means that we cannot call enable_irq() * if interrupts are already enabled.  This can happen in two situations: * * 1. The tty layer makes two back-to-back calls to ehv_bc_tty_write() * 2. A transmit interrupt occurs while executing ehv_bc_tx_dequeue() * * To work around this, we keep a flag to tell us if the IRQ is enabled or not. */static void enable_tx_interrupt(struct ehv_bc_data *bc){	if (!bc->tx_irq_enabled) {		enable_irq(bc->tx_irq);		bc->tx_irq_enabled = 1;	}} static void disable_tx_interrupt(struct ehv_bc_data *bc){	if (bc->tx_irq_enabled) {		disable_irq_nosync(bc->tx_irq);		bc->tx_irq_enabled = 0;	}} /* * find the byte channel handle to use for the console * * The byte channel to be used for the console is specified via a "stdout" * property in the /chosen node. */static int find_console_handle(void){	struct device_node *np = of_stdout;	const uint32_t *iprop; 	/* We don't care what the aliased node is actually called.  We only	 * care if it's compatible with "epapr,hv-byte-channel", because that	 * indicates that it's a byte channel node.	 */	if (!np || !of_device_is_compatible(np, "epapr,hv-byte-channel"))		return 0; 	stdout_irq = irq_of_parse_and_map(np, 0);	if (!stdout_irq) {		pr_err("ehv-bc: no 'interrupts' property in %pOF node\n", np);		return 0;	} 	/*	 * The 'hv-handle' property contains the handle for this byte channel.	 */	iprop = of_get_property(np, "hv-handle", NULL);	if (!iprop) {		pr_err("ehv-bc: no 'hv-handle' property in %pOFn node\n",		       np);		return 0;	}	stdout_bc = be32_to_cpu(*iprop);	return 1;} static unsigned int local_ev_byte_channel_send(unsigned int handle,					       unsigned int *count,					       const u8 *p){	u8 buffer[EV_BYTE_CHANNEL_MAX_BYTES];	unsigned int c = *count; 	/*	 * ev_byte_channel_send() expects at least EV_BYTE_CHANNEL_MAX_BYTES	 * (16 B) in the buffer. Fake it using a local buffer if needed.	 */	if (c < sizeof(buffer)) {		memcpy_and_pad(buffer, sizeof(buffer), p, c, 0);		p = buffer;	}	return ev_byte_channel_send(handle, count, p);} /*************************** EARLY CONSOLE DRIVER ***************************/ #ifdef CONFIG_PPC_EARLY_DEBUG_EHV_BC /* * send a byte to a byte channel, wait if necessary * * This function sends a byte to a byte channel, and it waits and * retries if the byte channel is full.  It returns if the character * has been sent, or if some error has occurred. * */static void byte_channel_spin_send(const u8 data){	int ret, count; 	do {		count = 1;		ret = local_ev_byte_channel_send(CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE,					   &count, &data);	} while (ret == EV_EAGAIN);} /* * The udbg subsystem calls this function to display a single character. * We convert CR to a CR/LF. */static void ehv_bc_udbg_putc(char c){	if (c == '\n')		byte_channel_spin_send('\r'); 	byte_channel_spin_send(c);} /* * early console initialization * * PowerPC kernels support an early printk console, also known as udbg. * This function must be called via the ppc_md.init_early function pointer. * At this point, the device tree has been unflattened, so we can obtain the * byte channel handle for stdout. * * We only support displaying of characters (putc).  We do not support * keyboard input. */void __init udbg_init_ehv_bc(void){	unsigned int rx_count, tx_count;	unsigned int ret; 	/* Verify the byte channel handle */	ret = ev_byte_channel_poll(CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE,				   &rx_count, &tx_count);	if (ret)		return; 	udbg_putc = ehv_bc_udbg_putc;	register_early_udbg_console(); 	udbg_printf("ehv-bc: early console using byte channel handle %u\n",		    CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);} #endif /****************************** CONSOLE DRIVER ******************************/ static struct tty_driver *ehv_bc_driver; /* * Byte channel console sending worker function. * * For consoles, if the output buffer is full, we should just spin until it * clears. */static int ehv_bc_console_byte_channel_send(unsigned int handle, const char *s,			     unsigned int count){	unsigned int len;	int ret = 0; 	while (count) {		len = min_t(unsigned int, count, EV_BYTE_CHANNEL_MAX_BYTES);		do {			ret = local_ev_byte_channel_send(handle, &len, s);		} while (ret == EV_EAGAIN);		count -= len;		s += len;	} 	return ret;} /* * write a string to the console * * This function gets called to write a string from the kernel, typically from * a printk().  This function spins until all data is written. * * We copy the data to a temporary buffer because we need to insert a \r in * front of every \n.  It's more efficient to copy the data to the buffer than * it is to make multiple hcalls for each character or each newline. */static void ehv_bc_console_write(struct console *co, const char *s,				 unsigned int count){	char s2[EV_BYTE_CHANNEL_MAX_BYTES];	unsigned int i, j = 0;	char c; 	for (i = 0; i < count; i++) {		c = *s++; 		if (c == '\n')			s2[j++] = '\r'; 		s2[j++] = c;		if (j >= (EV_BYTE_CHANNEL_MAX_BYTES - 1)) {			if (ehv_bc_console_byte_channel_send(stdout_bc, s2, j))				return;			j = 0;		}	} 	if (j)		ehv_bc_console_byte_channel_send(stdout_bc, s2, j);} /* * When /dev/console is opened, the kernel iterates the console list looking * for one with ->device and then calls that method. On success, it expects * the passed-in int* to contain the minor number to use. */static struct tty_driver *ehv_bc_console_device(struct console *co, int *index){	*index = co->index; 	return ehv_bc_driver;} static struct console ehv_bc_console = {	.name		= "ttyEHV",	.write		= ehv_bc_console_write,	.device		= ehv_bc_console_device,	.flags		= CON_PRINTBUFFER | CON_ENABLED,}; /* * Console initialization * * This is the first function that is called after the device tree is * available, so here is where we determine the byte channel handle and IRQ for * stdout/stdin, even though that information is used by the tty and character * drivers. */static int __init ehv_bc_console_init(void){	if (!find_console_handle()) {		pr_debug("ehv-bc: stdout is not a byte channel\n");		return -ENODEV;	} #ifdef CONFIG_PPC_EARLY_DEBUG_EHV_BC	/* Print a friendly warning if the user chose the wrong byte channel	 * handle for udbg.	 */	if (stdout_bc != CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE)		pr_warn("ehv-bc: udbg handle %u is not the stdout handle\n",			CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);#endif 	/* add_preferred_console() must be called before register_console(),	   otherwise it won't work.  However, we don't want to enumerate all the	   byte channels here, either, since we only care about one. */ 	add_preferred_console(ehv_bc_console.name, ehv_bc_console.index, NULL);	register_console(&ehv_bc_console); 	pr_info("ehv-bc: registered console driver for byte channel %u\n",		stdout_bc); 	return 0;}console_initcall(ehv_bc_console_init); /******************************** TTY DRIVER ********************************/ /* * byte channel receive interrupt handler * * This ISR is called whenever data is available on a byte channel. */static irqreturn_t ehv_bc_tty_rx_isr(int irq, void *data){	struct ehv_bc_data *bc = data;	unsigned int rx_count, tx_count, len;	int count;	char buffer[EV_BYTE_CHANNEL_MAX_BYTES];	int ret; 	/* Find out how much data needs to be read, and then ask the TTY layer	 * if it can handle that much.  We want to ensure that every byte we	 * read from the byte channel will be accepted by the TTY layer.	 */	ev_byte_channel_poll(bc->handle, &rx_count, &tx_count);	count = tty_buffer_request_room(&bc->port, rx_count); 	/* 'count' is the maximum amount of data the TTY layer can accept at	 * this time.  However, during testing, I was never able to get 'count'	 * to be less than 'rx_count'.  I'm not sure whether I'm calling it	 * correctly.	 */ 	while (count > 0) {		len = min_t(unsigned int, count, sizeof(buffer)); 		/* Read some data from the byte channel.  This function will		 * never return more than EV_BYTE_CHANNEL_MAX_BYTES bytes.		 */		ev_byte_channel_receive(bc->handle, &len, buffer); 		/* 'len' is now the amount of data that's been received. 'len'		 * can't be zero, and most likely it's equal to one.		 */ 		/* Pass the received data to the tty layer. */		ret = tty_insert_flip_string(&bc->port, buffer, len); 		/* 'ret' is the number of bytes that the TTY layer accepted.		 * If it's not equal to 'len', then it means the buffer is		 * full, which should never happen.  If it does happen, we can		 * exit gracefully, but we drop the last 'len - ret' characters		 * that we read from the byte channel.		 */		if (ret != len)			break; 		count -= len;	} 	/* Tell the tty layer that we're done. */	tty_flip_buffer_push(&bc->port); 	return IRQ_HANDLED;} /* * dequeue the transmit buffer to the hypervisor * * This function, which can be called in interrupt context, dequeues as much * data as possible from the transmit buffer to the byte channel. */static void ehv_bc_tx_dequeue(struct ehv_bc_data *bc){	unsigned int count;	unsigned int len, ret;	unsigned long flags; 	do {		spin_lock_irqsave(&bc->lock, flags);		len = min_t(unsigned int,			    CIRC_CNT_TO_END(bc->head, bc->tail, BUF_SIZE),			    EV_BYTE_CHANNEL_MAX_BYTES); 		ret = local_ev_byte_channel_send(bc->handle, &len, bc->buf + bc->tail); 		/* 'len' is valid only if the return code is 0 or EV_EAGAIN */		if (!ret || (ret == EV_EAGAIN))			bc->tail = (bc->tail + len) & (BUF_SIZE - 1); 		count = CIRC_CNT(bc->head, bc->tail, BUF_SIZE);		spin_unlock_irqrestore(&bc->lock, flags);	} while (count && !ret); 	spin_lock_irqsave(&bc->lock, flags);	if (CIRC_CNT(bc->head, bc->tail, BUF_SIZE))		/*		 * If we haven't emptied the buffer, then enable the TX IRQ.		 * We'll get an interrupt when there's more room in the		 * hypervisor's output buffer.		 */		enable_tx_interrupt(bc);	else		disable_tx_interrupt(bc);	spin_unlock_irqrestore(&bc->lock, flags);} /* * byte channel transmit interrupt handler * * This ISR is called whenever space becomes available for transmitting * characters on a byte channel. */static irqreturn_t ehv_bc_tty_tx_isr(int irq, void *data){	struct ehv_bc_data *bc = data; 	ehv_bc_tx_dequeue(bc);	tty_port_tty_wakeup(&bc->port); 	return IRQ_HANDLED;} /* * This function is called when the tty layer has data for us send.  We store * the data first in a circular buffer, and then dequeue as much of that data * as possible. * * We don't need to worry about whether there is enough room in the buffer for * all the data.  The purpose of ehv_bc_tty_write_room() is to tell the tty * layer how much data it can safely send to us.  We guarantee that * ehv_bc_tty_write_room() will never lie, so the tty layer will never send us * too much data. */static ssize_t ehv_bc_tty_write(struct tty_struct *ttys, const u8 *s,				size_t count){	struct ehv_bc_data *bc = ttys->driver_data;	unsigned long flags;	size_t len, written = 0; 	while (1) {		spin_lock_irqsave(&bc->lock, flags);		len = CIRC_SPACE_TO_END(bc->head, bc->tail, BUF_SIZE);		if (count < len)			len = count;		if (len) {			memcpy(bc->buf + bc->head, s, len);			bc->head = (bc->head + len) & (BUF_SIZE - 1);		}		spin_unlock_irqrestore(&bc->lock, flags);		if (!len)			break; 		s += len;		count -= len;		written += len;	} 	ehv_bc_tx_dequeue(bc); 	return written;}

Lines 1–500 of 820. Load more