[net-next-2.6.git] / drivers / scsi / qla2xxx / qla_inline.h

/*
 * QLogic Fibre Channel HBA Driver
 * Copyright (c)  2003-2005 QLogic Corporation
 *
 * See LICENSE.qla2xxx for copyright and licensing details.
 */

static __inline__ uint16_t qla2x00_debounce_register(volatile uint16_t __iomem *);
/*
 * qla2x00_debounce_register
 *      Debounce register.
 *
 * Input:
 *      port = register address.
 *
 * Returns:
 *      register value.
 */
static __inline__ uint16_t
qla2x00_debounce_register(volatile uint16_t __iomem *addr)
{
	volatile uint16_t first;
	volatile uint16_t second;

	do {
		first = RD_REG_WORD(addr);
		barrier();
		cpu_relax();
		second = RD_REG_WORD(addr);
	} while (first != second);

	return (first);
}

static __inline__ int qla2x00_normalize_dma_addr(
    dma_addr_t *e_addr,  uint32_t *e_len,
    dma_addr_t *ne_addr, uint32_t *ne_len);

/**
 * qla2x00_normalize_dma_addr() - Normalize an DMA address.
 * @e_addr: Raw DMA address
 * @e_len: Raw DMA length
 * @ne_addr: Normalized second DMA address
 * @ne_len: Normalized second DMA length
 *
 * If the address does not span a 4GB page boundary, the contents of @ne_addr
 * and @ne_len are undefined.  @e_len is updated to reflect a normalization.
 *
 * Example:
 *
 * 	ffffabc0ffffeeee	(e_addr) start of DMA address
 * 	0000000020000000	(e_len)  length of DMA transfer
 *	ffffabc11fffeeed	end of DMA transfer
 *
 * Is the 4GB boundary crossed?
 *
 * 	ffffabc0ffffeeee	(e_addr)
 *	ffffabc11fffeeed	(e_addr + e_len - 1)
 *	00000001e0000003	((e_addr ^ (e_addr + e_len - 1))
 *	0000000100000000	((e_addr ^ (e_addr + e_len - 1)) & ~(0xffffffff)
 *
 * Compute start of second DMA segment:
 *
 * 	ffffabc0ffffeeee	(e_addr)
 *	ffffabc1ffffeeee	(0x100000000 + e_addr)
 *	ffffabc100000000	(0x100000000 + e_addr) & ~(0xffffffff)
 *	ffffabc100000000	(ne_addr)
 *
 * Compute length of second DMA segment:
 *
 *	00000000ffffeeee	(e_addr & 0xffffffff)
 *	0000000000001112	(0x100000000 - (e_addr & 0xffffffff))
 *	000000001fffeeee	(e_len - (0x100000000 - (e_addr & 0xffffffff))
 *	000000001fffeeee	(ne_len)
 *
 * Adjust length of first DMA segment
 *
 * 	0000000020000000	(e_len)
 *	0000000000001112	(e_len - ne_len)
 *	0000000000001112	(e_len)
 *
 * Returns non-zero if the specified address was normalized, else zero.
 */
static __inline__ int
qla2x00_normalize_dma_addr(
    dma_addr_t *e_addr,  uint32_t *e_len,
    dma_addr_t *ne_addr, uint32_t *ne_len)
{
	int normalized;

	normalized = 0;
	if ((*e_addr ^ (*e_addr + *e_len - 1)) & ~(0xFFFFFFFFULL)) {
		/* Compute normalized crossed address and len */
		*ne_addr = (0x100000000ULL + *e_addr) & ~(0xFFFFFFFFULL);
		*ne_len = *e_len - (0x100000000ULL - (*e_addr & 0xFFFFFFFFULL));
		*e_len -= *ne_len;

		normalized++;
	}
	return (normalized);
}

static __inline__ void qla2x00_poll(scsi_qla_host_t *);
static inline void
qla2x00_poll(scsi_qla_host_t *ha)
{
	ha->isp_ops.intr_handler(0, ha);
}

static __inline__ void qla2x00_check_fabric_devices(scsi_qla_host_t *);
/*
 * This routine will wait for fabric devices for
 * the reset delay.
 */
static __inline__ void qla2x00_check_fabric_devices(scsi_qla_host_t *ha)
{
	uint16_t	fw_state;

	qla2x00_get_firmware_state(ha, &fw_state);
}

/**
 * qla2x00_issue_marker() - Issue a Marker IOCB if necessary.
 * @ha: HA context
 * @ha_locked: is function called with the hardware lock
 *
 * Returns non-zero if a failure occured, else zero.
 */
