projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
TTY: switch tty_flip_buffer_push
[deliverable/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/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);
Linux kernel - Deliverables
This page took 0.046108 seconds and 5 git commands to generate.