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