linux/drivers/tty/serial/jsm/jsm_neo.c

// SPDX-License-Identifier: GPL-2.0+
/************************************************************************
 * Copyright 2003 Digi International (www.digi.com)
 *
 * Copyright (C) 2004 IBM Corporation. All rights reserved.
 *
 * Contact Information:
 * Scott H Kilau <[email protected]>
 * Wendy Xiong   <[email protected]>
 *
 ***********************************************************************/
#include <linux/delay.h>	/* For udelay */
#include <linux/serial_reg.h>	/* For the various UART offsets */
#include <linux/tty.h>
#include <linux/pci.h>
#include <asm/io.h>

#include "jsm.h"		/* Driver main header file */

static u32 jsm_offset_table[8] = …;

/*
 * This function allows calls to ensure that all outstanding
 * PCI writes have been completed, by doing a PCI read against
 * a non-destructive, read-only location on the Neo card.
 *
 * In this case, we are reading the DVID (Read-only Device Identification)
 * value of the Neo card.
 */
static inline void neo_pci_posting_flush(struct jsm_board *bd)
{ … }

static void neo_set_cts_flow_control(struct jsm_channel *ch)
{ … }

static void neo_set_rts_flow_control(struct jsm_channel *ch)
{ … }


static void neo_set_ixon_flow_control(struct jsm_channel *ch)
{ … }

static void neo_set_ixoff_flow_control(struct jsm_channel *ch)
{ … }

static void neo_set_no_input_flow_control(struct jsm_channel *ch)
{ … }

static void neo_set_no_output_flow_control(struct jsm_channel *ch)
{ … }

static inline void neo_set_new_start_stop_chars(struct jsm_channel *ch)
{ … }

static void neo_copy_data_from_uart_to_queue(struct jsm_channel *ch)
{ … }

static void neo_copy_data_from_queue_to_uart(struct jsm_channel *ch)
{ … }

static void neo_parse_modem(struct jsm_channel *ch, u8 signals)
{ … }

/* Make the UART raise any of the output signals we want up */
static void neo_assert_modem_signals(struct jsm_channel *ch)
{ … }

/*
 * Flush the WRITE FIFO on the Neo.
 *
 * NOTE: Channel lock MUST be held before calling this function!
 */
static void neo_flush_uart_write(struct jsm_channel *ch)
{ … }


/*
 * Flush the READ FIFO on the Neo.
 *
 * NOTE: Channel lock MUST be held before calling this function!
 */
static void neo_flush_uart_read(struct jsm_channel *ch)
{ … }

/*
 * No locks are assumed to be held when calling this function.
 */
static void neo_clear_break(struct jsm_channel *ch)
{ … }

/*
 * Parse the ISR register.
 */
static void neo_parse_isr(struct jsm_board *brd, u32 port)
{ … }

static inline void neo_parse_lsr(struct jsm_board *brd, u32 port)
{ … }

/*
 * neo_param()
 * Send any/all changes to the line to the UART.
 */
static void neo_param(struct jsm_channel *ch)
{ … }

/*
 * jsm_neo_intr()
 *
 * Neo specific interrupt handler.
 */
static irqreturn_t neo_intr(int irq, void *voidbrd)
{ … }

/*
 * Neo specific way of turning off the receiver.
 * Used as a way to enforce queue flow control when in
 * hardware flow control mode.
 */
static void neo_disable_receiver(struct jsm_channel *ch)
{ … }


/*
 * Neo specific way of turning on the receiver.
 * Used as a way to un-enforce queue flow control when in
 * hardware flow control mode.
 */
static void neo_enable_receiver(struct jsm_channel *ch)
{ … }

static void neo_send_start_character(struct jsm_channel *ch)
{ … }

static void neo_send_stop_character(struct jsm_channel *ch)
{ … }

/*
 * neo_uart_init
 */
static void neo_uart_init(struct jsm_channel *ch)
{ … }

/*
 * Make the UART completely turn off.
 */
static void neo_uart_off(struct jsm_channel *ch)
{ … }

/* Channel lock MUST be held by the calling function! */
static void neo_send_break(struct jsm_channel *ch)
{ … }

struct board_ops jsm_neo_ops = …;