pcibr_reg.c

来自「Linux Kernel 2.6.9 for OMAP1710」· C语言 代码 · 共 880 行 · 第 1/2 页

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2003 Silicon Graphics, Inc. All rights reserved.
 */

#include <linux/types.h>
#include <asm/sn/sgi.h>
#include <asm/sn/addrs.h>
#include <asm/sn/pci/pcibr.h>
#include <asm/sn/pci/pcibr_private.h>
#include <asm/sn/pci/pci_defs.h>


/*
 * Identification Register Access -- Read Only			    0000_0000 
 */
static uint64_t
__pcireg_id_get(pic_t *bridge)
{
	return bridge->p_wid_id;
}

uint64_t
pcireg_bridge_id_get(void *ptr)
{
	return __pcireg_id_get((pic_t *)ptr);
}

uint64_t
pcireg_id_get(pcibr_soft_t ptr)
{
	return __pcireg_id_get((pic_t *)ptr->bs_base);
}



/*
 * Address Bus Side Holding Register Access -- Read Only	    0000_0010
 */
uint64_t
pcireg_bus_err_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_wid_err;
}


/*
 * Control Register Access -- Read/Write			    0000_0020
 */
static uint64_t
__pcireg_control_get(pic_t *bridge)
{
	return bridge->p_wid_control;
}

uint64_t
pcireg_bridge_control_get(void *ptr)
{
	return __pcireg_control_get((pic_t *)ptr);
}

uint64_t
pcireg_control_get(pcibr_soft_t ptr)
{
	return __pcireg_control_get((pic_t *)ptr->bs_base);
}


void
pcireg_control_set(pcibr_soft_t ptr, uint64_t val)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	/* WAR for PV 439897 & 454474.  Add a readback of the control 
	 * register.  Lock to protect against MP accesses to this
	 * register along with other write-only registers (See PVs).
	 * This register isnt accessed in the "hot path" so the splhi
	 * shouldn't be a bottleneck
	 */

	bridge->p_wid_control = val;
	bridge->p_wid_control;	/* WAR */
}


void
pcireg_control_bit_clr(pcibr_soft_t ptr, uint64_t bits)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	/* WAR for PV 439897 & 454474.  Add a readback of the control
	 * register.  Lock to protect against MP accesses to this
	 * register along with other write-only registers (See PVs).
	 * This register isnt accessed in the "hot path" so the splhi
	 * shouldn't be a bottleneck
	 */

	bridge->p_wid_control &= ~bits;
	bridge->p_wid_control;	/* WAR */
}


void
pcireg_control_bit_set(pcibr_soft_t ptr, uint64_t bits)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	/* WAR for PV 439897 & 454474.  Add a readback of the control
	 * register.  Lock to protect against MP accesses to this
	 * register along with other write-only registers (See PVs).
	 * This register isnt accessed in the "hot path" so the splhi
	 * shouldn't be a bottleneck
	 */

	bridge->p_wid_control |= bits;
	bridge->p_wid_control;	/* WAR */
}

/*
 * Bus Speed (from control register); -- Read Only access	    0000_0020
 * 0x00 == 33MHz, 0x01 == 66MHz, 0x10 == 100MHz, 0x11 == 133MHz
 */
uint64_t
pcireg_speed_get(pcibr_soft_t ptr)
{
	uint64_t speedbits;
	pic_t *bridge = (pic_t *)ptr->bs_base;

	speedbits = bridge->p_wid_control & PIC_CTRL_PCI_SPEED;
	return (speedbits >> 4);
}

/*
 * Bus Mode (ie. PCIX or PCI) (from Status register);		    0000_0008
 * 0x0 == PCI, 0x1 == PCI-X
 */
uint64_t
pcireg_mode_get(pcibr_soft_t ptr)
{
	uint64_t pcix_active_bit;
	pic_t *bridge = (pic_t *)ptr->bs_base;

	pcix_active_bit = bridge->p_wid_stat & PIC_STAT_PCIX_ACTIVE;
	return (pcix_active_bit >> PIC_STAT_PCIX_ACTIVE_SHFT);
}

void
pcireg_req_timeout_set(pcibr_soft_t ptr, uint64_t val)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_wid_req_timeout = val;
}

/*
 * Interrupt Destination Addr Register Access -- Read/Write	    0000_0038
 */

void
pcireg_intr_dst_set(pcibr_soft_t ptr, uint64_t val)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_wid_int = val;
}

/*
 * Intr Destination Addr Reg Access (target_id) -- Read/Write	    0000_0038
 */
uint64_t
pcireg_intr_dst_target_id_get(pcibr_soft_t ptr)
{
	uint64_t tid_bits;
	pic_t *bridge = (pic_t *)ptr->bs_base;

	tid_bits = (bridge->p_wid_int & PIC_INTR_DEST_TID);
	return (tid_bits >> PIC_INTR_DEST_TID_SHFT);
}

void
pcireg_intr_dst_target_id_set(pcibr_soft_t ptr, uint64_t target_id)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_wid_int &= ~PIC_INTR_DEST_TID;
	bridge->p_wid_int |=
		    ((target_id << PIC_INTR_DEST_TID_SHFT) & PIC_INTR_DEST_TID);
}

