static void a2232_shutdown_port(void *ptr) { struct a2232_port *port; volatile struct a2232status *stat; unsigned long flags; port = ptr; stat = a2232stat(port->which_a2232, port->which_port_on_a2232); local_irq_save(flags); port->gs.port.flags &= ~GS_ACTIVE; if (port->gs.port.tty && port->gs.port.tty->termios->c_cflag & HUPCL) { /* Set DTR and RTS to Low, flush output. The NetBSD driver "msc.c" does it this way. */ stat->Command = ( (stat->Command & ~A2232CMD_CMask) | A2232CMD_Close ); stat->OutFlush = -1; stat->Setup = -1; } local_irq_restore(flags); /* After analyzing control flow, I think a2232_shutdown_port is actually the last call from the system when at application level someone issues a "echo Hello >>/dev/ttyY0". Therefore I think the MOD_DEC_USE_COUNT should be here and not in "a2232_close()". See the comment in "sx.c", too. If you run into problems, compile this driver into the kernel instead of compiling it as a module. */ }
static int a2232_chars_in_buffer(void *ptr) { struct a2232_port *port; volatile struct a2232status *status; unsigned char ret; /* we need modulo-256 arithmetics */ port = ptr; status = a2232stat(port->which_a2232, port->which_port_on_a2232); #if A2232_IOBUFLEN != 256 #error "Re-Implement a2232_chars_in_buffer()!" #endif ret = (status->OutHead - status->OutTail); return ret; }
static void a2232_enable_tx_interrupts(void *ptr) { struct a2232_port *port; volatile struct a2232status *stat; unsigned long flags; port = ptr; stat = a2232stat(port->which_a2232, port->which_port_on_a2232); stat->OutDisable = 0; /* Does this here really have to be? */ local_irq_save(flags); port->gs.port.flags |= GS_TX_INTEN; local_irq_restore(flags); }
static void a2232_disable_tx_interrupts(void *ptr) { struct a2232_port *port; volatile struct a2232status *stat; unsigned long flags; port = ptr; stat = a2232stat(port->which_a2232, port->which_port_on_a2232); stat->OutDisable = -1; /* Does this here really have to be? */ save_flags(flags); cli(); port->gs.flags &= ~GS_TX_INTEN; restore_flags(flags); }
static irqreturn_t a2232_vbl_inter(int irq, void *data) { #if A2232_IOBUFLEN != 256 #error "Re-Implement a2232_vbl_inter()!" #endif struct a2232_port *port; volatile struct a2232memory *mem; volatile struct a2232status *status; unsigned char newhead; unsigned char bufpos; /* Must be unsigned char. We need the modulo-256 arithmetics */ unsigned char ncd, ocd, ccd; /* names consistent with the NetBSD driver */ volatile u_char *ibuf, *cbuf, *obuf; int ch, err, n, p; for (n = 0; n < nr_a2232; n++){ /* for every completely initialized A2232 board */ mem = a2232mem(n); for (p = 0; p < NUMLINES; p++){ /* for every port on this board */ err = 0; port = &a2232_ports[n*NUMLINES+p]; if ( port->gs.port.flags & GS_ACTIVE ){ /* if the port is used */ status = a2232stat(n,p); if (!port->disable_rx && !port->throttle_input){ /* If input is not disabled */ newhead = status->InHead; /* 65EC02 write pointer */ bufpos = status->InTail; /* check for input for this port */ if (newhead != bufpos) { /* buffer for input chars/events */ ibuf = mem->InBuf[p]; /* data types of bytes in ibuf */ cbuf = mem->InCtl[p]; /* do for all chars */ while (bufpos != newhead) { /* which type of input data? */ switch (cbuf[bufpos]) { /* switch on input event (CD, BREAK, etc.) */ case A2232INCTL_EVENT: switch (ibuf[bufpos++]) { case A2232EVENT_Break: /* TODO: Handle BREAK signal */ break; /* A2232EVENT_CarrierOn and A2232EVENT_CarrierOff are handled in a separate queue and should not occur here. */ case A2232EVENT_Sync: printk("A2232: 65EC02 software sent SYNC event, don't know what to do. Ignoring."); break; default: printk("A2232: 65EC02 software broken, unknown event type %d occurred.\n",ibuf[bufpos-1]); } /* event type switch */ break; case A2232INCTL_CHAR: /* Receive incoming char */ a2232_receive_char(port, ibuf[bufpos], err); bufpos++; break; default: printk("A2232: 65EC02 software broken, unknown data type %d occurred.\n",cbuf[bufpos]); bufpos++; } /* switch on input data type */ } /* while there's something in the buffer */ status->InTail = bufpos; /* tell 65EC02 what we've read */ } /* if there was something in the buffer */ } /* If input is not disabled */ /* Now check if there's something to output */ obuf = mem->OutBuf[p]; bufpos = status->OutHead; while ( (port->gs.xmit_cnt > 0) && (!port->gs.port.tty->stopped) && (!port->gs.port.tty->hw_stopped) ){ /* While there are chars to transmit */ if (((bufpos+1) & A2232_IOBUFLENMASK) != status->OutTail) { /* If the A2232 buffer is not full */ ch = port->gs.xmit_buf[port->gs.xmit_tail]; /* get the next char to transmit */ port->gs.xmit_tail = (port->gs.xmit_tail+1) & (SERIAL_XMIT_SIZE-1); /* modulo-addition for the gs.xmit_buf ring-buffer */ obuf[bufpos++] = ch; /* put it into the A2232 buffer */ port->gs.xmit_cnt--; } else{ /* If A2232 the buffer is full */ break; /* simply stop filling it. */ } } status->OutHead = bufpos; /* WakeUp if output buffer runs low */ if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.port.tty) { tty_wakeup(port->gs.port.tty); } } // if the port is used } // for every port on the board /* Now check the CD message queue */ newhead = mem->Common.CDHead; bufpos = mem->Common.CDTail; if (newhead != bufpos){ /* There are CD events in queue */ ocd = mem->Common.CDStatus; /* get old status bits */ while (newhead != bufpos){ /* read all events */ ncd = mem->CDBuf[bufpos++]; /* get one event */ ccd = ncd ^ ocd; /* mask of changed lines */ ocd = ncd; /* save new status bits */ for(p=0; p < NUMLINES; p++){ /* for all ports */ if (ccd & 1){ /* this one changed */ struct a2232_port *port = &a2232_ports[n*7+p]; port->cd_status = !(ncd & 1); /* ncd&1 <=> CD is now off */ if (!(port->gs.port.flags & ASYNC_CHECK_CD)) ; /* Don't report DCD changes */ else if (port->cd_status) { // if DCD on: DCD went UP! /* Are we blocking in open?*/ wake_up_interruptible(&port->gs.port.open_wait); } else { // if DCD off: DCD went DOWN! if (port->gs.port.tty) tty_hangup (port->gs.port.tty); } } // if CD changed for this port ccd >>= 1; ncd >>= 1; /* Shift bits for next line */ } // for every port } // while CD events in queue mem->Common.CDStatus = ocd; /* save new status */ mem->Common.CDTail = bufpos; /* remove events */ } // if events in CD queue } // for every completely initialized A2232 board
static int a2232_set_real_termios(void *ptr) { unsigned int cflag, baud, chsize, stopb, parity, softflow; int rate; int a2232_param, a2232_cmd; unsigned long flags; unsigned int i; struct a2232_port *port = ptr; volatile struct a2232status *status; volatile struct a2232memory *mem; if (!port->gs.port.tty || !port->gs.port.tty->termios) return 0; status = a2232stat(port->which_a2232, port->which_port_on_a2232); mem = a2232mem(port->which_a2232); a2232_param = a2232_cmd = 0; // get baud rate baud = port->gs.baud; if (baud == 0) { /* speed == 0 -> drop DTR, do nothing else */ local_irq_save(flags); // Clear DTR (and RTS... mhhh). status->Command = ( (status->Command & ~A2232CMD_CMask) | A2232CMD_Close ); status->OutFlush = -1; status->Setup = -1; local_irq_restore(flags); return 0; } rate = A2232_BAUD_TABLE_NOAVAIL; for (i=0; i < A2232_BAUD_TABLE_NUM_RATES * 3; i += 3){ if (a2232_baud_table[i] == baud){ if (mem->Common.Crystal == A2232_TURBO) rate = a2232_baud_table[i+2]; else rate = a2232_baud_table[i+1]; } } if (rate == A2232_BAUD_TABLE_NOAVAIL){ printk("a2232: Board %d Port %d unsupported baud rate: %d baud. Using another.\n",port->which_a2232,port->which_port_on_a2232,baud); // This is useful for both (turbo or normal) Crystal versions. rate = A2232PARAM_B9600; } a2232_param |= rate; cflag = port->gs.port.tty->termios->c_cflag; // get character size chsize = cflag & CSIZE; switch (chsize){ case CS8: a2232_param |= A2232PARAM_8Bit; break; case CS7: a2232_param |= A2232PARAM_7Bit; break; case CS6: a2232_param |= A2232PARAM_6Bit; break; case CS5: a2232_param |= A2232PARAM_5Bit; break; default: printk("a2232: Board %d Port %d unsupported character size: %d. Using 8 data bits.\n", port->which_a2232,port->which_port_on_a2232,chsize); a2232_param |= A2232PARAM_8Bit; break; } // get number of stop bits stopb = cflag & CSTOPB; if (stopb){ // two stop bits instead of one printk("a2232: Board %d Port %d 2 stop bits unsupported. Using 1 stop bit.\n", port->which_a2232,port->which_port_on_a2232); } // Warn if RTS/CTS not wanted if (!(cflag & CRTSCTS)){ #ifndef A2232_SUPPRESS_RTSCTS_WARNING printk("a2232: Board %d Port %d cannot switch off firmware-implemented RTS/CTS hardware flow control.\n", port->which_a2232,port->which_port_on_a2232); #endif } /* I think this is correct. However, IXOFF means _input_ flow control and I wonder if one should care about IXON _output_ flow control, too. If this makes problems, one should turn the A2232 firmware XON/XOFF "SoftFlow" flow control off and use the conventional way of inserting START/STOP characters by hand in throttle()/unthrottle(). */ softflow = !!( port->gs.port.tty->termios->c_iflag & IXOFF ); // get Parity (Enabled/Disabled? If Enabled, Odd or Even?) parity = cflag & (PARENB | PARODD); if (parity & PARENB){ if (parity & PARODD){ a2232_cmd |= A2232CMD_OddParity; } else{ a2232_cmd |= A2232CMD_EvenParity; } } else a2232_cmd |= A2232CMD_NoParity; /* Hmm. Maybe an own a2232_port structure member would be cleaner? */ if (cflag & CLOCAL) port->gs.port.flags &= ~ASYNC_CHECK_CD; else port->gs.port.flags |= ASYNC_CHECK_CD; /* Now we have all parameters and can go to set them: */ local_irq_save(flags); status->Param = a2232_param | A2232PARAM_RcvBaud; status->Command = a2232_cmd | A2232CMD_Open | A2232CMD_Enable; status->SoftFlow = softflow; status->OutDisable = 0; status->Setup = -1; local_irq_restore(flags); return 0; }