Merge branch 'fix/asoc' into for-linus
[pandora-kernel.git] / drivers / infiniband / hw / ipath / ipath_eeprom.c
1 /*
2  * Copyright (c) 2006, 2007, 2008 QLogic Corporation. All rights reserved.
3  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/delay.h>
35 #include <linux/pci.h>
36 #include <linux/vmalloc.h>
37
38 #include "ipath_kernel.h"
39
40 /*
41  * InfiniPath I2C driver for a serial eeprom.  This is not a generic
42  * I2C interface.  For a start, the device we're using (Atmel AT24C11)
43  * doesn't work like a regular I2C device.  It looks like one
44  * electrically, but not logically.  Normal I2C devices have a single
45  * 7-bit or 10-bit I2C address that they respond to.  Valid 7-bit
46  * addresses range from 0x03 to 0x77.  Addresses 0x00 to 0x02 and 0x78
47  * to 0x7F are special reserved addresses (e.g. 0x00 is the "general
48  * call" address.)  The Atmel device, on the other hand, responds to ALL
49  * 7-bit addresses.  It's designed to be the only device on a given I2C
50  * bus.  A 7-bit address corresponds to the memory address within the
51  * Atmel device itself.
52  *
53  * Also, the timing requirements mean more than simple software
54  * bitbanging, with readbacks from chip to ensure timing (simple udelay
55  * is not enough).
56  *
57  * This all means that accessing the device is specialized enough
58  * that using the standard kernel I2C bitbanging interface would be
59  * impossible.  For example, the core I2C eeprom driver expects to find
60  * a device at one or more of a limited set of addresses only.  It doesn't
61  * allow writing to an eeprom.  It also doesn't provide any means of
62  * accessing eeprom contents from within the kernel, only via sysfs.
63  */
64
65 /* Added functionality for IBA7220-based cards */
66 #define IPATH_EEPROM_DEV_V1 0xA0
67 #define IPATH_EEPROM_DEV_V2 0xA2
68 #define IPATH_TEMP_DEV 0x98
69 #define IPATH_BAD_DEV (IPATH_EEPROM_DEV_V2+2)
70 #define IPATH_NO_DEV (0xFF)
71
72 /*
73  * The number of I2C chains is proliferating. Table below brings
74  * some order to the madness. The basic principle is that the
75  * table is scanned from the top, and a "probe" is made to the
76  * device probe_dev. If that succeeds, the chain is considered
77  * to be of that type, and dd->i2c_chain_type is set to the index+1
78  * of the entry.
79  * The +1 is so static initialization can mean "unknown, do probe."
80  */
81 static struct i2c_chain_desc {
82         u8 probe_dev;   /* If seen at probe, chain is this type */
83         u8 eeprom_dev;  /* Dev addr (if any) for EEPROM */
84         u8 temp_dev;    /* Dev Addr (if any) for Temp-sense */
85 } i2c_chains[] = {
86         { IPATH_BAD_DEV, IPATH_NO_DEV, IPATH_NO_DEV }, /* pre-iba7220 bds */
87         { IPATH_EEPROM_DEV_V1, IPATH_EEPROM_DEV_V1, IPATH_TEMP_DEV}, /* V1 */
88         { IPATH_EEPROM_DEV_V2, IPATH_EEPROM_DEV_V2, IPATH_TEMP_DEV}, /* V2 */
89         { IPATH_NO_DEV }
90 };
91
92 enum i2c_type {
93         i2c_line_scl = 0,
94         i2c_line_sda
95 };
96
97 enum i2c_state {
98         i2c_line_low = 0,
99         i2c_line_high
100 };
101
102 #define READ_CMD 1
103 #define WRITE_CMD 0
104
105 /**
106  * i2c_gpio_set - set a GPIO line
107  * @dd: the infinipath device
108  * @line: the line to set
109  * @new_line_state: the state to set
110  *
111  * Returns 0 if the line was set to the new state successfully, non-zero
112  * on error.
113  */
114 static int i2c_gpio_set(struct ipath_devdata *dd,
115                         enum i2c_type line,
116                         enum i2c_state new_line_state)
117 {
118         u64 out_mask, dir_mask, *gpioval;
119         unsigned long flags = 0;
120
121         gpioval = &dd->ipath_gpio_out;
122
123         if (line == i2c_line_scl) {
124                 dir_mask = dd->ipath_gpio_scl;
125                 out_mask = (1UL << dd->ipath_gpio_scl_num);
126         } else {
127                 dir_mask = dd->ipath_gpio_sda;
128                 out_mask = (1UL << dd->ipath_gpio_sda_num);
129         }
130
131         spin_lock_irqsave(&dd->ipath_gpio_lock, flags);
132         if (new_line_state == i2c_line_high) {
133                 /* tri-state the output rather than force high */
134                 dd->ipath_extctrl &= ~dir_mask;
135         } else {
136                 /* config line to be an output */
137                 dd->ipath_extctrl |= dir_mask;
138         }
139         ipath_write_kreg(dd, dd->ipath_kregs->kr_extctrl, dd->ipath_extctrl);
140
141         /* set output as well (no real verify) */
142         if (new_line_state == i2c_line_high)
143                 *gpioval |= out_mask;
144         else
145                 *gpioval &= ~out_mask;
146
147         ipath_write_kreg(dd, dd->ipath_kregs->kr_gpio_out, *gpioval);
148         spin_unlock_irqrestore(&dd->ipath_gpio_lock, flags);
149
150         return 0;
151 }
152
153 /**
154  * i2c_gpio_get - get a GPIO line state
155  * @dd: the infinipath device
156  * @line: the line to get
157  * @curr_statep: where to put the line state
158  *
159  * Returns 0 if the line was set to the new state successfully, non-zero
160  * on error.  curr_state is not set on error.
161  */
162 static int i2c_gpio_get(struct ipath_devdata *dd,
163                         enum i2c_type line,
164                         enum i2c_state *curr_statep)
165 {
166         u64 read_val, mask;
167         int ret;
168         unsigned long flags = 0;
169
170         /* check args */
171         if (curr_statep == NULL) {
172                 ret = 1;
173                 goto bail;
174         }
175
176         /* config line to be an input */
177         if (line == i2c_line_scl)
178                 mask = dd->ipath_gpio_scl;
179         else
180                 mask = dd->ipath_gpio_sda;
181
182         spin_lock_irqsave(&dd->ipath_gpio_lock, flags);
183         dd->ipath_extctrl &= ~mask;
184         ipath_write_kreg(dd, dd->ipath_kregs->kr_extctrl, dd->ipath_extctrl);
185         /*
186          * Below is very unlikely to reflect true input state if Output
187          * Enable actually changed.
188          */
189         read_val = ipath_read_kreg64(dd, dd->ipath_kregs->kr_extstatus);
190         spin_unlock_irqrestore(&dd->ipath_gpio_lock, flags);
191
192         if (read_val & mask)
193                 *curr_statep = i2c_line_high;
194         else
195                 *curr_statep = i2c_line_low;
196
197         ret = 0;
198
199 bail:
200         return ret;
201 }
202
203 /**
204  * i2c_wait_for_writes - wait for a write
205  * @dd: the infinipath device
206  *
207  * We use this instead of udelay directly, so we can make sure
208  * that previous register writes have been flushed all the way
209  * to the chip.  Since we are delaying anyway, the cost doesn't
210  * hurt, and makes the bit twiddling more regular
211  */
212 static void i2c_wait_for_writes(struct ipath_devdata *dd)
213 {
214         (void)ipath_read_kreg32(dd, dd->ipath_kregs->kr_scratch);
215         rmb();
216 }
217
218 static void scl_out(struct ipath_devdata *dd, u8 bit)
219 {
220         udelay(1);
221         i2c_gpio_set(dd, i2c_line_scl, bit ? i2c_line_high : i2c_line_low);
222
223         i2c_wait_for_writes(dd);
224 }
225
226 static void sda_out(struct ipath_devdata *dd, u8 bit)
227 {
228         i2c_gpio_set(dd, i2c_line_sda, bit ? i2c_line_high : i2c_line_low);
229
230         i2c_wait_for_writes(dd);
231 }
232
233 static u8 sda_in(struct ipath_devdata *dd, int wait)
234 {
235         enum i2c_state bit;
236
237         if (i2c_gpio_get(dd, i2c_line_sda, &bit))
238                 ipath_dbg("get bit failed!\n");
239
240         if (wait)
241                 i2c_wait_for_writes(dd);
242
243         return bit == i2c_line_high ? 1U : 0;
244 }
245
246 /**
247  * i2c_ackrcv - see if ack following write is true
248  * @dd: the infinipath device
249  */
250 static int i2c_ackrcv(struct ipath_devdata *dd)
251 {
252         u8 ack_received;
253
254         /* AT ENTRY SCL = LOW */
255         /* change direction, ignore data */
256         ack_received = sda_in(dd, 1);
257         scl_out(dd, i2c_line_high);
258         ack_received = sda_in(dd, 1) == 0;
259         scl_out(dd, i2c_line_low);
260         return ack_received;
261 }
262
263 /**
264  * rd_byte - read a byte, leaving ACK, STOP, etc up to caller
265  * @dd: the infinipath device
266  *
267  * Returns byte shifted out of device
268  */
269 static int rd_byte(struct ipath_devdata *dd)
270 {
271         int bit_cntr, data;
272
273         data = 0;
274
275         for (bit_cntr = 7; bit_cntr >= 0; --bit_cntr) {
276                 data <<= 1;
277                 scl_out(dd, i2c_line_high);
278                 data |= sda_in(dd, 0);
279                 scl_out(dd, i2c_line_low);
280         }
281         return data;
282 }
283
284 /**
285  * wr_byte - write a byte, one bit at a time
286  * @dd: the infinipath device
287  * @data: the byte to write
288  *
289  * Returns 0 if we got the following ack, otherwise 1
290  */
291 static int wr_byte(struct ipath_devdata *dd, u8 data)
292 {
293         int bit_cntr;
294         u8 bit;
295
296         for (bit_cntr = 7; bit_cntr >= 0; bit_cntr--) {
297                 bit = (data >> bit_cntr) & 1;
298                 sda_out(dd, bit);
299                 scl_out(dd, i2c_line_high);
300                 scl_out(dd, i2c_line_low);
301         }
302         return (!i2c_ackrcv(dd)) ? 1 : 0;
303 }
304
305 static void send_ack(struct ipath_devdata *dd)
306 {
307         sda_out(dd, i2c_line_low);
308         scl_out(dd, i2c_line_high);
309         scl_out(dd, i2c_line_low);
310         sda_out(dd, i2c_line_high);
311 }
312
313 /**
314  * i2c_startcmd - transmit the start condition, followed by address/cmd
315  * @dd: the infinipath device
316  * @offset_dir: direction byte
317  *
318  *      (both clock/data high, clock high, data low while clock is high)
319  */
320 static int i2c_startcmd(struct ipath_devdata *dd, u8 offset_dir)
321 {
322         int res;
323
324         /* issue start sequence */
325         sda_out(dd, i2c_line_high);
326         scl_out(dd, i2c_line_high);
327         sda_out(dd, i2c_line_low);
328         scl_out(dd, i2c_line_low);
329
330         /* issue length and direction byte */
331         res = wr_byte(dd, offset_dir);
332
333         if (res)
334                 ipath_cdbg(VERBOSE, "No ack to complete start\n");
335
336         return res;
337 }
338
339 /**
340  * stop_cmd - transmit the stop condition
341  * @dd: the infinipath device
342  *
343  * (both clock/data low, clock high, data high while clock is high)
344  */
345 static void stop_cmd(struct ipath_devdata *dd)
346 {
347         scl_out(dd, i2c_line_low);
348         sda_out(dd, i2c_line_low);
349         scl_out(dd, i2c_line_high);
350         sda_out(dd, i2c_line_high);
351         udelay(2);
352 }
353
354 /**
355  * eeprom_reset - reset I2C communication
356  * @dd: the infinipath device
357  */
358
359 static int eeprom_reset(struct ipath_devdata *dd)
360 {
361         int clock_cycles_left = 9;
362         u64 *gpioval = &dd->ipath_gpio_out;
363         int ret;
364         unsigned long flags;
365
366         spin_lock_irqsave(&dd->ipath_gpio_lock, flags);
367         /* Make sure shadows are consistent */
368         dd->ipath_extctrl = ipath_read_kreg64(dd, dd->ipath_kregs->kr_extctrl);
369         *gpioval = ipath_read_kreg64(dd, dd->ipath_kregs->kr_gpio_out);
370         spin_unlock_irqrestore(&dd->ipath_gpio_lock, flags);
371
372         ipath_cdbg(VERBOSE, "Resetting i2c eeprom; initial gpioout reg "
373                    "is %llx\n", (unsigned long long) *gpioval);
374
375         /*
376          * This is to get the i2c into a known state, by first going low,
377          * then tristate sda (and then tristate scl as first thing
378          * in loop)
379          */
380         scl_out(dd, i2c_line_low);
381         sda_out(dd, i2c_line_high);
382
383         /* Clock up to 9 cycles looking for SDA hi, then issue START and STOP */
384         while (clock_cycles_left--) {
385                 scl_out(dd, i2c_line_high);
386
387                 /* SDA seen high, issue START by dropping it while SCL high */
388                 if (sda_in(dd, 0)) {
389                         sda_out(dd, i2c_line_low);
390                         scl_out(dd, i2c_line_low);
391                         /* ATMEL spec says must be followed by STOP. */
392                         scl_out(dd, i2c_line_high);
393                         sda_out(dd, i2c_line_high);
394                         ret = 0;
395                         goto bail;
396                 }
397
398                 scl_out(dd, i2c_line_low);
399         }
400
401         ret = 1;
402
403 bail:
404         return ret;
405 }
406
407 /*
408  * Probe for I2C device at specified address. Returns 0 for "success"
409  * to match rest of this file.
410  * Leave bus in "reasonable" state for further commands.
411  */
412 static int i2c_probe(struct ipath_devdata *dd, int devaddr)
413 {
414         int ret = 0;
415
416         ret = eeprom_reset(dd);
417         if (ret) {
418                 ipath_dev_err(dd, "Failed reset probing device 0x%02X\n",
419                               devaddr);
420                 return ret;
421         }
422         /*
423          * Reset no longer leaves bus in start condition, so normal
424          * i2c_startcmd() will do.
425          */
426         ret = i2c_startcmd(dd, devaddr | READ_CMD);
427         if (ret)
428                 ipath_cdbg(VERBOSE, "Failed startcmd for device 0x%02X\n",
429                            devaddr);
430         else {
431                 /*
432                  * Device did respond. Complete a single-byte read, because some
433                  * devices apparently cannot handle STOP immediately after they
434                  * ACK the start-cmd.
435                  */
436                 int data;
437                 data = rd_byte(dd);
438                 stop_cmd(dd);
439                 ipath_cdbg(VERBOSE, "Response from device 0x%02X\n", devaddr);
440         }
441         return ret;
442 }
443
444 /*
445  * Returns the "i2c type". This is a pointer to a struct that describes
446  * the I2C chain on this board. To minimize impact on struct ipath_devdata,
447  * the (small integer) index into the table is actually memoized, rather
448  * then the pointer.
449  * Memoization is because the type is determined on the first call per chip.
450  * An alternative would be to move type determination to early
451  * init code.
452  */
453 static struct i2c_chain_desc *ipath_i2c_type(struct ipath_devdata *dd)
454 {
455         int idx;
456
457         /* Get memoized index, from previous successful probes */
458         idx = dd->ipath_i2c_chain_type - 1;
459         if (idx >= 0 && idx < (ARRAY_SIZE(i2c_chains) - 1))
460                 goto done;
461
462         idx = 0;
463         while (i2c_chains[idx].probe_dev != IPATH_NO_DEV) {
464                 /* if probe succeeds, this is type */
465                 if (!i2c_probe(dd, i2c_chains[idx].probe_dev))
466                         break;
467                 ++idx;
468         }
469
470         /*
471          * Old EEPROM (first entry) may require a reset after probe,
472          * rather than being able to "start" after "stop"
473          */
474         if (idx == 0)
475                 eeprom_reset(dd);
476
477         if (i2c_chains[idx].probe_dev == IPATH_NO_DEV)
478                 idx = -1;
479         else
480                 dd->ipath_i2c_chain_type = idx + 1;
481 done:
482         return (idx >= 0) ? i2c_chains + idx : NULL;
483 }
484
485 static int ipath_eeprom_internal_read(struct ipath_devdata *dd,
486                                         u8 eeprom_offset, void *buffer, int len)
487 {
488         int ret;
489         struct i2c_chain_desc *icd;
490         u8 *bp = buffer;
491
492         ret = 1;
493         icd = ipath_i2c_type(dd);
494         if (!icd)
495                 goto bail;
496
497         if (icd->eeprom_dev == IPATH_NO_DEV) {
498                 /* legacy not-really-I2C */
499                 ipath_cdbg(VERBOSE, "Start command only address\n");
500                 eeprom_offset = (eeprom_offset << 1) | READ_CMD;
501                 ret = i2c_startcmd(dd, eeprom_offset);
502         } else {
503                 /* Actual I2C */
504                 ipath_cdbg(VERBOSE, "Start command uses devaddr\n");
505                 if (i2c_startcmd(dd, icd->eeprom_dev | WRITE_CMD)) {
506                         ipath_dbg("Failed EEPROM startcmd\n");
507                         stop_cmd(dd);
508                         ret = 1;
509                         goto bail;
510                 }
511                 ret = wr_byte(dd, eeprom_offset);
512                 stop_cmd(dd);
513                 if (ret) {
514                         ipath_dev_err(dd, "Failed to write EEPROM address\n");
515                         ret = 1;
516                         goto bail;
517                 }
518                 ret = i2c_startcmd(dd, icd->eeprom_dev | READ_CMD);
519         }
520         if (ret) {
521                 ipath_dbg("Failed startcmd for dev %02X\n", icd->eeprom_dev);
522                 stop_cmd(dd);
523                 ret = 1;
524                 goto bail;
525         }
526
527         /*
528          * eeprom keeps clocking data out as long as we ack, automatically
529          * incrementing the address.
530          */
531         while (len-- > 0) {
532                 /* get and store data */
533                 *bp++ = rd_byte(dd);
534                 /* send ack if not the last byte */
535                 if (len)
536                         send_ack(dd);
537         }
538
539         stop_cmd(dd);
540
541         ret = 0;
542
543 bail:
544         return ret;
545 }
546
547 static int ipath_eeprom_internal_write(struct ipath_devdata *dd, u8 eeprom_offset,
548                                        const void *buffer, int len)
549 {
550         int sub_len;
551         const u8 *bp = buffer;
552         int max_wait_time, i;
553         int ret;
554         struct i2c_chain_desc *icd;
555
556         ret = 1;
557         icd = ipath_i2c_type(dd);
558         if (!icd)
559                 goto bail;
560
561         while (len > 0) {
562                 if (icd->eeprom_dev == IPATH_NO_DEV) {
563                         if (i2c_startcmd(dd,
564                                          (eeprom_offset << 1) | WRITE_CMD)) {
565                                 ipath_dbg("Failed to start cmd offset %u\n",
566                                         eeprom_offset);
567                                 goto failed_write;
568                         }
569                 } else {
570                         /* Real I2C */
571                         if (i2c_startcmd(dd, icd->eeprom_dev | WRITE_CMD)) {
572                                 ipath_dbg("Failed EEPROM startcmd\n");
573                                 goto failed_write;
574                         }
575                         ret = wr_byte(dd, eeprom_offset);
576                         if (ret) {
577                                 ipath_dev_err(dd, "Failed to write EEPROM "
578                                               "address\n");
579                                 goto failed_write;
580                         }
581                 }
582
583                 sub_len = min(len, 4);
584                 eeprom_offset += sub_len;
585                 len -= sub_len;
586
587                 for (i = 0; i < sub_len; i++) {
588                         if (wr_byte(dd, *bp++)) {
589                                 ipath_dbg("no ack after byte %u/%u (%u "
590                                           "total remain)\n", i, sub_len,
591                                           len + sub_len - i);
592                                 goto failed_write;
593                         }
594                 }
595
596                 stop_cmd(dd);
597
598                 /*
599                  * wait for write complete by waiting for a successful
600                  * read (the chip replies with a zero after the write
601                  * cmd completes, and before it writes to the eeprom.
602                  * The startcmd for the read will fail the ack until
603                  * the writes have completed.   We do this inline to avoid
604                  * the debug prints that are in the real read routine
605                  * if the startcmd fails.
606                  * We also use the proper device address, so it doesn't matter
607                  * whether we have real eeprom_dev. legacy likes any address.
608                  */
609                 max_wait_time = 100;
610                 while (i2c_startcmd(dd, icd->eeprom_dev | READ_CMD)) {
611                         stop_cmd(dd);
612                         if (!--max_wait_time) {
613                                 ipath_dbg("Did not get successful read to "
614                                           "complete write\n");
615                                 goto failed_write;
616                         }
617                 }
618                 /* now read (and ignore) the resulting byte */
619                 rd_byte(dd);
620                 stop_cmd(dd);
621         }
622
623         ret = 0;
624         goto bail;
625
626 failed_write:
627         stop_cmd(dd);
628         ret = 1;
629
630 bail:
631         return ret;
632 }
633
634 /**
635  * ipath_eeprom_read - receives bytes from the eeprom via I2C
636  * @dd: the infinipath device
637  * @eeprom_offset: address to read from
638  * @buffer: where to store result
639  * @len: number of bytes to receive
640  */
641 int ipath_eeprom_read(struct ipath_devdata *dd, u8 eeprom_offset,
642                         void *buff, int len)
643 {
644         int ret;
645
646         ret = mutex_lock_interruptible(&dd->ipath_eep_lock);
647         if (!ret) {
648                 ret = ipath_eeprom_internal_read(dd, eeprom_offset, buff, len);
649                 mutex_unlock(&dd->ipath_eep_lock);
650         }
651
652         return ret;
653 }
654
655 /**
656  * ipath_eeprom_write - writes data to the eeprom via I2C
657  * @dd: the infinipath device
658  * @eeprom_offset: where to place data
659  * @buffer: data to write
660  * @len: number of bytes to write
661  */
662 int ipath_eeprom_write(struct ipath_devdata *dd, u8 eeprom_offset,
663                         const void *buff, int len)
664 {
665         int ret;
666
667         ret = mutex_lock_interruptible(&dd->ipath_eep_lock);
668         if (!ret) {
669                 ret = ipath_eeprom_internal_write(dd, eeprom_offset, buff, len);
670                 mutex_unlock(&dd->ipath_eep_lock);
671         }
672
673         return ret;
674 }
675
676 static u8 flash_csum(struct ipath_flash *ifp, int adjust)
677 {
678         u8 *ip = (u8 *) ifp;
679         u8 csum = 0, len;
680
681         /*
682          * Limit length checksummed to max length of actual data.
683          * Checksum of erased eeprom will still be bad, but we avoid
684          * reading past the end of the buffer we were passed.
685          */
686         len = ifp->if_length;
687         if (len > sizeof(struct ipath_flash))
688                 len = sizeof(struct ipath_flash);
689         while (len--)
690                 csum += *ip++;
691         csum -= ifp->if_csum;
692         csum = ~csum;
693         if (adjust)
694                 ifp->if_csum = csum;
695
696         return csum;
697 }
698
699 /**
700  * ipath_get_guid - get the GUID from the i2c device
701  * @dd: the infinipath device
702  *
703  * We have the capability to use the ipath_nguid field, and get
704  * the guid from the first chip's flash, to use for all of them.
705  */
706 void ipath_get_eeprom_info(struct ipath_devdata *dd)
707 {
708         void *buf;
709         struct ipath_flash *ifp;
710         __be64 guid;
711         int len, eep_stat;
712         u8 csum, *bguid;
713         int t = dd->ipath_unit;
714         struct ipath_devdata *dd0 = ipath_lookup(0);
715
716         if (t && dd0->ipath_nguid > 1 && t <= dd0->ipath_nguid) {
717                 u8 oguid;
718                 dd->ipath_guid = dd0->ipath_guid;
719                 bguid = (u8 *) & dd->ipath_guid;
720
721                 oguid = bguid[7];
722                 bguid[7] += t;
723                 if (oguid > bguid[7]) {
724                         if (bguid[6] == 0xff) {
725                                 if (bguid[5] == 0xff) {
726                                         ipath_dev_err(
727                                                 dd,
728                                                 "Can't set %s GUID from "
729                                                 "base, wraps to OUI!\n",
730                                                 ipath_get_unit_name(t));
731                                         dd->ipath_guid = 0;
732                                         goto bail;
733                                 }
734                                 bguid[5]++;
735                         }
736                         bguid[6]++;
737                 }
738                 dd->ipath_nguid = 1;
739
740                 ipath_dbg("nguid %u, so adding %u to device 0 guid, "
741                           "for %llx\n",
742                           dd0->ipath_nguid, t,
743                           (unsigned long long) be64_to_cpu(dd->ipath_guid));
744                 goto bail;
745         }
746
747         /*
748          * read full flash, not just currently used part, since it may have
749          * been written with a newer definition
750          * */
751         len = sizeof(struct ipath_flash);
752         buf = vmalloc(len);
753         if (!buf) {
754                 ipath_dev_err(dd, "Couldn't allocate memory to read %u "
755                               "bytes from eeprom for GUID\n", len);
756                 goto bail;
757         }
758
759         mutex_lock(&dd->ipath_eep_lock);
760         eep_stat = ipath_eeprom_internal_read(dd, 0, buf, len);
761         mutex_unlock(&dd->ipath_eep_lock);
762
763         if (eep_stat) {
764                 ipath_dev_err(dd, "Failed reading GUID from eeprom\n");
765                 goto done;
766         }
767         ifp = (struct ipath_flash *)buf;
768
769         csum = flash_csum(ifp, 0);
770         if (csum != ifp->if_csum) {
771                 dev_info(&dd->pcidev->dev, "Bad I2C flash checksum: "
772                          "0x%x, not 0x%x\n", csum, ifp->if_csum);
773                 goto done;
774         }
775         if (*(__be64 *) ifp->if_guid == cpu_to_be64(0) ||
776             *(__be64 *) ifp->if_guid == ~cpu_to_be64(0)) {
777                 ipath_dev_err(dd, "Invalid GUID %llx from flash; "
778                               "ignoring\n",
779                               *(unsigned long long *) ifp->if_guid);
780                 /* don't allow GUID if all 0 or all 1's */
781                 goto done;
782         }
783
784         /* complain, but allow it */
785         if (*(u64 *) ifp->if_guid == 0x100007511000000ULL)
786                 dev_info(&dd->pcidev->dev, "Warning, GUID %llx is "
787                          "default, probably not correct!\n",
788                          *(unsigned long long *) ifp->if_guid);
789
790         bguid = ifp->if_guid;
791         if (!bguid[0] && !bguid[1] && !bguid[2]) {
792                 /* original incorrect GUID format in flash; fix in
793                  * core copy, by shifting up 2 octets; don't need to
794                  * change top octet, since both it and shifted are
795                  * 0.. */
796                 bguid[1] = bguid[3];
797                 bguid[2] = bguid[4];
798                 bguid[3] = bguid[4] = 0;
799                 guid = *(__be64 *) ifp->if_guid;
800                 ipath_cdbg(VERBOSE, "Old GUID format in flash, top 3 zero, "
801                            "shifting 2 octets\n");
802         } else
803                 guid = *(__be64 *) ifp->if_guid;
804         dd->ipath_guid = guid;
805         dd->ipath_nguid = ifp->if_numguid;
806         /*
807          * Things are slightly complicated by the desire to transparently
808          * support both the Pathscale 10-digit serial number and the QLogic
809          * 13-character version.
810          */
811         if ((ifp->if_fversion > 1) && ifp->if_sprefix[0]
812                 && ((u8 *)ifp->if_sprefix)[0] != 0xFF) {
813                 /* This board has a Serial-prefix, which is stored
814                  * elsewhere for backward-compatibility.
815                  */
816                 char *snp = dd->ipath_serial;
817                 memcpy(snp, ifp->if_sprefix, sizeof ifp->if_sprefix);
818                 snp[sizeof ifp->if_sprefix] = '\0';
819                 len = strlen(snp);
820                 snp += len;
821                 len = (sizeof dd->ipath_serial) - len;
822                 if (len > sizeof ifp->if_serial) {
823                         len = sizeof ifp->if_serial;
824                 }
825                 memcpy(snp, ifp->if_serial, len);
826         } else
827                 memcpy(dd->ipath_serial, ifp->if_serial,
828                        sizeof ifp->if_serial);
829         if (!strstr(ifp->if_comment, "Tested successfully"))
830                 ipath_dev_err(dd, "Board SN %s did not pass functional "
831                         "test: %s\n", dd->ipath_serial,
832                         ifp->if_comment);
833
834         ipath_cdbg(VERBOSE, "Initted GUID to %llx from eeprom\n",
835                    (unsigned long long) be64_to_cpu(dd->ipath_guid));
836
837         memcpy(&dd->ipath_eep_st_errs, &ifp->if_errcntp, IPATH_EEP_LOG_CNT);
838         /*
839          * Power-on (actually "active") hours are kept as little-endian value
840          * in EEPROM, but as seconds in a (possibly as small as 24-bit)
841          * atomic_t while running.
842          */
843         atomic_set(&dd->ipath_active_time, 0);
844         dd->ipath_eep_hrs = ifp->if_powerhour[0] | (ifp->if_powerhour[1] << 8);
845
846 done:
847         vfree(buf);
848
849 bail:;
850 }
851
852 /**
853  * ipath_update_eeprom_log - copy active-time and error counters to eeprom
854  * @dd: the infinipath device
855  *
856  * Although the time is kept as seconds in the ipath_devdata struct, it is
857  * rounded to hours for re-write, as we have only 16 bits in EEPROM.
858  * First-cut code reads whole (expected) struct ipath_flash, modifies,
859  * re-writes. Future direction: read/write only what we need, assuming
860  * that the EEPROM had to have been "good enough" for driver init, and
861  * if not, we aren't making it worse.
862  *
863  */
864
865 int ipath_update_eeprom_log(struct ipath_devdata *dd)
866 {
867         void *buf;
868         struct ipath_flash *ifp;
869         int len, hi_water;
870         uint32_t new_time, new_hrs;
871         u8 csum;
872         int ret, idx;
873         unsigned long flags;
874
875         /* first, check if we actually need to do anything. */
876         ret = 0;
877         for (idx = 0; idx < IPATH_EEP_LOG_CNT; ++idx) {
878                 if (dd->ipath_eep_st_new_errs[idx]) {
879                         ret = 1;
880                         break;
881                 }
882         }
883         new_time = atomic_read(&dd->ipath_active_time);
884
885         if (ret == 0 && new_time < 3600)
886                 return 0;
887
888         /*
889          * The quick-check above determined that there is something worthy
890          * of logging, so get current contents and do a more detailed idea.
891          * read full flash, not just currently used part, since it may have
892          * been written with a newer definition
893          */
894         len = sizeof(struct ipath_flash);
895         buf = vmalloc(len);
896         ret = 1;
897         if (!buf) {
898                 ipath_dev_err(dd, "Couldn't allocate memory to read %u "
899                                 "bytes from eeprom for logging\n", len);
900                 goto bail;
901         }
902
903         /* Grab semaphore and read current EEPROM. If we get an
904          * error, let go, but if not, keep it until we finish write.
905          */
906         ret = mutex_lock_interruptible(&dd->ipath_eep_lock);
907         if (ret) {
908                 ipath_dev_err(dd, "Unable to acquire EEPROM for logging\n");
909                 goto free_bail;
910         }
911         ret = ipath_eeprom_internal_read(dd, 0, buf, len);
912         if (ret) {
913                 mutex_unlock(&dd->ipath_eep_lock);
914                 ipath_dev_err(dd, "Unable read EEPROM for logging\n");
915                 goto free_bail;
916         }
917         ifp = (struct ipath_flash *)buf;
918
919         csum = flash_csum(ifp, 0);
920         if (csum != ifp->if_csum) {
921                 mutex_unlock(&dd->ipath_eep_lock);
922                 ipath_dev_err(dd, "EEPROM cks err (0x%02X, S/B 0x%02X)\n",
923                                 csum, ifp->if_csum);
924                 ret = 1;
925                 goto free_bail;
926         }
927         hi_water = 0;
928         spin_lock_irqsave(&dd->ipath_eep_st_lock, flags);
929         for (idx = 0; idx < IPATH_EEP_LOG_CNT; ++idx) {
930                 int new_val = dd->ipath_eep_st_new_errs[idx];
931                 if (new_val) {
932                         /*
933                          * If we have seen any errors, add to EEPROM values
934                          * We need to saturate at 0xFF (255) and we also
935                          * would need to adjust the checksum if we were
936                          * trying to minimize EEPROM traffic
937                          * Note that we add to actual current count in EEPROM,
938                          * in case it was altered while we were running.
939                          */
940                         new_val += ifp->if_errcntp[idx];
941                         if (new_val > 0xFF)
942                                 new_val = 0xFF;
943                         if (ifp->if_errcntp[idx] != new_val) {
944                                 ifp->if_errcntp[idx] = new_val;
945                                 hi_water = offsetof(struct ipath_flash,
946                                                 if_errcntp) + idx;
947                         }
948                         /*
949                          * update our shadow (used to minimize EEPROM
950                          * traffic), to match what we are about to write.
951                          */
952                         dd->ipath_eep_st_errs[idx] = new_val;
953                         dd->ipath_eep_st_new_errs[idx] = 0;
954                 }
955         }
956         /*
957          * now update active-time. We would like to round to the nearest hour
958          * but unless atomic_t are sure to be proper signed ints we cannot,
959          * because we need to account for what we "transfer" to EEPROM and
960          * if we log an hour at 31 minutes, then we would need to set
961          * active_time to -29 to accurately count the _next_ hour.
962          */
963         if (new_time >= 3600) {
964                 new_hrs = new_time / 3600;
965                 atomic_sub((new_hrs * 3600), &dd->ipath_active_time);
966                 new_hrs += dd->ipath_eep_hrs;
967                 if (new_hrs > 0xFFFF)
968                         new_hrs = 0xFFFF;
969                 dd->ipath_eep_hrs = new_hrs;
970                 if ((new_hrs & 0xFF) != ifp->if_powerhour[0]) {
971                         ifp->if_powerhour[0] = new_hrs & 0xFF;
972                         hi_water = offsetof(struct ipath_flash, if_powerhour);
973                 }
974                 if ((new_hrs >> 8) != ifp->if_powerhour[1]) {
975                         ifp->if_powerhour[1] = new_hrs >> 8;
976                         hi_water = offsetof(struct ipath_flash, if_powerhour)
977                                         + 1;
978                 }
979         }
980         /*
981          * There is a tiny possibility that we could somehow fail to write
982          * the EEPROM after updating our shadows, but problems from holding
983          * the spinlock too long are a much bigger issue.
984          */
985         spin_unlock_irqrestore(&dd->ipath_eep_st_lock, flags);
986         if (hi_water) {
987                 /* we made some change to the data, uopdate cksum and write */
988                 csum = flash_csum(ifp, 1);
989                 ret = ipath_eeprom_internal_write(dd, 0, buf, hi_water + 1);
990         }
991         mutex_unlock(&dd->ipath_eep_lock);
992         if (ret)
993                 ipath_dev_err(dd, "Failed updating EEPROM\n");
994
995 free_bail:
996         vfree(buf);
997 bail:
998         return ret;
999
1000 }
1001
1002 /**
1003  * ipath_inc_eeprom_err - increment one of the four error counters
1004  * that are logged to EEPROM.
1005  * @dd: the infinipath device
1006  * @eidx: 0..3, the counter to increment
1007  * @incr: how much to add
1008  *
1009  * Each counter is 8-bits, and saturates at 255 (0xFF). They
1010  * are copied to the EEPROM (aka flash) whenever ipath_update_eeprom_log()
1011  * is called, but it can only be called in a context that allows sleep.
1012  * This function can be called even at interrupt level.
1013  */
1014
1015 void ipath_inc_eeprom_err(struct ipath_devdata *dd, u32 eidx, u32 incr)
1016 {
1017         uint new_val;
1018         unsigned long flags;
1019
1020         spin_lock_irqsave(&dd->ipath_eep_st_lock, flags);
1021         new_val = dd->ipath_eep_st_new_errs[eidx] + incr;
1022         if (new_val > 255)
1023                 new_val = 255;
1024         dd->ipath_eep_st_new_errs[eidx] = new_val;
1025         spin_unlock_irqrestore(&dd->ipath_eep_st_lock, flags);
1026         return;
1027 }
1028
1029 static int ipath_tempsense_internal_read(struct ipath_devdata *dd, u8 regnum)
1030 {
1031         int ret;
1032         struct i2c_chain_desc *icd;
1033
1034         ret = -ENOENT;
1035
1036         icd = ipath_i2c_type(dd);
1037         if (!icd)
1038                 goto bail;
1039
1040         if (icd->temp_dev == IPATH_NO_DEV) {
1041                 /* tempsense only exists on new, real-I2C boards */
1042                 ret = -ENXIO;
1043                 goto bail;
1044         }
1045
1046         if (i2c_startcmd(dd, icd->temp_dev | WRITE_CMD)) {
1047                 ipath_dbg("Failed tempsense startcmd\n");
1048                 stop_cmd(dd);
1049                 ret = -ENXIO;
1050                 goto bail;
1051         }
1052         ret = wr_byte(dd, regnum);
1053         stop_cmd(dd);
1054         if (ret) {
1055                 ipath_dev_err(dd, "Failed tempsense WR command %02X\n",
1056                               regnum);
1057                 ret = -ENXIO;
1058                 goto bail;
1059         }
1060         if (i2c_startcmd(dd, icd->temp_dev | READ_CMD)) {
1061                 ipath_dbg("Failed tempsense RD startcmd\n");
1062                 stop_cmd(dd);
1063                 ret = -ENXIO;
1064                 goto bail;
1065         }
1066         /*
1067          * We can only clock out one byte per command, sensibly
1068          */
1069         ret = rd_byte(dd);
1070         stop_cmd(dd);
1071
1072 bail:
1073         return ret;
1074 }
1075
1076 #define VALID_TS_RD_REG_MASK 0xBF
1077
1078 /**
1079  * ipath_tempsense_read - read register of temp sensor via I2C
1080  * @dd: the infinipath device
1081  * @regnum: register to read from
1082  *
1083  * returns reg contents (0..255) or < 0 for error
1084  */
1085 int ipath_tempsense_read(struct ipath_devdata *dd, u8 regnum)
1086 {
1087         int ret;
1088
1089         if (regnum > 7)
1090                 return -EINVAL;
1091
1092         /* return a bogus value for (the one) register we do not have */
1093         if (!((1 << regnum) & VALID_TS_RD_REG_MASK))
1094                 return 0;
1095
1096         ret = mutex_lock_interruptible(&dd->ipath_eep_lock);
1097         if (!ret) {
1098                 ret = ipath_tempsense_internal_read(dd, regnum);
1099                 mutex_unlock(&dd->ipath_eep_lock);
1100         }
1101
1102         /*
1103          * There are three possibilities here:
1104          * ret is actual value (0..255)
1105          * ret is -ENXIO or -EINVAL from code in this file
1106          * ret is -EINTR from mutex_lock_interruptible.
1107          */
1108         return ret;
1109 }
1110
1111 static int ipath_tempsense_internal_write(struct ipath_devdata *dd,
1112                                           u8 regnum, u8 data)
1113 {
1114         int ret = -ENOENT;
1115         struct i2c_chain_desc *icd;
1116
1117         icd = ipath_i2c_type(dd);
1118         if (!icd)
1119                 goto bail;
1120
1121         if (icd->temp_dev == IPATH_NO_DEV) {
1122                 /* tempsense only exists on new, real-I2C boards */
1123                 ret = -ENXIO;
1124                 goto bail;
1125         }
1126         if (i2c_startcmd(dd, icd->temp_dev | WRITE_CMD)) {
1127                 ipath_dbg("Failed tempsense startcmd\n");
1128                 stop_cmd(dd);
1129                 ret = -ENXIO;
1130                 goto bail;
1131         }
1132         ret = wr_byte(dd, regnum);
1133         if (ret) {
1134                 stop_cmd(dd);
1135                 ipath_dev_err(dd, "Failed to write tempsense command %02X\n",
1136                               regnum);
1137                 ret = -ENXIO;
1138                 goto bail;
1139         }
1140         ret = wr_byte(dd, data);
1141         stop_cmd(dd);
1142         ret = i2c_startcmd(dd, icd->temp_dev | READ_CMD);
1143         if (ret) {
1144                 ipath_dev_err(dd, "Failed tempsense data wrt to %02X\n",
1145                               regnum);
1146                 ret = -ENXIO;
1147         }
1148
1149 bail:
1150         return ret;
1151 }
1152
1153 #define VALID_TS_WR_REG_MASK ((1 << 9) | (1 << 0xB) | (1 << 0xD))
1154
1155 /**
1156  * ipath_tempsense_write - write register of temp sensor via I2C
1157  * @dd: the infinipath device
1158  * @regnum: register to write
1159  * @data: data to write
1160  *
1161  * returns 0 for success or < 0 for error
1162  */
1163 int ipath_tempsense_write(struct ipath_devdata *dd, u8 regnum, u8 data)
1164 {
1165         int ret;
1166
1167         if (regnum > 15 || !((1 << regnum) & VALID_TS_WR_REG_MASK))
1168                 return -EINVAL;
1169
1170         ret = mutex_lock_interruptible(&dd->ipath_eep_lock);
1171         if (!ret) {
1172                 ret = ipath_tempsense_internal_write(dd, regnum, data);
1173                 mutex_unlock(&dd->ipath_eep_lock);
1174         }
1175
1176         /*
1177          * There are three possibilities here:
1178          * ret is 0 for success
1179          * ret is -ENXIO or -EINVAL from code in this file
1180          * ret is -EINTR from mutex_lock_interruptible.
1181          */
1182         return ret;
1183 }