开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ski2c.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：32k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ski2c.c：源码内容
  1. /******************************************************************************
  2.  *
  3.  * Name: ski2c.c
  4.  * Project: GEnesis, PCI Gigabit Ethernet Adapter
  5.  * Version: $Revision: 1.47 $
  6.  * Date: $Date: 2001/04/05 11:38:09 $
  7.  * Purpose: Functions to access Voltage and Temperature Sensor
  8.  * (taken from Monalisa (taken from Concentrator))
  9.  *
  10.  ******************************************************************************/
  12. /******************************************************************************
  13.  *
  14.  * (C)Copyright 1998-2001 SysKonnect GmbH.
  15.  *
  16.  * This program is free software; you can redistribute it and/or modify
  17.  * it under the terms of the GNU General Public License as published by
  18.  * the Free Software Foundation; either version 2 of the License, or
  19.  * (at your option) any later version.
  20.  *
  21.  * The information in this file is provided "AS IS" without warranty.
  22.  *
  23.  ******************************************************************************/
  25. /******************************************************************************
  26.  *
  27.  * History:
  28.  *
  29.  * $Log: ski2c.c,v $
  30.  * Revision 1.47  2001/04/05 11:38:09  rassmann
  31.  * Set SenState to idle in SkI2cWaitIrq().
  32.  * Changed error message in SkI2cWaitIrq().
  33.  *
  34.  * Revision 1.46  2001/04/02 14:03:35  rassmann
  35.  * Changed pAC to IoC in SK_IN32().
  36.  *
  37.  * Revision 1.45  2001/03/21 12:12:49  rassmann
  38.  * Resetting I2C_READY interrupt in SkI2cInit1().
  39.  *
  40.  * Revision 1.44  2000/08/07 15:49:03  gklug
  41.  * Fix: SK_INFAST only in NetWare driver.
  42.  *
  43.  * Revision 1.43  2000/08/03 14:28:17  rassmann
  44.  * Added function to wait for I2C being ready before resetting the board.
  45.  * Replaced one duplicate "out of range" message with correct one.
  46.  *
  47.  * Revision 1.42  1999/11/22 13:35:12  cgoos
  48.  * Changed license header to GPL.
  49.  *
  50.  * Revision 1.41  1999/09/14 14:11:30  malthoff
  51.  * The 1000BT Dual Link adapter has got only one Fan.
  52.  * The second Fan has been removed.
  53.  *
  54.  * Revision 1.40  1999/05/27 13:37:27  malthoff
  55.  * Set divisor of 1 for fan count calculation.
  56.  *
  57.  * Revision 1.39  1999/05/20 14:54:43  malthoff
  58.  * I2c.DummyReads is not used in Diagnostics.
  59.  *
  60.  * Revision 1.38  1999/05/20 09:20:56  cgoos
  61.  * Changes for 1000Base-T (up to 9 sensors and fans).
  62.  *
  63.  * Revision 1.37  1999/03/25 15:11:36  gklug
  64.  * fix: reset error flag if sensor reads correct value
  65.  *
  66.  * Revision 1.36  1999/01/07 14:11:16  gklug
  67.  * fix: break added
  68.  *
  69.  * Revision 1.35  1999/01/05 15:31:49  gklug
  70.  * fix: CLEAR STAT command is now added correctly
  71.  *
  72.  * Revision 1.34  1998/12/01 13:45:16  gklug
  73.  * fix: introduced Init level, because we don't need reinits
  74.  *
  75.  * Revision 1.33  1998/11/09 14:54:25  malthoff
  76.  * Modify I2C Transfer Timeout handling for Diagnostics.
  77.  *
  78.  * Revision 1.32  1998/11/03 06:54:35  gklug
  79.  * fix: Need dummy reads at the beginning to init sensors
  80.  *
  81.  * Revision 1.31  1998/11/03 06:42:42  gklug
  82.  * fix: select correctVIO range only if between warning levels
  83.  *
  84.  * Revision 1.30  1998/11/02 07:36:53  gklug
  85.  * fix: Error should not include WARNING message
  86.  *
  87.  * Revision 1.29  1998/10/30 15:07:43  malthoff
  88.  * Disable 'I2C does not compelete' error log for diagnostics.
  89.  *
  90.  * Revision 1.28  1998/10/22 09:48:11  gklug
  91.  * fix: SysKonnectFileId typo
  92.  *
  93.  * Revision 1.27  1998/10/20 09:59:46  gklug
  94.  * add: parameter to SkOsGetTime
  95.  *
  96.  * Revision 1.26  1998/10/09 06:10:59  malthoff
  97.  * Remove ID_sccs by SysKonnectFileId.
  98.  *
  99.  * Revision 1.25  1998/09/08 12:40:26  gklug
  100.  * fix: syntax error in if clause
  101.  *
  102.  * Revision 1.24  1998/09/08 12:19:42  gklug
  103.  * chg: INIT Level checking
  104.  *
  105.  * Revision 1.23  1998/09/08 07:37:20  gklug
  106.  * fix: log error if PCI_IO voltage sensor could not be initialized
  107.  *
  108.  * Revision 1.22  1998/09/04 08:30:03  malthoff
  109.  * Bugfixes during SK_DIAG testing:
  110.  * - correct NS2BCLK() macro
  111.  * - correct SkI2cSndDev()
  112.  * - correct SkI2cWait() loop waiting for an event
  113.  *
  114.  * Revision 1.21  1998/08/27 14:46:01  gklug
  115.  * chg: if-then-else replaced by switch
  116.  *
  117.  * Revision 1.20  1998/08/27 14:40:07  gklug
  118.  * test: integral types
  119.  *
  120.  * Revision 1.19  1998/08/25 07:51:54  gklug
  121.  * fix: typos for compiling
  122.  *
  123.  * Revision 1.18  1998/08/25 06:12:24  gklug
  124.  * add: count errors and warnings
  125.  * fix: check not the sensor state but the ErrFlag!
  126.  *
  127.  * Revision 1.17  1998/08/25 05:56:48  gklug
  128.  * add: CheckSensor function
  129.  *
  130.  * Revision 1.16  1998/08/20 11:41:10  gklug
  131.  * chg: omit STRCPY macro by using char * as Sensor Description
  132.  *
  133.  * Revision 1.15  1998/08/20 11:37:35  gklug
  134.  * chg: change Ioc to IoC
  135.  *
  136.  * Revision 1.14  1998/08/20 11:32:52  gklug
  137.  * fix: Para compile error
  138.  *
  139.  * Revision 1.13  1998/08/20 11:27:41  gklug
  140.  * fix: Compile bugs with new awrning constants
  141.  *
  142.  * Revision 1.12  1998/08/20 08:53:05  gklug
  143.  * fix: compiler errors
  144.  * add: Threshold values
  145.  *
  146.  * Revision 1.11  1998/08/19 12:39:22  malthoff
  147.  * Compiler Fix: Some names have changed.
  148.  *
  149.  * Revision 1.10  1998/08/19 12:20:56  gklug
  150.  * fix: remove struct from C files (see CCC)
  151.  *
  152.  * Revision 1.9  1998/08/19 06:28:46  malthoff
  153.  * SkOsGetTime returns SK_U64 now.
  154.  *
  155.  * Revision 1.8  1998/08/17 13:53:33  gklug
  156.  * fix: Parameter of event function and its result
  157.  *
  158.  * Revision 1.7  1998/08/17 07:02:15  malthoff
  159.  * Modify the functions for accessing the I2C SW Registers.
  160.  * Modify SkI2cWait().
  161.  * Put Lm80RcvReg into sklm80.c
  162.  * Remove Compiler Errors.
  163.  *
  164.  * Revision 1.6  1998/08/14 07:13:20  malthoff
  165.  * remove pAc with pAC
  166.  * remove smc with pAC
  167.  * change names to new convention
  168.  *
  169.  * Revision 1.5  1998/08/14 06:24:49  gklug
  170.  * add: init level 1 and 2
  171.  *
  172.  * Revision 1.4  1998/08/12 14:31:12  gklug
  173.  * add: error log for unknown event
  174.  *
  175.  * Revision 1.3  1998/08/12 13:37:04  gklug
  176.  * add: Init 0 function
  177.  *
  178.  * Revision 1.2  1998/08/11 07:27:15  gklug
  179.  * add: functions of the interface
  180.  * adapt rest of source to C coding Conventions
  181.  * rmv: unneccessary code taken from Mona Lisa
  182.  *
  183.  * Revision 1.1  1998/06/19 14:28:43  malthoff
  184.  * Created. Sources taken from ML Projekt.
  185.  * Sources have to be reworked for GE.
  186.  *
  187.  *
  188.  ******************************************************************************/
  191. /*
  192.  * I2C Protocol
  193.  */
  194. static const char SysKonnectFileId[] =
  195. "$Id: ski2c.c,v 1.47 2001/04/05 11:38:09 rassmann Exp $";
  197. #include "h/skdrv1st.h" /* Driver Specific Definitions */
  198. #include "h/lm80.h"
  199. #include "h/skdrv2nd.h" /* Adapter Control- and Driver specific Def. */
  201. #ifdef __C2MAN__
  202. /*
  203. I2C protocol implementation.
  205. General Description:
  207. The I2C protocol is used for the temperature sensors and for
  208. the serial EEPROM which hold the configuration.
  210. This file covers functions that allow to read write and do
  211. some bulk requests a specified I2C address.
  213. The Genesis has 2 I2C buses. One for the EEPROM which holds
  214. the VPD Data and one for temperature and voltage sensor.
  215. The following picture shows the I2C buses, I2C devices and
  216. there control registers.
  218. Note: The VPD functions are in skvpd.c
  219. .
  220. . PCI Config I2C Bus for VPD Data:
  221. .
  222. .       +------------+
  223. .       | VPD EEPROM |
  224. .       +------------+
  225. .      |
  226. .      | <-- I2C
  227. .      |
  228. .  +-----------+-----------+
  229. .  |  |
  230. . +-----------------+ +-----------------+
  231. . | PCI_VPD_ADR_REG | | PCI_VPD_DAT_REG |
  232. . +-----------------+ +-----------------+
  233. .
  234. .
  235. . I2C Bus for LM80 sensor:
  236. .
  237. . +-----------------+
  238. . | Temperature and |
  239. . | Voltage Sensor  |
  240. . |  LM80   |
  241. . +-----------------+
  242. . |
  243. . |
  244. . I2C --> |
  245. . |
  246. .      +----+
  247. .      +-------------->| OR |<--+
  248. .      |      +----+   |
  249. .     +------+------+       |
  250. .     |     |       |
  251. . +--------+ +--------+ +----------+
  252. . | B2_I2C | | B2_I2C | |  B2_I2C  |
  253. . | _CTRL  | | _DATA  | |   _SW    |
  254. . +--------+ +--------+ +----------+
  255. .
  256. The I2C bus may be driven by the B2_I2C_SW or by the B2_I2C_CTRL
  257. and B2_I2C_DATA registers.
  258. For driver software it is recommended to use the I2C control and
  259. data register, because I2C bus timing is done by the ASIC and
  260. an interrupt may be received when the I2C request is completed.
  262. Clock Rate Timing: MIN MAX generated by
  263. VPD EEPROM: 50 kHz 100 kHz HW
  264. LM80 over I2C Ctrl/Data reg. 50 kHz 100 kHz HW
  265. LM80 over B2_I2C_SW register 0 400 kHz SW
  267. Note: The clock generated by the hardware is dependend on the
  268. PCI clock. If the PCI bus clock is 33 MHz, the I2C/VPD
  269. clock is 50 kHz.
  270.  */
  271. intro()
  272. {}
  273. #endif
  275. #ifdef SK_DIAG
  276. /*
  277.  * I2C Fast Mode timing values used by the LM80.
  278.  * If new devices are added to the I2C bus the timing values have to be checked.
  279.  */
  280. #ifndef I2C_SLOW_TIMING
  281. #define T_CLK_LOW 1300L /* clock low time in ns */
  282. #define T_CLK_HIGH  600L /* clock high time in ns */
  283. #define T_DATA_IN_SETUP  100L /* data in Set-UP Time */
  284. #define T_START_HOLD  600L /* start condition hold time */
  285. #define T_START_SETUP  600L /* start condition Set-up time */
  286. #define T_STOP_SETUP  600L /* stop condition Set-up time */
  287. #define T_BUS_IDLE 1300L /* time the bus must free after tx */
  288. #define T_CLK_2_DATA_OUT  900L /* max. clock low to data output valid */
  289. #else /* I2C_SLOW_TIMING */
  290. /* I2C Standard Mode Timing */
  291. #define T_CLK_LOW 4700L /* clock low time in ns */
  292. #define T_CLK_HIGH 4000L /* clock high time in ns */
  293. #define T_DATA_IN_SETUP  250L /* data in Set-UP Time */
  294. #define T_START_HOLD 4000L /* start condition hold time */
  295. #define T_START_SETUP 4700L /* start condition Set_up time */
  296. #define T_STOP_SETUP 4000L /* stop condition Set-up time */
  297. #define T_BUS_IDLE 4700L /* time the bus must free after tx */
  298. #endif /* !I2C_SLOW_TIMING */
  300. #define NS2BCLK(x) (((x)*125)/10000)
  302. /*
  303.  * I2C Wire Operations
  304.  *
  305.  * About I2C_CLK_LOW():
  306.  *
  307.  * The Data Direction bit (I2C_DATA_DIR) has to be set to input when setting
  308.  * clock to low, to prevent the ASIC and the I2C data client from driving the
  309.  * serial data line simultaneously (ASIC: last bit of a byte = '1', I2C client
  310.  * send an 'ACK'). See also Concentrator Bugreport No. 10192.
  311.  */
  312. #define I2C_DATA_HIGH(IoC) SK_I2C_SET_BIT(IoC, I2C_DATA)
  313. #define I2C_DATA_LOW(IoC) SK_I2C_CLR_BIT(IoC, I2C_DATA)
  314. #define I2C_DATA_OUT(IoC) SK_I2C_SET_BIT(IoC, I2C_DATA_DIR)
  315. #define I2C_DATA_IN(IoC) SK_I2C_CLR_BIT(IoC, I2C_DATA_DIR|I2C_DATA)
  316. #define I2C_CLK_HIGH(IoC) SK_I2C_SET_BIT(IoC, I2C_CLK)
  317. #define I2C_CLK_LOW(IoC) SK_I2C_CLR_BIT(IoC, I2C_CLK|I2C_DATA_DIR)
  318. #define I2C_START_COND(IoC) SK_I2C_CLR_BIT(IoC, I2C_CLK)
  320. #define NS2CLKT(x) ((x*125L)/10000)
  322. /*--------------- I2C Interface Register Functions --------------- */
  324. /*
  325.  * sending one bit
  326.  */
  327. void SkI2cSndBit(
  328. SK_IOC IoC, /* I/O Context */
  329. SK_U8 Bit) /* Bit to send */
  330. {
  331. I2C_DATA_OUT(IoC);
  332. if (Bit) {
  333. I2C_DATA_HIGH(IoC);
  334. } else {
  335. I2C_DATA_LOW(IoC);
  336. }
  337. SkDgWaitTime(IoC, NS2BCLK(T_DATA_IN_SETUP));
  338. I2C_CLK_HIGH(IoC);
  339. SkDgWaitTime(IoC, NS2BCLK(T_CLK_HIGH));
  340. I2C_CLK_LOW(IoC);
  341. } /* SkI2cSndBit*/
  344. /*
  345.  * Signal a start to the I2C Bus.
  346.  *
  347.  * A start is signaled when data goes to low in a high clock cycle.
  348.  *
  349.  * Ends with Clock Low.
  350.  *
  351.  * Status: not tested
  352.  */
  353. void SkI2cStart(
  354. SK_IOC IoC) /* I/O Context */
  355. {
  356. /* Init data and Clock to output lines */
  357. /* Set Data high */
  358. I2C_DATA_OUT(IoC);
  359. I2C_DATA_HIGH(IoC);
  360. /* Set Clock high */
  361. I2C_CLK_HIGH(IoC);
  363. SkDgWaitTime(IoC, NS2BCLK(T_START_SETUP));
  365. /* Set Data Low */
  366. I2C_DATA_LOW(IoC);
  368. SkDgWaitTime(IoC, NS2BCLK(T_START_HOLD));
  370. /* Clock low without Data to Input */
  371. I2C_START_COND(IoC);
  373. SkDgWaitTime(IoC, NS2BCLK(T_CLK_LOW));
  374. } /* SkI2cStart */
  377. void SkI2cStop(
  378. SK_IOC IoC) /* I/O Context */
  379. {
  380. /* Init data and Clock to output lines */
  381. /* Set Data low */
  382. I2C_DATA_OUT(IoC);
  383. I2C_DATA_LOW(IoC);
  385. SkDgWaitTime(IoC, NS2BCLK(T_CLK_2_DATA_OUT));
  387. /* Set Clock high */
  388. I2C_CLK_HIGH(IoC);
  390. SkDgWaitTime(IoC, NS2BCLK(T_STOP_SETUP));
  392. /*
  393.  * Set Data High: Do it by setting the Data Line to Input.
  394.  * Because of a pull up resistor the Data Line
  395.  * floods to high.
  396.  */
  397. I2C_DATA_IN(IoC);
  399. /*
  400.  * When I2C activity is stopped
  401.  *  o DATA should be set to input and
  402.  *  o CLOCK should be set to high!
  403.  */
  404. SkDgWaitTime(IoC, NS2BCLK(T_BUS_IDLE));
  405. } /* SkI2cStop */
  408. /*
  409.  * Receive just one bit via the I2C bus.
  410.  *
  411.  * Note: Clock must be set to LOW before calling this function.
  412.  *
  413.  * Returns The received bit.
  414.  */
  415. int SkI2cRcvBit(
  416. SK_IOC IoC) /* I/O Context */
  417. {
  418. int Bit;
  419. SK_U8 I2cSwCtrl;
  421. /* Init data as input line */
  422. I2C_DATA_IN(IoC);
  424. SkDgWaitTime(IoC, NS2BCLK(T_CLK_2_DATA_OUT));
  426. I2C_CLK_HIGH(IoC);
  428. SkDgWaitTime(IoC, NS2BCLK(T_CLK_HIGH));
  430. SK_I2C_GET_SW(IoC, &I2cSwCtrl);
  431. if (I2cSwCtrl & I2C_DATA) {
  432. Bit = 1;
  433. } else {
  434. Bit = 0;
  435. }
  437. I2C_CLK_LOW(IoC);
  438. SkDgWaitTime(IoC, NS2BCLK(T_CLK_LOW-T_CLK_2_DATA_OUT));
  440. return(Bit);
  441. } /* SkI2cRcvBit */
  444. /*
  445.  * Receive an ACK.
  446.  *
  447.  * returns 0 If acknoledged
  448.  * 1 in case of an error
  449.  */
  450. int SkI2cRcvAck(
  451. SK_IOC IoC) /* I/O Context */
  452. {
  453. /*
  454.  * Received bit must be zero.
  455.  */
  456. return (SkI2cRcvBit(IoC) != 0);
  457. } /* SkI2cRcvAck */
  460. /*
  461.  * Send an NACK.
  462.  */
  463. void SkI2cSndNAck(
  464. SK_IOC IoC) /* I/O Context */
  465. {
  466. /*
  467.  * Received bit must be zero.
  468.  */
  469. SkI2cSndBit(IoC, 1);
  470. } /* SkI2cSndNAck */
  473. /*
  474.  * Send an ACK.
  475.  */
  476. void SkI2cSndAck(
  477. SK_IOC IoC) /* I/O Context */
  478. {
  479. /*
  480.  * Received bit must be zero.
  481.  *
  482.  */
  483. SkI2cSndBit(IoC, 0);
  484. } /* SkI2cSndAck */
  487. /*
  488.  * Send one byte to the I2C device and wait for ACK.
  489.  *
  490.  * Return acknoleged status.
  491.  */
  492. int SkI2cSndByte(
  493. SK_IOC IoC, /* I/O Context */
  494. int Byte) /* byte to send */
  495. {
  496. int i;
  498. for (i = 0; i < 8; i++) {
  499. if (Byte & (1<<(7-i))) {
  500. SkI2cSndBit(IoC, 1);
  501. } else {
  502. SkI2cSndBit(IoC, 0);
  503. }
  504. }
  506. return(SkI2cRcvAck(IoC));
  507. } /* SkI2cSndByte */
  510. /*
  511.  * Receive one byte and ack it.
  512.  *
  513.  * Return byte.
  514.  */
  515. int SkI2cRcvByte(
  516. SK_IOC IoC, /* I/O Context */
  517. int Last) /* Last Byte Flag */
  518. {
  519. int i;
  520. int Byte = 0;
  522. for (i = 0; i < 8; i++) {
  523. Byte <<= 1;
  524. Byte |= SkI2cRcvBit(IoC);
  525. }
  527. if (Last) {
  528. SkI2cSndNAck(IoC);
  529. } else {
  530. SkI2cSndAck(IoC);
  531. }
  533. return(Byte);
  534. } /* SkI2cRcvByte */
  537. /*
  538.  * Start dialog and send device address
  539.  *
  540.  * Return 0 if acknoleged, 1 in case of an error
  541.  */
  542. int SkI2cSndDev(
  543. SK_IOC IoC, /* I/O Context */
  544. int Addr, /* Device Address */
  545. int Rw) /* Read / Write Flag */
  546. {
  547. SkI2cStart(IoC);
  548. Rw = ~Rw; 
  549. Rw &= I2C_WRITE;
  550. return(SkI2cSndByte(IoC, (Addr<<1) | Rw));
  551. } /* SkI2cSndDev */
  553. #endif /* SK_DIAG */
  555. /*----------------- I2C CTRL Register Functions ----------*/
  557. /*
  558.  * waits for a completion of an I2C transfer
  559.  *
  560.  * returns 0: success, transfer completes
  561.  * 1: error,  transfer does not complete, I2C transfer
  562.  *  killed, wait loop terminated.
  563.  */
  564. int SkI2cWait(
  565. SK_AC *pAC, /* Adapter Context */
  566. SK_IOC IoC, /* I/O Context */
  567. int Event) /* complete event to wait for (I2C_READ or I2C_WRITE) */
  568. {
  569. SK_U64 StartTime;
  570. SK_U32 I2cCtrl;
  572. StartTime = SkOsGetTime(pAC);
  573. do {
  574. if (SkOsGetTime(pAC) - StartTime > SK_TICKS_PER_SEC / 8) {
  575. SK_I2C_STOP(IoC);
  576. #ifndef SK_DIAG
  577. SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_I2C_E002, SKERR_I2C_E002MSG);
  578. #endif /* !SK_DIAG */
  579. return(1);
  580. }
  581. SK_I2C_GET_CTL(IoC, &I2cCtrl);
  582. } while ((I2cCtrl & I2C_FLAG) == (SK_U32)Event << 31);
  584. return(0);
  585. } /* SkI2cWait */
  588. /*
  589.  * waits for a completion of an I2C transfer
  590.  *
  591.  * Returns
  592.  * Nothing
  593.  */
  594. void SkI2cWaitIrq(
  595. SK_AC *pAC, /* Adapter Context */
  596. SK_IOC IoC) /* I/O Context */
  597. {
  598. SK_SENSOR *pSen;
  599. SK_U64 StartTime;
  600. SK_U32 IrqSrc;
  602. pSen = &pAC->I2c.SenTable[pAC->I2c.CurrSens];
  604. if (pSen->SenState == SK_SEN_IDLE) {
  605. return;
  606. }
  608. StartTime = SkOsGetTime(pAC);
  609. do {
  610. if (SkOsGetTime(pAC) - StartTime > SK_TICKS_PER_SEC / 8) {
  611. SK_I2C_STOP(IoC);
  612. #ifndef SK_DIAG
  613. SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_I2C_E016, SKERR_I2C_E016MSG);
  614. #endif /* !SK_DIAG */
  615. return;
  616. }
  617. SK_IN32(IoC, B0_ISRC, &IrqSrc);
  618. } while ((IrqSrc & IS_I2C_READY) == 0);
  620. pSen->SenState = SK_SEN_IDLE;
  621. return;
  622. } /* SkI2cWaitIrq */
  624. #ifdef SK_DIAG
  626. /*
  627.  * writes a single byte or 4 bytes into the I2C device
  628.  *
  629.  * returns 0: success
  630.  * 1: error
  631.  */
  632. int SkI2cWrite(
  633. SK_AC *pAC, /* Adapter Context */
  634. SK_IOC IoC, /* I/O Context */
  635. SK_U32 I2cData, /* I2C Data to write */
  636. int I2cDev, /* I2C Device Address */
  637. int I2cReg, /* I2C Device Register Address */
  638. int I2cBurst) /* I2C Burst Flag ( 0 || I2C_BURST ) */
  639. {
  640. SK_OUT32(IoC, B2_I2C_DATA, I2cData);
  641. SK_I2C_CTL(IoC, I2C_WRITE, I2cDev, I2cReg, I2cBurst);
  642. return(SkI2cWait(pAC, IoC, I2C_WRITE));
  643. } /* SkI2cWrite*/
  646. /*
  647.  * reads a single byte or 4 bytes from the I2C device
  648.  *
  649.  * returns the word read
  650.  */
  651. SK_U32 SkI2cRead(
  652. SK_AC *pAC, /* Adapter Context */
  653. SK_IOC IoC, /* I/O Context */
  654. int I2cDev, /* I2C Device Address */
  655. int I2cReg, /* I2C Device Register Address */
  656. int I2cBurst) /* I2C Burst Flag ( 0 || I2C_BURST ) */
  657. {
  658. SK_U32 Data;
  660. SK_OUT32(IoC, B2_I2C_DATA, 0);
  661. SK_I2C_CTL(IoC, I2C_READ, I2cDev, I2cReg, I2cBurst);
  662. if (SkI2cWait(pAC, IoC, I2C_READ)) {
  663. w_print("I2C Transfer Timeout!n"); 
  664. }
  665. SK_IN32(IoC, B2_I2C_DATA, &Data);
  666. return(Data);
  667. } /* SkI2cRead */
  669. #endif /* SK_DIAG */
  672. /*
  673.  * read a sensor's value
  674.  *
  675.  * This function reads a sensor's value from the I2C sensor chip. The sensor
  676.  * is defined by its index into the sensors database in the struct pAC points
  677.  * to.
  678.  * Returns
  679.  * 1 if the read is completed
  680.  * 0 if the read must be continued (I2C Bus still allocated)
  681.  */
  682. int SkI2cReadSensor(
  683. SK_AC *pAC, /* Adapter Context */
  684. SK_IOC IoC, /* I/O Context */
  685. SK_SENSOR *pSen) /* Sensor to be read */
  686. {
  687. return((*pSen->SenRead)(pAC, IoC, pSen));
  688. } /* SkI2cReadSensor*/
  690. /*
  691.  * Do the Init state 0 initialization
  692.  */
  693. static int SkI2cInit0(
  694. SK_AC *pAC) /* Adapter Context */
  695. {
  696. int i;
  698. /* Begin with first sensor */
  699. pAC->I2c.CurrSens = 0;
  701. /* Set to mimimum sensor number */
  702. pAC->I2c.MaxSens = SK_MIN_SENSORS;
  704. #ifndef SK_DIAG
  705. /* Initialize Number of Dummy Reads */
  706. pAC->I2c.DummyReads = SK_MAX_SENSORS;
  707. #endif
  709. for (i = 0; i < SK_MAX_SENSORS; i ++) {
  710. switch (i) {
  711. case 0:
  712. pAC->I2c.SenTable[i].SenDesc = "Temperature";
  713. pAC->I2c.SenTable[i].SenType = SK_SEN_TEMP;
  714. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH0;
  715. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW0;
  716. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH0;
  717. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW0;
  718. pAC->I2c.SenTable[i].SenReg = LM80_TEMP_IN;
  719. pAC->I2c.SenTable[i].SenInit = SK_TRUE;
  720. break;
  721. case 1:
  722. pAC->I2c.SenTable[i].SenDesc = "Voltage PCI";
  723. pAC->I2c.SenTable[i].SenType = SK_SEN_VOLT;
  724. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH1;
  725. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW1;
  726. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH1;
  727. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW1;
  728. pAC->I2c.SenTable[i].SenReg = LM80_VT0_IN;
  729. pAC->I2c.SenTable[i].SenInit = SK_TRUE;
  730. break;
  731. case 2:
  732. pAC->I2c.SenTable[i].SenDesc = "Voltage PCI-IO";
  733. pAC->I2c.SenTable[i].SenType = SK_SEN_VOLT;
  734. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH2;
  735. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW2;
  736. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH2;
  737. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW2;
  738. pAC->I2c.SenTable[i].SenReg = LM80_VT1_IN;
  739. pAC->I2c.SenTable[i].SenInit = SK_FALSE;
  740. break;
  741. case 3:
  742. pAC->I2c.SenTable[i].SenDesc = "Voltage ASIC";
  743. pAC->I2c.SenTable[i].SenType = SK_SEN_VOLT;
  744. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH3;
  745. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW3;
  746. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH3;
  747. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW3;
  748. pAC->I2c.SenTable[i].SenReg = LM80_VT2_IN;
  749. pAC->I2c.SenTable[i].SenInit = SK_TRUE;
  750. break;
  751. case 4:
  752. pAC->I2c.SenTable[i].SenDesc = "Voltage PMA";
  753. pAC->I2c.SenTable[i].SenType = SK_SEN_VOLT;
  754. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH4;
  755. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW4;
  756. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH4;
  757. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW4;
  758. pAC->I2c.SenTable[i].SenReg = LM80_VT3_IN;
  759. pAC->I2c.SenTable[i].SenInit = SK_TRUE;
  760. break;
  761. case 5:
  762. pAC->I2c.SenTable[i].SenDesc = "Voltage PHY 2V5";
  763. pAC->I2c.SenTable[i].SenType = SK_SEN_VOLT;
  764. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH5;
  765. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW5;
  766. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH5;
  767. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW5;
  768. pAC->I2c.SenTable[i].SenReg = LM80_VT4_IN;
  769. pAC->I2c.SenTable[i].SenInit = SK_TRUE;
  770. break;
  771. case 6:
  772. pAC->I2c.SenTable[i].SenDesc = "Voltage PHY B PLL";
  773. pAC->I2c.SenTable[i].SenType = SK_SEN_VOLT;
  774. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH6;
  775. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW6;
  776. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH6;
  777. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW6;
  778. pAC->I2c.SenTable[i].SenReg = LM80_VT5_IN;
  779. pAC->I2c.SenTable[i].SenInit = SK_TRUE;
  780. break;
  781. case 7:
  782. pAC->I2c.SenTable[i].SenDesc = "Speed Fan";
  783. pAC->I2c.SenTable[i].SenType = SK_SEN_FAN;
  784. pAC->I2c.SenTable[i].SenThreErrHigh = SK_SEN_ERRHIGH;
  785. pAC->I2c.SenTable[i].SenThreErrLow = SK_SEN_ERRLOW;
  786. pAC->I2c.SenTable[i].SenThreWarnHigh = SK_SEN_WARNHIGH;
  787. pAC->I2c.SenTable[i].SenThreWarnLow = SK_SEN_WARNLOW;
  788. pAC->I2c.SenTable[i].SenReg = LM80_FAN2_IN;
  789. pAC->I2c.SenTable[i].SenInit = SK_TRUE;
  790. break;
  791. default:
  792. SK_ERR_LOG(pAC, SK_ERRCL_INIT | SK_ERRCL_SW,
  793. SKERR_I2C_E001, SKERR_I2C_E001MSG);
  794. break;
  795. }
  797. pAC->I2c.SenTable[i].SenValue = 0;
  798. pAC->I2c.SenTable[i].SenErrFlag = SK_SEN_ERR_OK;
  799. pAC->I2c.SenTable[i].SenErrCts = 0;
  800. pAC->I2c.SenTable[i].SenBegErrTS = 0;
  801. pAC->I2c.SenTable[i].SenState = SK_SEN_IDLE;
  802. pAC->I2c.SenTable[i].SenRead = SkLm80ReadSensor;
  803. pAC->I2c.SenTable[i].SenDev = LM80_ADDR;
  804. }
  806. /* Now we are "INIT data"ed */
  807. pAC->I2c.InitLevel = SK_INIT_DATA;
  808. return(0);
  809. } /* SkI2cInit0*/
  812. /*
  813.  * Do the init state 1 initialization
  814.  *
  815.  * initialize the following register of the LM80:
  816.  * Configuration register:
  817.  * - START, noINT, activeLOW, noINT#Clear, noRESET, noCI, noGPO#, noINIT
  818.  *
  819.  * Interrupt Mask Register 1:
  820.  * - all interrupts are Disabled (0xff)
  821.  *
  822.  * Interrupt Mask Register 2:
  823.  * - all interrupts are Disabled (0xff) Interrupt modi doesn't matter.
  824.  *
  825.  * Fan Divisor/RST_OUT register:
  826.  * - Divisors set to 1 (bits 00), all others 0s.
  827.  *
  828.  * OS# Configuration/Temperature resolution Register:
  829.  * - all 0s
  830.  *
  831.  */
  832. static int SkI2cInit1(
  833. SK_AC *pAC, /* Adapter Context */
  834. SK_IOC IoC) /* I/O Context */
  835. {
  836. if (pAC->I2c.InitLevel != SK_INIT_DATA) {
  837. /* ReInit not needed in I2C module */
  838. return(0);
  839. }
  841. SK_OUT32(IoC, B2_I2C_DATA, 0);
  842. SK_I2C_CTL(IoC, I2C_WRITE, LM80_ADDR, LM80_CFG, 0);
  843. (void)SkI2cWait(pAC, IoC, I2C_WRITE);
  845. SK_OUT32(IoC, B2_I2C_DATA, 0xff);
  846. SK_I2C_CTL(IoC, I2C_WRITE, LM80_ADDR, LM80_IMSK_1, 0);
  847. (void)SkI2cWait(pAC, IoC, I2C_WRITE);
  849. SK_OUT32(IoC, B2_I2C_DATA, 0xff);
  850. SK_I2C_CTL(IoC, I2C_WRITE, LM80_ADDR, LM80_IMSK_2, 0);
  851. (void)SkI2cWait(pAC, IoC, I2C_WRITE);
  853. SK_OUT32(IoC, B2_I2C_DATA, 0x0);
  854. SK_I2C_CTL(IoC, I2C_WRITE, LM80_ADDR, LM80_FAN_CTRL, 0);
  855. (void)SkI2cWait(pAC, IoC, I2C_WRITE);
  857. SK_OUT32(IoC, B2_I2C_DATA, 0);
  858. SK_I2C_CTL(IoC, I2C_WRITE, LM80_ADDR, LM80_TEMP_CTRL, 0);
  859. (void)SkI2cWait(pAC, IoC, I2C_WRITE);
  861. SK_OUT32(IoC, B2_I2C_DATA, LM80_CFG_START);
  862. SK_I2C_CTL(IoC, I2C_WRITE, LM80_ADDR, LM80_CFG, 0);
  863. (void)SkI2cWait(pAC, IoC, I2C_WRITE);
  865. /*
  866.  * MaxSens has to be initialized here, because PhyType is not
  867.  * set when performing Init Level 1
  868.  */
  869. switch (pAC->GIni.GP[0].PhyType) {
  870. case SK_PHY_XMAC:
  871. pAC->I2c.MaxSens = 5;
  872. break;
  873. case SK_PHY_BCOM:
  874. pAC->I2c.SenTable[4].SenDesc = "Voltage PHY A PLL";
  875. if (pAC->GIni.GIMacsFound == 1) {
  876. pAC->I2c.MaxSens = 6;
  877. } 
  878. else {
  879. pAC->I2c.MaxSens = 8;
  880. }
  881. break;
  882. case SK_PHY_LONE:
  883. pAC->I2c.MaxSens = 5;
  884. break;
  885. }
  887. #ifndef SK_DIAG
  888. pAC->I2c.DummyReads = pAC->I2c.MaxSens;
  890. /* Clear the interrupt source */
  891. SK_OUT32(IoC, B2_I2C_IRQ, I2C_CLR_IRQ);
  892. #endif /* !SK_DIAG */
  894. /* Now we are I/O initialized */
  895. pAC->I2c.InitLevel = SK_INIT_IO;
  896. return(0);
  897. } /* SkI2cInit1 */
  900. /*
  901.  * Init level 2: Start first sensor read.
  902.  */
  903. static int SkI2cInit2(
  904. SK_AC *pAC, /* Adapter Context */
  905. SK_IOC IoC) /* I/O Context */
  906. {
  907. int ReadComplete;
  908. SK_SENSOR *pSen;
  910. if (pAC->I2c.InitLevel != SK_INIT_IO) {
  911. /* ReInit not needed in I2C module */
  912. /* Init0 and Init2 not permitted */
  913. return(0);
  914. }
  916. pSen = &pAC->I2c.SenTable[pAC->I2c.CurrSens];
  917. ReadComplete = SkI2cReadSensor(pAC, IoC, pSen);
  919. if (ReadComplete) {
  920. SK_ERR_LOG(pAC, SK_ERRCL_INIT, SKERR_I2C_E008, SKERR_I2C_E008MSG);
  921. }
  923. /* Now we are correctly initialized */
  924. pAC->I2c.InitLevel = SK_INIT_RUN;
  926. return(0);
  927. } /* SkI2cInit2*/
  930. /*
  931.  * Initialize I2C devices
  932.  *
  933.  * Get the first voltage value and discard it.
  934.  * Go into temperature read mode. A default pointer is not set.
  935.  *
  936.  * The things to be done depend on the init level in the parameter list:
  937.  * Level 0:
  938.  * Initialize only the data structures. Do NOT access hardware.
  939.  * Level 1:
  940.  * Initialize hardware through SK_IN / SK_OUT commands. Do NOT use interrupts.
  941.  * Level 2:
  942.  * Everything is possible. Interrupts may be used from now on.
  943.  *
  944.  * return:
  945.  * 0 = success
  946.  * other = error.
  947.  */
  948. int SkI2cInit(
  949. SK_AC *pAC, /* Adapter Context */
  950. SK_IOC IoC, /* I/O Context needed in levels 1 and 2 */
  951. int Level) /* Init Level */
  952. {
  954. switch (Level) {
  955. case SK_INIT_DATA:
  956. return(SkI2cInit0(pAC));
  957. case SK_INIT_IO:
  958. return(SkI2cInit1(pAC, IoC));
  959. case SK_INIT_RUN:
  960. return(SkI2cInit2(pAC, IoC));
  961. default:
  962. break;
  963. }
  965. return(0);
  966. } /* SkI2cInit */
  969. #ifndef SK_DIAG
  971. /*
  972.  * Interrupt service function for the I2C Interface
  973.  *
  974.  * Clears the Interrupt source
  975.  *
  976.  * Reads the register and check it for sending a trap.
  977.  *
  978.  * Starts the timer if necessary.
  979.  */
  980. void SkI2cIsr(
  981. SK_AC *pAC, /* Adapter Context */
  982. SK_IOC IoC) /* I/O Context */
  983. {
  984. SK_EVPARA Para;
  986. /* Clear the interrupt source */
  987. SK_OUT32(IoC, B2_I2C_IRQ, I2C_CLR_IRQ);
  989. Para.Para64 = 0;
  990. SkEventQueue(pAC, SKGE_I2C, SK_I2CEV_IRQ, Para);
  991. } /* SkI2cIsr */
  994. /*
  995.  * Check this sensors Value against the threshold and send events.
  996.  */
  997. static void SkI2cCheckSensor(
  998. SK_AC *pAC, /* Adapter Context */
  999. SK_SENSOR *pSen)
  1000. {
  1001. SK_EVPARA ParaLocal;
  1002. SK_BOOL TooHigh; /* Is sensor too high? */
  1003. SK_BOOL TooLow; /* Is sensor too low? */
  1004. SK_U64 CurrTime; /* Current Time */
  1005. SK_BOOL DoTrapSend; /* We need to send a trap */
  1006. SK_BOOL DoErrLog; /* We need to log the error */
  1007. SK_BOOL IsError; /* We need to log the error */
  1009. /* Check Dummy Reads first */
  1010. if (pAC->I2c.DummyReads > 0) {
  1011. pAC->I2c.DummyReads --;
  1012. return;
  1013. }
  1015. /* Get the current time */
  1016. CurrTime = SkOsGetTime(pAC);
  1018. /* Set para to the most useful setting: The current sensor. */
  1019. ParaLocal.Para64 = (SK_U64) pAC->I2c.CurrSens;
  1021. /* Check the Value against the thresholds. First: Error Thresholds */
  1022. TooHigh = (pSen->SenValue > pSen->SenThreErrHigh);
  1023. TooLow = (pSen->SenValue < pSen->SenThreErrLow);
  1025. IsError = SK_FALSE;
  1026. if (TooHigh || TooLow) {
  1027. /* Error condition is satisfied */
  1028. DoTrapSend = SK_TRUE;
  1029. DoErrLog = SK_TRUE;
  1031. /* Now error condition is satisfied */
  1032. IsError = SK_TRUE;
  1034. if (pSen->SenErrFlag == SK_SEN_ERR_ERR) {
  1035. /* This state is the former one */
  1037. /* So check first whether we have to send a trap */
  1038. if (pSen->SenLastErrTrapTS + SK_SEN_ERR_TR_HOLD >
  1039.     CurrTime) {
  1040. /*
  1041.  * Do NOT send the Trap. The hold back time
  1042.  * has to run out first.
  1043.  */
  1044. DoTrapSend = SK_FALSE;
  1045. }
  1047. /* Check now whether we have to log an Error */
  1048. if (pSen->SenLastErrLogTS + SK_SEN_ERR_LOG_HOLD >
  1049.     CurrTime) {
  1050. /*
  1051.  * Do NOT log the error. The hold back time
  1052.  * has to run out first.
  1053.  */
  1054. DoErrLog = SK_FALSE;
  1055. }
  1056. } else {
  1057. /* We came from a different state */
  1058. /* -> Set Begin Time Stamp */
  1059. pSen->SenBegErrTS = CurrTime;
  1060. pSen->SenErrFlag = SK_SEN_ERR_ERR;
  1061. }
  1063. if (DoTrapSend) {
  1064. /* Set current Time */
  1065. pSen->SenLastErrTrapTS = CurrTime;
  1066. pSen->SenErrCts ++;
  1068. /* Queue PNMI Event */
  1069. SkEventQueue(pAC, SKGE_PNMI, (TooHigh ?
  1070. SK_PNMI_EVT_SEN_ERR_UPP :
  1071. SK_PNMI_EVT_SEN_ERR_LOW),
  1072. ParaLocal);
  1073. }
  1075. if (DoErrLog) {
  1076. /* Set current Time */
  1077. pSen->SenLastErrLogTS = CurrTime;
  1079. if (pSen->SenType == SK_SEN_TEMP) {
  1080. SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_I2C_E011,
  1081. SKERR_I2C_E011MSG);
  1082. } else if (pSen->SenType == SK_SEN_VOLT) {
  1083. SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_I2C_E012,
  1084. SKERR_I2C_E012MSG);
  1085. } else
  1086. {
  1087. SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_I2C_E015,
  1088. SKERR_I2C_E015MSG);
  1089. }
  1090. }
  1091. }
  1093. /* Check the Value against the thresholds */
  1094. /* 2nd: Warning thresholds */
  1095. TooHigh = (pSen->SenValue > pSen->SenThreWarnHigh);
  1096. TooLow = (pSen->SenValue < pSen->SenThreWarnLow);
  1099. if (!IsError && (TooHigh || TooLow)) {
  1100. /* Error condition is satisfied */
  1101. DoTrapSend = SK_TRUE;
  1102. DoErrLog = SK_TRUE;
  1104. if (pSen->SenErrFlag == SK_SEN_ERR_WARN) {
  1105. /* This state is the former one */
  1107. /* So check first whether we have to send a trap */
  1108. if (pSen->SenLastWarnTrapTS + SK_SEN_WARN_TR_HOLD >
  1109.     CurrTime) {
  1110. /*
  1111.  * Do NOT send the Trap. The hold back time
  1112.  * has to run out first.
  1113.  */
  1114. DoTrapSend = SK_FALSE;
  1115. }
  1117. /* Check now whether we have to log an Error */
  1118. if (pSen->SenLastWarnLogTS + SK_SEN_WARN_LOG_HOLD >
  1119.     CurrTime) {
  1120. /*
  1121.  * Do NOT log the error. The hold back time
  1122.  * has to run out first.
  1123.  */
  1124. DoErrLog = SK_FALSE;
  1125. }
  1126. } else {
  1127. /* We came from a different state */
  1128. /* -> Set Begin Time Stamp */
  1129. pSen->SenBegWarnTS = CurrTime;
  1130. pSen->SenErrFlag = SK_SEN_ERR_WARN;
  1131. }
  1133. if (DoTrapSend) {
  1134. /* Set current Time */
  1135. pSen->SenLastWarnTrapTS = CurrTime;
  1136. pSen->SenWarnCts ++;
  1138. /* Queue PNMI Event */
  1139. SkEventQueue(pAC, SKGE_PNMI, (TooHigh ?
  1140. SK_PNMI_EVT_SEN_WAR_UPP :
  1141. SK_PNMI_EVT_SEN_WAR_LOW),
  1142. ParaLocal);
  1143. }
  1145. if (DoErrLog) {
  1146. /* Set current Time */
  1147. pSen->SenLastWarnLogTS = CurrTime;
  1149. if (pSen->SenType == SK_SEN_TEMP) {
  1150. SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_I2C_E009,
  1151. SKERR_I2C_E009MSG);
  1152. } else if (pSen->SenType == SK_SEN_VOLT) {
  1153. SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_I2C_E010,
  1154. SKERR_I2C_E010MSG);
  1155. } else
  1156. {
  1157. SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_I2C_E014,
  1158. SKERR_I2C_E014MSG);
  1159. }
  1160. }
  1161. }
  1163. /* Check for NO error at all */
  1164. if (!IsError && !TooHigh && !TooLow) {
  1165. /* Set o.k. Status if no error and no warning condition */
  1166. pSen->SenErrFlag = SK_SEN_ERR_OK;
  1167. }
  1169. /* End of check against the thresholds */
  1171. /*
  1172.  * Check initialization state:
  1173.  * The VIO Thresholds need adaption
  1174.  */
  1175. if (!pSen->SenInit && pSen->SenReg == LM80_VT1_IN &&
  1176.      pSen->SenValue > SK_SEN_WARNLOW2C &&
  1177.      pSen->SenValue < SK_SEN_WARNHIGH2) {
  1178. pSen->SenThreErrLow = SK_SEN_ERRLOW2C; 
  1179. pSen->SenThreWarnLow = SK_SEN_WARNLOW2C; 
  1180. pSen->SenInit = SK_TRUE;
  1181. }
  1183. if (!pSen->SenInit && pSen->SenReg == LM80_VT1_IN &&
  1184.      pSen->SenValue > SK_SEN_WARNLOW2 &&
  1185.      pSen->SenValue < SK_SEN_WARNHIGH2C) {
  1186. pSen->SenThreErrHigh = SK_SEN_ERRHIGH2C; 
  1187. pSen->SenThreWarnHigh = SK_SEN_WARNHIGH2C; 
  1188. pSen->SenInit = SK_TRUE;
  1189. }
  1191. if (!pSen->SenInit) {
  1192. SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_I2C_E013, SKERR_I2C_E013MSG);
  1193. }
  1194. } /* SkI2cCheckSensor*/
  1197. /*
  1198.  * The only Event to be served is the timeout event
  1199.  *
  1200.  */
  1201. int SkI2cEvent(
  1202. SK_AC *pAC, /* Adapter Context */
  1203. SK_IOC IoC, /* I/O Context */
  1204. SK_U32 Event, /* Module specific Event */
  1205. SK_EVPARA Para) /* Event specific Parameter */
  1206. {
  1207. int ReadComplete;
  1208. SK_SENSOR *pSen;
  1209. SK_U32 Time;
  1210. SK_EVPARA ParaLocal;
  1211. int i;
  1213. switch (Event) {
  1214. case SK_I2CEV_IRQ:
  1215. case SK_I2CEV_TIM:
  1216. pSen = &pAC->I2c.SenTable[pAC->I2c.CurrSens];
  1217. ReadComplete = SkI2cReadSensor(pAC, IoC, pSen);
  1219. if (ReadComplete) {
  1220. /* Check sensor against defined thresholds */
  1221. SkI2cCheckSensor (pAC, pSen);
  1223. /* Increment Current and set appropriate Timeout */
  1224. Time = SK_I2C_TIM_SHORT;
  1226. pAC->I2c.CurrSens ++;
  1227. if (pAC->I2c.CurrSens == pAC->I2c.MaxSens) {
  1228. pAC->I2c.CurrSens = 0;
  1229. Time = SK_I2C_TIM_LONG;
  1230. }
  1232. /* Start Timer */
  1233. ParaLocal.Para64 = (SK_U64) 0;
  1234. SkTimerStart(pAC, IoC, &pAC->I2c.SenTimer, Time,
  1235. SKGE_I2C, SK_I2CEV_TIM, ParaLocal);
  1236. }
  1237. break;
  1238. case SK_I2CEV_CLEAR:
  1239. for (i = 0; i < SK_MAX_SENSORS; i ++) {
  1240. pAC->I2c.SenTable[i].SenErrFlag = SK_SEN_ERR_OK;
  1241. pAC->I2c.SenTable[i].SenErrCts = 0;
  1242. pAC->I2c.SenTable[i].SenWarnCts = 0;
  1243. pAC->I2c.SenTable[i].SenBegErrTS = 0;
  1244. pAC->I2c.SenTable[i].SenBegWarnTS = 0;
  1245. pAC->I2c.SenTable[i].SenLastErrTrapTS = (SK_U64)0;
  1246. pAC->I2c.SenTable[i].SenLastErrLogTS = (SK_U64)0;
  1247. pAC->I2c.SenTable[i].SenLastWarnTrapTS = (SK_U64)0;
  1248. pAC->I2c.SenTable[i].SenLastWarnLogTS = (SK_U64)0;
  1249. }
  1250. break;
  1251. default:
  1252. SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_I2C_E006, SKERR_I2C_E006MSG);
  1253. }
  1255. return(0);
  1256. } /* SkI2cEvent*/
  1258. #endif /* !SK_DIAG */