/*
 * Intr Destination Addr Register Access (addr) -- Read/Write	    0000_0038
 */
uint64_t
pcireg_intr_dst_addr_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_wid_int & PIC_XTALK_ADDR_MASK;
}

void
pcireg_intr_dst_addr_set(pcibr_soft_t ptr, uint64_t addr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_wid_int &= ~PIC_XTALK_ADDR_MASK;
	bridge->p_wid_int |= (addr & PIC_XTALK_ADDR_MASK);
}

/*
 * Cmd Word Holding Bus Side Error Register Access -- Read Only	    0000_0040
 */
uint64_t
pcireg_cmdword_err_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_wid_err_cmdword;
}

/*
 * PCI/PCIX Target Flush Register Access -- Read Only		    0000_0050
 */
uint64_t
pcireg_tflush_get(pcibr_soft_t ptr)
{
	uint64_t ret = 0;
	pic_t *bridge = (pic_t *)ptr->bs_base;

	ret = bridge->p_wid_tflush;

	/* Read of the Targer Flush should always return zero */
	ASSERT_ALWAYS(ret == 0);
	return ret;
}

/*
 * Cmd Word Holding Link Side Error Register Access -- Read Only    0000_0058
 */
uint64_t
pcireg_linkside_err_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_wid_aux_err;
}

/*
 * PCI Response Buffer Address Holding Register -- Read Only	    0000_0068
 */
uint64_t
pcireg_resp_err_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_wid_resp;
}

/*
 * PCI Resp Buffer Address Holding Reg (Address) -- Read Only	    0000_0068
 */
uint64_t
pcireg_resp_err_addr_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_wid_resp & PIC_RSP_BUF_ADDR;
}

/*
 * PCI Resp Buffer Address Holding Register (Buffer)-- Read Only    0000_0068
 */
uint64_t
pcireg_resp_err_buf_get(pcibr_soft_t ptr)
{
	uint64_t bufnum_bits;
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bufnum_bits = (bridge->p_wid_resp_upper & PIC_RSP_BUF_NUM);
	return (bufnum_bits >> PIC_RSP_BUF_NUM_SHFT);
}

/*
 * PCI Resp Buffer Address Holding Register (Device)-- Read Only    0000_0068
 */
uint64_t
pcireg_resp_err_dev_get(pcibr_soft_t ptr)
{
	uint64_t devnum_bits;
	pic_t *bridge = (pic_t *)ptr->bs_base;

	devnum_bits = (bridge->p_wid_resp_upper & PIC_RSP_BUF_DEV_NUM);
	return (devnum_bits >> PIC_RSP_BUF_DEV_NUM_SHFT);
}

/*
 * Address Holding Register Link Side Errors -- Read Only	    0000_0078
 */
uint64_t
pcireg_linkside_err_addr_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_wid_addr_lkerr;
}

void
pcireg_dirmap_wid_set(pcibr_soft_t ptr, uint64_t target)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_dir_map &= ~PIC_DIRMAP_WID;
	bridge->p_dir_map |=
		    ((target << PIC_DIRMAP_WID_SHFT) & PIC_DIRMAP_WID);
}

void
pcireg_dirmap_diroff_set(pcibr_soft_t ptr, uint64_t dir_off)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_dir_map &= ~PIC_DIRMAP_DIROFF;
	bridge->p_dir_map |= (dir_off & PIC_DIRMAP_DIROFF);
}

void
pcireg_dirmap_add512_set(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_dir_map |= PIC_DIRMAP_ADD512;
}

void
pcireg_dirmap_add512_clr(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_dir_map &= ~PIC_DIRMAP_ADD512;
}

/*
 * PCI Page Map Fault Address Register Access -- Read Only	    0000_0090
 */
uint64_t
pcireg_map_fault_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_map_fault;
}

/*
 * Arbitration Register Access -- Read/Write			    0000_00A0
 */
uint64_t
pcireg_arbitration_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_arb;
}

void
pcireg_arbitration_bit_set(pcibr_soft_t ptr, uint64_t bits)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_arb |= bits;
}

/*
 * Internal Ram Parity Error Register Access -- Read Only	    0000_00B0
 */
uint64_t
pcireg_parity_err_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_ate_parity_err;
}

/*
 * Type 1 Configuration Register Access -- Read/Write		    0000_00C8
 */
void
pcireg_type1_cntr_set(pcibr_soft_t ptr, uint64_t val)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	bridge->p_pci_cfg = val;
}

/*
 * PCI Bus Error Lower Addr Holding Reg Access -- Read Only	    0000_00D8
 */
uint64_t
pcireg_pci_bus_addr_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_pci_err;
}

/*
 * PCI Bus Error Addr Holding Reg Access (Address) -- Read Only	    0000_00D8
 */
uint64_t
pcireg_pci_bus_addr_addr_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_pci_err & PIC_XTALK_ADDR_MASK;
}

/*
 * Interrupt Status Register Access -- Read Only		    0000_0100
 */
uint64_t
pcireg_intr_status_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_int_status;
}

/*
 * Interrupt Enable Register Access -- Read/Write		    0000_0108
 */
uint64_t
pcireg_intr_enable_get(pcibr_soft_t ptr)
{
	pic_t *bridge = (pic_t *)ptr->bs_base;

	return bridge->p_int_enable;