Port Driver - 16c95x Serial
The 16C95x Serial Port driver is typically required for high-performance RS-232 serial adapter cards based on the Oxford Semiconductor (now Asix/PLX) chipset. These ports are common in industrial, retail, and workstation environments for connecting devices like barcode scanners, receipt printers, and modems. 🛠️ How to Get the Driver
Since "16C95x" refers to the chipset rather than a specific brand, your best source for a driver is the manufacturer of your serial card or computer: 1. Identify Your Hardware
If you don't know the manufacturer, use Device Manager to find the Hardware ID:
Right-click PCI Serial Port (often marked with a yellow "!"). Select Properties > Details tab. Choose Hardware Ids from the dropdown.
Look for a string like PCI\VEN_1415&DEV_9501 (Example for Oxford). 2. Download from Official Sources StarTech.com: Many 16C95x cards are StarTech models (e.g., ). Search their support page with your product ID.
HP / Dell / Pegatron: If the port is built into your PC (like an HP ProDesk 600 G1 Go to product viewer dialog for this item.
), visit the manufacturer’s support site and enter your serial number.
Legacy Chips: For generic cards using the Oxford OX16C95x chipset, some users find drivers through repositories like DriverIdentifier or DriverScape, though manufacturer sites are safer. ⚡ Manual Installation Steps Once you have downloaded and extracted the driver files: Open Device Manager (Win + X > Device Manager). Right-click the PCI Serial Port and select Update driver. Choose Browse my computer for drivers.
Navigate to the folder where you unzipped the files and click Next. 16C95x Serial Port Driver for Pegatron - DriverIdentifier
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:
- Transmitter: Converts parallel data into serial data and transmits it over the serial line.
- Receiver: Receives serial data from the serial line and converts it into parallel data.
- 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:
- RBR (Receive Buffer Register): Stores received data.
- THR (Transmit Hold Register): Stores data to be transmitted.
- IER (Interrupt Enable Register): Enables or disables interrupts.
- 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:
- Initialization: Configuring the chip's registers and setting up interrupt handling.
- Data Transmission: Writing data to the THR register and managing the transmission process.
- Data Reception: Reading data from the RBR register and handling receive interrupts.
- Error Handling: Detecting and handling errors, such as parity errors and overrun errors.
The driver implementation involves several key steps:
- 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.
- 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.
- 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:
- Read IIR Register: Reads the IIR register to determine the source of the interrupt.
- 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: 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 driver is a fundamental piece of software infrastructure that enables high-performance asynchronous communication between modern operating systems and high-speed UART (Universal Asynchronous Receiver/Transmitter) hardware. Specifically designed for the Oxford Semiconductor (now part of Diodes Incorporated) 16C950, 16C954, and 16C958 families, these drivers are the bridge that allows industrial and legacy hardware to interface with contemporary computing environments. Technical Foundation and Architecture
The 16C95x family is renowned in the embedded and industrial sectors for significantly exceeding the capabilities of the standard 16550 UART. While the classic 16550 utilizes a 16-byte FIFO (First-In, First-Out) buffer, the 16C95x series features a massive 128-byte FIFO.
The driver is responsible for managing this increased buffer depth to:
Prevent Data Overruns: By leveraging the larger buffer, the driver reduces the frequency of interrupts sent to the CPU, allowing the system to handle high-speed data streams (up to 15 Mbps in some configurations) without losing packets.
Automatic Flow Control: The driver configures the hardware's built-in automated RTS/CTS (Request to Send/Clear to Send) or XON/XOFF flow control, ensuring that communication pauses and resumes seamlessly based on buffer availability. Evolution of the Driver
Originally developed for Windows 95 and NT, the 16C95x driver has undergone several transformations to maintain compatibility with modern systems:
Legacy WDM Drivers: In the early 2000s, these drivers functioned as Windows Driver Model (WDM) components, often bundled with PCI or PCMCIA expansion cards.
Universal Windows Drivers (UWD): Modern iterations are often compliant with Windows 10 and 11, focusing on 64-bit architecture and Secure Boot compatibility.
Linux Integration: In the Linux ecosystem, support for the 16C95x is typically baked into the kernel's 8250 or serial core drivers. Because the 16C950 is backward compatible with the 16550, the kernel automatically detects the enhanced features (like the larger FIFO) and enables them via the standard serial interface (/dev/ttyS*). Implementation in Industrial Contexts
You will most commonly encounter the 16C95x driver when deploying:
Multi-Port Serial Cards: Used in server rooms to manage multiple consoles or in retail for Point-of-Sale (POS) systems.
Automation Hardware: PLCs and CNC machines that require low-latency, high-reliability serial links.
Scientific Instruments: Data loggers that output high-density information over RS-232, RS-422, or RS-485 protocols. Installation and Troubleshooting
When installing a 16C95x driver, the process usually involves an .inf file that tells the operating system how to map the hardware’s I/O ports and IRQs (Interrupt Requests). Common troubleshooting steps for these drivers include:
FIFO Tuning: If data corruption occurs, users often use the driver's advanced settings to lower the "Receive Buffer" trigger level.
Baud Rate Aliasing: Because the 16C95x supports non-standard high speeds, drivers sometimes use "clock multipliers" to achieve specific baud rates that standard software doesn't recognize.
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 The 16C95x Serial Port driver is typically required
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
The 16C95x Serial Port driver is a specialized driver used to manage high-performance serial communication ports based on the Oxford Semiconductor (now part of Diodes Incorporated) 16C950 UART (Universal Asynchronous Receiver-Transmitter) architecture. Driver Overview
The 16C95x driver is commonly found in legacy and industrial-grade hardware, specifically for PCI and PCI Express (PCIe) expansion cards that add RS-232, RS-422, or RS-485 ports to a computer.
Chipset Heritage: Originally developed by Oxford Semiconductor, these chips (like the OX16C950 or OXPCIe952) are known for their high-speed capabilities, often reaching up to 921.6 Kbps.
Key Features: These drivers support deep FIFO (First-In, First-Out) buffers—typically 128 or 256 bytes—which significantly reduce CPU overhead compared to standard 16550 UARTs (which have only 16-byte buffers). Common Use Cases You will typically encounter this driver on:
Industrial Workstations: Dell Precision, HP ProDesk, and Fujitsu Esprimo systems often use these cards for legacy equipment connectivity.
Multi-Port Serial Cards: Expansion cards that provide 2, 4, 8, or 16 additional serial ports.
Specialized Peripherals: Connecting CNC machines, barcode scanners, or older industrial printers. Compatibility & Installation Issues
The 16C95x is largely considered a legacy device, which can lead to modern driver conflicts. OS Support
Historically native to Windows XP and 7. Support for Windows 10/11 often requires manually browsing for drivers or using "Legacy Hardware" wizards. Hardware ID
Often appears in Device Manager under "Other Devices" with the Hardware ID OXPCIEMF\PNP0501 or OXPCI\VEN_1415. Installation Failures
Frequently fails to install automatically through Windows Update. Manual installation via Device Manager is usually required. How to Install/Update
Identify the Chip: Check Device Manager for a "PCI Serial Port" with a yellow exclamation mark.
Manual Update: Right-click the device -> Update Driver -> Browse my computer for drivers. Transmitter: Converts parallel data into serial data and
Vendor Sources: If you have an HP or Dell machine, search their Support Sites for "Oxford Serial Port" or "PCI Express Serial Card" drivers.
Workaround: If official drivers for Windows 11 are missing, Windows 7 or 8 drivers often work when installed in Compatibility Mode.
Are you trying to fix a "missing driver" error in your Device Manager right now? 16C95x Serial Port Driver for Pegatron - DriverIdentifier
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.
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
4) Key registers and access patterns (typical)
Note: actual offsets vary by vendor/card. Check datasheet for exact register map.
- Device global registers:
- Global Interrupt Status / Mask — used to quickly determine which channel(s) caused interrupts.
- Device control / reset register — global reset and configuration bits.
- Per-channel register bank (windowed or indexed):
- RBR (Receiver Buffer Register) / THR (Transmitter Holding Register).
- IER (Interrupt Enable Register).
- IIR (Interrupt Identification Register).
- LCR (Line Control Register) — data bits, parity, stop bits, and DLAB.
- MCR (Modem Control Register) — RTS/DTR control.
- LSR (Line Status Register) — data ready, overrun, framing, parity, THR empty.
- MSR (Modem Status Register) — CTS/DSR/CD/RI changes.
- DLL/DLM (Divisor Latch Low/High) – baud-rate divisor accessible when DLAB=1.
- Bank-switching or indexed access:
- Some designs require selecting a channel index before accessing per-channel registers; minimize bank-switches in hot code paths and keep per-port copies of static registers where helpful.
3.1 Initialization and Enumeration
Upon loading, the driver performs the following sequence:
- Hardware Identification: The driver reads the Device ID registers to confirm the presence of a 16C95x device (distinguishing it from a 16550A).
- Configuration: It configures the base clock and initial line parameters (8N1 default).
- FIFO Enablement: The driver explicitly enables the 128-byte FIFO mode. Without this step, the device may default to 16550A compatibility mode (16-byte FIFO).
3. Initialization Sequence
A proper driver starts by resetting and configuring the UART. Below is a typical initialization routine (pseudo-code for a bare-metal driver).
void uart16c95x_init(uintptr_t base_addr, uint32_t baud_rate, uint8_t data_bits, uint8_t parity, uint8_t stop_bits)
uint8_t lcr = 0;
// 1. Reset FIFOs via FCR
write_reg(base_addr + UART_FCR, FCR_ENABLE_FIFO
Introduction
The Universal Asynchronous Receiver-Transmitter (UART) remains one of the most enduring interfaces in computing, from legacy RS-232 ports to modern industrial IoT gateways. Among UART controllers, the 16C95x family (including variants like 16C950, 16C952, and 16C954) stands out as a high-performance descendant of the iconic 16550. However, its advanced features—such as large transmit/receive FIFOs (up to 128 bytes per channel), automatic hardware flow control, and I²C/SPI expansion interfaces—demand a driver architecture far more sophisticated than the classic 8250/16550 driver. This essay analyzes the design, core responsibilities, and optimization strategies of a 16C95x serial port driver within the Linux kernel, arguing that it represents a crucial evolution in handling high-throughput, low-latency serial communication without sacrificing compatibility.
