JOIN
DONATE

View More Articles

Donate Subscribe

16c95x Serial Port Driver [updated] Online

Lucy Gellman | November 18th, 2022

16c95x Serial Port Driver [updated] Online

16C95x Serial Port Driver is a high-performance communication software designed to support the advanced features of the Oxford Semiconductor

(now part of Diodes Incorporated) UART chipset. It is commonly found in industrial-grade multi-port serial cards, docking stations, and legacy-compatible business desktops from manufacturers like Core Technical Features

The driver unlocks specific hardware capabilities of the 16C95x chip that exceed standard 16550 UART specifications: Expanded Data Buffering

: Supports massive 128-byte receiver and transmitter FIFOs (First-In, First-Out), significantly reducing the risk of data loss during high-speed transfers. High-Speed Data Rates : Enables flexible baud rate generation up to

, often utilizing a "Quad speed" mode via the Times clock register. Advanced Flow Control

: Automates flow control to prevent buffer overflows without taxing the main system CPU. Precision Interrupt Management

: Features adjustable receiver and transmitter interrupt trigger levels for optimized data handling in time-sensitive applications. RS485 Half-Duplex Support

: Includes dedicated configuration for RS485 half-duplex operation, making it suitable for industrial fieldbus communications. Compatibility and Installation While primarily built for Windows 2000 and XP

, the driver continues to be used in modern environments like Windows 10 and 11 for specialized hardware. HP Support Community Manual Installation

: If the device appears as an "Unknown PCI Device," you can manually point the Windows Device Manager to the driver files or use the Add Legacy Hardware Configuration

: Once installed, you can modify COM port assignments and performance settings via the Port Settings > Advanced tab in the device properties. specific download link for a particular hardware model or operating system? Resolved: Windows serial port driver problem - Mbed

16C95x Serial Port Driver a high-performance communication driver for the Oxford Semiconductor OX16C95x UART (now part of Diodes Incorporated

). These chips are commonly found in industrial computers, PCI/PCIe expansion cards, and legacy-equipped desktop models like the HP ProDesk 600 G1 Key Specifications & Features 16c95x serial port driver

The OX16C95x series (e.g., OX16C950, OX16C954) is designed for high-speed data transmission with low CPU overhead. www.fastcomproducts.com Deep FIFOs

: 128-byte (standard) or 256-byte receiver and transmitter buffers to prevent data loss at high speeds. High Baud Rates : Supports speeds up to (standard) and up to in specialized clock modes. Flow Control

: Features automated in-band (Xon/Xoff) and out-of-band (CTS/RTS and DSR/DTR) hardware flow control. Backward Compatibility

: Fully compatible with industry-standard 16C450, 16C550, and 16C650 UARTs. Interface Support

: Common on PCI, PCI Express (PCIe), and ExpressCard interfaces. Driver Installation & Troubleshooting

If you see "16C95x Serial Port" or "PCI Serial Port" with a yellow exclamation mark in Windows Device Manager , use these steps: PCI Serial port driver. - Microsoft Q&A

Title: Implementation and Analysis of the 16C95X Serial Port Driver

Abstract: The 16C95X is a popular UART (Universal Asynchronous Receiver-Transmitter) chip used in various computer systems for serial communication. This paper presents an in-depth analysis and implementation of the 16C95X serial port driver. We discuss the architecture of the 16C95X, its features, and the challenges faced while developing a driver for it. The paper also provides a detailed overview of the driver implementation, including the interrupt handling mechanism, data transmission and reception, and error handling.

Introduction: Serial communication is a widely used method for transferring data between devices. The 16C95X UART chip is a widely used component in many computer systems, providing a reliable and efficient way to perform serial communication. However, to utilize the 16C95X chip, a driver is required to manage its operations and facilitate communication between the chip and the operating system. This paper focuses on the development of a 16C95X serial port driver.

Architecture of 16C95X: The 16C95X UART chip consists of several key components:

  1. Transmitter: Converts parallel data into serial data and transmits it over the serial line.
  2. Receiver: Receives serial data from the serial line and converts it into parallel data.
  3. Control Unit: Manages the overall operation of the chip, including interrupt generation and handling.

The 16C95X chip has several registers that are used to configure and control its operation. These registers include:

  1. RBR (Receive Buffer Register): Stores received data.
  2. THR (Transmit Hold Register): Stores data to be transmitted.
  3. IER (Interrupt Enable Register): Enables or disables interrupts.
  4. IIR (Interrupt Identification Register): Identifies the source of an interrupt.

