494 lines
12 KiB
C
494 lines
12 KiB
C
/* Copyright(c) 2000, Compaq Computer Corporation
|
|
* Fibre Channel Host Bus Adapter
|
|
* 64-bit, 66MHz PCI
|
|
* Originally developed and tested on:
|
|
* (front): [chip] Tachyon TS HPFC-5166A/1.2 L2C1090 ...
|
|
* SP# P225CXCBFIEL6T, Rev XC
|
|
* SP# 161290-001, Rev XD
|
|
* (back): Board No. 010008-001 A/W Rev X5, FAB REV X5
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2, or (at your option) any
|
|
* later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
* Written by Don Zimmerman
|
|
*/
|
|
// These functions control the NVRAM I2C hardware on
|
|
// non-intelligent Fibre Host Adapters.
|
|
// The primary purpose is to read the HBA's NVRAM to get adapter's
|
|
// manufactured WWN to copy into Tachyon chip registers
|
|
// Orignal source author unknown
|
|
|
|
#include <linux/types.h>
|
|
enum boolean { FALSE, TRUE } ;
|
|
|
|
|
|
#ifndef UCHAR
|
|
typedef __u8 UCHAR;
|
|
#endif
|
|
#ifndef BOOLEAN
|
|
typedef __u8 BOOLEAN;
|
|
#endif
|
|
#ifndef USHORT
|
|
typedef __u16 USHORT;
|
|
#endif
|
|
#ifndef ULONG
|
|
typedef __u32 ULONG;
|
|
#endif
|
|
|
|
|
|
#include <linux/string.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/sched.h>
|
|
#include <asm/io.h> // struct pt_regs for IRQ handler & Port I/O
|
|
|
|
#include "cpqfcTSchip.h"
|
|
|
|
static void tl_i2c_tx_byte( void* GPIOout, UCHAR data );
|
|
/*static BOOLEAN tl_write_i2c_page_portion( void* GPIOin, void* GPIOout,
|
|
USHORT startOffset, // e.g. 0x2f for WWN start
|
|
USHORT count,
|
|
UCHAR *buf );
|
|
*/
|
|
|
|
//
|
|
// Tachlite GPIO2, GPIO3 (I2C) DEFINES
|
|
// The NVRAM chip NM24C03 defines SCL (serial clock) and SDA (serial data)
|
|
// GPIO2 drives SDA, and GPIO3 drives SCL
|
|
//
|
|
// Since Tachlite inverts the state of the GPIO 0-3 outputs, SET writes 0
|
|
// and clear writes 1. The input lines (read in TL status) is NOT inverted
|
|
// This really helps confuse the code and debugging.
|
|
|
|
#define SET_DATA_HI 0x0
|
|
#define SET_DATA_LO 0x8
|
|
#define SET_CLOCK_HI 0x0
|
|
#define SET_CLOCK_LO 0x4
|
|
|
|
#define SENSE_DATA_HI 0x8
|
|
#define SENSE_DATA_LO 0x0
|
|
#define SENSE_CLOCK_HI 0x4
|
|
#define SENSE_CLOCK_LO 0x0
|
|
|
|
#define SLAVE_READ_ADDRESS 0xA1
|
|
#define SLAVE_WRITE_ADDRESS 0xA0
|
|
|
|
|
|
static void i2c_delay(ULONG mstime);
|
|
static void tl_i2c_clock_pulse( UCHAR , void* GPIOout);
|
|
static UCHAR tl_read_i2c_data( void* );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Name: I2C_RX_ACK
|
|
//
|
|
// This routine receives an acknowledge over the I2C bus.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static unsigned short tl_i2c_rx_ack( void* GPIOin, void* GPIOout )
|
|
{
|
|
unsigned long value;
|
|
|
|
// do clock pulse, let data line float high
|
|
tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
|
|
|
|
// slave must drive data low for acknowledge
|
|
value = tl_read_i2c_data( GPIOin);
|
|
if (value & SENSE_DATA_HI )
|
|
return( FALSE );
|
|
|
|
return( TRUE );
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Name: READ_I2C_REG
|
|
//
|
|
// This routine reads the I2C control register using the global
|
|
// IO address stored in gpioreg.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static UCHAR tl_read_i2c_data( void* gpioreg )
|
|
{
|
|
return( (UCHAR)(readl( gpioreg ) & 0x08L) ); // GPIO3
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Name: WRITE_I2C_REG
|
|
//
|
|
// This routine writes the I2C control register using the global
|
|
// IO address stored in gpioreg.
|
|
// In Tachlite, we don't want to modify other bits in TL Control reg.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static void tl_write_i2c_reg( void* gpioregOUT, UCHAR value )
|
|
{
|
|
ULONG temp;
|
|
|
|
// First read the register and clear out the old bits
|
|
temp = readl( gpioregOUT ) & 0xfffffff3L;
|
|
|
|
// Now or in the new data and send it back out
|
|
writel( temp | value, gpioregOUT);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Name: I2C_TX_START
|
|
//
|
|
// This routine transmits a start condition over the I2C bus.
|
|
// 1. Set SCL (clock, GPIO2) HIGH, set SDA (data, GPIO3) HIGH,
|
|
// wait 5us to stabilize.
|
|
// 2. With SCL still HIGH, drive SDA low. The low transition marks
|
|
// the start condition to NM24Cxx (the chip)
|
|
// NOTE! In TL control reg., output 1 means chip sees LOW
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static unsigned short tl_i2c_tx_start( void* GPIOin, void* GPIOout )
|
|
{
|
|
unsigned short i;
|
|
ULONG value;
|
|
|
|
if ( !(tl_read_i2c_data(GPIOin) & SENSE_DATA_HI))
|
|
{
|
|
// start with clock high, let data float high
|
|
tl_write_i2c_reg( GPIOout, SET_DATA_HI | SET_CLOCK_HI );
|
|
|
|
// keep sending clock pulses if slave is driving data line
|
|
for (i = 0; i < 10; i++)
|
|
{
|
|
tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
|
|
|
|
if ( tl_read_i2c_data(GPIOin) & SENSE_DATA_HI )
|
|
break;
|
|
}
|
|
|
|
// if he's still driving data low after 10 clocks, abort
|
|
value = tl_read_i2c_data( GPIOin ); // read status
|
|
if (!(value & 0x08) )
|
|
return( FALSE );
|
|
}
|
|
|
|
|
|
// To START, bring data low while clock high
|
|
tl_write_i2c_reg( GPIOout, SET_CLOCK_HI | SET_DATA_LO );
|
|
|
|
i2c_delay(0);
|
|
|
|
return( TRUE ); // TX start successful
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Name: I2C_TX_STOP
|
|
//
|
|
// This routine transmits a stop condition over the I2C bus.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static unsigned short tl_i2c_tx_stop( void* GPIOin, void* GPIOout )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 10; i++)
|
|
{
|
|
// Send clock pulse, drive data line low
|
|
tl_i2c_clock_pulse( SET_DATA_LO, GPIOout );
|
|
|
|
// To STOP, bring data high while clock high
|
|
tl_write_i2c_reg( GPIOout, SET_DATA_HI | SET_CLOCK_HI );
|
|
|
|
// Give the data line time to float high
|
|
i2c_delay(0);
|
|
|
|
// If slave is driving data line low, there's a problem; retry
|
|
if ( tl_read_i2c_data(GPIOin) & SENSE_DATA_HI )
|
|
return( TRUE ); // TX STOP successful!
|
|
}
|
|
|
|
return( FALSE ); // error
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Name: I2C_TX_uchar
|
|
//
|
|
// This routine transmits a byte across the I2C bus.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static void tl_i2c_tx_byte( void* GPIOout, UCHAR data )
|
|
{
|
|
UCHAR bit;
|
|
|
|
for (bit = 0x80; bit; bit >>= 1)
|
|
{
|
|
if( data & bit )
|
|
tl_i2c_clock_pulse( (UCHAR)SET_DATA_HI, GPIOout);
|
|
else
|
|
tl_i2c_clock_pulse( (UCHAR)SET_DATA_LO, GPIOout);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Name: I2C_RX_uchar
|
|
//
|
|
// This routine receives a byte across the I2C bus.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static UCHAR tl_i2c_rx_byte( void* GPIOin, void* GPIOout )
|
|
{
|
|
UCHAR bit;
|
|
UCHAR data = 0;
|
|
|
|
|
|
for (bit = 0x80; bit; bit >>= 1) {
|
|
// do clock pulse, let data line float high
|
|
tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
|
|
|
|
// read data line
|
|
if ( tl_read_i2c_data( GPIOin) & 0x08 )
|
|
data |= bit;
|
|
}
|
|
|
|
return (data);
|
|
}
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
// Function: read_i2c_nvram
|
|
// Arguments: UCHAR count number of bytes to read
|
|
// UCHAR *buf area to store the bytes read
|
|
// Returns: 0 - failed
|
|
// 1 - success
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
unsigned long cpqfcTS_ReadNVRAM( void* GPIOin, void* GPIOout , USHORT count,
|
|
UCHAR *buf )
|
|
{
|
|
unsigned short i;
|
|
|
|
if( !( tl_i2c_tx_start(GPIOin, GPIOout) ))
|
|
return FALSE;
|
|
|
|
// Select the NVRAM for "dummy" write, to set the address
|
|
tl_i2c_tx_byte( GPIOout , SLAVE_WRITE_ADDRESS );
|
|
if ( !tl_i2c_rx_ack(GPIOin, GPIOout ) )
|
|
return( FALSE );
|
|
|
|
// Now send the address where we want to start reading
|
|
tl_i2c_tx_byte( GPIOout , 0 );
|
|
if ( !tl_i2c_rx_ack(GPIOin, GPIOout ) )
|
|
return( FALSE );
|
|
|
|
// Send a repeated start condition and select the
|
|
// slave for reading now.
|
|
if( tl_i2c_tx_start(GPIOin, GPIOout) )
|
|
tl_i2c_tx_byte( GPIOout, SLAVE_READ_ADDRESS );
|
|
|
|
if ( !tl_i2c_rx_ack(GPIOin, GPIOout) )
|
|
return( FALSE );
|
|
|
|
// this loop will now read out the data and store it
|
|
// in the buffer pointed to by buf
|
|
for ( i=0; i<count; i++)
|
|
{
|
|
*buf++ = tl_i2c_rx_byte(GPIOin, GPIOout);
|
|
|
|
// Send ACK by holding data line low for 1 clock
|
|
if ( i < (count-1) )
|
|
tl_i2c_clock_pulse( 0x08, GPIOout );
|
|
else {
|
|
// Don't send ack for final byte
|
|
tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
|
|
}
|
|
}
|
|
|
|
tl_i2c_tx_stop(GPIOin, GPIOout);
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
//****************************************************************
|
|
//
|
|
//
|
|
//
|
|
// routines to set and clear the data and clock bits
|
|
//
|
|
//
|
|
//
|
|
//****************************************************************
|
|
|
|
static void tl_set_clock(void* gpioreg)
|
|
{
|
|
ULONG ret_val;
|
|
|
|
ret_val = readl( gpioreg );
|
|
ret_val &= 0xffffffFBL; // clear GPIO2 (SCL)
|
|
writel( ret_val, gpioreg);
|
|
}
|
|
|
|
static void tl_clr_clock(void* gpioreg)
|
|
{
|
|
ULONG ret_val;
|
|
|
|
ret_val = readl( gpioreg );
|
|
ret_val |= SET_CLOCK_LO;
|
|
writel( ret_val, gpioreg);
|
|
}
|
|
|
|
//*****************************************************************
|
|
//
|
|
//
|
|
// This routine will advance the clock by one period
|
|
//
|
|
//
|
|
//*****************************************************************
|
|
static void tl_i2c_clock_pulse( UCHAR value, void* GPIOout )
|
|
{
|
|
ULONG ret_val;
|
|
|
|
// clear the clock bit
|
|
tl_clr_clock( GPIOout );
|
|
|
|
i2c_delay(0);
|
|
|
|
|
|
// read the port to preserve non-I2C bits
|
|
ret_val = readl( GPIOout );
|
|
|
|
// clear the data & clock bits
|
|
ret_val &= 0xFFFFFFf3;
|
|
|
|
// write the value passed in...
|
|
// data can only change while clock is LOW!
|
|
ret_val |= value; // the data
|
|
ret_val |= SET_CLOCK_LO; // the clock
|
|
writel( ret_val, GPIOout );
|
|
|
|
i2c_delay(0);
|
|
|
|
|
|
//set clock bit
|
|
tl_set_clock( GPIOout);
|
|
}
|
|
|
|
|
|
|
|
|
|
//*****************************************************************
|
|
//
|
|
//
|
|
// This routine returns the 64-bit WWN
|
|
//
|
|
//
|
|
//*****************************************************************
|
|
int cpqfcTS_GetNVRAM_data( UCHAR *wwnbuf, UCHAR *buf )
|
|
{
|
|
ULONG len;
|
|
ULONG sub_len;
|
|
ULONG ptr_inc;
|
|
ULONG i;
|
|
ULONG j;
|
|
UCHAR *data_ptr;
|
|
UCHAR z;
|
|
UCHAR name;
|
|
UCHAR sub_name;
|
|
UCHAR done;
|
|
int iReturn=0; // def. 0 offset is failure to find WWN field
|
|
|
|
|
|
|
|
data_ptr = (UCHAR *)buf;
|
|
|
|
done = FALSE;
|
|
i = 0;
|
|
|
|
while ( (i < 128) && (!done) )
|
|
{
|
|
z = data_ptr[i];\
|
|
if ( !(z & 0x80) )
|
|
{
|
|
len = 1 + (z & 0x07);
|
|
|
|
name = (z & 0x78) >> 3;
|
|
if (name == 0x0F)
|
|
done = TRUE;
|
|
}
|
|
else
|
|
{
|
|
name = z & 0x7F;
|
|
len = 3 + data_ptr[i+1] + (data_ptr[i+2] << 8);
|
|
|
|
switch (name)
|
|
{
|
|
case 0x0D:
|
|
//
|
|
j = i + 3;
|
|
//
|
|
if ( data_ptr[j] == 0x3b ) {
|
|
len = 6;
|
|
break;
|
|
}
|
|
|
|
while ( j<(i+len) ) {
|
|
sub_name = (data_ptr[j] & 0x3f);
|
|
sub_len = data_ptr[j+1] +
|
|
(data_ptr[j+2] << 8);
|
|
ptr_inc = sub_len + 3;
|
|
switch (sub_name)
|
|
{
|
|
case 0x3C:
|
|
memcpy( wwnbuf, &data_ptr[j+3], 8);
|
|
iReturn = j+3;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
j += ptr_inc;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
i += len;
|
|
} // end while
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// define a short 5 micro sec delay, and longer (ms) delay
|
|
|
|
static void i2c_delay(ULONG mstime)
|
|
{
|
|
ULONG i;
|
|
|
|
// NOTE: we only expect to use these delays when reading
|
|
// our adapter's NVRAM, which happens only during adapter reset.
|
|
// Delay technique from "Linux Device Drivers", A. Rubini
|
|
// (1st Ed.) pg 137.
|
|
|
|
// printk(" delay %lx ", mstime);
|
|
if( mstime ) // ms delay?
|
|
{
|
|
// delay technique
|
|
for( i=0; i < mstime; i++)
|
|
udelay(1000); // 1ms per loop
|
|
|
|
}
|
|
else // 5 micro sec delay
|
|
|
|
udelay( 5 ); // micro secs
|
|
|
|
// printk("done\n");
|
|
}
|
|
|
|
|
|
|