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