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