powerpc: set the driver.owner field for all vio drivers
[linux-2.6] / drivers / scsi / cpqfcTSi2c.c
1 /* Copyright(c) 2000, Compaq Computer Corporation 
2  * Fibre Channel Host Bus Adapter 
3  * 64-bit, 66MHz PCI 
4  * Originally developed and tested on:
5  * (front): [chip] Tachyon TS HPFC-5166A/1.2  L2C1090 ...
6  *          SP# P225CXCBFIEL6T, Rev XC
7  *          SP# 161290-001, Rev XD
8  * (back): Board No. 010008-001 A/W Rev X5, FAB REV X5
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the
12  * Free Software Foundation; either version 2, or (at your option) any
13  * later version.
14  *
15  * This program is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * General Public License for more details.
19  * Written by Don Zimmerman
20 */
21 // These functions control the NVRAM I2C hardware on 
22 // non-intelligent Fibre Host Adapters.
23 // The primary purpose is to read the HBA's NVRAM to get adapter's 
24 // manufactured WWN to copy into Tachyon chip registers
25 // Orignal source author unknown
26
27 #include <linux/types.h>
28 enum boolean { FALSE, TRUE } ;
29
30
31 #ifndef UCHAR
32 typedef __u8 UCHAR;
33 #endif
34 #ifndef BOOLEAN
35 typedef __u8 BOOLEAN;
36 #endif
37 #ifndef USHORT
38 typedef __u16 USHORT;
39 #endif
40 #ifndef ULONG
41 typedef __u32 ULONG;
42 #endif
43
44
45 #include <linux/string.h>
46 #include <linux/pci.h>
47 #include <linux/delay.h>
48 #include <linux/sched.h>
49 #include <asm/io.h>  // struct pt_regs for IRQ handler & Port I/O
50
51 #include "cpqfcTSchip.h"
52
53 static void tl_i2c_tx_byte( void* GPIOout, UCHAR data );
54 /*static BOOLEAN tl_write_i2c_page_portion( void* GPIOin, void* GPIOout,
55   USHORT startOffset,  // e.g. 0x2f for WWN start
56   USHORT count,
57   UCHAR *buf );
58 */
59
60 //
61 // Tachlite GPIO2, GPIO3 (I2C) DEFINES
62 // The NVRAM chip NM24C03 defines SCL (serial clock) and SDA (serial data)
63 // GPIO2 drives SDA, and GPIO3 drives SCL
64 // 
65 // Since Tachlite inverts the state of the GPIO 0-3 outputs, SET writes 0
66 // and clear writes 1. The input lines (read in TL status) is NOT inverted
67 // This really helps confuse the code and debugging.
68
69 #define SET_DATA_HI  0x0
70 #define SET_DATA_LO  0x8
71 #define SET_CLOCK_HI 0x0
72 #define SET_CLOCK_LO 0x4
73
74 #define SENSE_DATA_HI  0x8
75 #define SENSE_DATA_LO  0x0
76 #define SENSE_CLOCK_HI 0x4
77 #define SENSE_CLOCK_LO 0x0
78
79 #define SLAVE_READ_ADDRESS    0xA1
80 #define SLAVE_WRITE_ADDRESS   0xA0
81                                               
82
83 static void i2c_delay(ULONG mstime);
84 static void tl_i2c_clock_pulse( UCHAR , void* GPIOout);
85 static UCHAR tl_read_i2c_data( void* );
86
87
88 //-----------------------------------------------------------------------------
89 //
90 //      Name:   I2C_RX_ACK
91 //
92 //      This routine receives an acknowledge over the I2C bus.
93 //
94 //-----------------------------------------------------------------------------
95 static unsigned short tl_i2c_rx_ack( void* GPIOin, void* GPIOout )
96 {
97   unsigned long value;
98
99         // do clock pulse, let data line float high
100   tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
101
102         // slave must drive data low for acknowledge
103   value = tl_read_i2c_data( GPIOin);
104   if (value & SENSE_DATA_HI )
105     return( FALSE );
106
107   return( TRUE );
108 }
109 //-----------------------------------------------------------------------------
110 //
111 //      Name:   READ_I2C_REG
112 //
113 //      This routine reads the I2C control register using the global
114 //      IO address stored in gpioreg.
115 //
116 //-----------------------------------------------------------------------------
117 static UCHAR tl_read_i2c_data( void* gpioreg )
118 {
119   return( (UCHAR)(readl( gpioreg ) & 0x08L) ); // GPIO3
120 }
121 //-----------------------------------------------------------------------------
122 //
123 //      Name:   WRITE_I2C_REG
124 //
125 //      This routine writes the I2C control register using the global
126 //      IO address stored in gpioreg.
127 //      In Tachlite, we don't want to modify other bits in TL Control reg.
128 //
129 //-----------------------------------------------------------------------------
130 static void tl_write_i2c_reg( void* gpioregOUT, UCHAR value )
131 {
132   ULONG  temp;
133
134         // First read the register and clear out the old bits
135   temp = readl( gpioregOUT ) & 0xfffffff3L;
136
137         // Now or in the new data and send it back out
138   writel( temp | value, gpioregOUT);
139 }
140 //-----------------------------------------------------------------------------
141 //
142 //      Name:   I2C_TX_START
143 //
144 //      This routine transmits a start condition over the I2C bus.
145 //      1. Set SCL (clock, GPIO2) HIGH, set SDA (data, GPIO3) HIGH,
146 //      wait 5us to stabilize.
147 //      2. With SCL still HIGH, drive SDA low.  The low transition marks
148 //         the start condition to NM24Cxx (the chip)
149 //      NOTE! In TL control reg., output 1 means chip sees LOW
150 //
151 //-----------------------------------------------------------------------------
152 static unsigned short tl_i2c_tx_start( void* GPIOin, void* GPIOout )
153 {
154   unsigned short i;
155   ULONG value;
156
157   if ( !(tl_read_i2c_data(GPIOin) & SENSE_DATA_HI))
158   {
159     // start with clock high, let data float high
160     tl_write_i2c_reg(  GPIOout, SET_DATA_HI | SET_CLOCK_HI );
161
162     // keep sending clock pulses if slave is driving data line
163     for (i = 0; i < 10; i++)
164     {
165       tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
166
167       if ( tl_read_i2c_data(GPIOin) & SENSE_DATA_HI )
168         break;
169     }
170
171                 // if he's still driving data low after 10 clocks, abort
172     value = tl_read_i2c_data( GPIOin ); // read status
173     if (!(value & 0x08) )
174       return( FALSE );
175   }
176
177
178         // To START, bring data low while clock high
179   tl_write_i2c_reg(  GPIOout, SET_CLOCK_HI | SET_DATA_LO );
180
181   i2c_delay(0);
182
183   return( TRUE );                           // TX start successful
184 }
185 //-----------------------------------------------------------------------------
186 //
187 //      Name:   I2C_TX_STOP
188 //
189 //      This routine transmits a stop condition over the I2C bus.
190 //
191 //-----------------------------------------------------------------------------
192
193 static unsigned short tl_i2c_tx_stop( void* GPIOin, void* GPIOout )
194 {
195   int i;
196
197   for (i = 0; i < 10; i++) 
198   {
199   // Send clock pulse, drive data line low
200     tl_i2c_clock_pulse( SET_DATA_LO, GPIOout );
201
202   // To STOP, bring data high while clock high
203     tl_write_i2c_reg(  GPIOout, SET_DATA_HI | SET_CLOCK_HI );
204
205   // Give the data line time to float high
206     i2c_delay(0);
207
208   // If slave is driving data line low, there's a problem; retry
209     if ( tl_read_i2c_data(GPIOin) & SENSE_DATA_HI )
210       return( TRUE );  // TX STOP successful!
211   }
212
213   return( FALSE );                      // error
214 }
215 //-----------------------------------------------------------------------------
216 //
217 //      Name:   I2C_TX_uchar
218 //
219 //      This routine transmits a byte across the I2C bus.
220 //
221 //-----------------------------------------------------------------------------
222 static void tl_i2c_tx_byte( void* GPIOout, UCHAR data )
223 {
224   UCHAR bit;
225
226   for (bit = 0x80; bit; bit >>= 1)
227   {
228     if( data & bit )
229       tl_i2c_clock_pulse( (UCHAR)SET_DATA_HI, GPIOout);
230     else
231       tl_i2c_clock_pulse( (UCHAR)SET_DATA_LO, GPIOout);
232   }  
233 }
234 //-----------------------------------------------------------------------------
235 //
236 //      Name:   I2C_RX_uchar
237 //
238 //      This routine receives a byte across the I2C bus.
239 //
240 //-----------------------------------------------------------------------------
241 static UCHAR tl_i2c_rx_byte( void* GPIOin, void* GPIOout )
242 {
243   UCHAR bit;
244   UCHAR data = 0;
245
246
247   for (bit = 0x80; bit; bit >>= 1) {
248     // do clock pulse, let data line float high
249     tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
250
251     // read data line
252     if ( tl_read_i2c_data( GPIOin) & 0x08 )
253       data |= bit;
254   }
255
256   return (data);
257 }
258 //*****************************************************************************
259 //*****************************************************************************
260 // Function:   read_i2c_nvram
261 // Arguments:  UCHAR count     number of bytes to read
262 //             UCHAR *buf      area to store the bytes read
263 // Returns:    0 - failed
264 //             1 - success
265 //*****************************************************************************
266 //*****************************************************************************
267 unsigned long cpqfcTS_ReadNVRAM( void* GPIOin, void* GPIOout , USHORT count,
268         UCHAR *buf )
269 {
270   unsigned short i;
271
272   if( !( tl_i2c_tx_start(GPIOin, GPIOout) ))
273     return FALSE;
274
275   // Select the NVRAM for "dummy" write, to set the address
276   tl_i2c_tx_byte( GPIOout , SLAVE_WRITE_ADDRESS );
277   if ( !tl_i2c_rx_ack(GPIOin, GPIOout ) )
278     return( FALSE );
279
280   // Now send the address where we want to start reading  
281   tl_i2c_tx_byte( GPIOout , 0 );
282   if ( !tl_i2c_rx_ack(GPIOin, GPIOout ) )
283     return( FALSE );
284
285   // Send a repeated start condition and select the
286   //  slave for reading now.
287   if( tl_i2c_tx_start(GPIOin, GPIOout) )
288     tl_i2c_tx_byte( GPIOout, SLAVE_READ_ADDRESS );
289
290   if ( !tl_i2c_rx_ack(GPIOin, GPIOout) )
291     return( FALSE );
292
293   // this loop will now read out the data and store it
294   //  in the buffer pointed to by buf
295   for ( i=0; i<count; i++) 
296   {
297     *buf++ = tl_i2c_rx_byte(GPIOin, GPIOout);
298
299     // Send ACK by holding data line low for 1 clock
300     if ( i < (count-1) )
301       tl_i2c_clock_pulse( 0x08, GPIOout );
302     else {
303         // Don't send ack for final byte
304       tl_i2c_clock_pulse( SET_DATA_HI, GPIOout );
305     }
306   }
307
308   tl_i2c_tx_stop(GPIOin, GPIOout);
309
310   return( TRUE );
311 }
312
313 //****************************************************************
314 //
315 //
316 //
317 // routines to set and clear the data and clock bits
318 //
319 //
320 //
321 //****************************************************************
322
323 static void tl_set_clock(void* gpioreg)
324 {
325   ULONG ret_val;
326
327   ret_val = readl( gpioreg );
328   ret_val &= 0xffffffFBL;  // clear GPIO2 (SCL)
329   writel( ret_val, gpioreg);
330 }
331
332 static void tl_clr_clock(void* gpioreg)
333 {
334   ULONG ret_val;
335
336   ret_val = readl( gpioreg );
337   ret_val |= SET_CLOCK_LO;
338   writel( ret_val, gpioreg);
339 }
340
341 //*****************************************************************
342 //
343 //
344 // This routine will advance the clock by one period
345 //
346 //
347 //*****************************************************************
348 static void tl_i2c_clock_pulse( UCHAR value, void* GPIOout  )
349 {
350   ULONG ret_val;
351
352   // clear the clock bit
353   tl_clr_clock( GPIOout );
354
355   i2c_delay(0);
356
357
358   // read the port to preserve non-I2C bits
359   ret_val = readl( GPIOout );
360
361   // clear the data & clock bits
362   ret_val &= 0xFFFFFFf3;
363
364   // write the value passed in...
365   // data can only change while clock is LOW!
366   ret_val |= value;           // the data
367   ret_val |= SET_CLOCK_LO;    // the clock
368   writel( ret_val, GPIOout );
369
370   i2c_delay(0);
371
372
373   //set clock bit
374   tl_set_clock( GPIOout);
375 }
376
377
378
379
380 //*****************************************************************
381 //
382 //
383 // This routine returns the 64-bit WWN
384 //
385 //
386 //*****************************************************************
387 int cpqfcTS_GetNVRAM_data( UCHAR *wwnbuf, UCHAR *buf )
388 {
389   ULONG len;
390   ULONG sub_len;
391   ULONG ptr_inc;
392   ULONG i;
393   ULONG j;
394   UCHAR *data_ptr;
395   UCHAR  z;
396   UCHAR  name;
397   UCHAR  sub_name;
398   UCHAR  done;
399   int iReturn=0;  // def. 0 offset is failure to find WWN field
400   
401
402           
403   data_ptr = (UCHAR *)buf;
404
405   done = FALSE;
406   i = 0;
407
408   while ( (i < 128) && (!done) ) 
409   {
410     z = data_ptr[i];\
411     if ( !(z & 0x80) )  
412     {   
413       len  = 1 + (z & 0x07);
414
415       name = (z & 0x78) >> 3;
416       if (name == 0x0F)
417         done = TRUE;
418     }
419     else 
420     {
421       name = z & 0x7F;
422       len  = 3 + data_ptr[i+1] + (data_ptr[i+2] << 8);
423            
424       switch (name) 
425       {
426       case 0x0D:
427         //
428           j = i + 3;
429           //
430           if ( data_ptr[j] == 0x3b ) {
431             len = 6;
432             break;
433           }
434
435           while ( j<(i+len) ) {
436             sub_name = (data_ptr[j] & 0x3f);
437             sub_len  = data_ptr[j+1] + 
438                        (data_ptr[j+2] << 8);
439             ptr_inc  = sub_len + 3; 
440             switch (sub_name) 
441             {
442             case 0x3C:
443               memcpy( wwnbuf, &data_ptr[j+3], 8);
444               iReturn = j+3;
445               break;
446             default:
447               break;
448             }
449             j += ptr_inc;
450           }
451           break;
452         default:
453           break;
454       }  
455     }  
456   //
457     i += len;
458   }  // end while 
459   return iReturn;
460 }
461
462
463
464
465
466 // define a short 5 micro sec delay, and longer (ms) delay
467
468 static void i2c_delay(ULONG mstime)
469 {
470   ULONG i;
471   
472 // NOTE: we only expect to use these delays when reading
473 // our adapter's NVRAM, which happens only during adapter reset.
474 // Delay technique from "Linux Device Drivers", A. Rubini 
475 // (1st Ed.) pg 137.
476
477 //  printk(" delay %lx  ", mstime);
478   if( mstime ) // ms delay?
479   {
480     // delay technique
481     for( i=0; i < mstime; i++)
482       udelay(1000); // 1ms per loop
483         
484   }
485   else  // 5 micro sec delay
486   
487     udelay( 5 ); // micro secs
488   
489 //  printk("done\n");
490 }
491
492
493