Driver Implementation: The 16C95X serial port driver is responsible for managing the chip's operations, including: Transmitter: Converts parallel data into serial data and

  1. Initialization: Configuring the chip's registers and setting up interrupt handling.
  2. Data Transmission: Writing data to the THR register and managing the transmission process.
  3. Data Reception: Reading data from the RBR register and handling receive interrupts.
  4. Error Handling: Detecting and handling errors, such as parity errors and overrun errors.

The driver implementation involves several key steps:

  1. Interrupt Handling: The driver installs an interrupt handler to manage interrupts generated by the 16C95X chip. The interrupt handler reads the IIR register to determine the source of the interrupt and performs the necessary actions.
  2. Data Transmission: The driver uses the THR register to transmit data. It writes data to the THR register and sets the transmitter empty interrupt enable bit in the IER register.
  3. Data Reception: The driver uses the RBR register to receive data. It reads data from the RBR register and handles receive interrupts.

Interrupt Handling Mechanism: The interrupt handling mechanism is a critical component of the 16C95X serial port driver. The driver installs an interrupt handler that is called when an interrupt occurs. The interrupt handler performs the following steps:

  1. Read IIR Register: Reads the IIR register to determine the source of the interrupt.
  2. Handle Interrupt: Performs the necessary actions based on the interrupt source, such as reading data from the RBR register or writing data to the THR register.

Conclusion: In this paper, we presented an in-depth analysis and implementation of the 16C95X serial port driver. We discussed the architecture of the 16C95X chip, its features, and the challenges faced while developing a driver for it. The paper provided a detailed overview of the driver implementation, including the interrupt handling mechanism, data transmission and reception, and error handling. The 16C95X serial port driver is a critical component of many computer systems, and its proper implementation is essential for reliable and efficient serial communication.

References:

  • [1] 16C95X UART Chip Datasheet
  • [2] Serial Communication Tutorial
  • [3] Linux Device Drivers, 3rd Edition

Appendix: Here is a sample code snippet that demonstrates the implementation of the 16C95X serial port driver:

#include <linux/module.h>
#include <linux/init.h>
#include <linux/tty.h>
#include <linux/serial.h>
#define UART_PORT 0x3F8
#define UART_IRQ 4
static struct uart_ops ops = 
    .tx_empty = my_tx_empty,
    .get_mctrl = my_get_mctrl,
    .set_mctrl = my_set_mctrl,
    .putc = my_putc,
    .getc = my_getc,
;
static int my_uart_init(void)
int retval;
    retval = request_irq(UART_IRQ, my_uart_interrupt, IRQF_SHARED, "my_uart", NULL);
    if (retval) 
        printk(KERN_ERR "my_uart: unable to request IRQ\n");
        return retval;
uart_register(&ops, UART_PORT);
    return 0;
static void my_uart_interrupt(int irq, void *dev_id, struct pt_regs *regs)
unsigned char iir;
    iir = inb(UART_PORT + UART_IIR);
    if (iir & UART_IIR_RXDA) 
        /* Handle receive interrupt */
     else if (iir & UART_IIR_TXDE) 
        /* Handle transmit interrupt */
static int my_putc(struct uart_port *port, int c)
outb(c, UART_PORT + UART_THR);
    return 0;
static int my_getc(struct uart_port *port)
return inb(UART_PORT + UART_RBR);
module_init(my_uart_init);

Note that this is a simplified example and may require modifications to work with a specific operating system and hardware configuration.

The 16C95x Serial Port refers to a high-performance UART (Universal Asynchronous Receiver/Transmitter) typically found on Oxford Semiconductor based PCI or PCIe expansion cards. These ports are common in industrial equipment, modems, and legacy hardware interfaces due to their large 128-byte or 256-byte FIFO buffers. Quick Fix: Installation Guide

If you see "PCI Serial Port" with a yellow exclamation mark in your Device Manager, follow these steps to resolve it:

Identify Your Chipset: Most 16C95x devices use Oxford Semiconductor (now part of PLX Technology/Broadcom) chips. Look for Hardware IDs like PCI\VEN_1415 or OXPCIMF\PNP0501 in the device properties. Download Sources:

Manufacturer Support: Check the website of the card manufacturer (e.g., StarTech, SIIG, or Perle). For example, Perle provides standard Linux and Windows drivers for their multiport cards.