static inline int
qla2x00_issue_marker(scsi_qla_host_t *ha, int ha_locked)
{
	/* Send marker if required */
	if (ha->marker_needed != 0) {
		if (ha_locked) {
			if (__qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) !=
			    QLA_SUCCESS)
				return (QLA_FUNCTION_FAILED);
		} else {
			if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) !=
			    QLA_SUCCESS)
				return (QLA_FUNCTION_FAILED);
		}
		ha->marker_needed = 0;
	}
	return (QLA_SUCCESS);
}

static inline uint8_t *host_to_fcp_swap(uint8_t *, uint32_t);
static inline uint8_t *
host_to_fcp_swap(uint8_t *fcp, uint32_t bsize)
{
       uint32_t *ifcp = (uint32_t *) fcp;
       uint32_t *ofcp = (uint32_t *) fcp;
       uint32_t iter = bsize >> 2;

       for (; iter ; iter--)
               *ofcp++ = swab32(*ifcp++);

       return fcp;
}

static inline int qla2x00_is_reserved_id(scsi_qla_host_t *, uint16_t);
static inline int
qla2x00_is_reserved_id(scsi_qla_host_t *ha, uint16_t loop_id)
{
	if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
		return (loop_id > NPH_LAST_HANDLE);

	return ((loop_id > ha->last_loop_id && loop_id < SNS_FIRST_LOOP_ID) ||
	    loop_id == MANAGEMENT_SERVER || loop_id == BROADCAST);
};
Commit	Line	Data
1da177e4	1	/*
fa90c54f AV	2	* QLogic Fibre Channel HBA Driver
fa90c54f AV	3	* Copyright (c) 2003-2005 QLogic Corporation
1da177e4	4	*
fa90c54f	5	* See LICENSE.qla2xxx for copyright and licensing details.
1da177e4 LT	6	*/
1da177e4 LT	7
1da177e4 LT	8	static __inline__ uint16_t qla2x00_debounce_register(volatile uint16_t __iomem *);
	9	/*
	10	* qla2x00_debounce_register
	11	* Debounce register.
	12	*
	13	* Input:
	14	* port = register address.
	15	*
	16	* Returns:
	17	* register value.
	18	*/
	19	static __inline__ uint16_t
fa2a1ce5	20	qla2x00_debounce_register(volatile uint16_t __iomem *addr)
1da177e4 LT	21	{
	22	volatile uint16_t first;
	23	volatile uint16_t second;
	24
	25	do {
	26	first = RD_REG_WORD(addr);
	27	barrier();
	28	cpu_relax();
	29	second = RD_REG_WORD(addr);
	30	} while (first != second);
	31
	32	return (first);
	33	}
	34
	35	static __inline__ int qla2x00_normalize_dma_addr(
	36	dma_addr_t e_addr, uint32_t e_len,
	37	dma_addr_t ne_addr, uint32_t ne_len);
	38
	39	/**
	40	* qla2x00_normalize_dma_addr() - Normalize an DMA address.
	41	* @e_addr: Raw DMA address
	42	* @e_len: Raw DMA length
	43	* @ne_addr: Normalized second DMA address
	44	* @ne_len: Normalized second DMA length
	45	*
	46	* If the address does not span a 4GB page boundary, the contents of @ne_addr
	47	* and @ne_len are undefined. @e_len is updated to reflect a normalization.
	48	*
	49	* Example:
	50	*
	51	* ffffabc0ffffeeee (e_addr) start of DMA address
	52	* 0000000020000000 (e_len) length of DMA transfer
	53	* ffffabc11fffeeed end of DMA transfer
	54	*
	55	* Is the 4GB boundary crossed?
	56	*
	57	* ffffabc0ffffeeee (e_addr)
	58	* ffffabc11fffeeed (e_addr + e_len - 1)
	59	* 00000001e0000003 ((e_addr ^ (e_addr + e_len - 1))
	60	* 0000000100000000 ((e_addr ^ (e_addr + e_len - 1)) & ~(0xffffffff)
	61	*
	62	* Compute start of second DMA segment:
	63	*
	64	* ffffabc0ffffeeee (e_addr)
	65	* ffffabc1ffffeeee (0x100000000 + e_addr)
	66	* ffffabc100000000 (0x100000000 + e_addr) & ~(0xffffffff)
	67	* ffffabc100000000 (ne_addr)
fa2a1ce5	68	*
1da177e4 LT	69	* Compute length of second DMA segment:
	70	*
	71	* 00000000ffffeeee (e_addr & 0xffffffff)
	72	* 0000000000001112 (0x100000000 - (e_addr & 0xffffffff))
	73	* 000000001fffeeee (e_len - (0x100000000 - (e_addr & 0xffffffff))
	74	* 000000001fffeeee (ne_len)
	75	*
	76	* Adjust length of first DMA segment
	77	*
	78	* 0000000020000000 (e_len)
	79	* 0000000000001112 (e_len - ne_len)
	80	* 0000000000001112 (e_len)
	81	*
	82	* Returns non-zero if the specified address was normalized, else zero.
	83	*/
	84	static __inline__ int
	85	qla2x00_normalize_dma_addr(
	86	dma_addr_t e_addr, uint32_t e_len,
	87	dma_addr_t ne_addr, uint32_t ne_len)
	88	{
	89	int normalized;
	90
	91	normalized = 0;
	92	if ((e_addr ^ (e_addr + *e_len - 1)) & ~(0xFFFFFFFFULL)) {
	93	/* Compute normalized crossed address and len */
	94	ne_addr = (0x100000000ULL + e_addr) & ~(0xFFFFFFFFULL);
	95	ne_len = e_len - (0x100000000ULL - (*e_addr & 0xFFFFFFFFULL));
	96	e_len -= ne_len;
	97
	98	normalized++;
	99	}
	100	return (normalized);
	101	}
	102
	103	static __inline__ void qla2x00_poll(scsi_qla_host_t *);
