xref: /linux/drivers/ipack/devices/ipoctal.c (revision 06d07429858317ded2db7986113a9e0129cd599b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * driver for the GE IP-OCTAL boards
4  *
5  * Copyright (C) 2009-2012 CERN (www.cern.ch)
6  * Author: Nicolas Serafini, EIC2 SA
7  * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.com>
8  */
9 
10 #include <linux/device.h>
11 #include <linux/module.h>
12 #include <linux/interrupt.h>
13 #include <linux/sched.h>
14 #include <linux/tty.h>
15 #include <linux/serial.h>
16 #include <linux/tty_flip.h>
17 #include <linux/slab.h>
18 #include <linux/io.h>
19 #include <linux/ipack.h>
20 #include "ipoctal.h"
21 #include "scc2698.h"
22 
23 #define IP_OCTAL_ID_SPACE_VECTOR    0x41
24 #define IP_OCTAL_NB_BLOCKS          4
25 
26 static const struct tty_operations ipoctal_fops;
27 
28 struct ipoctal_channel {
29 	struct ipoctal_stats		stats;
30 	unsigned int			nb_bytes;
31 	wait_queue_head_t		queue;
32 	spinlock_t			lock;
33 	unsigned int			pointer_read;
34 	unsigned int			pointer_write;
35 	struct tty_port			tty_port;
36 	bool				tty_registered;
37 	union scc2698_channel __iomem	*regs;
38 	union scc2698_block __iomem	*block_regs;
39 	unsigned int			board_id;
40 	u8				isr_rx_rdy_mask;
41 	u8				isr_tx_rdy_mask;
42 	unsigned int			rx_enable;
43 };
44 
45 struct ipoctal {
46 	struct ipack_device		*dev;
47 	unsigned int			board_id;
48 	struct ipoctal_channel		channel[NR_CHANNELS];
49 	struct tty_driver		*tty_drv;
50 	u8 __iomem			*mem8_space;
51 	u8 __iomem			*int_space;
52 };
53 
chan_to_ipoctal(struct ipoctal_channel * chan,unsigned int index)54 static inline struct ipoctal *chan_to_ipoctal(struct ipoctal_channel *chan,
55 					      unsigned int index)
56 {
57 	return container_of(chan, struct ipoctal, channel[index]);
58 }
59 
ipoctal_reset_channel(struct ipoctal_channel * channel)60 static void ipoctal_reset_channel(struct ipoctal_channel *channel)
61 {
62 	iowrite8(CR_DISABLE_RX | CR_DISABLE_TX, &channel->regs->w.cr);
63 	channel->rx_enable = 0;
64 	iowrite8(CR_CMD_RESET_RX, &channel->regs->w.cr);
65 	iowrite8(CR_CMD_RESET_TX, &channel->regs->w.cr);
66 	iowrite8(CR_CMD_RESET_ERR_STATUS, &channel->regs->w.cr);
67 	iowrite8(CR_CMD_RESET_MR, &channel->regs->w.cr);
68 }
69 
ipoctal_port_activate(struct tty_port * port,struct tty_struct * tty)70 static int ipoctal_port_activate(struct tty_port *port, struct tty_struct *tty)
71 {
72 	struct ipoctal_channel *channel;
73 
74 	channel = dev_get_drvdata(tty->dev);
75 
76 	/*
77 	 * Enable RX. TX will be enabled when
78 	 * there is something to send
79 	 */
80 	iowrite8(CR_ENABLE_RX, &channel->regs->w.cr);
81 	channel->rx_enable = 1;
82 	return 0;
83 }
84 
ipoctal_install(struct tty_driver * driver,struct tty_struct * tty)85 static int ipoctal_install(struct tty_driver *driver, struct tty_struct *tty)
86 {
87 	struct ipoctal_channel *channel = dev_get_drvdata(tty->dev);
88 	struct ipoctal *ipoctal = chan_to_ipoctal(channel, tty->index);
89 	int res;
90 
91 	if (!ipack_get_carrier(ipoctal->dev))
92 		return -EBUSY;
93 
94 	res = tty_standard_install(driver, tty);
95 	if (res)
96 		goto err_put_carrier;
97 
98 	tty->driver_data = channel;
99 
100 	return 0;
101 
102 err_put_carrier:
103 	ipack_put_carrier(ipoctal->dev);
104 
105 	return res;
106 }
107 
ipoctal_open(struct tty_struct * tty,struct file * file)108 static int ipoctal_open(struct tty_struct *tty, struct file *file)
109 {
110 	struct ipoctal_channel *channel = tty->driver_data;
111 
112 	return tty_port_open(&channel->tty_port, tty, file);
113 }
114 
ipoctal_reset_stats(struct ipoctal_stats * stats)115 static void ipoctal_reset_stats(struct ipoctal_stats *stats)
116 {
117 	stats->tx = 0;
118 	stats->rx = 0;
119 	stats->rcv_break = 0;
120 	stats->framing_err = 0;
121 	stats->overrun_err = 0;
122 	stats->parity_err = 0;
123 }
124 
ipoctal_free_channel(struct ipoctal_channel * channel)125 static void ipoctal_free_channel(struct ipoctal_channel *channel)
126 {
127 	ipoctal_reset_stats(&channel->stats);
128 	channel->pointer_read = 0;
129 	channel->pointer_write = 0;
130 	channel->nb_bytes = 0;
131 }
132 
ipoctal_close(struct tty_struct * tty,struct file * filp)133 static void ipoctal_close(struct tty_struct *tty, struct file *filp)
134 {
135 	struct ipoctal_channel *channel = tty->driver_data;
136 
137 	tty_port_close(&channel->tty_port, tty, filp);
138 	ipoctal_free_channel(channel);
139 }
140 
ipoctal_get_icount(struct tty_struct * tty,struct serial_icounter_struct * icount)141 static int ipoctal_get_icount(struct tty_struct *tty,
142 			      struct serial_icounter_struct *icount)
143 {
144 	struct ipoctal_channel *channel = tty->driver_data;
145 
146 	icount->cts = 0;
147 	icount->dsr = 0;
148 	icount->rng = 0;
149 	icount->dcd = 0;
150 	icount->rx = channel->stats.rx;
151 	icount->tx = channel->stats.tx;
152 	icount->frame = channel->stats.framing_err;
153 	icount->parity = channel->stats.parity_err;
154 	icount->brk = channel->stats.rcv_break;
155 	return 0;
156 }
157 
ipoctal_irq_rx(struct ipoctal_channel * channel,u8 sr)158 static void ipoctal_irq_rx(struct ipoctal_channel *channel, u8 sr)
159 {
160 	struct tty_port *port = &channel->tty_port;
161 	u8 isr, value, flag;
162 
163 	do {
164 		value = ioread8(&channel->regs->r.rhr);
165 		flag = TTY_NORMAL;
166 		/* Error: count statistics */
167 		if (sr & SR_ERROR) {
168 			iowrite8(CR_CMD_RESET_ERR_STATUS, &channel->regs->w.cr);
169 
170 			if (sr & SR_OVERRUN_ERROR) {
171 				channel->stats.overrun_err++;
172 				/* Overrun doesn't affect the current character*/
173 				tty_insert_flip_char(port, 0, TTY_OVERRUN);
174 			}
175 			if (sr & SR_PARITY_ERROR) {
176 				channel->stats.parity_err++;
177 				flag = TTY_PARITY;
178 			}
179 			if (sr & SR_FRAMING_ERROR) {
180 				channel->stats.framing_err++;
181 				flag = TTY_FRAME;
182 			}
183 			if (sr & SR_RECEIVED_BREAK) {
184 				channel->stats.rcv_break++;
185 				flag = TTY_BREAK;
186 			}
187 		}
188 		tty_insert_flip_char(port, value, flag);
189 
190 		/* Check if there are more characters in RX FIFO
191 		 * If there are more, the isr register for this channel
192 		 * has enabled the RxRDY|FFULL bit.
193 		 */
194 		isr = ioread8(&channel->block_regs->r.isr);
195 		sr = ioread8(&channel->regs->r.sr);
196 	} while (isr & channel->isr_rx_rdy_mask);
197 
198 	tty_flip_buffer_push(port);
199 }
200 
ipoctal_irq_tx(struct ipoctal_channel * channel)201 static void ipoctal_irq_tx(struct ipoctal_channel *channel)
202 {
203 	unsigned int *pointer_write = &channel->pointer_write;
204 	u8 value;
205 
206 	if (channel->nb_bytes == 0)
207 		return;
208 
209 	spin_lock(&channel->lock);
210 	value = channel->tty_port.xmit_buf[*pointer_write];
211 	iowrite8(value, &channel->regs->w.thr);
212 	channel->stats.tx++;
213 	(*pointer_write)++;
214 	*pointer_write = *pointer_write % PAGE_SIZE;
215 	channel->nb_bytes--;
216 	spin_unlock(&channel->lock);
217 }
218 
ipoctal_irq_channel(struct ipoctal_channel * channel)219 static void ipoctal_irq_channel(struct ipoctal_channel *channel)
220 {
221 	u8 isr, sr;
222 
223 	/* The HW is organized in pair of channels.  See which register we need
224 	 * to read from */
225 	isr = ioread8(&channel->block_regs->r.isr);
226 	sr = ioread8(&channel->regs->r.sr);
227 
228 	if (isr & (IMR_DELTA_BREAK_A | IMR_DELTA_BREAK_B))
229 		iowrite8(CR_CMD_RESET_BREAK_CHANGE, &channel->regs->w.cr);
230 
231 	if ((sr & SR_TX_EMPTY) && (channel->nb_bytes == 0)) {
232 		iowrite8(CR_DISABLE_TX, &channel->regs->w.cr);
233 		/* In case of RS-485, change from TX to RX when finishing TX.
234 		 * Half-duplex. */
235 		if (channel->board_id == IPACK1_DEVICE_ID_SBS_OCTAL_485) {
236 			iowrite8(CR_CMD_NEGATE_RTSN, &channel->regs->w.cr);
237 			iowrite8(CR_ENABLE_RX, &channel->regs->w.cr);
238 			channel->rx_enable = 1;
239 		}
240 	}
241 
242 	/* RX data */
243 	if ((isr & channel->isr_rx_rdy_mask) && (sr & SR_RX_READY))
244 		ipoctal_irq_rx(channel, sr);
245 
246 	/* TX of each character */
247 	if ((isr & channel->isr_tx_rdy_mask) && (sr & SR_TX_READY))
248 		ipoctal_irq_tx(channel);
249 }
250 
ipoctal_irq_handler(void * arg)251 static irqreturn_t ipoctal_irq_handler(void *arg)
252 {
253 	unsigned int i;
254 	struct ipoctal *ipoctal = arg;
255 
256 	/* Clear the IPack device interrupt */
257 	readw(ipoctal->int_space + ACK_INT_REQ0);
258 	readw(ipoctal->int_space + ACK_INT_REQ1);
259 
260 	/* Check all channels */
261 	for (i = 0; i < NR_CHANNELS; i++)
262 		ipoctal_irq_channel(&ipoctal->channel[i]);
263 
264 	return IRQ_HANDLED;
265 }
266 
267 static const struct tty_port_operations ipoctal_tty_port_ops = {
268 	.dtr_rts = NULL,
269 	.activate = ipoctal_port_activate,
270 };
271 
ipoctal_inst_slot(struct ipoctal * ipoctal,unsigned int bus_nr,unsigned int slot)272 static int ipoctal_inst_slot(struct ipoctal *ipoctal, unsigned int bus_nr,
273 			     unsigned int slot)
274 {
275 	int res;
276 	int i;
277 	struct tty_driver *drv;
278 	struct ipoctal_channel *channel;
279 	struct ipack_region *region;
280 	void __iomem *addr;
281 	union scc2698_channel __iomem *chan_regs;
282 	union scc2698_block __iomem *block_regs;
283 
284 	ipoctal->board_id = ipoctal->dev->id_device;
285 
286 	region = &ipoctal->dev->region[IPACK_IO_SPACE];
287 	addr = devm_ioremap(&ipoctal->dev->dev,
288 				    region->start, region->size);
289 	if (!addr) {
290 		dev_err(&ipoctal->dev->dev,
291 			"Unable to map slot [%d:%d] IO space!\n",
292 			bus_nr, slot);
293 		return -EADDRNOTAVAIL;
294 	}
295 	/* Save the virtual address to access the registers easily */
296 	chan_regs =
297 		(union scc2698_channel __iomem *) addr;
298 	block_regs =
299 		(union scc2698_block __iomem *) addr;
300 
301 	region = &ipoctal->dev->region[IPACK_INT_SPACE];
302 	ipoctal->int_space =
303 		devm_ioremap(&ipoctal->dev->dev,
304 				     region->start, region->size);
305 	if (!ipoctal->int_space) {
306 		dev_err(&ipoctal->dev->dev,
307 			"Unable to map slot [%d:%d] INT space!\n",
308 			bus_nr, slot);
309 		return -EADDRNOTAVAIL;
310 	}
311 
312 	region = &ipoctal->dev->region[IPACK_MEM8_SPACE];
313 	ipoctal->mem8_space =
314 		devm_ioremap(&ipoctal->dev->dev,
315 				     region->start, 0x8000);
316 	if (!ipoctal->mem8_space) {
317 		dev_err(&ipoctal->dev->dev,
318 			"Unable to map slot [%d:%d] MEM8 space!\n",
319 			bus_nr, slot);
320 		return -EADDRNOTAVAIL;
321 	}
322 
323 
324 	/* Disable RX and TX before touching anything */
325 	for (i = 0; i < NR_CHANNELS ; i++) {
326 		struct ipoctal_channel *channel = &ipoctal->channel[i];
327 		channel->regs = chan_regs + i;
328 		channel->block_regs = block_regs + (i >> 1);
329 		channel->board_id = ipoctal->board_id;
330 		if (i & 1) {
331 			channel->isr_tx_rdy_mask = ISR_TxRDY_B;
332 			channel->isr_rx_rdy_mask = ISR_RxRDY_FFULL_B;
333 		} else {
334 			channel->isr_tx_rdy_mask = ISR_TxRDY_A;
335 			channel->isr_rx_rdy_mask = ISR_RxRDY_FFULL_A;
336 		}
337 
338 		ipoctal_reset_channel(channel);
339 		iowrite8(MR1_CHRL_8_BITS | MR1_ERROR_CHAR | MR1_RxINT_RxRDY,
340 			 &channel->regs->w.mr); /* mr1 */
341 		iowrite8(0, &channel->regs->w.mr); /* mr2 */
342 		iowrite8(TX_CLK_9600  | RX_CLK_9600, &channel->regs->w.csr);
343 	}
344 
345 	for (i = 0; i < IP_OCTAL_NB_BLOCKS; i++) {
346 		iowrite8(ACR_BRG_SET2, &block_regs[i].w.acr);
347 		iowrite8(OPCR_MPP_OUTPUT | OPCR_MPOa_RTSN | OPCR_MPOb_RTSN,
348 			 &block_regs[i].w.opcr);
349 		iowrite8(IMR_TxRDY_A | IMR_RxRDY_FFULL_A | IMR_DELTA_BREAK_A |
350 			 IMR_TxRDY_B | IMR_RxRDY_FFULL_B | IMR_DELTA_BREAK_B,
351 			 &block_regs[i].w.imr);
352 	}
353 
354 	/* Dummy write */
355 	iowrite8(1, ipoctal->mem8_space + 1);
356 
357 	/* Register the TTY device */
358 
359 	/* Each IP-OCTAL channel is a TTY port */
360 	drv = tty_alloc_driver(NR_CHANNELS, TTY_DRIVER_REAL_RAW |
361 			TTY_DRIVER_DYNAMIC_DEV);
362 	if (IS_ERR(drv))
363 		return PTR_ERR(drv);
364 
365 	/* Fill struct tty_driver with ipoctal data */
366 	drv->owner = THIS_MODULE;
367 	drv->driver_name = KBUILD_MODNAME;
368 	drv->name = kasprintf(GFP_KERNEL, KBUILD_MODNAME ".%d.%d.", bus_nr, slot);
369 	if (!drv->name) {
370 		res = -ENOMEM;
371 		goto err_put_driver;
372 	}
373 	drv->major = 0;
374 
375 	drv->minor_start = 0;
376 	drv->type = TTY_DRIVER_TYPE_SERIAL;
377 	drv->subtype = SERIAL_TYPE_NORMAL;
378 	drv->init_termios = tty_std_termios;
379 	drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
380 	drv->init_termios.c_ispeed = 9600;
381 	drv->init_termios.c_ospeed = 9600;
382 
383 	tty_set_operations(drv, &ipoctal_fops);
384 	res = tty_register_driver(drv);
385 	if (res) {
386 		dev_err(&ipoctal->dev->dev, "Can't register tty driver.\n");
387 		goto err_free_name;
388 	}
389 
390 	/* Save struct tty_driver for use it when uninstalling the device */
391 	ipoctal->tty_drv = drv;
392 
393 	for (i = 0; i < NR_CHANNELS; i++) {
394 		struct device *tty_dev;
395 
396 		channel = &ipoctal->channel[i];
397 		tty_port_init(&channel->tty_port);
398 		res = tty_port_alloc_xmit_buf(&channel->tty_port);
399 		if (res)
400 			continue;
401 		channel->tty_port.ops = &ipoctal_tty_port_ops;
402 
403 		ipoctal_reset_stats(&channel->stats);
404 		channel->nb_bytes = 0;
405 		spin_lock_init(&channel->lock);
406 		channel->pointer_read = 0;
407 		channel->pointer_write = 0;
408 		tty_dev = tty_port_register_device_attr(&channel->tty_port, drv,
409 							i, NULL, channel, NULL);
410 		if (IS_ERR(tty_dev)) {
411 			dev_err(&ipoctal->dev->dev, "Failed to register tty device.\n");
412 			tty_port_free_xmit_buf(&channel->tty_port);
413 			tty_port_destroy(&channel->tty_port);
414 			continue;
415 		}
416 		channel->tty_registered = true;
417 	}
418 
419 	/*
420 	 * IP-OCTAL has different addresses to copy its IRQ vector.
421 	 * Depending of the carrier these addresses are accesible or not.
422 	 * More info in the datasheet.
423 	 */
424 	ipoctal->dev->bus->ops->request_irq(ipoctal->dev,
425 				       ipoctal_irq_handler, ipoctal);
426 
427 	return 0;
428 
429 err_free_name:
430 	kfree(drv->name);
431 err_put_driver:
432 	tty_driver_kref_put(drv);
433 
434 	return res;
435 }
436 
ipoctal_copy_write_buffer(struct ipoctal_channel * channel,const u8 * buf,size_t count)437 static inline size_t ipoctal_copy_write_buffer(struct ipoctal_channel *channel,
438 					       const u8 *buf, size_t count)
439 {
440 	unsigned long flags;
441 	size_t i;
442 	unsigned int *pointer_read = &channel->pointer_read;
443 
444 	/* Copy the bytes from the user buffer to the internal one */
445 	for (i = 0; i < count; i++) {
446 		if (i <= (PAGE_SIZE - channel->nb_bytes)) {
447 			spin_lock_irqsave(&channel->lock, flags);
448 			channel->tty_port.xmit_buf[*pointer_read] = buf[i];
449 			*pointer_read = (*pointer_read + 1) % PAGE_SIZE;
450 			channel->nb_bytes++;
451 			spin_unlock_irqrestore(&channel->lock, flags);
452 		} else {
453 			break;
454 		}
455 	}
456 	return i;
457 }
458 
ipoctal_write_tty(struct tty_struct * tty,const u8 * buf,size_t count)459 static ssize_t ipoctal_write_tty(struct tty_struct *tty, const u8 *buf,
460 				 size_t count)
461 {
462 	struct ipoctal_channel *channel = tty->driver_data;
463 	size_t char_copied;
464 
465 	char_copied = ipoctal_copy_write_buffer(channel, buf, count);
466 
467 	/* As the IP-OCTAL 485 only supports half duplex, do it manually */
468 	if (channel->board_id == IPACK1_DEVICE_ID_SBS_OCTAL_485) {
469 		iowrite8(CR_DISABLE_RX, &channel->regs->w.cr);
470 		channel->rx_enable = 0;
471 		iowrite8(CR_CMD_ASSERT_RTSN, &channel->regs->w.cr);
472 	}
473 
474 	/*
475 	 * Send a packet and then disable TX to avoid failure after several send
476 	 * operations
477 	 */
478 	iowrite8(CR_ENABLE_TX, &channel->regs->w.cr);
479 	return char_copied;
480 }
481 
ipoctal_write_room(struct tty_struct * tty)482 static unsigned int ipoctal_write_room(struct tty_struct *tty)
483 {
484 	struct ipoctal_channel *channel = tty->driver_data;
485 
486 	return PAGE_SIZE - channel->nb_bytes;
487 }
488 
ipoctal_chars_in_buffer(struct tty_struct * tty)489 static unsigned int ipoctal_chars_in_buffer(struct tty_struct *tty)
490 {
491 	struct ipoctal_channel *channel = tty->driver_data;
492 
493 	return channel->nb_bytes;
494 }
495 
ipoctal_set_termios(struct tty_struct * tty,const struct ktermios * old_termios)496 static void ipoctal_set_termios(struct tty_struct *tty,
497 				const struct ktermios *old_termios)
498 {
499 	unsigned int cflag;
500 	unsigned char mr1 = 0;
501 	unsigned char mr2 = 0;
502 	unsigned char csr = 0;
503 	struct ipoctal_channel *channel = tty->driver_data;
504 	speed_t baud;
505 
506 	cflag = tty->termios.c_cflag;
507 
508 	/* Disable and reset everything before change the setup */
509 	ipoctal_reset_channel(channel);
510 
511 	/* Set Bits per chars */
512 	switch (cflag & CSIZE) {
513 	case CS6:
514 		mr1 |= MR1_CHRL_6_BITS;
515 		break;
516 	case CS7:
517 		mr1 |= MR1_CHRL_7_BITS;
518 		break;
519 	case CS8:
520 	default:
521 		mr1 |= MR1_CHRL_8_BITS;
522 		/* By default, select CS8 */
523 		tty->termios.c_cflag = (cflag & ~CSIZE) | CS8;
524 		break;
525 	}
526 
527 	/* Set Parity */
528 	if (cflag & PARENB)
529 		if (cflag & PARODD)
530 			mr1 |= MR1_PARITY_ON | MR1_PARITY_ODD;
531 		else
532 			mr1 |= MR1_PARITY_ON | MR1_PARITY_EVEN;
533 	else
534 		mr1 |= MR1_PARITY_OFF;
535 
536 	/* Mark or space parity is not supported */
537 	tty->termios.c_cflag &= ~CMSPAR;
538 
539 	/* Set stop bits */
540 	if (cflag & CSTOPB)
541 		mr2 |= MR2_STOP_BITS_LENGTH_2;
542 	else
543 		mr2 |= MR2_STOP_BITS_LENGTH_1;
544 
545 	/* Set the flow control */
546 	switch (channel->board_id) {
547 	case IPACK1_DEVICE_ID_SBS_OCTAL_232:
548 		if (cflag & CRTSCTS) {
549 			mr1 |= MR1_RxRTS_CONTROL_ON;
550 			mr2 |= MR2_TxRTS_CONTROL_OFF | MR2_CTS_ENABLE_TX_ON;
551 		} else {
552 			mr1 |= MR1_RxRTS_CONTROL_OFF;
553 			mr2 |= MR2_TxRTS_CONTROL_OFF | MR2_CTS_ENABLE_TX_OFF;
554 		}
555 		break;
556 	case IPACK1_DEVICE_ID_SBS_OCTAL_422:
557 		mr1 |= MR1_RxRTS_CONTROL_OFF;
558 		mr2 |= MR2_TxRTS_CONTROL_OFF | MR2_CTS_ENABLE_TX_OFF;
559 		break;
560 	case IPACK1_DEVICE_ID_SBS_OCTAL_485:
561 		mr1 |= MR1_RxRTS_CONTROL_OFF;
562 		mr2 |= MR2_TxRTS_CONTROL_ON | MR2_CTS_ENABLE_TX_OFF;
563 		break;
564 	default:
565 		return;
566 	}
567 
568 	baud = tty_get_baud_rate(tty);
569 	tty_termios_encode_baud_rate(&tty->termios, baud, baud);
570 
571 	/* Set baud rate */
572 	switch (baud) {
573 	case 75:
574 		csr |= TX_CLK_75 | RX_CLK_75;
575 		break;
576 	case 110:
577 		csr |= TX_CLK_110 | RX_CLK_110;
578 		break;
579 	case 150:
580 		csr |= TX_CLK_150 | RX_CLK_150;
581 		break;
582 	case 300:
583 		csr |= TX_CLK_300 | RX_CLK_300;
584 		break;
585 	case 600:
586 		csr |= TX_CLK_600 | RX_CLK_600;
587 		break;
588 	case 1200:
589 		csr |= TX_CLK_1200 | RX_CLK_1200;
590 		break;
591 	case 1800:
592 		csr |= TX_CLK_1800 | RX_CLK_1800;
593 		break;
594 	case 2000:
595 		csr |= TX_CLK_2000 | RX_CLK_2000;
596 		break;
597 	case 2400:
598 		csr |= TX_CLK_2400 | RX_CLK_2400;
599 		break;
600 	case 4800:
601 		csr |= TX_CLK_4800  | RX_CLK_4800;
602 		break;
603 	case 9600:
604 		csr |= TX_CLK_9600  | RX_CLK_9600;
605 		break;
606 	case 19200:
607 		csr |= TX_CLK_19200 | RX_CLK_19200;
608 		break;
609 	case 38400:
610 	default:
611 		csr |= TX_CLK_38400 | RX_CLK_38400;
612 		/* In case of default, we establish 38400 bps */
613 		tty_termios_encode_baud_rate(&tty->termios, 38400, 38400);
614 		break;
615 	}
616 
617 	mr1 |= MR1_ERROR_CHAR;
618 	mr1 |= MR1_RxINT_RxRDY;
619 
620 	/* Write the control registers */
621 	iowrite8(mr1, &channel->regs->w.mr);
622 	iowrite8(mr2, &channel->regs->w.mr);
623 	iowrite8(csr, &channel->regs->w.csr);
624 
625 	/* Enable again the RX, if it was before */
626 	if (channel->rx_enable)
627 		iowrite8(CR_ENABLE_RX, &channel->regs->w.cr);
628 }
629 
ipoctal_hangup(struct tty_struct * tty)630 static void ipoctal_hangup(struct tty_struct *tty)
631 {
632 	unsigned long flags;
633 	struct ipoctal_channel *channel = tty->driver_data;
634 
635 	if (channel == NULL)
636 		return;
637 
638 	spin_lock_irqsave(&channel->lock, flags);
639 	channel->nb_bytes = 0;
640 	channel->pointer_read = 0;
641 	channel->pointer_write = 0;
642 	spin_unlock_irqrestore(&channel->lock, flags);
643 
644 	tty_port_hangup(&channel->tty_port);
645 
646 	ipoctal_reset_channel(channel);
647 	tty_port_set_initialized(&channel->tty_port, false);
648 	wake_up_interruptible(&channel->tty_port.open_wait);
649 }
650 
ipoctal_shutdown(struct tty_struct * tty)651 static void ipoctal_shutdown(struct tty_struct *tty)
652 {
653 	struct ipoctal_channel *channel = tty->driver_data;
654 
655 	if (channel == NULL)
656 		return;
657 
658 	ipoctal_reset_channel(channel);
659 	tty_port_set_initialized(&channel->tty_port, false);
660 }
661 
ipoctal_cleanup(struct tty_struct * tty)662 static void ipoctal_cleanup(struct tty_struct *tty)
663 {
664 	struct ipoctal_channel *channel = tty->driver_data;
665 	struct ipoctal *ipoctal = chan_to_ipoctal(channel, tty->index);
666 
667 	/* release the carrier driver */
668 	ipack_put_carrier(ipoctal->dev);
669 }
670 
671 static const struct tty_operations ipoctal_fops = {
672 	.ioctl =		NULL,
673 	.install =		ipoctal_install,
674 	.open =			ipoctal_open,
675 	.close =		ipoctal_close,
676 	.write =		ipoctal_write_tty,
677 	.set_termios =		ipoctal_set_termios,
678 	.write_room =		ipoctal_write_room,
679 	.chars_in_buffer =	ipoctal_chars_in_buffer,
680 	.get_icount =		ipoctal_get_icount,
681 	.hangup =		ipoctal_hangup,
682 	.shutdown =		ipoctal_shutdown,
683 	.cleanup =              ipoctal_cleanup,
684 };
685 
ipoctal_probe(struct ipack_device * dev)686 static int ipoctal_probe(struct ipack_device *dev)
687 {
688 	int res;
689 	struct ipoctal *ipoctal;
690 
691 	ipoctal = kzalloc(sizeof(struct ipoctal), GFP_KERNEL);
692 	if (ipoctal == NULL)
693 		return -ENOMEM;
694 
695 	ipoctal->dev = dev;
696 	res = ipoctal_inst_slot(ipoctal, dev->bus->bus_nr, dev->slot);
697 	if (res)
698 		goto out_uninst;
699 
700 	dev_set_drvdata(&dev->dev, ipoctal);
701 	return 0;
702 
703 out_uninst:
704 	kfree(ipoctal);
705 	return res;
706 }
707 
__ipoctal_remove(struct ipoctal * ipoctal)708 static void __ipoctal_remove(struct ipoctal *ipoctal)
709 {
710 	int i;
711 
712 	ipoctal->dev->bus->ops->free_irq(ipoctal->dev);
713 
714 	for (i = 0; i < NR_CHANNELS; i++) {
715 		struct ipoctal_channel *channel = &ipoctal->channel[i];
716 
717 		if (!channel->tty_registered)
718 			continue;
719 
720 		tty_unregister_device(ipoctal->tty_drv, i);
721 		tty_port_free_xmit_buf(&channel->tty_port);
722 		tty_port_destroy(&channel->tty_port);
723 	}
724 
725 	tty_unregister_driver(ipoctal->tty_drv);
726 	kfree(ipoctal->tty_drv->name);
727 	tty_driver_kref_put(ipoctal->tty_drv);
728 	kfree(ipoctal);
729 }
730 
ipoctal_remove(struct ipack_device * idev)731 static void ipoctal_remove(struct ipack_device *idev)
732 {
733 	__ipoctal_remove(dev_get_drvdata(&idev->dev));
734 }
735 
736 static DEFINE_IPACK_DEVICE_TABLE(ipoctal_ids) = {
737 	{ IPACK_DEVICE(IPACK_ID_VERSION_1, IPACK1_VENDOR_ID_SBS,
738 			IPACK1_DEVICE_ID_SBS_OCTAL_232) },
739 	{ IPACK_DEVICE(IPACK_ID_VERSION_1, IPACK1_VENDOR_ID_SBS,
740 			IPACK1_DEVICE_ID_SBS_OCTAL_422) },
741 	{ IPACK_DEVICE(IPACK_ID_VERSION_1, IPACK1_VENDOR_ID_SBS,
742 			IPACK1_DEVICE_ID_SBS_OCTAL_485) },
743 	{ 0, },
744 };
745 
746 MODULE_DEVICE_TABLE(ipack, ipoctal_ids);
747 
748 static const struct ipack_driver_ops ipoctal_drv_ops = {
749 	.probe  = ipoctal_probe,
750 	.remove = ipoctal_remove,
751 };
752 
753 static struct ipack_driver driver = {
754 	.ops      = &ipoctal_drv_ops,
755 	.id_table = ipoctal_ids,
756 };
757 
ipoctal_init(void)758 static int __init ipoctal_init(void)
759 {
760 	return ipack_driver_register(&driver, THIS_MODULE, KBUILD_MODNAME);
761 }
762 
ipoctal_exit(void)763 static void __exit ipoctal_exit(void)
764 {
765 	ipack_driver_unregister(&driver);
766 }
767 
768 MODULE_DESCRIPTION("IP-Octal 232, 422 and 485 device driver");
769 MODULE_LICENSE("GPL");
770 
771 module_init(ipoctal_init);
772 module_exit(ipoctal_exit);
773