// SPDX-License-Identifier: GPL-2.0-only/* * driver for the GE IP-OCTAL boards * * Copyright (C) 2009-2012 CERN (www.cern.ch) * Author: Nicolas Serafini, EIC2 SA * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.com> */ #include <linux/device.h>#include <linux/module.h>#include <linux/interrupt.h>#include <linux/kref.h>#include <linux/rwsem.h>#include <linux/sched.h>#include <linux/tty.h>#include <linux/serial.h>#include <linux/tty_flip.h>#include <linux/slab.h>#include <linux/io.h>#include <linux/ipack.h>#include "ipoctal.h"#include "scc2698.h" #define IP_OCTAL_ID_SPACE_VECTOR    0x41#define IP_OCTAL_NB_BLOCKS          4 static const struct tty_operations ipoctal_fops; static void ipoctal_release(struct kref *kref); struct ipoctal_channel {	struct ipoctal_stats		stats;	unsigned int			nb_bytes;	wait_queue_head_t		queue;	spinlock_t			lock;	unsigned int			pointer_read;	unsigned int			pointer_write;	struct tty_port			tty_port;	bool				tty_registered;	union scc2698_channel __iomem	*regs;	union scc2698_block __iomem	*block_regs;	unsigned int			board_id;	u8				isr_rx_rdy_mask;	u8				isr_tx_rdy_mask;	unsigned int			rx_enable;}; struct ipoctal {	struct ipack_device		*dev;	unsigned int			board_id;	struct ipoctal_channel		channel[NR_CHANNELS];	struct tty_driver		*tty_drv;	u8 __iomem			*mem8_space;	u8 __iomem			*int_space;	struct kref			kref;	struct module			*carrier_owner;	struct rw_semaphore		remove_sem;	bool				removed;}; static inline struct ipoctal *chan_to_ipoctal(struct ipoctal_channel *chan,					      unsigned int index){	return container_of(chan, struct ipoctal, channel[index]);} static void ipoctal_reset_channel(struct ipoctal_channel *channel){	iowrite8(CR_DISABLE_RX | CR_DISABLE_TX, &channel->regs->w.cr);	channel->rx_enable = 0;	iowrite8(CR_CMD_RESET_RX, &channel->regs->w.cr);	iowrite8(CR_CMD_RESET_TX, &channel->regs->w.cr);	iowrite8(CR_CMD_RESET_ERR_STATUS, &channel->regs->w.cr);	iowrite8(CR_CMD_RESET_MR, &channel->regs->w.cr);} static int ipoctal_port_activate(struct tty_port *port, struct tty_struct *tty){	struct ipoctal_channel *channel;	struct ipoctal *ipoctal; 	channel = dev_get_drvdata(tty->dev);	ipoctal = chan_to_ipoctal(channel, tty->index); 	guard(rwsem_read)(&ipoctal->remove_sem);	if (ipoctal->removed)		return -ENODEV; 	/*	 * Enable RX. TX will be enabled when	 * there is something to send	 */	iowrite8(CR_ENABLE_RX, &channel->regs->w.cr);	channel->rx_enable = 1;	return 0;} static int ipoctal_install(struct tty_driver *driver, struct tty_struct *tty){	struct ipoctal_channel *channel = dev_get_drvdata(tty->dev);	struct ipoctal *ipoctal = chan_to_ipoctal(channel, tty->index);	int res; 	if (!ipack_get_carrier(ipoctal->dev))		return -EBUSY; 	res = tty_standard_install(driver, tty);	if (res)		goto err_put_carrier; 	kref_get(&ipoctal->kref);	tty->driver_data = channel; 	return 0; err_put_carrier:	ipack_put_carrier(ipoctal->dev); 	return res;} static int ipoctal_open(struct tty_struct *tty, struct file *file){	struct ipoctal_channel *channel = tty->driver_data; 	return tty_port_open(&channel->tty_port, tty, file);} static void ipoctal_reset_stats(struct ipoctal_stats *stats){	stats->tx = 0;	stats->rx = 0;	stats->rcv_break = 0;	stats->framing_err = 0;	stats->overrun_err = 0;	stats->parity_err = 0;} static void ipoctal_free_channel(struct ipoctal_channel *channel){	ipoctal_reset_stats(&channel->stats);	channel->pointer_read = 0;	channel->pointer_write = 0;	channel->nb_bytes = 0;} static void ipoctal_close(struct tty_struct *tty, struct file *filp){	struct ipoctal_channel *channel = tty->driver_data; 	tty_port_close(&channel->tty_port, tty, filp);	ipoctal_free_channel(channel);} static int ipoctal_get_icount(struct tty_struct *tty,			      struct serial_icounter_struct *icount){	struct ipoctal_channel *channel = tty->driver_data; 	icount->cts = 0;	icount->dsr = 0;	icount->rng = 0;	icount->dcd = 0;	icount->rx = channel->stats.rx;	icount->tx = channel->stats.tx;	icount->frame = channel->stats.framing_err;	icount->parity = channel->stats.parity_err;	icount->brk = channel->stats.rcv_break;	return 0;} static void ipoctal_irq_rx(struct ipoctal_channel *channel, u8 sr){	struct tty_port *port = &channel->tty_port;	u8 isr, value, flag; 	do {		value = ioread8(&channel->regs->r.rhr);		flag = TTY_NORMAL;		/* Error: count statistics */		if (sr & SR_ERROR) {			iowrite8(CR_CMD_RESET_ERR_STATUS, &channel->regs->w.cr); 			if (sr & SR_OVERRUN_ERROR) {				channel->stats.overrun_err++;				/* Overrun doesn't affect the current character*/				tty_insert_flip_char(port, 0, TTY_OVERRUN);			}			if (sr & SR_PARITY_ERROR) {				channel->stats.parity_err++;				flag = TTY_PARITY;			}			if (sr & SR_FRAMING_ERROR) {				channel->stats.framing_err++;				flag = TTY_FRAME;			}			if (sr & SR_RECEIVED_BREAK) {				channel->stats.rcv_break++;				flag = TTY_BREAK;			}		}		tty_insert_flip_char(port, value, flag); 		/* Check if there are more characters in RX FIFO		 * If there are more, the isr register for this channel		 * has enabled the RxRDY|FFULL bit.		 */		isr = ioread8(&channel->block_regs->r.isr);		sr = ioread8(&channel->regs->r.sr);	} while (isr & channel->isr_rx_rdy_mask); 	tty_flip_buffer_push(port);} static void ipoctal_irq_tx(struct ipoctal_channel *channel){	unsigned int *pointer_write = &channel->pointer_write;	u8 value; 	if (channel->nb_bytes == 0)		return; 	spin_lock(&channel->lock);	value = channel->tty_port.xmit_buf[*pointer_write];	iowrite8(value, &channel->regs->w.thr);	channel->stats.tx++;	(*pointer_write)++;	*pointer_write = *pointer_write % PAGE_SIZE;	channel->nb_bytes--;	spin_unlock(&channel->lock);} static void ipoctal_irq_channel(struct ipoctal_channel *channel){	u8 isr, sr; 	/* The HW is organized in pair of channels.  See which register we need	 * to read from */	isr = ioread8(&channel->block_regs->r.isr);	sr = ioread8(&channel->regs->r.sr); 	if (isr & (IMR_DELTA_BREAK_A | IMR_DELTA_BREAK_B))		iowrite8(CR_CMD_RESET_BREAK_CHANGE, &channel->regs->w.cr); 	if ((sr & SR_TX_EMPTY) && (channel->nb_bytes == 0)) {		iowrite8(CR_DISABLE_TX, &channel->regs->w.cr);		/* In case of RS-485, change from TX to RX when finishing TX.		 * Half-duplex. */		if (channel->board_id == IPACK1_DEVICE_ID_SBS_OCTAL_485) {			iowrite8(CR_CMD_NEGATE_RTSN, &channel->regs->w.cr);			iowrite8(CR_ENABLE_RX, &channel->regs->w.cr);			channel->rx_enable = 1;		}	} 	/* RX data */	if ((isr & channel->isr_rx_rdy_mask) && (sr & SR_RX_READY))		ipoctal_irq_rx(channel, sr); 	/* TX of each character */	if ((isr & channel->isr_tx_rdy_mask) && (sr & SR_TX_READY))		ipoctal_irq_tx(channel);} static irqreturn_t ipoctal_irq_handler(void *arg){	unsigned int i;	struct ipoctal *ipoctal = arg; 	/* Clear the IPack device interrupt */	readw(ipoctal->int_space + ACK_INT_REQ0);	readw(ipoctal->int_space + ACK_INT_REQ1); 	/* Check all channels */	for (i = 0; i < NR_CHANNELS; i++)		ipoctal_irq_channel(&ipoctal->channel[i]); 	return IRQ_HANDLED;} static const struct tty_port_operations ipoctal_tty_port_ops = {	.dtr_rts = NULL,	.activate = ipoctal_port_activate,}; static int ipoctal_inst_slot(struct ipoctal *ipoctal, unsigned int bus_nr,			     unsigned int slot){	int res;	int i;	struct tty_driver *drv;	struct ipoctal_channel *channel;	struct ipack_region *region;	void __iomem *addr;	union scc2698_channel __iomem *chan_regs;	union scc2698_block __iomem *block_regs; 	ipoctal->board_id = ipoctal->dev->id_device; 	region = &ipoctal->dev->region[IPACK_IO_SPACE];	addr = devm_ioremap(&ipoctal->dev->dev,				    region->start, region->size);	if (!addr) {		dev_err(&ipoctal->dev->dev,			"Unable to map slot [%d:%d] IO space!\n",			bus_nr, slot);		return -EADDRNOTAVAIL;	}	/* Save the virtual address to access the registers easily */	chan_regs =		(union scc2698_channel __iomem *) addr;	block_regs =		(union scc2698_block __iomem *) addr; 	region = &ipoctal->dev->region[IPACK_INT_SPACE];	ipoctal->int_space =		devm_ioremap(&ipoctal->dev->dev,				     region->start, region->size);	if (!ipoctal->int_space) {		dev_err(&ipoctal->dev->dev,			"Unable to map slot [%d:%d] INT space!\n",			bus_nr, slot);		return -EADDRNOTAVAIL;	} 	region = &ipoctal->dev->region[IPACK_MEM8_SPACE];	ipoctal->mem8_space =		devm_ioremap(&ipoctal->dev->dev,				     region->start, 0x8000);	if (!ipoctal->mem8_space) {		dev_err(&ipoctal->dev->dev,			"Unable to map slot [%d:%d] MEM8 space!\n",			bus_nr, slot);		return -EADDRNOTAVAIL;	}  	/* Disable RX and TX before touching anything */	for (i = 0; i < NR_CHANNELS ; i++) {		struct ipoctal_channel *channel = &ipoctal->channel[i];		channel->regs = chan_regs + i;		channel->block_regs = block_regs + (i >> 1);		channel->board_id = ipoctal->board_id;		if (i & 1) {			channel->isr_tx_rdy_mask = ISR_TxRDY_B;			channel->isr_rx_rdy_mask = ISR_RxRDY_FFULL_B;		} else {			channel->isr_tx_rdy_mask = ISR_TxRDY_A;			channel->isr_rx_rdy_mask = ISR_RxRDY_FFULL_A;		} 		ipoctal_reset_channel(channel);		iowrite8(MR1_CHRL_8_BITS | MR1_ERROR_CHAR | MR1_RxINT_RxRDY,			 &channel->regs->w.mr); /* mr1 */		iowrite8(0, &channel->regs->w.mr); /* mr2 */		iowrite8(TX_CLK_9600  | RX_CLK_9600, &channel->regs->w.csr);	} 	for (i = 0; i < IP_OCTAL_NB_BLOCKS; i++) {		iowrite8(ACR_BRG_SET2, &block_regs[i].w.acr);		iowrite8(OPCR_MPP_OUTPUT | OPCR_MPOa_RTSN | OPCR_MPOb_RTSN,			 &block_regs[i].w.opcr);		iowrite8(IMR_TxRDY_A | IMR_RxRDY_FFULL_A | IMR_DELTA_BREAK_A |			 IMR_TxRDY_B | IMR_RxRDY_FFULL_B | IMR_DELTA_BREAK_B,			 &block_regs[i].w.imr);	} 	/* Dummy write */	iowrite8(1, ipoctal->mem8_space + 1); 	/* Register the TTY device */ 	/* Each IP-OCTAL channel is a TTY port */	drv = tty_alloc_driver(NR_CHANNELS, TTY_DRIVER_REAL_RAW |			TTY_DRIVER_DYNAMIC_DEV);	if (IS_ERR(drv))		return PTR_ERR(drv); 	/* Fill struct tty_driver with ipoctal data */	drv->owner = THIS_MODULE;	drv->driver_name = KBUILD_MODNAME;	drv->name = kasprintf(GFP_KERNEL, KBUILD_MODNAME ".%d.%d.", bus_nr, slot);	if (!drv->name) {		res = -ENOMEM;		goto err_put_driver;	}	drv->major = 0; 	drv->minor_start = 0;	drv->type = TTY_DRIVER_TYPE_SERIAL;	drv->subtype = SERIAL_TYPE_NORMAL;	drv->init_termios = tty_std_termios;	drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;	drv->init_termios.c_ispeed = 9600;	drv->init_termios.c_ospeed = 9600; 	tty_set_operations(drv, &ipoctal_fops);	res = tty_register_driver(drv);	if (res) {		dev_err(&ipoctal->dev->dev, "Can't register tty driver.\n");		goto err_free_name;	} 	/* Save struct tty_driver for use it when uninstalling the device */	ipoctal->tty_drv = drv; 	for (i = 0; i < NR_CHANNELS; i++) {		struct device *tty_dev; 		channel = &ipoctal->channel[i];		tty_port_init(&channel->tty_port);		res = tty_port_alloc_xmit_buf(&channel->tty_port);		if (res)			continue;		channel->tty_port.ops = &ipoctal_tty_port_ops; 		ipoctal_reset_stats(&channel->stats);		channel->nb_bytes = 0;		spin_lock_init(&channel->lock);		channel->pointer_read = 0;		channel->pointer_write = 0;		tty_dev = tty_port_register_device_attr(&channel->tty_port, drv,							i, NULL, channel, NULL);		if (IS_ERR(tty_dev)) {			dev_err(&ipoctal->dev->dev, "Failed to register tty device.\n");			tty_port_free_xmit_buf(&channel->tty_port);			tty_port_destroy(&channel->tty_port);			continue;		}		channel->tty_registered = true;	} 	/*	 * IP-OCTAL has different addresses to copy its IRQ vector.	 * Depending of the carrier these addresses are accesible or not.	 * More info in the datasheet.	 */	ipoctal->dev->bus->ops->request_irq(ipoctal->dev,				       ipoctal_irq_handler, ipoctal); 	return 0; err_free_name:	kfree(drv->name);err_put_driver:	tty_driver_kref_put(drv); 	return res;} static inline size_t ipoctal_copy_write_buffer(struct ipoctal_channel *channel,					       const u8 *buf, size_t count){	unsigned long flags;	size_t i;	unsigned int *pointer_read = &channel->pointer_read; 	/* Copy the bytes from the user buffer to the internal one */	for (i = 0; i < count; i++) {		if (i <= (PAGE_SIZE - channel->nb_bytes)) {			spin_lock_irqsave(&channel->lock, flags);			channel->tty_port.xmit_buf[*pointer_read] = buf[i];			*pointer_read = (*pointer_read + 1) % PAGE_SIZE;			channel->nb_bytes++;			spin_unlock_irqrestore(&channel->lock, flags);		} else {			break;		}	}	return i;} static ssize_t ipoctal_write_tty(struct tty_struct *tty, const u8 *buf,				 size_t count){	struct ipoctal_channel *channel = tty->driver_data;	struct ipoctal *ipoctal = chan_to_ipoctal(channel, tty->index);	size_t char_copied; 	guard(rwsem_read)(&ipoctal->remove_sem);	if (ipoctal->removed || !channel->tty_port.xmit_buf)		return 0; 	char_copied = ipoctal_copy_write_buffer(channel, buf, count); 	/* As the IP-OCTAL 485 only supports half duplex, do it manually */	if (channel->board_id == IPACK1_DEVICE_ID_SBS_OCTAL_485) {		iowrite8(CR_DISABLE_RX, &channel->regs->w.cr);		channel->rx_enable = 0;		iowrite8(CR_CMD_ASSERT_RTSN, &channel->regs->w.cr);	} 	/*	 * Send a packet and then disable TX to avoid failure after several send	 * operations	 */	iowrite8(CR_ENABLE_TX, &channel->regs->w.cr);	return char_copied;}

Lines 1–500 of 824. Load more