fa2a1ce5	104	static inline void
1da177e4 LT	105	qla2x00_poll(scsi_qla_host_t *ha)
1da177e4 LT	106	{
7d12e780	107	ha->isp_ops.intr_handler(0, ha);
1da177e4 LT	108	}
1da177e4 LT	109
1da177e4 LT	110	static __inline__ void qla2x00_check_fabric_devices(scsi_qla_host_t *);
	111	/*
	112	* This routine will wait for fabric devices for
	113	* the reset delay.
	114	*/
fa2a1ce5	115	static __inline__ void qla2x00_check_fabric_devices(scsi_qla_host_t *ha)
1da177e4 LT	116	{
	117	uint16_t fw_state;
	118
	119	qla2x00_get_firmware_state(ha, &fw_state);
	120	}
	121
	122	/**
	123	* qla2x00_issue_marker() - Issue a Marker IOCB if necessary.
	124	* @ha: HA context
	125	* @ha_locked: is function called with the hardware lock
	126	*
	127	* Returns non-zero if a failure occured, else zero.
	128	*/
	129	static inline int
	130	qla2x00_issue_marker(scsi_qla_host_t *ha, int ha_locked)
	131	{
	132	/* Send marker if required */
	133	if (ha->marker_needed != 0) {
	134	if (ha_locked) {
	135	if (__qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) !=
	136	QLA_SUCCESS)
	137	return (QLA_FUNCTION_FAILED);
	138	} else {
	139	if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) !=
	140	QLA_SUCCESS)
	141	return (QLA_FUNCTION_FAILED);
	142	}
	143	ha->marker_needed = 0;
	144	}
	145	return (QLA_SUCCESS);
	146	}
	147
2b6c0cee AV	148	static inline uint8_t host_to_fcp_swap(uint8_t , uint32_t);
	149	static inline uint8_t *
	150	host_to_fcp_swap(uint8_t *fcp, uint32_t bsize)
	151	{
	152	uint32_t ifcp = (uint32_t ) fcp;
	153	uint32_t ofcp = (uint32_t ) fcp;
	154	uint32_t iter = bsize >> 2;
	155
	156	for (; iter ; iter--)
	157	ofcp++ = swab32(ifcp++);
	158
	159	return fcp;
	160	}
3d71644c AV	161
	162	static inline int qla2x00_is_reserved_id(scsi_qla_host_t *, uint16_t);
	163	static inline int
	164	qla2x00_is_reserved_id(scsi_qla_host_t *ha, uint16_t loop_id)
	165	{
044cc6c8	166	if (IS_QLA24XX(ha) \|\| IS_QLA54XX(ha))
3d71644c AV	167	return (loop_id > NPH_LAST_HANDLE);
	168
	169	return ((loop_id > ha->last_loop_id && loop_id < SNS_FIRST_LOOP_ID) \|\|
	170	loop_id == MANAGEMENT_SERVER \|\| loop_id == BROADCAST);
	171	};