Generic Drivers: If you lack a specific brand, search for "Oxford OX16C95x Reference Drivers." DriverIdentifier often hosts mirrors for legacy hardware like HP, Dell, and Pegatron systems. Manual Update:

Right-click the device in Device Manager and select Update Driver. The 16C95X chip has several registers that are

Choose "Browse my computer for drivers" and point it to the extracted folder of the driver you downloaded. Technical Features of 16C95x

High Speed: Supports baud rates up to 15 Mbps (standard UARTs often cap at 115.2 Kbps).

Enhanced Buffering: Features 128-byte or 256-byte FIFOs to prevent data loss during high-speed transfers.

Compatibility: Supports automated flow control and is often backwards compatible with 16C450, 16C550, and 16C650 UARTs. Common Troubleshooting 16C95x Serial Port Driver for Pegatron - DriverIdentifier

Integration with Device Tree

On embedded platforms, the driver should match against a compatible string, e.g.:

compatible = "exar,xr16c950";

The probe function initializes the port, requests IRQ, and registers with the serial core.

Mastering High-Performance Serial Communication: A Deep Dive into the 16C95x UART Driver

Key Driver Features and Capabilities

A correctly implemented driver exposes the following hardware strengths:

Configuration Steps

  1. Set EFR bits: EFR_AUTO_RTS | EFR_AUTO_CTS
  2. Program TCR (Transmission Control Register) to define Rx FIFO thresholds for RTS deassertion/assertion. For example:
    • RTS deassert (stop remote sender) when Rx FIFO ≥ 112 bytes
    • RTS reassert when Rx FIFO ≤ 32 bytes
  3. Program MCR to ensure RTS/CTS pins are enabled (MCR_RTS = 1 for output, MCR_AFE = 1 for auto flow control – if present).

Without auto flow control, the driver would need to toggle RTS in software, which introduces latency and risks FIFO overrun. With auto flow, the driver is free to service interrupts at its own pace.

Step 1: Identify Your Hardware

Run lspci -v (Linux) or check device manager (Windows) for a serial controller with PCI vendor ID 0x13F0 (Sundance) or 0x14CB (Exar). Look for “UART with 128-byte FIFO”.

Overview

The 16C95x family (e.g., TI’s TL16C754, Exar’s XR16C95x) is a high-performance UART with FIFO depths up to 128 bytes, automatic hardware/software flow control, and multiple channels (often 4). The driver enables communication via RS-232/RS-485 in industrial, telecom, or embedded systems.

2.1 Key Features

  • Deep FIFOs: 128-byte Transmit and Receive FIFOs (compared to 16-byte in the 16550A). This significantly reduces CPU interrupt load.
  • High Speed: Capable of sustaining data rates up to 15 Mbps (depending on the specific variant and clock source).
  • Fractional Baud Rate Generator: Allows for precise baud rate generation at non-standard frequencies, reducing baud rate error margins.
  • Enhanced Register Set: Utilizes an expanded register set accessible via a bank-switching mechanism or specific index registers (e.g., LCR = 0xBF to access enhanced features).

Extended Registers (Via LCR = 0xBF)

Writing 0xBF to LCR (Line Control Register) accesses the extended register set at offsets 0x00–0x0F. Key extended registers for the driver:

| Offset | Register | Purpose | |--------|----------|---------| | 0x00 | EFR | Enhanced Function Register – enables auto flow control and special features | | 0x01 | XON1 | XON character 1 | | 0x02 | XON2 | XON character 2 | | 0x03 | XOFF1 | XOFF character 1 | | 0x04 | XOFF2 | XOFF character 2 | | 0x05 | TCR | Transmission Control Register – Rx trigger level for auto-RTS | | 0x06 | TLR | Trigger Level Register – Rx FIFO interrupt trigger | | 0x07 | TXLVL | Tx FIFO level (read) / Resume Tx (write) | | 0x08 | RXLVL | Rx FIFO level (read) | | 0x09 | IODIR | I/O pin direction (GPIO mode) | | 0x0A | IOSTATE | I/O pin state | | 0x0B | IOINTENA | I/O interrupt enable | | 0x0C | IOCONTROL | I/O control (e.g., RS-485 enable) | | 0x0D | EFCR | Extra Features Control – selects enhanced modes |

The driver must manage bank switching carefully, restoring LCR after accessing extended registers.