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