source: SVN/rincon/u-boot/board/trab/cmd_trab.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 20.1 KB
Line 
1/*
2 * (C) Copyright 2003
3 * Martin Krause, TQ-Systems GmbH, martin.krause@tqs.de.
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21 * MA 02111-1307 USA
22 */
23
24#undef DEBUG
25
26#include <common.h>
27#include <command.h>
28#include <s3c2400.h>
29#include <rtc.h>
30
31/*
32 * TRAB board specific commands. Especially commands for burn-in and function
33 * test.
34 */
35#if defined(CONFIG_CMD_BSP)
36
37/* limits for valid range of VCC5V in mV  */
38#define VCC5V_MIN       4500
39#define VCC5V_MAX       5500
40
41/*
42 * Test strings for EEPROM test. Length of string 2 must not exceed length of
43 * string 1. Otherwise a buffer overrun could occur!
44 */
45#define EEPROM_TEST_STRING_1    "0987654321 :tset a si siht"
46#define EEPROM_TEST_STRING_2    "this is a test: 1234567890"
47
48/*
49 * min/max limits for valid contact temperature during burn in test (in
50 * degree Centigrade * 100)
51 */
52#define MIN_CONTACT_TEMP        -1000
53#define MAX_CONTACT_TEMP        +9000
54
55/* blinking frequency of status LED */
56#define LED_BLINK_FREQ          5
57
58/* delay time between burn in cycles in seconds */
59#ifndef BURN_IN_CYCLE_DELAY     /* if not defined in include/configs/trab.h */
60#define BURN_IN_CYCLE_DELAY     5
61#endif
62
63/* physical SRAM parameters */
64#define SRAM_ADDR       0x02000000 /* GCS1 */
65#define SRAM_SIZE       0x40000 /* 256 kByte */
66
67/* CPLD-Register for controlling TRAB hardware functions */
68#define CPLD_BUTTONS            ((volatile unsigned long *)0x04020000)
69#define CPLD_FILL_LEVEL         ((volatile unsigned long *)0x04008000)
70#define CPLD_ROTARY_SWITCH      ((volatile unsigned long *)0x04018000)
71#define CPLD_RS485_RE           ((volatile unsigned long *)0x04028000)
72
73/* I2C EEPROM device address */
74#define I2C_EEPROM_DEV_ADDR     0x54
75
76/* EEPROM address map */
77#define EE_ADDR_TEST                    192
78#define EE_ADDR_MAX_CYCLES              256
79#define EE_ADDR_STATUS                  258
80#define EE_ADDR_PASS_CYCLES             259
81#define EE_ADDR_FIRST_ERROR_CYCLE       261
82#define EE_ADDR_FIRST_ERROR_NUM         263
83#define EE_ADDR_FIRST_ERROR_NAME        264
84#define EE_ADDR_ACT_CYCLE               280
85
86/* Bit definitions for ADCCON */
87#define ADC_ENABLE_START     0x1
88#define ADC_READ_START       0x2
89#define ADC_STDBM            0x4
90#define ADC_INP_AIN0         (0x0 << 3)
91#define ADC_INP_AIN1         (0x1 << 3)
92#define ADC_INP_AIN2         (0x2 << 3)
93#define ADC_INP_AIN3         (0x3 << 3)
94#define ADC_INP_AIN4         (0x4 << 3)
95#define ADC_INP_AIN5         (0x5 << 3)
96#define ADC_INP_AIN6         (0x6 << 3)
97#define ADC_INP_AIN7         (0x7 << 3)
98#define ADC_PRSCEN           0x4000
99#define ADC_ECFLG            0x800
100
101/* misc */
102
103/* externals */
104extern int memory_post_tests (unsigned long start, unsigned long size);
105extern int i2c_write (uchar, uint, int , uchar* , int);
106extern int i2c_read (uchar, uint, int , uchar* , int);
107extern void tsc2000_reg_init (void);
108extern s32 tsc2000_contact_temp (void);
109extern void spi_init(void);
110
111/* function declarations */
112int do_dip (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
113int do_vcc5v (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
114int do_burn_in (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
115int do_contact_temp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
116int do_burn_in_status (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
117int i2c_write_multiple (uchar chip, uint addr, int alen,
118                        uchar *buffer, int len);
119int i2c_read_multiple (uchar chip, uint addr, int alen,
120                        uchar *buffer, int len);
121int do_temp_log (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
122
123/* helper functions */
124static void adc_init (void);
125static int adc_read (unsigned int channel);
126static int read_dip (void);
127static int read_vcc5v (void);
128static int test_dip (void);
129static int test_vcc5v (void);
130static int test_rotary_switch (void);
131static int test_sram (void);
132static int test_eeprom (void);
133static int test_contact_temp (void);
134static void led_set (unsigned int);
135static void led_blink (void);
136static void led_init (void);
137static void sdelay (unsigned long seconds); /* delay in seconds */
138static int dummy (void);
139static int read_max_cycles(void);
140static void test_function_table_init (void);
141static void global_vars_init (void);
142static int global_vars_write_to_eeprom (void);
143
144/* globals */
145u16 max_cycles;
146u8 status;
147u16 pass_cycles;
148u16 first_error_cycle;
149u8 first_error_num;
150char first_error_name[16];
151u16 act_cycle;
152
153typedef struct test_function_s {
154        char *name;
155        int (*pf)(void);
156} test_function_t;
157
158/* max number of Burn In Functions */
159#define BIF_MAX 6
160
161/* table with burn in functions */
162test_function_t test_function[BIF_MAX];
163
164
165int do_burn_in (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
166{
167        int i;
168        int cycle_status;
169
170        if (argc > 1) {
171                printf ("Usage:\n%s\n", cmdtp->usage);
172                return 1;
173        }
174
175        led_init ();
176        global_vars_init ();
177        test_function_table_init ();
178        spi_init ();
179
180        if (global_vars_write_to_eeprom () != 0) {
181                printf ("%s: error writing global_vars to eeprom\n",
182                        __FUNCTION__);
183                return (1);
184        }
185
186        if (read_max_cycles () != 0) {
187                printf ("%s: error reading max_cycles from eeprom\n",
188                        __FUNCTION__);
189                return (1);
190        }
191
192        if (max_cycles == 0) {
193                printf ("%s: error, burn in max_cycles = 0\n", __FUNCTION__);
194                return (1);
195        }
196
197        status = 0;
198        for (act_cycle = 1; act_cycle <= max_cycles; act_cycle++) {
199
200                cycle_status = 0;
201
202                /*
203                 * avoid timestamp overflow problem after about 68 minutes of
204                 * udelay() time.
205                 */
206                reset_timer_masked ();
207                for (i = 0; i < BIF_MAX; i++) {
208
209                        /* call test function */
210                        if ((*test_function[i].pf)() != 0) {
211                                printf ("error in %s test\n",
212                                        test_function[i].name);
213
214                                /* is it the first error? */
215                                if (status == 0) {
216                                        status = 1;
217                                        first_error_cycle = act_cycle;
218
219                                        /* do not use error_num 0 */
220                                        first_error_num = i+1;
221                                        strncpy (first_error_name,
222                                                 test_function[i].name,
223                                                 sizeof (first_error_name));
224                                        led_set (0);
225                                }
226                                cycle_status = 1;
227                        }
228                }
229                /* were all tests of actual cycle OK? */
230                if (cycle_status == 0)
231                        pass_cycles++;
232
233                /* set status LED if no error is occoured since yet */
234                if (status == 0)
235                        led_set (1);
236
237                printf ("%s: cycle %d finished\n", __FUNCTION__, act_cycle);
238
239                /* pause between cycles */
240                sdelay (BURN_IN_CYCLE_DELAY);
241        }
242
243        if (global_vars_write_to_eeprom () != 0) {
244                led_set (0);
245                printf ("%s: error writing global_vars to eeprom\n",
246                        __FUNCTION__);
247                status = 1;
248        }
249
250        if (status == 0) {
251                led_blink ();   /* endless loop!! */
252                return (0);
253        } else {
254                led_set (0);
255                return (1);
256        }
257}
258
259U_BOOT_CMD(
260        burn_in,        1,      1,      do_burn_in,
261        "burn_in - start burn-in test application on TRAB\n",
262        "\n"
263        "    -  start burn-in test application\n"
264        "       The burn-in test could took a while to finish!\n"
265        "       The content of the onboard EEPROM is modified!\n"
266);
267
268
269int do_dip (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
270{
271        int i, dip;
272
273        if (argc > 1) {
274                printf ("Usage:\n%s\n", cmdtp->usage);
275                return 1;
276        }
277
278        if ((dip = read_dip ()) == -1) {
279                return 1;
280        }
281
282        for (i = 0; i < 4; i++) {
283                if ((dip & (1 << i)) == 0)
284                        printf("0");
285                else
286                        printf("1");
287        }
288        printf("\n");
289
290        return 0;
291}
292
293U_BOOT_CMD(
294        dip,    1,      1,      do_dip,
295        "dip     - read dip switch on TRAB\n",
296        "\n"
297        "    - read state of dip switch (S1) on TRAB board\n"
298        "      read sequence: 1-2-3-4; ON=1; OFF=0; e.g.: \"0100\"\n"
299);
300
301
302int do_vcc5v (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
303{
304        int vcc5v;
305
306        if (argc > 1) {
307                printf ("Usage:\n%s\n", cmdtp->usage);
308                return 1;
309        }
310
311        if ((vcc5v = read_vcc5v ()) == -1) {
312                return (1);
313        }
314
315        printf ("%d", (vcc5v / 1000));
316        printf (".%d", (vcc5v % 1000) / 100);
317        printf ("%d V\n", (vcc5v % 100) / 10) ;
318
319        return 0;
320}
321
322U_BOOT_CMD(
323        vcc5v,  1,      1,      do_vcc5v,
324        "vcc5v   - read VCC5V on TRAB\n",
325        "\n"
326        "    - read actual value of voltage VCC5V\n"
327);
328
329
330int do_contact_temp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
331{
332        int contact_temp;
333
334        if (argc > 1) {
335                printf ("Usage:\n%s\n", cmdtp->usage);
336                return 1;
337        }
338
339        spi_init ();
340
341        contact_temp = tsc2000_contact_temp();
342        printf ("%d degree C * 100\n", contact_temp) ;
343
344        return 0;
345}
346
347U_BOOT_CMD(
348        c_temp, 1,      1,      do_contact_temp,
349        "c_temp  - read contact temperature on TRAB\n",
350        "\n"
351        "    -  reads the onboard temperature (=contact temperature)\n"
352);
353
354
355int do_burn_in_status (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
356{
357        if (argc > 1) {
358                printf ("Usage:\n%s\n", cmdtp->usage);
359                return 1;
360        }
361
362        if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_STATUS, 1,
363                                (unsigned char*) &status, 1)) {
364                return (1);
365        }
366        if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_PASS_CYCLES, 1,
367                                (unsigned char*) &pass_cycles, 2)) {
368                return (1);
369        }
370        if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_FIRST_ERROR_CYCLE,
371                                1, (unsigned char*) &first_error_cycle, 2)) {
372                return (1);
373        }
374        if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_FIRST_ERROR_NUM,
375                                1, (unsigned char*) &first_error_num, 1)) {
376                return (1);
377        }
378        if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_FIRST_ERROR_NAME,
379                               1, (unsigned char*)first_error_name,
380                               sizeof (first_error_name))) {
381                return (1);
382        }
383
384        if (read_max_cycles () != 0) {
385                return (1);
386        }
387
388        printf ("max_cycles = %d\n", max_cycles);
389        printf ("status = %d\n", status);
390        printf ("pass_cycles = %d\n", pass_cycles);
391        printf ("first_error_cycle = %d\n", first_error_cycle);
392        printf ("first_error_num = %d\n", first_error_num);
393        printf ("first_error_name = %.*s\n",(int) sizeof(first_error_name),
394                first_error_name);
395
396        return 0;
397}
398
399U_BOOT_CMD(
400        bis,    1,      1,      do_burn_in_status,
401        "bis     - print burn in status on TRAB\n",
402        "\n"
403        "    -  prints the status variables of the last burn in test\n"
404        "       stored in the onboard EEPROM on TRAB board\n"
405);
406
407static int read_dip (void)
408{
409        unsigned int result = 0;
410        int adc_val;
411        int i;
412
413        /***********************************************************
414         DIP switch connection (according to wa4-cpu.sp.301.pdf, page 3):
415           SW1 - AIN4
416           SW2 - AIN5
417           SW3 - AIN6
418           SW4 - AIN7
419
420           "On" DIP switch position short-circuits the voltage from
421           the input channel (i.e. '0' conversion result means "on").
422        *************************************************************/
423
424        for (i = 7; i > 3; i--) {
425
426                if ((adc_val = adc_read (i)) == -1) {
427                        printf ("%s: Channel %d could not be read\n",
428                                 __FUNCTION__, i);
429                        return (-1);
430                }
431
432                /*
433                 * Input voltage (switch open) is 1.8 V.
434                 * (Vin_High/VRef)*adc_res = (1,8V/2,5V)*1023) = 736
435                 * Set trigger at halve that value.
436                 */
437                if (adc_val < 368)
438                        result |= (1 << (i-4));
439        }
440        return (result);
441}
442
443
444static int read_vcc5v (void)
445{
446        s32 result;
447
448        /* VCC5V is connected to channel 2 */
449
450        if ((result = adc_read (2)) == -1) {
451                printf ("%s: VCC5V could not be read\n", __FUNCTION__);
452                return (-1);
453        }
454        /*
455         * Calculate voltage value. Split in two parts because there is no
456         * floating point support.  VCC5V is connected over an resistor divider:
457         * VCC5V=ADCval*2,5V/1023*(10K+30K)/10K.
458         */
459        result = result * 10 * 1000 / 1023; /* result in mV */
460
461        return (result);
462}
463
464
465static int test_dip (void)
466{
467        static int first_run = 1;
468        static int first_dip;
469
470        if (first_run) {
471                if ((first_dip = read_dip ()) == -1) {
472                        return (1);
473                }
474                first_run = 0;
475                debug ("%s: first_dip=%d\n", __FUNCTION__, first_dip);
476        }
477        if (first_dip != read_dip ()) {
478                return (1);
479        } else {
480                return (0);
481        }
482}
483
484
485static int test_vcc5v (void)
486{
487        int vcc5v;
488
489        if ((vcc5v = read_vcc5v ()) == -1) {
490                return (1);
491        }
492
493        if ((vcc5v > VCC5V_MAX) || (vcc5v < VCC5V_MIN)) {
494                printf ("%s: vcc5v[V/100]=%d\n", __FUNCTION__, vcc5v);
495                return (1);
496        } else {
497                return (0);
498        }
499}
500
501
502static int test_rotary_switch (void)
503{
504        static int first_run = 1;
505        static int first_rs;
506
507        if (first_run) {
508                /*
509                 * clear bits in CPLD, because they have random values after
510                 * power-up or reset.
511                 */
512                *CPLD_ROTARY_SWITCH |= (1 << 16) | (1 << 17);
513
514                first_rs = ((*CPLD_ROTARY_SWITCH >> 16) & 0x7);
515                first_run = 0;
516                debug ("%s: first_rs=%d\n", __FUNCTION__, first_rs);
517        }
518
519        if (first_rs != ((*CPLD_ROTARY_SWITCH >> 16) & 0x7)) {
520                return (1);
521        } else {
522                return (0);
523        }
524}
525
526
527static int test_sram (void)
528{
529        return (memory_post_tests (SRAM_ADDR, SRAM_SIZE));
530}
531
532
533static int test_eeprom (void)
534{
535        unsigned char temp[sizeof (EEPROM_TEST_STRING_1)];
536        int result = 0;
537
538        /* write test string 1, read back and verify */
539        if (i2c_write_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_TEST, 1,
540                                (unsigned char*)EEPROM_TEST_STRING_1,
541                                sizeof (EEPROM_TEST_STRING_1))) {
542                return (1);
543        }
544
545        if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_TEST, 1,
546                               temp, sizeof (EEPROM_TEST_STRING_1))) {
547                return (1);
548        }
549
550        if (strcmp ((char *)temp, EEPROM_TEST_STRING_1) != 0) {
551                result = 1;
552                printf ("%s: error; read_str = \"%s\"\n", __FUNCTION__, temp);
553        }
554
555        /* write test string 2, read back and verify */
556        if (result == 0) {
557                if (i2c_write_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_TEST, 1,
558                                        (unsigned char*)EEPROM_TEST_STRING_2,
559                                        sizeof (EEPROM_TEST_STRING_2))) {
560                        return (1);
561                }
562
563                if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_TEST, 1,
564                                       temp, sizeof (EEPROM_TEST_STRING_2))) {
565                        return (1);
566                }
567
568                if (strcmp ((char *)temp, EEPROM_TEST_STRING_2) != 0) {
569                        result = 1;
570                        printf ("%s: error; read str = \"%s\"\n",
571                                __FUNCTION__, temp);
572                }
573        }
574        return (result);
575}
576
577
578static int test_contact_temp (void)
579{
580        int contact_temp;
581
582        contact_temp = tsc2000_contact_temp ();
583
584        if ((contact_temp < MIN_CONTACT_TEMP)
585            || (contact_temp > MAX_CONTACT_TEMP))
586                return (1);
587        else
588                return (0);
589}
590
591
592int i2c_write_multiple (uchar chip, uint addr, int alen,
593                        uchar *buffer, int len)
594{
595        int i;
596
597        if (alen != 1) {
598                printf ("%s: addr len other than 1 not supported\n",
599                         __FUNCTION__);
600                return (1);
601        }
602
603        for (i = 0; i < len; i++) {
604                if (i2c_write (chip, addr+i, alen, buffer+i, 1)) {
605                        printf ("%s: could not write to i2c device %d"
606                                 ", addr %d\n", __FUNCTION__, chip, addr);
607                        return (1);
608                }
609#if 0
610                printf ("chip=%#x, addr+i=%#x+%d=%p, alen=%d, *buffer+i="
611                        "%#x+%d=%p=\"%.1s\"\n", chip, addr, i, addr+i,
612                        alen, buffer, i, buffer+i, buffer+i);
613#endif
614
615                udelay (30000);
616        }
617        return (0);
618}
619
620
621int i2c_read_multiple ( uchar chip, uint addr, int alen,
622                        uchar *buffer, int len)
623{
624        int i;
625
626        if (alen != 1) {
627                printf ("%s: addr len other than 1 not supported\n",
628                         __FUNCTION__);
629                return (1);
630        }
631
632        for (i = 0; i < len; i++) {
633                if (i2c_read (chip, addr+i, alen, buffer+i, 1)) {
634                        printf ("%s: could not read from i2c device %#x"
635                                 ", addr %d\n", __FUNCTION__, chip, addr);
636                        return (1);
637                }
638        }
639        return (0);
640}
641
642
643static int adc_read (unsigned int channel)
644{
645        int j = 1000; /* timeout value for wait loop in us */
646        int result;
647        S3C2400_ADC *padc;
648
649        padc = S3C2400_GetBase_ADC();
650        channel &= 0x7;
651
652        adc_init ();
653
654        padc->ADCCON &= ~ADC_STDBM; /* select normal mode */
655        padc->ADCCON &= ~(0x7 << 3); /* clear the channel bits */
656        padc->ADCCON |= ((channel << 3) | ADC_ENABLE_START);
657
658        while (j--) {
659                if ((padc->ADCCON & ADC_ENABLE_START) == 0)
660                        break;
661                udelay (1);
662        }
663
664        if (j == 0) {
665                printf("%s: ADC timeout\n", __FUNCTION__);
666                padc->ADCCON |= ADC_STDBM; /* select standby mode */
667                return -1;
668        }
669
670        result = padc->ADCDAT & 0x3FF;
671
672        padc->ADCCON |= ADC_STDBM; /* select standby mode */
673
674        debug ("%s: channel %d, result[DIGIT]=%d\n", __FUNCTION__,
675               (padc->ADCCON >> 3) & 0x7, result);
676
677        /*
678         * Wait for ADC to be ready for next conversion. This delay value was
679         * estimated, because the datasheet does not specify a value.
680         */
681        udelay (1000);
682
683        return (result);
684}
685
686
687static void adc_init (void)
688{
689        S3C2400_ADC *padc;
690
691        padc = S3C2400_GetBase_ADC();
692
693        padc->ADCCON &= ~(0xff << 6); /* clear prescaler bits */
694        padc->ADCCON |= ((65 << 6) | ADC_PRSCEN); /* set prescaler */
695
696        /*
697         * Wait some time to avoid problem with very first call of
698         * adc_read(). Without this delay, sometimes the first read
699         * adc value is 0. Perhaps because the adjustment of prescaler
700         * takes some clock cycles?
701         */
702        udelay (1000);
703
704        return;
705}
706
707
708static void led_set (unsigned int state)
709{
710        S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
711
712        led_init ();
713
714        switch (state) {
715        case 0: /* turn LED off */
716                gpio->PADAT |= (1 << 12);
717                break;
718        case 1: /* turn LED on */
719                gpio->PADAT &= ~(1 << 12);
720                break;
721        default:
722                break;
723        }
724}
725
726static void led_blink (void)
727{
728        led_init ();
729
730        /* blink LED. This function does not return! */
731        while (1) {
732                reset_timer_masked ();
733                led_set (1);
734                udelay (1000000 / LED_BLINK_FREQ / 2);
735                led_set (0);
736                udelay (1000000 / LED_BLINK_FREQ / 2);
737        }
738}
739
740
741static void led_init (void)
742{
743        S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
744
745        /* configure GPA12 as output and set to High -> LED off */
746        gpio->PACON &= ~(1 << 12);
747        gpio->PADAT |= (1 << 12);
748}
749
750
751static void sdelay (unsigned long seconds)
752{
753        unsigned long i;
754
755        for (i = 0; i < seconds; i++) {
756                udelay (1000000);
757        }
758}
759
760
761static int global_vars_write_to_eeprom (void)
762{
763        if (i2c_write_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_STATUS, 1,
764                                (unsigned char*) &status, 1)) {
765                return (1);
766        }
767        if (i2c_write_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_PASS_CYCLES, 1,
768                                (unsigned char*) &pass_cycles, 2)) {
769                return (1);
770        }
771        if (i2c_write_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_FIRST_ERROR_CYCLE,
772                                1, (unsigned char*) &first_error_cycle, 2)) {
773                return (1);
774        }
775        if (i2c_write_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_FIRST_ERROR_NUM,
776                                1, (unsigned char*) &first_error_num, 1)) {
777                return (1);
778        }
779        if (i2c_write_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_FIRST_ERROR_NAME,
780                                1, (unsigned char*) first_error_name,
781                                sizeof(first_error_name))) {
782                return (1);
783        }
784        return (0);
785}
786
787static void global_vars_init (void)
788{
789        status                  = 1; /* error */
790        pass_cycles             = 0;
791        first_error_cycle       = 0;
792        first_error_num         = 0;
793        first_error_name[0]     = '\0';
794        act_cycle               = 0;
795        max_cycles              = 0;
796}
797
798
799static void test_function_table_init (void)
800{
801        int i;
802
803        for (i = 0; i < BIF_MAX; i++)
804                test_function[i].pf = dummy;
805
806        /*
807         * the length of "name" must not exceed 16, including the '\0'
808         * termination. See also the EEPROM address map.
809         */
810        test_function[0].pf = test_dip;
811        test_function[0].name = "dip";
812
813        test_function[1].pf = test_vcc5v;
814        test_function[1].name = "vcc5v";
815
816        test_function[2].pf = test_rotary_switch;
817        test_function[2].name = "rotary_switch";
818
819        test_function[3].pf = test_sram;
820        test_function[3].name = "sram";
821
822        test_function[4].pf = test_eeprom;
823        test_function[4].name = "eeprom";
824
825        test_function[5].pf = test_contact_temp;
826        test_function[5].name = "contact_temp";
827}
828
829
830static int read_max_cycles (void)
831{
832        if (i2c_read_multiple (I2C_EEPROM_DEV_ADDR, EE_ADDR_MAX_CYCLES, 1,
833                               (unsigned char *) &max_cycles, 2) != 0) {
834                return (1);
835        }
836
837        return (0);
838}
839
840static int dummy(void)
841{
842        return (0);
843}
844
845int do_temp_log (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
846{
847        int contact_temp;
848        int delay = 0;
849#if defined(CONFIG_CMD_DATE)
850        struct rtc_time tm;
851#endif
852
853        if (argc > 2) {
854                printf ("Usage:\n%s\n", cmdtp->usage);
855                return 1;
856        }
857
858        if (argc > 1) {
859                delay = simple_strtoul(argv[1], NULL, 10);
860        }
861
862        spi_init ();
863        while (1) {
864
865#if defined(CONFIG_CMD_DATE)
866                rtc_get (&tm);
867                printf ("%4d-%02d-%02d %2d:%02d:%02d - ",
868                        tm.tm_year, tm.tm_mon, tm.tm_mday,
869                        tm.tm_hour, tm.tm_min, tm.tm_sec);
870#endif
871
872                contact_temp = tsc2000_contact_temp();
873                printf ("%d\n", contact_temp) ;
874
875                if (delay != 0)
876                        /*
877                         * reset timer to avoid timestamp overflow problem
878                         * after about 68 minutes of udelay() time.
879                         */
880                        reset_timer_masked ();
881                        sdelay (delay);
882        }
883
884        return 0;
885}
886
887U_BOOT_CMD(
888        tlog,   2,      1,      do_temp_log,
889        "tlog    - log contact temperature [1/100 C] to console (endlessly)\n",
890        "delay\n"
891        "    - contact temperature [1/100 C] is printed endlessly to console\n"
892        "      <delay> specifies the seconds to wait between two measurements\n"
893        "      For each measurment a timestamp is printeted\n"
894);
895
896#endif
Note: See TracBrowser for help on using the repository browser.