1261 lines
36 KiB
C
1261 lines
36 KiB
C
/*
|
|
* Copyright (c) 1997, 1998, 1999
|
|
* Alex Feldman <al.feldman@sangoma.com>. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Alex Feldman.
|
|
* 4. Neither the name of the author nor the names of any co-contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY Alex Feldman AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL Alex Feldman OR THE VOICES IN HIS HEAD
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* $Id: sdladrv.h,v 1.97 2008-04-21 19:03:31 sangoma Exp $
|
|
*/
|
|
|
|
/*****************************************************************************
|
|
* sdladrv.h SDLA Support Module. Kernel API Definitions.
|
|
*
|
|
* Author: Alex Feldman <al.feldman@sangoma.com>
|
|
*
|
|
* ============================================================================
|
|
* Nov 27, 2007 David Rokhvarg Implemented functions/definitions for
|
|
* Sangoma MS Windows Driver and API.
|
|
*
|
|
* Dec 06, 1999 Alex Feldman Updated to FreeBSD 3.2
|
|
*
|
|
* Dec 06, 1995 Gene Kozin Initial version.
|
|
*****************************************************************************
|
|
*/
|
|
|
|
#ifndef _SDLADRV_H
|
|
# define _SDLADRV_H
|
|
#ifdef __SDLADRV__
|
|
# define WP_EXTERN
|
|
#else
|
|
# define WP_EXTERN extern
|
|
#endif
|
|
|
|
#if defined(__LINUX__)
|
|
#ifdef CONFIG_ISA
|
|
# define WAN_ISA_SUPPORT
|
|
#else
|
|
# undef WAN_ISA_SUPPORT
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
******************************************************************
|
|
** I N C L U D E S **
|
|
******************************************************************
|
|
*/
|
|
#if defined(__LINUX__)
|
|
# include <linux/version.h>
|
|
#endif
|
|
|
|
#include "wanpipe_kernel.h"
|
|
#include "sdlasfm.h"
|
|
#include "sdlapci.h"
|
|
#include "wanpipe_api.h"
|
|
|
|
#if defined(__FreeBSD__)
|
|
# if defined(__SDLADRV__)
|
|
# if defined(SDLA_AUTO_PROBE)
|
|
# include <sdla_bsd.h>
|
|
# else
|
|
# include <i386/isa/sdla_dev.h>
|
|
# endif
|
|
# endif
|
|
#elif defined(__OpenBSD__) || defined(__NetBSD__)
|
|
# ifdef __SDLADRV__
|
|
# include <dev/ic/sdla_dev.h>
|
|
# endif
|
|
#endif
|
|
|
|
/*
|
|
******************************************************************
|
|
** D E F I N E S **
|
|
******************************************************************
|
|
*/
|
|
|
|
#define SDLADRV_MAGIC 0x414C4453L /* signature: 'SDLA' reversed */
|
|
|
|
#define SDLADRV_MODE_WANPIPE 0
|
|
#define SDLADRV_MODE_LIMITED 1
|
|
|
|
#define SDLADRV_MAJOR_VER 2
|
|
#define SDLADRV_MINOR_VER 1
|
|
|
|
#define SDLA_MAXIORANGE 4 /* maximum I/O port range */
|
|
#define SDLA_WINDOWSIZE 0x2000 /* default dual-port memory window size */
|
|
|
|
enum {
|
|
SDLA_MEMBASE = 0x01,
|
|
SDLA_MEMEND,
|
|
SDLA_MEMSIZE,
|
|
SDLA_IRQ,
|
|
SDLA_ADAPTERTYPE,
|
|
SDLA_CPU,
|
|
SDLA_SLOT,
|
|
SDLA_IOPORT,
|
|
SDLA_IORANGE,
|
|
SDLA_CARDTYPE,
|
|
SDLA_DMATAG,
|
|
SDLA_MEMORY,
|
|
SDLA_PCIEXTRAVER,
|
|
SDLA_HWTYPE,
|
|
SDLA_BUS,
|
|
SDLA_BASEADDR,
|
|
SDLA_COREREV,
|
|
SDLA_HWCPU_USEDCNT,
|
|
SDLA_ADAPTERSUBTYPE,
|
|
SDLA_HWEC_NO,
|
|
SDLA_COREID,
|
|
SDLA_PCIEXPRESS,
|
|
SDLA_CHANS_NO,
|
|
SDLA_HWPORTUSED,
|
|
SDLA_HWLINEREG,
|
|
SDLA_HWLINEREGMAP,
|
|
SDLA_CHANS_MAP,
|
|
SDLA_RECOVERY_CLOCK_FLAG,
|
|
SDLA_HWTYPE_USEDCNT
|
|
};
|
|
|
|
#define SDLA_MAX_CPUS 2
|
|
|
|
/* Serial card - 2, A104 - 4, A108 - 8, A200/A400 - 1, A500-24 */
|
|
#define SDLA_MAX_HWDEVS 32
|
|
#define SDLA_MAX_HWPORTS 32
|
|
|
|
/* Status values */
|
|
#define SDLA_MEM_RESERVED 0x0001
|
|
#define SDLA_MEM_MAPPED 0x0002
|
|
#define SDLA_IO_MAPPED 0x0004
|
|
#define SDLA_PCI_ENABLE 0x0008
|
|
|
|
#define SDLA_NAME_SIZE 20
|
|
|
|
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
|
|
# define PCI_DMA_FROMDEVICE 1
|
|
# define PCI_DMA_TODEVICE 2
|
|
#endif
|
|
|
|
#define SDLA_ISA_CARD 0
|
|
#define SDLA_PCI_CARD 1
|
|
#define SDLA_PCI_EXP_CARD 2
|
|
#define SDLA_USB_CARD 3
|
|
|
|
#define SDLA_MAGIC(hw) WAN_ASSERT((hw)->magic != SDLADRV_MAGIC)
|
|
#define SDLA_MAGIC_RC(hw,rc) WAN_ASSERT_RC((hw)->magic != SDLADRV_MAGIC, (rc))
|
|
#define SDLA_MAGIC_VOID(hw) WAN_ASSERT_VOID((hw)->magic != SDLADRV_MAGIC)
|
|
|
|
#define WAN_BUS_ID_SIZE 20
|
|
|
|
/*
|
|
******************************************************************
|
|
** T Y P E D E F S **
|
|
******************************************************************
|
|
*/
|
|
#if defined(__FreeBSD__)
|
|
typedef void* sdla_mem_handle_t;
|
|
# if (__FreeBSD_version < 400000)
|
|
typedef bus_addr_t sdla_base_addr_t;
|
|
typedef bus_addr_t sdla_dma_addr_t;
|
|
typedef pcici_t sdla_pci_dev_t;
|
|
# else
|
|
typedef bus_addr_t sdla_base_addr_t;
|
|
typedef bus_addr_t sdla_dma_addr_t;
|
|
typedef struct device* sdla_pci_dev_t;
|
|
# endif
|
|
#elif defined(__OpenBSD__)
|
|
typedef bus_space_handle_t sdla_mem_handle_t;
|
|
typedef bus_addr_t sdla_base_addr_t;
|
|
typedef bus_addr_t sdla_dma_addr_t;
|
|
typedef struct pci_attach_args* sdla_pci_dev_t;
|
|
#elif defined(__NetBSD__)
|
|
typedef bus_space_handle_t sdla_mem_handle_t;
|
|
typedef bus_addr_t sdla_base_addr_t;
|
|
typedef bus_addr_t sdla_dma_addr_t;
|
|
typedef struct pci_attach_args* sdla_pci_dev_t;
|
|
#elif defined(__LINUX__)
|
|
#if defined(__iomem)
|
|
typedef void __iomem* sdla_mem_handle_t;
|
|
#else
|
|
typedef void * sdla_mem_handle_t;
|
|
#endif
|
|
typedef unsigned long sdla_base_addr_t;
|
|
typedef dma_addr_t sdla_dma_addr_t;
|
|
typedef struct pci_dev* sdla_pci_dev_t;
|
|
#elif defined(__WINDOWS__)
|
|
|
|
typedef void * sdla_mem_handle_t;
|
|
typedef LONGLONG sdla_base_addr_t; /* LONGLONG is 64 bit*/
|
|
typedef dma_addr_t sdla_dma_addr_t;
|
|
typedef struct pci_dev* sdla_pci_dev_t;
|
|
extern
|
|
sdla_base_addr_t
|
|
pci_resource_start(
|
|
IN struct pci_dev *pci_dev,
|
|
IN int resource_index
|
|
);
|
|
|
|
#else
|
|
# warning "Undefined types sdla_mem_handle_t/sdla_base_addr_t!"
|
|
#endif
|
|
|
|
/*****************************************************************
|
|
** M A C R O S **
|
|
*****************************************************************/
|
|
|
|
|
|
#define IS_HWCARD_ISA(hwcard) ((hwcard)->hw_type == SDLA_ISA_CARD)
|
|
#define IS_HWCARD_PCI(hwcard) ((hwcard)->hw_type == SDLA_PCI_CARD)
|
|
#define IS_HWCARD_PCIE(hwcard) ((hwcard)->hw_type == SDLA_PCI_EXP_CARD)
|
|
#define IS_HWCARD_USB(hwcard) ((hwcard)->hw_type == SDLA_USB_CARD)
|
|
|
|
|
|
#if defined(__FreeBSD__)
|
|
# if defined(__i386__)
|
|
# define virt_to_phys(x) kvtop((caddr_t)x)
|
|
# else
|
|
# define virt_to_phys(x) (sdla_dma_addr_t)(x)
|
|
# endif
|
|
# define phys_to_virt(x) (sdla_mem_handle_t)x
|
|
#elif defined(__OpenBSD__)
|
|
# define virt_to_phys(x) kvtop((caddr_t)x)
|
|
# define phys_to_virt(x) (bus_space_handle_t)x
|
|
#elif defined(__NetBSD__)
|
|
# define virt_to_phys(x) kvtop((caddr_t)x)
|
|
# define phys_to_virt(x) (bus_space_handle_t)x
|
|
#elif defined(__LINUX__)
|
|
#elif defined(__WINDOWS__)
|
|
# define phys_to_virt(x) NULL
|
|
/*
|
|
static sdla_dma_addr_t virt_to_phys(void *virt_buf)
|
|
{
|
|
sdla_dma_addr_t ph;
|
|
FUNC_NOT_IMPL();
|
|
memset(&ph, 0x00, sizeof(sdla_dma_addr_t));
|
|
return ph;
|
|
}
|
|
*/
|
|
#else
|
|
# warning "Undefined virt_to_phys/phys_to_virt macros!"
|
|
#endif
|
|
|
|
#if defined(__WINDOWS__)
|
|
#define INIT_PHYSICAL_ADDR(phaddr) memset(&phaddr, 0x00, sizeof(sdla_dma_addr_t))
|
|
#else
|
|
#define INIT_PHYSICAL_ADDR(phaddr) phaddr = (sdla_dma_addr_t)NULL;
|
|
#endif
|
|
|
|
#define IS_SDLA_PCI(hw) (hw->type == SDLA_S514 || hw->type == SDLA_ADSL)
|
|
#define IS_SDLA_ISA(hw) (hw->type == SDLA_S508)
|
|
|
|
#define WAN_HWCALL(func, x) \
|
|
if (card->hw_iface.func){ \
|
|
card->hw_iface.func x; \
|
|
}else{ \
|
|
DEBUG_EVENT("%s: Unknown hw function pointer (%s:%d)!\n",\
|
|
card->devname, __FUNCTION__,__LINE__); \
|
|
}
|
|
|
|
/*
|
|
******************************************************************
|
|
** S T R U C T U R E S **
|
|
******************************************************************
|
|
*/
|
|
/* DMA structure */
|
|
#define SDLA_DMA_FLAG_READY 0
|
|
#define SDLA_DMA_FLAG_INIT 1
|
|
#define SDLA_DMA_FLAG_ALLOC 2
|
|
|
|
#if defined(__FreeBSD__)
|
|
# define SDLA_DMA_POSTREAD BUS_DMASYNC_POSTREAD
|
|
# define SDLA_DMA_PREREAD BUS_DMASYNC_PREREAD
|
|
# define SDLA_DMA_POSTWRITE BUS_DMASYNC_POSTWRITE
|
|
# define SDLA_DMA_PREWRITE BUS_DMASYNC_PREWRITE
|
|
#elif defined(__LINUX__)
|
|
# define SDLA_DMA_POSTREAD PCI_DMA_FROMDEVICE
|
|
# define SDLA_DMA_PREREAD PCI_DMA_FROMDEVICE
|
|
# define SDLA_DMA_POSTWRITE PCI_DMA_TODEVICE
|
|
# define SDLA_DMA_PREWRITE PCI_DMA_TODEVICE
|
|
#else
|
|
# define SDLA_DMA_POSTREAD 1
|
|
# define SDLA_DMA_PREREAD 2
|
|
# define SDLA_DMA_POSTWRITE 3
|
|
# define SDLA_DMA_PREWRITE 4
|
|
#endif
|
|
typedef struct wan_dma_descr_
|
|
{
|
|
unsigned long init;
|
|
unsigned long flag;
|
|
u32 alignment;
|
|
u32 max_len;
|
|
|
|
sdla_dma_addr_t dma_addr; /* physical address */
|
|
u32 dma_len; /* total dma data len */
|
|
u32 dma_map_len; /* actual dma mapped len (address range) */
|
|
netskb_t *skb;
|
|
u32 index;
|
|
|
|
u32 dma_descr;
|
|
u32 len_align;
|
|
u32 reg;
|
|
|
|
u8 pkt_error;
|
|
void* dma_virt;
|
|
u32 dma_offset;
|
|
u32 dma_toggle;
|
|
#if defined(__FreeBSD__)
|
|
bus_dma_tag_t dmat;
|
|
bus_dmamap_t dmam;
|
|
#elif defined(__OpenBSD__)
|
|
bus_dma_tag_t dmat;
|
|
bus_dma_segment_t dmaseg;
|
|
int rsegs;
|
|
#elif defined(__NetBSD__)
|
|
bus_dma_tag_t dmat;
|
|
bus_dma_segment_t dmaseg;
|
|
int rsegs;
|
|
#elif defined(__WINDOWS__)
|
|
sdla_mem_handle_t virtualAddr;
|
|
sdla_dma_addr_t physicalAddr;
|
|
PDMA_ADAPTER DmaAdapterObject;
|
|
#endif
|
|
} wan_dma_descr_t;
|
|
|
|
typedef struct sdla_hw_probe
|
|
{
|
|
int internal_used;
|
|
int used;
|
|
unsigned char hw_info[100];
|
|
unsigned char hw_info_verbose[500];
|
|
unsigned char hw_info_dump[1000];
|
|
WAN_LIST_ENTRY(sdla_hw_probe) next;
|
|
} sdla_hw_probe_t;
|
|
|
|
typedef struct sdlahw_isa_
|
|
{
|
|
unsigned int ioport;
|
|
unsigned io_range; /* I/O port range */
|
|
unsigned char regs[SDLA_MAXIORANGE]; /* was written to registers */
|
|
unsigned pclk; /* CPU clock rate, kHz */
|
|
|
|
#if defined(__NetBSD__) || defined(__OpenBSD__)
|
|
bus_space_tag_t iot; /* adapter I/O port tag */
|
|
bus_space_handle_t ioh; /* adapter I/O port handle */
|
|
bus_space_tag_t memt;
|
|
bus_dma_tag_t dmat;
|
|
#endif
|
|
|
|
} sdlahw_isa_t;
|
|
|
|
typedef struct sdlahw_pci_
|
|
{
|
|
unsigned int slot_no;
|
|
unsigned int bus_no;
|
|
sdla_pci_dev_t pci_dev; /* PCI config header info */
|
|
sdla_pci_dev_t pci_bridge_dev; /* PCI Bridge config header info */
|
|
unsigned int pci_bridge_slot;/* PCI Bridge slot number */
|
|
unsigned int pci_bridge_bus; /* PCI Bridge bus number */
|
|
} sdlahw_pci_t;
|
|
|
|
#if defined(CONFIG_PRODUCT_WANPIPE_USB)
|
|
|
|
#define SDLA_USB_OPMODE_TRANNING 0x00
|
|
#define SDLA_USB_OPMODE_VOICE 0x01
|
|
#define SDLA_USB_OPMODE_API 0x02
|
|
|
|
#define SDLA_URB_STATUS_READY 1
|
|
struct wan_urb {
|
|
void *pvt;
|
|
int id;
|
|
int next_off;
|
|
unsigned int ready;
|
|
struct urb urb;
|
|
};
|
|
|
|
/* move these define in source file */
|
|
#define WP_USB_CHUNKSIZE 8
|
|
#define WP_USB_FRAMESCALE 1
|
|
#define WP_USB_RXTX_CHUNKSIZE (WP_USB_CHUNKSIZE*WP_USB_FRAMESCALE) //16
|
|
#define WP_USB_MAX_CHUNKSIZE (WP_USB_CHUNKSIZE*WP_USB_FRAMESCALE) //16
|
|
|
|
#define MAX_READ_URB_COUNT 1
|
|
#define MAX_WRITE_URB_COUNT 2
|
|
#define MAX_USB_RX_LEN (4*WP_USB_RXTX_CHUNKSIZE)
|
|
#define MAX_USB_TX_LEN (4*WP_USB_RXTX_CHUNKSIZE)
|
|
#define MAX_READ_BUF_LEN (MAX_USB_RX_LEN*100)
|
|
#define MAX_WRITE_BUF_LEN (MAX_USB_TX_LEN*100)
|
|
#define MAX_USB_CTRL_CMD_LEN (WP_USB_TIMESCALE*8) //16 /* bytes */
|
|
|
|
#define WP_USB_BUSID(hwcard) ((hwcard)->u_usb.usb_dev) ? WAN_DEV_NAME((hwcard)->u_usb.usb_dev) : "Unknown"
|
|
|
|
typedef struct {
|
|
|
|
int core_notready_cnt;
|
|
|
|
int cmd_overrun;
|
|
int cmd_timeout;
|
|
int cmd_invalid;
|
|
|
|
int rx_sync_err_cnt;
|
|
int rx_start_fr_err_cnt;
|
|
int rx_start_err_cnt;
|
|
int rx_cmd_reset_cnt;
|
|
int rx_cmd_drop_cnt;
|
|
int rx_cmd_unknown;
|
|
int rx_overrun_cnt;
|
|
int rx_underrun_cnt;
|
|
int tx_overrun_cnt;
|
|
int tx_notready_cnt;
|
|
|
|
unsigned char dev_fifo_status;
|
|
unsigned char dev_uart_status;
|
|
unsigned char dev_hostif_status;
|
|
int dev_sync_err_cnt;
|
|
|
|
} sdla_usb_comm_err_stats_t;
|
|
|
|
typedef struct sdlahw_usb_
|
|
{
|
|
int opmode; /* Voice or API Data protocol */
|
|
unsigned char hw_rev; /* hardware (pcb) revision */
|
|
|
|
# if defined(__LINUX__)
|
|
char bus_id[WAN_BUS_ID_SIZE];
|
|
struct usb_device *usb_dev;
|
|
struct usb_interface *usb_intf;
|
|
# endif
|
|
|
|
|
|
unsigned char reg_cpu_ctrl; /* Reg 0x03 */
|
|
int urbcount_read;
|
|
int urb_read_ind;
|
|
struct wan_urb dataread[MAX_READ_URB_COUNT];
|
|
|
|
int urbcount_write;
|
|
int urb_write_ind;
|
|
struct wan_urb datawrite[MAX_WRITE_URB_COUNT];
|
|
|
|
char readchunk[2][WP_USB_MAX_CHUNKSIZE * 2+1];
|
|
char writechunk[2][WP_USB_MAX_CHUNKSIZE * 2+1];
|
|
u8 regs[2][110]; /* register shadow */
|
|
|
|
wan_spinlock_t cmd_lock;
|
|
wan_spinlock_t lock;
|
|
wan_spinlock_t tx_lock;
|
|
|
|
int rxtx_len; /* number of data bytes in record */
|
|
int rxtx_count; /* number records in single transcation */
|
|
int rxtx_total_len; /* total number of data bytes in record */
|
|
|
|
int rxtx_buf_len; /* total number of bytes in transcation */
|
|
int read_buf_len; /* size of read cycle buffer */
|
|
int write_buf_len; /* size of write cycle buffer */
|
|
|
|
int rx_sync;
|
|
int tx_sync;
|
|
int next_rx_ind;
|
|
int next_read_ind;
|
|
char *readbuf;
|
|
|
|
int next_tx_ind;
|
|
int next_write_ind;
|
|
char *writebuf;
|
|
|
|
char idlebuf[MAX_USB_TX_LEN+1];
|
|
|
|
wan_tasklet_t bh_task;
|
|
|
|
unsigned char ctrl_idle_pattern;
|
|
|
|
unsigned int status;
|
|
|
|
wan_ticks_t tx_cmd_start;
|
|
|
|
wan_skb_queue_t tx_cmd_list;
|
|
wan_skb_queue_t tx_cmd_free_list;
|
|
wan_skb_queue_t rx_cmd_list;
|
|
wan_skb_queue_t rx_cmd_free_list;
|
|
|
|
void (*isr_func)(void*);
|
|
void *isr_arg;
|
|
|
|
/* Statistics */
|
|
sdla_usb_comm_err_stats_t stats;
|
|
|
|
|
|
} sdlahw_usb_t;
|
|
#else
|
|
#define WP_USB_BUSID(hwcard) "usb not supported"
|
|
#endif
|
|
|
|
/* This structure keeps common parameters per physical card */
|
|
typedef struct sdlahw_card {
|
|
int internal_used;
|
|
unsigned char name[SDLA_NAME_SIZE]; /* Card name */
|
|
unsigned int hw_type; /* ISA/PCI */
|
|
unsigned int type; /* S50x/S514/ADSL/SDLA_AFT */
|
|
unsigned char cfg_type; /* Config card type WANOPT_XXX */
|
|
unsigned int adptr_type; /* Adapter type */
|
|
unsigned char adptr_subtype; /* Adapter Subtype (Normal|Shark) */
|
|
unsigned char adptr_name[SDLA_NAME_SIZE];
|
|
unsigned char core_id; /* SubSystem ID [0..7] */
|
|
unsigned char core_rev; /* SubSystem ID [8..15] */
|
|
unsigned char pci_extra_ver;
|
|
unsigned int recovery_clock_flag; /* 1 - already used, 0 - not used */
|
|
|
|
union {
|
|
sdlahw_isa_t isa;
|
|
sdlahw_pci_t pci;
|
|
#if defined(CONFIG_PRODUCT_WANPIPE_USB)
|
|
sdlahw_usb_t usb;
|
|
#endif
|
|
} u_hwif;
|
|
#define u_isa u_hwif.isa
|
|
#define u_pci u_hwif.pci
|
|
#define u_usb u_hwif.usb
|
|
|
|
wan_spinlock_t pcard_lock; /* lock per physical card for FE */
|
|
wan_spinlock_t pcard_ec_lock; /* lock per physical card for EC */
|
|
#if 0
|
|
/* moved to cpu, type */
|
|
wan_smp_flag_t fe_rw_flag;
|
|
#endif
|
|
unsigned char adptr_security; /* Adapter security (AFT cards) */
|
|
u16 hwec_chan_no; /* max hwec channels number */
|
|
int hwec_ind; /* hwec index */
|
|
unsigned char cpld_rev;
|
|
|
|
#if defined(__WINDOWS__)
|
|
u16 number_of_ports;/* Number of ports/lines on the card. Initialized exactly one time,
|
|
when add_pci_hw() called for the card for the FIRST time. */
|
|
#endif
|
|
|
|
WAN_LIST_ENTRY(sdlahw_card) next;
|
|
} sdlahw_card_t;
|
|
|
|
typedef struct {
|
|
int usage;
|
|
int total_line_no;
|
|
u_int32_t line_map;
|
|
|
|
wan_smp_flag_t fe_rw_flag;
|
|
wan_spinlock_t pcard_lock; /* lock per physical card for FE */
|
|
} sdlahw_info_t;
|
|
|
|
struct sdlahw_;
|
|
typedef struct sdlahw_cpu
|
|
{
|
|
unsigned magic;
|
|
int internal_used;
|
|
int used;
|
|
|
|
u16 status;
|
|
unsigned fwid; /* firmware ID */
|
|
#if defined(__NetBSD__) || defined(__OpenBSD__)
|
|
bus_space_handle_t ioh; /* adapter I/O port handle */
|
|
bus_dma_tag_t dmat;
|
|
#endif
|
|
int irq; /* interrupt request level */
|
|
#if (defined(__FreeBSD__) && __FreeBSD_version >= 450000)
|
|
void* irqh[SDLA_MAX_HWDEVS];
|
|
#endif
|
|
unsigned int cpu_no; /* PCI CPU Number */
|
|
sdla_mem_handle_t dpmbase; /* dual-port memory base */
|
|
sdla_base_addr_t mem_base_addr;
|
|
unsigned dpmsize; /* dual-port memory size */
|
|
unsigned long memory; /* memory size */
|
|
sdla_mem_handle_t vector; /* local offset of the DPM window */
|
|
|
|
# if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
|
|
void *sdla_dev; /* used only for FreeBSD/OpenBSD */
|
|
# endif
|
|
u16 configured;
|
|
|
|
int max_lines_num; /* maximum number of ports */
|
|
|
|
sdlahw_info_t lines_info[MAX_ADPTRS];
|
|
|
|
u_int32_t reg_line_map; /* configured port */
|
|
int reg_line[SDLA_MAX_HWDEVS];
|
|
struct sdlahw_dev *hwdev[SDLA_MAX_HWDEVS];
|
|
|
|
void *line_ptr_isr_array[SDLA_MAX_HWDEVS];
|
|
|
|
sdlahw_card_t *hwcard;
|
|
WAN_LIST_ENTRY(sdlahw_cpu) next;
|
|
#if defined(__WINDOWS__)
|
|
PHYSICAL_ADDRESS unmapped_memory_base;/* memory BEFORE it was mapped in to virtual space */
|
|
ulong_t unmapped_memory_length;/* actual memory aperture size */
|
|
#endif
|
|
|
|
} sdlahw_cpu_t;
|
|
|
|
typedef struct sdlahw_port_
|
|
{
|
|
int used;
|
|
char *devname;
|
|
sdla_hw_probe_t *hwprobe;
|
|
} sdlahw_port_t;
|
|
|
|
typedef struct sdlahw_dev
|
|
{
|
|
int internal_used;
|
|
int magic;
|
|
int used;
|
|
char *devname;
|
|
unsigned int adptr_type;
|
|
unsigned char cfg_type;
|
|
unsigned int line_no; /* Port number per CPU (line) */
|
|
|
|
int max_chans_num; /* maximum number of channels (timeslots) */
|
|
u_int32_t chans_map; /* channels map per hw device (A200/A400/ISDN) */
|
|
u_int32_t fxo_map; /* FXO channels map per hw device (A200/A400) */
|
|
u_int32_t fxs_map; /* FXS channels map per hw device (A200/A400) */
|
|
int bri_modtype; /* BRI type for hw device (ISDN) */
|
|
|
|
int max_port_no;
|
|
sdlahw_port_t hwport[SDLA_MAX_HWPORTS];
|
|
|
|
sdlahw_cpu_t *hwcpu;
|
|
WAN_LIST_ENTRY(sdlahw_dev) next;
|
|
} sdlahw_t;
|
|
|
|
typedef struct sdlahw_iface
|
|
{
|
|
int (*setup)(void*,wandev_conf_t*);
|
|
int (*load)(void*,void*, unsigned);
|
|
int (*hw_down)(void*);
|
|
int (*start)(sdlahw_t* hw, unsigned addr);
|
|
int (*hw_halt)(void*);
|
|
int (*intack)(void*, uint32_t);
|
|
int (*read_int_stat)(void*, uint32_t*);
|
|
int (*mapmem)(void*, ulong_ptr_t);
|
|
int (*check_mismatch)(void*, unsigned char);
|
|
int (*getcfg)(void*, int, void*);
|
|
int (*get_totalines)(void*,int*);
|
|
int (*setcfg)(void*, int, void*);
|
|
int (*isa_read_1)(void* hw, unsigned int offset, u8*);
|
|
int (*isa_write_1)(void* hw, unsigned int offset, u8);
|
|
int (*io_write_1)(void* hw, unsigned int offset, u8);
|
|
int (*io_read_1)(void* hw, unsigned int offset, u8*);
|
|
int (*bus_write_1)(void* hw, unsigned int offset, u8);
|
|
int (*bus_write_2)(void* hw, unsigned int offset, u16);
|
|
int (*bus_write_4)(void* hw, unsigned int offset, u32);
|
|
int (*bus_read_1)(void* hw, unsigned int offset, u8*);
|
|
int (*bus_read_2)(void* hw, unsigned int offset, u16*);
|
|
int (*bus_read_4)(void* hw, unsigned int offset, u32*);
|
|
int (*pci_write_config_byte)(void* hw, int reg, u8 value);
|
|
int (*pci_write_config_word)(void* hw, int reg, u16 value);
|
|
int (*pci_write_config_dword)(void* hw, int reg, u32 value);
|
|
int (*pci_read_config_byte)(void* hw, int reg, u8* value);
|
|
int (*pci_read_config_word)(void* hw, int reg, u16* value);
|
|
int (*pci_read_config_dword)(void* hw, int reg, u32* value);
|
|
int (*pci_bridge_write_config_dword)(void* hw, int reg, u32 value);
|
|
int (*pci_bridge_write_config_byte)(void* hw, int reg, u_int8_t value);
|
|
int (*pci_bridge_read_config_dword)(void* hw, int reg, u32* value);
|
|
int (*pci_bridge_read_config_byte)(void* hw, int reg, u_int8_t* value);
|
|
int (*cmd)(void* phw, unsigned long offset, wan_mbox_t* mbox);
|
|
int (*peek)(void*,unsigned long, void*,unsigned);
|
|
int (*poke)(void*,unsigned long, void*,unsigned);
|
|
int (*poke_byte)(void*,unsigned long, u8);
|
|
int (*set_bit)(void*,unsigned long, u8);
|
|
int (*clear_bit)(void*,unsigned long,u8);
|
|
int (*set_intrhand)(void*, void (*isr_func)(void*), void*,int);
|
|
int (*restore_intrhand)(void*,int);
|
|
int (*is_te1)(void*);
|
|
int (*is_56k)(void*);
|
|
int (*get_hwcard)(void*, void**);
|
|
int (*get_hwprobe)(void*, int comm_port, void**);
|
|
int (*hw_unlock)(void *phw, wan_smp_flag_t *flag);
|
|
int (*hw_lock)(void *phw, wan_smp_flag_t *flag);
|
|
int (*hw_ec_unlock)(void *phw, wan_smp_flag_t *flag);
|
|
int (*hw_ec_lock)(void *phw, wan_smp_flag_t *flag);
|
|
int (*hw_ec_trylock)(void *phw, wan_smp_flag_t *flag);
|
|
int (*hw_same)(void *phw1, void *phw2);
|
|
int (*hwcpu_same)(void *phw1, void *phw2);
|
|
int (*fe_test_and_set_bit)(void *phw, int value);
|
|
int (*fe_test_bit)(void *phw,int value);
|
|
int (*fe_set_bit)(void *phw,int value);
|
|
int (*fe_clear_bit)(void *phw,int value);
|
|
sdla_dma_addr_t (*pci_map_dma)(void *phw, void *buf, int len, int ctrl);
|
|
int (*pci_unmap_dma)(void *phw, sdla_dma_addr_t buf, int len, int ctrl);
|
|
int (*read_cpld)(void *phw, u16, u8*);
|
|
int (*write_cpld)(void *phw, u16, u8);
|
|
int (*fe_write)(void*, ...);
|
|
u_int8_t (*fe_read)(void*, ...);
|
|
u_int8_t (*__fe_read)(void*, ...);
|
|
wan_dma_descr_t* (*busdma_descr_alloc)(void *phw, int);
|
|
void (*busdma_descr_free)(void *phw, wan_dma_descr_t*);
|
|
int (*busdma_tag_create)(void *phw, wan_dma_descr_t*, u32, u32, int);
|
|
int (*busdma_tag_destroy)(void *phw, wan_dma_descr_t*, int);
|
|
int (*busdma_create)(void *phw, wan_dma_descr_t*);
|
|
int (*busdma_destroy)(void *phw, wan_dma_descr_t*);
|
|
int (*busdma_alloc)(void *phw, wan_dma_descr_t*);
|
|
void (*busdma_free)(void *phw, wan_dma_descr_t*);
|
|
int (*busdma_load)(void *phw, wan_dma_descr_t*, u32);
|
|
void (*busdma_unload)(void *phw, wan_dma_descr_t*);
|
|
void (*busdma_map)(void *phw, wan_dma_descr_t*, void *buf, int len, int map_len, int dir, void *skb);
|
|
void (*busdma_unmap)(void *phw, wan_dma_descr_t*, int dir);
|
|
void (*busdma_sync)(void *phw, wan_dma_descr_t*, int ndescr, int single, int dir);
|
|
char* (*hwec_name)(void *phw);
|
|
int (*get_hwec_index)(void *phw);
|
|
|
|
/* usb function interface (FIXME) */
|
|
int (*usb_cpu_read)(void *phw, unsigned char off, unsigned char *data);
|
|
int (*usb_cpu_write)(void *phw, unsigned char off, unsigned char data);
|
|
int (*usb_write_poll)(void *phw, unsigned char off, unsigned char data);
|
|
int (*usb_read_poll)(void *phw, unsigned char off, unsigned char *data);
|
|
int (*usb_hwec_enable)(void *phw, int, int);
|
|
int (*usb_rxevent_enable)(void *phw, int, int);
|
|
int (*usb_rxevent)(void *phw, int, u8*, int);
|
|
int (*usb_rxtx_data_init)(void *phw, int, unsigned char**, unsigned char**);
|
|
int (*usb_rxdata_enable)(void *phw, int enable);
|
|
int (*usb_fwupdate_enable)(void *phw);
|
|
int (*usb_txdata_raw)(void *phw, unsigned char*, int);
|
|
int (*usb_txdata_raw_ready)(void *phw);
|
|
int (*usb_rxdata_raw)(void *phw, unsigned char*, int);
|
|
int (*usb_err_stats)(void *phw, void*, int);
|
|
int (*usb_flush_err_stats)(void *phw);
|
|
void (*reset_fe)(void*);
|
|
|
|
} sdlahw_iface_t;
|
|
|
|
typedef struct sdla_hw_type_cnt
|
|
{
|
|
unsigned char s508_adapters;
|
|
unsigned char s514x_adapters;
|
|
unsigned char s518_adapters;
|
|
unsigned char aft101_adapters;
|
|
unsigned char aft104_adapters;
|
|
unsigned char aft300_adapters;
|
|
unsigned char aft200_adapters;
|
|
unsigned char aft108_adapters;
|
|
unsigned char aft_isdn_adapters;
|
|
unsigned char aft_56k_adapters;
|
|
unsigned char aft_serial_adapters;
|
|
unsigned char aft_a600_adapters;
|
|
unsigned char aft_b601_adapters;
|
|
unsigned char aft_a700_adapters;
|
|
unsigned char aft_b800_adapters;
|
|
|
|
unsigned char aft_x_adapters;
|
|
unsigned char usb_adapters;
|
|
}sdla_hw_type_cnt_t;
|
|
|
|
typedef struct sdladrv_callback_ {
|
|
int (*add_device)(void);
|
|
int (*delete_device)(char*);
|
|
} sdladrv_callback_t;
|
|
|
|
#if defined(SDLADRV_HW_IFACE)
|
|
typedef struct sdladrv_hw_probe_iface {
|
|
int (*add_pci_hw)(struct pci_dev *pci_dev, int slot, int bus, int irq);
|
|
int (*delete_pci_hw)(struct pci_dev *pci_dev, int slot, int bus, int irq);
|
|
sdlahw_card_t* (*search_sdlahw_card)(u8 hw_type, int slot, int bus);
|
|
} sdladrv_hw_probe_iface_t;
|
|
#endif
|
|
|
|
/****** Function Prototypes *************************************************/
|
|
|
|
WP_EXTERN int sdladrv_hw_mode(int);
|
|
WP_EXTERN unsigned int sdla_hw_probe(void);
|
|
WP_EXTERN unsigned int sdla_hw_bridge_probe(void);
|
|
WP_EXTERN void *sdla_get_hw_probe (void);
|
|
WP_EXTERN void *sdla_get_hw_adptr_cnt(void);
|
|
WP_EXTERN void* sdla_register (sdlahw_iface_t* hw_iface, wandev_conf_t*,char*);
|
|
WP_EXTERN int sdla_unregister (void**, char*);
|
|
#if defined(CONFIG_PRODUCT_WANPIPE_USB)
|
|
WP_EXTERN int sdla_get_hw_usb_adptr_cnt(void);
|
|
#endif
|
|
WP_EXTERN int sdla_get_hwinfo(hardware_info_t *hwinfo, int card_no);
|
|
|
|
|
|
#ifdef __SDLADRV__
|
|
|
|
static __inline unsigned int sdla_get_pci_bus(sdlahw_t* hw)
|
|
{
|
|
sdlahw_card_t *hwcard;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT(hw == NULL);
|
|
WAN_ASSERT(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT(hwcpu->hwcard == NULL);
|
|
hwcard = hwcpu->hwcard;
|
|
#if defined(__FreeBSD__)
|
|
# if (__FreeBSD_version > 400000)
|
|
return pci_get_bus(hwcard->u_pci.pci_dev);
|
|
# else
|
|
return hwcard->u_pci.pci_dev->bus;
|
|
# endif
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
return hwcard->u_pci.pci_dev->pa_bus;
|
|
#elif defined(__LINUX__)
|
|
return ((struct pci_bus*)hwcard->u_pci.pci_dev->bus)->number;
|
|
#elif defined(__WINDOWS__)
|
|
FUNC_NOT_IMPL();
|
|
#else
|
|
# warning "sdla_get_pci_bus: Not supported yet!"
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static __inline unsigned int sdla_get_pci_slot(sdlahw_t* hw)
|
|
{
|
|
sdlahw_card_t *hwcard;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT(hw == NULL);
|
|
WAN_ASSERT(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT(hwcpu->hwcard == NULL);
|
|
hwcard = hwcpu->hwcard;
|
|
#if defined(__FreeBSD__)
|
|
# if (__FreeBSD_version > 400000)
|
|
return pci_get_slot(hwcard->u_pci.pci_dev);
|
|
# else
|
|
return hwcard->u_pci.pci_dev->slot;
|
|
# endif
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
return hwcard->u_pci.pci_dev->pa_device;
|
|
#elif defined(__LINUX__)
|
|
return ((hwcard->u_pci.pci_dev->devfn >> 3) & PCI_DEV_SLOT_MASK);
|
|
#elif defined(__WINDOWS__)
|
|
FUNC_NOT_IMPL();
|
|
#else
|
|
# warning "sdla_get_pci_slot: Not supported yet!"
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static __inline int
|
|
sdla_bus_space_map(sdlahw_t* hw, int reg, int size, sdla_mem_handle_t* handle)
|
|
{
|
|
sdlahw_cpu_t *hwcpu;
|
|
int err = 0;
|
|
|
|
WAN_ASSERT(hw == NULL);
|
|
WAN_ASSERT(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT(hwcpu->hwcard == NULL);
|
|
#if defined(__FreeBSD__)
|
|
*handle = (sdla_mem_handle_t)pmap_mapdev(hwcpu->mem_base_addr + reg, size);
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
err = bus_space_map(hwcpu->hwcard->memt,
|
|
hwcpu->mem_base_addr+reg,
|
|
size,
|
|
0,
|
|
handle);
|
|
#elif defined(__LINUX__)
|
|
*handle = (sdla_mem_handle_t)ioremap(hwcpu->mem_base_addr+reg, size);
|
|
#elif defined(__WINDOWS__)
|
|
{
|
|
PHYSICAL_ADDRESS tmpPA;
|
|
tmpPA.QuadPart = (hwcpu->mem_base_addr+reg);
|
|
*handle = MmMapIoSpace(tmpPA, (ULONG)size, MmNonCached);
|
|
}
|
|
if(*handle == NULL){
|
|
err = 1;
|
|
}
|
|
#else
|
|
# warning "sdla_bus_space_map: Not supported yet!"
|
|
#endif
|
|
return err;
|
|
|
|
}
|
|
|
|
static __inline void
|
|
sdla_bus_space_unmap(sdlahw_t* hw, sdla_mem_handle_t offset, int size)
|
|
{
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT_VOID(hw == NULL);
|
|
WAN_ASSERT_VOID(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT_VOID(hwcpu->hwcard == NULL);
|
|
#if defined(__FreeBSD__)
|
|
int i = 0;
|
|
for (i = 0; i < size; i += PAGE_SIZE){
|
|
pmap_kremove((vm_offset_t)offset + i);
|
|
}
|
|
kmem_free(kernel_map, (vm_offset_t)offset, size);
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
bus_space_unmap(hwcpu->hwcard->memt, offset, size);
|
|
#elif defined(__LINUX__)
|
|
iounmap((void*)offset);
|
|
#elif defined(__WINDOWS__)
|
|
MmUnmapIoSpace(offset, size);
|
|
#else
|
|
# warning "sdla_bus_space_unmap: Not supported yet!"
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
static __inline void
|
|
sdla_bus_set_region_1(sdlahw_t* hw, unsigned int offset, unsigned char val, unsigned int cnt)
|
|
{
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT_VOID(hw == NULL);
|
|
WAN_ASSERT_VOID(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT_VOID(hwcpu->hwcard == NULL);
|
|
#if defined(__FreeBSD__)
|
|
return;
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
bus_space_set_region_1(hwcpu->hwcard->memt, hw->dpmbase, offset, val, cnt);
|
|
#elif defined(__LINUX__)
|
|
wp_memset_io(hwcpu->dpmbase + offset, val, cnt);
|
|
#elif defined(__WINDOWS__)
|
|
wp_memset_io(((u8*)hwcpu->dpmbase) + offset, val, cnt);
|
|
#else
|
|
# warning "sdla_bus_set_region_1: Not supported yet!"
|
|
#endif
|
|
}
|
|
|
|
static __inline int
|
|
sdla_request_mem_region(sdlahw_t* hw, sdla_base_addr_t base_addr, unsigned int len, unsigned char* name, void** pres)
|
|
{
|
|
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
|
|
/* We don't need for BSD */
|
|
return 0;
|
|
#elif defined(__LINUX__)
|
|
void* resource;
|
|
if ((resource = request_mem_region(base_addr, len, name)) == NULL){
|
|
return -EINVAL;
|
|
}
|
|
*pres = resource;
|
|
return 0;
|
|
#elif defined(__WINDOWS__)
|
|
/* request memory for exclusive use - was needed for NT4, not for XP - PnP takes care of it */
|
|
return 0;
|
|
#else
|
|
# warning "sdla_request_mem_region: Not supported yet!"
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
static __inline void
|
|
sdla_release_mem_region(sdlahw_t* hw, sdla_base_addr_t base_addr, unsigned int len)
|
|
{
|
|
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
|
|
return;
|
|
#elif defined(__LINUX__)
|
|
release_mem_region(base_addr, len);
|
|
#elif defined(__WINDOWS__)
|
|
/* release memory from exclusive use */
|
|
#else
|
|
# warning "sdla_release_mem_region: Not supported yet!"
|
|
#endif
|
|
}
|
|
|
|
static __inline int
|
|
sdla_pci_enable_device(sdlahw_t* hw)
|
|
{
|
|
sdlahw_card_t *hwcard;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT(hw == NULL);
|
|
WAN_ASSERT(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT(hwcpu->hwcard == NULL);
|
|
hwcard = hwcpu->hwcard;
|
|
#if defined(__FreeBSD__)
|
|
return pci_enable_io(hwcard->u_pci.pci_dev, SYS_RES_MEMORY);
|
|
#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
|
|
return 0;
|
|
#elif defined(__LINUX__)
|
|
return pci_enable_device(hwcard->u_pci.pci_dev);
|
|
#elif defined(__WINDOWS__)
|
|
return 0;
|
|
#else
|
|
# warning "sdla_release_mem_region: Not supported yet!"
|
|
return -EINVAL;
|
|
#endif
|
|
}
|
|
|
|
static __inline int
|
|
sdla_pci_disable_device(sdlahw_t* hw)
|
|
{
|
|
sdlahw_card_t *hwcard;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT(hw == NULL);
|
|
WAN_ASSERT(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT(hwcpu->hwcard == NULL);
|
|
hwcard = hwcpu->hwcard;
|
|
#if defined(__FreeBSD__)
|
|
return pci_disable_io(hwcard->u_pci.pci_dev, SYS_RES_MEMORY);
|
|
#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
|
|
return 0;
|
|
#elif defined(__LINUX__)
|
|
pci_disable_device(hwcard->u_pci.pci_dev);
|
|
return 0;
|
|
#elif defined(__WINDOWS__)
|
|
return 0;
|
|
#else
|
|
# warning "sdla_release_mem_region: Not supported yet!"
|
|
return -EINVAL;
|
|
#endif
|
|
}
|
|
|
|
static __inline void
|
|
sdla_pci_set_master(sdlahw_t* hw)
|
|
{
|
|
sdlahw_card_t *hwcard;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT1(hw == NULL);
|
|
WAN_ASSERT1(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT1(hwcpu->hwcard == NULL);
|
|
hwcard = hwcpu->hwcard;
|
|
#if defined(__FreeBSD__)
|
|
pci_enable_busmaster(hwcard->u_pci.pci_dev);
|
|
#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
|
|
return;
|
|
#elif defined(__LINUX__)
|
|
pci_set_master(hwcard->u_pci.pci_dev);
|
|
#elif defined(__WINDOWS__)
|
|
#else
|
|
# warning "sdla_pci_set_master: Not supported yet!"
|
|
#endif
|
|
}
|
|
|
|
|
|
static __inline void
|
|
sdla_get_pci_base_resource_addr(sdlahw_t* hw, int pci_offset, sdla_base_addr_t *base_addr)
|
|
{
|
|
sdlahw_card_t *hwcard;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT1(hw == NULL);
|
|
WAN_ASSERT1(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT1(hwcpu->hwcard == NULL);
|
|
hwcard = hwcpu->hwcard;
|
|
|
|
#if defined(__FreeBSD__)
|
|
# if (__FreeBSD_version > 400000)
|
|
*base_addr = (sdla_base_addr_t)pci_read_config(hwcard->u_pci.pci_dev, pci_offset, 4);
|
|
# else
|
|
*base_addr = (sdla_base_addr_t)ci_cfgread(hwcard->u_pci.pci_dev, pci_offset, 4);
|
|
# endif
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
*base_addr = (sdla_base_addr_t)pci_conf_read(hwcard->u_pci.pci_dev->pa_pc, hwcard->u_pci.pci_dev->pa_tag, pci_offset);
|
|
#elif defined(__LINUX__)
|
|
if (pci_offset == PCI_IO_BASE_DWORD){
|
|
*base_addr = (sdla_base_addr_t)pci_resource_start(hwcard->u_pci.pci_dev,0);
|
|
}else{
|
|
*base_addr = (sdla_base_addr_t)pci_resource_start(hwcard->u_pci.pci_dev,1);
|
|
}
|
|
#elif defined(__WINDOWS__)
|
|
switch(pci_offset)
|
|
{
|
|
case PCI_IO_BASE_DWORD:
|
|
/* first aperture */
|
|
*base_addr = (sdla_base_addr_t)pci_resource_start(hwcard->u_pci.pci_dev,0);
|
|
break;
|
|
case PCI_MEM_BASE0_DWORD:
|
|
/* second aperture */
|
|
*base_addr = (sdla_base_addr_t)pci_resource_start(hwcard->u_pci.pci_dev,1);
|
|
break;
|
|
default:
|
|
DEBUG_EVENT("%s(): line: %d: Error: invalid 'pci_offset' (memory aperture) requested: 0x%X\n",
|
|
__FUNCTION__, __LINE__, pci_offset);
|
|
break;
|
|
}
|
|
#else
|
|
# warning "sdla_get_pci_base_resource_addr: Not supported yet!"
|
|
#endif
|
|
}
|
|
|
|
#endif /* __SDLADRV__ */
|
|
|
|
|
|
static __inline int __sdla_bus_read_4(void* phw, unsigned int offset, u32* value)
|
|
{
|
|
sdlahw_t *hw = (sdlahw_t*)phw;
|
|
sdlahw_cpu_t *hwcpu;
|
|
unsigned int retry=3;
|
|
|
|
WAN_ASSERT2(hw == NULL, 0);
|
|
WAN_ASSERT2(hw->hwcpu == NULL, 0);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT2(hwcpu->hwcard == NULL, 0);
|
|
WAN_ASSERT2(hwcpu->dpmbase == 0, 0);
|
|
SDLA_MAGIC(hwcpu);
|
|
|
|
if (!(hwcpu->status & SDLA_MEM_MAPPED)) return 0;
|
|
|
|
do {
|
|
|
|
#if defined(__FreeBSD__)
|
|
*value = readl(((u8*)hw->hwcpu->dpmbase + offset));
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
*value = bus_space_read_4(hw->hwcard->memt, hwcpu->hwcpu->dpmbase, offset);
|
|
#elif defined(__LINUX__)
|
|
*value = wp_readl((unsigned char*)hw->hwcpu->dpmbase + offset);
|
|
#elif defined(__WINDOWS__)
|
|
*value = READ_REGISTER_ULONG((PULONG)((PUCHAR)hw->hwcpu->dpmbase + offset));
|
|
#else
|
|
*value = 0;
|
|
# warning "__sdla_bus_read_4: Not supported yet!"
|
|
#endif
|
|
|
|
if (offset == 0x40 && *value == (u32)-1) {
|
|
if (WAN_NET_RATELIMIT()){
|
|
DEBUG_EVENT("%s:%d: wanpipe PCI Error: Illegal Register read: 0x%04X = 0x%08X\n",
|
|
__FUNCTION__,__LINE__,offset,*value);
|
|
}
|
|
} else {
|
|
/* only check for register 0x40 */
|
|
break;
|
|
}
|
|
|
|
}while(--retry);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static __inline int __sdla_bus_write_4(void* phw, unsigned int offset, u32 value)
|
|
{
|
|
sdlahw_t *hw = (sdlahw_t*)phw;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT(hw == NULL);
|
|
WAN_ASSERT(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
WAN_ASSERT(hwcpu->hwcard == NULL);
|
|
SDLA_MAGIC(hwcpu);
|
|
|
|
if (!(hwcpu->status & SDLA_MEM_MAPPED)) return 0;
|
|
|
|
#if defined(__FreeBSD__)
|
|
writel(((u8*)hwcpu->dpmbase + offset), value);
|
|
#elif defined(__NetBSD__) || defined(__OpenBSD__)
|
|
bus_space_write_4(hwcpu->hwcard->memt, hwcpu->dpmbase, offset, value);
|
|
#elif defined(__LINUX__)
|
|
wp_writel(value,(u8*)hwcpu->dpmbase + offset);
|
|
#elif defined(__WINDOWS__)
|
|
WRITE_REGISTER_ULONG((PULONG)((PUCHAR)hwcpu->dpmbase + offset), value);
|
|
#else
|
|
# warning "__sdla_bus_write_4: Not supported yet!"
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static __inline int __sdla_is_same_hwcard(void* phw1, void *phw2)
|
|
{
|
|
sdlahw_cpu_t *hwcpu1, *hwcpu2;
|
|
|
|
WAN_ASSERT_RC(phw1 == NULL, 0);
|
|
WAN_ASSERT_RC(phw2 == NULL, 0);
|
|
WAN_ASSERT_RC(((sdlahw_t*)phw1)->hwcpu == NULL, 0);
|
|
WAN_ASSERT_RC(((sdlahw_t*)phw2)->hwcpu == NULL, 0);
|
|
hwcpu1 = ((sdlahw_t*)phw1)->hwcpu;
|
|
hwcpu2 = ((sdlahw_t*)phw2)->hwcpu;
|
|
if (hwcpu1->hwcard == hwcpu2->hwcard){
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static __inline void **__sdla_get_ptr_isr_array(void *phw)
|
|
{
|
|
sdlahw_t *hw = (sdlahw_t*)phw;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT_RC(hw == NULL, 0);
|
|
WAN_ASSERT_RC(hw->hwcpu == NULL, 0);
|
|
hwcpu = hw->hwcpu;
|
|
|
|
// return &hwcpu->port_ptr_isr_array[0];
|
|
//return &hwcpu->used_type[hw->cfg_type].port_ptr_isr_array[0];
|
|
return &hwcpu->line_ptr_isr_array[0];
|
|
}
|
|
|
|
static __inline void __sdla_push_ptr_isr_array(void *phw, void *card, int line)
|
|
{
|
|
sdlahw_t *hw = (sdlahw_t*)phw;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT_VOID(hw == NULL);
|
|
WAN_ASSERT_VOID(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
if (line >= SDLA_MAX_HWDEVS) {
|
|
return;
|
|
}
|
|
// hwcpu->port_ptr_isr_array[line]=card;
|
|
//hwcpu->used_type[hw->cfg_type].port_ptr_isr_array[line]=card;
|
|
//hwcpu->used_type[0].port_ptr_isr_array [line]=card;
|
|
hwcpu->line_ptr_isr_array[hw->line_no]=card;
|
|
}
|
|
|
|
static __inline void __sdla_pull_ptr_isr_array(void *phw, void *card, int line)
|
|
{
|
|
sdlahw_t *hw = (sdlahw_t*)phw;
|
|
sdlahw_cpu_t *hwcpu;
|
|
|
|
WAN_ASSERT_VOID(hw == NULL);
|
|
WAN_ASSERT_VOID(hw->hwcpu == NULL);
|
|
hwcpu = hw->hwcpu;
|
|
if (line >= SDLA_MAX_HWDEVS) {
|
|
return;
|
|
}
|
|
|
|
//hwcpu->port_ptr_isr_array[line]=NULL;
|
|
//hwcpu->used_type[hw->cfg_type].port_ptr_isr_array[line]=NULL;
|
|
//hwcpu->used_type[0].port_ptr_isr_array[line]=NULL;
|
|
hwcpu->line_ptr_isr_array[hw->line_no]=NULL;
|
|
return;
|
|
}
|
|
|
|
static __inline u32 SDLA_REG_OFF(sdlahw_card_t *hwcard, u32 reg)
|
|
{
|
|
if (hwcard == NULL) {
|
|
DEBUG_EVENT("sdladrv: Critical error: hw or hw->cpu is NULL\n");
|
|
return reg;
|
|
}
|
|
|
|
if (hwcard->adptr_type == AFT_ADPTR_A600 ||
|
|
hwcard->adptr_type == AFT_ADPTR_B601) {
|
|
if (reg < 0x100) {
|
|
return (reg+0x1000);
|
|
} else {
|
|
return (reg+0x2000);
|
|
}
|
|
}
|
|
|
|
return reg;
|
|
}
|
|
|
|
|
|
#undef WP_EXTERN
|
|
#endif /* _SDLADRV_H */
|