| #ifndef I2C_H |
| #define I2C_H |
| |
| /**************************************************** |
| * |
| * Copyright Motrola 1999 |
| * |
| ****************************************************/ |
| #define get_eumbbar() CFG_EUMB_ADDR |
| |
| #define I2CADR 0x00003000 |
| #define I2CFDR 0x00003004 |
| #define I2CCR 0x00003008 |
| #define I2CSR 0x0000300C |
| #define I2CDR 0x00003010 |
| |
| typedef enum _i2cstatus |
| { |
| I2CSUCCESS = 0x3000, |
| I2CADDRESS, |
| I2CERROR, |
| I2CBUFFFULL, |
| I2CBUFFEMPTY, |
| I2CXMITERROR, |
| I2CRCVERROR, |
| I2CBUSBUSY, |
| I2CALOSS, |
| I2CNOEVENT, |
| } I2CStatus; |
| |
| typedef enum i2c_control |
| { |
| MEN = 0x00000080, |
| MIEN = 0x00000040, |
| MSTA = 0x00000020, |
| MTX = 0x00000010, |
| TXAK = 0x00000008, |
| RSTA = 0x00000004, |
| } I2C_CONTROL; |
| |
| typedef enum i2c_status |
| { |
| MCF = 0x00000080, |
| MAAS = 0x00000040, |
| MBB = 0x00000020, |
| MAL = 0x00000010, |
| SRW = 0x00000004, |
| MIF = 0x00000002, |
| RXAK = 0x00000001, |
| } I2C_STATUS; |
| |
| typedef struct _i2c_ctrl |
| { |
| unsigned int reserved0 : 24; |
| unsigned int men : 1; |
| unsigned int mien : 1; |
| unsigned int msta : 1; |
| unsigned int mtx : 1; |
| unsigned int txak : 1; |
| unsigned int rsta : 1; |
| unsigned int reserved1 : 2; |
| } I2C_CTRL; |
| |
| typedef struct _i2c_stat |
| { |
| unsigned int rsrv0 : 24; |
| unsigned int mcf : 1; |
| unsigned int maas : 1; |
| unsigned int mbb : 1; |
| unsigned int mal : 1; |
| unsigned int rsrv1 : 1; |
| unsigned int srw : 1; |
| unsigned int mif : 1; |
| unsigned int rxak : 1; |
| } I2C_STAT; |
| |
| typedef enum _i2c_mode |
| { |
| RCV = 0, |
| XMIT = 1, |
| } I2C_MODE; |
| |
| /******************** App. API ******************** |
| * The application API is for user level application |
| * to use the funcitonality provided by I2C driver |
| * |
| * Note: Its App.s responsibility to swap the data |
| * byte. In our API, we just transfer whatever |
| * we are given |
| **************************************************/ |
| /** |
| * Note: |
| * |
| * In all following functions, |
| * the caller shall pass the configured embedded utility memory |
| * block base, EUMBBAR. |
| **/ |
| |
| /* Send a buffer of data to the intended rcv_addr. |
| * If stop_flag is set, after the whole buffer |
| * is sent, generate a STOP signal provided that the |
| * receiver doesn't signal the STOP in the middle. |
| * I2C is the master performing transmitting. If |
| * no STOP signal is generated at the end of current |
| * transaction, the master can generate a START signal |
| * to another slave addr. |
| * |
| * return I2CSUCCESS if no error. |
| */ |
| static I2CStatus I2C_put( unsigned int eumbbar, |
| unsigned char rcv_addr, /* receiver's address */ |
| unsigned char *buffer_ptr, /* pointer of data to be sent */ |
| unsigned int length, /* number of byte of in the buffer */ |
| unsigned int stop_flag, /* 1 - signal STOP when buffer is empty |
| * 0 - no STOP signal when buffer is empty |
| */ |
| unsigned int is_cnt ); /* 1 - this is a restart, don't check MBB |
| * 0 - this is a new start, check MBB |
| */ |
| |
| /* Receive a buffer of data from the desired sender_addr |
| * If stop_flag is set, when the buffer is full and the |
| * sender does not signal STOP, generate a STOP signal. |
| * I2C is the master performing receiving. If no STOP signal |
| * is generated, the master can generate a START signal |
| * to another slave addr. |
| * |
| * return I2CSUCCESS if no error. |
| */ |
| static I2CStatus I2C_get( unsigned int eumbbar, |
| unsigned char sender_addr, /* sender's address */ |
| unsigned char *buffer_ptr, /* pointer of receiving buffer */ |
| unsigned int length, /* length of the receiving buffer */ |
| unsigned int stop_flag, /* 1 - signal STOP when buffer is full |
| * 0 - no STOP signal when buffer is full |
| */ |
| unsigned int is_cnt ); /* 1 - this is a restart, don't check MBB |
| * 0 - this is a new start, check MBB |
| */ |
| |
| #if 0 /* the I2C_write and I2C_read functions are not active */ |
| /* Send a buffer of data to the requiring master. |
| * If stop_flag is set, after the whole buffer is sent, |
| * generate a STOP signal provided that the requiring |
| * receiver doesn't signal the STOP in the middle. |
| * I2C is the slave performing transmitting. |
| * |
| * return I2CSUCCESS if no error. |
| * |
| * Note: due to the Kahlua design, slave transmitter |
| * shall not signal STOP since there is no way |
| * for master to detect it, causing I2C bus hung. |
| * |
| * For the above reason, the stop_flag is always |
| * set, i.e., 1. |
| * |
| * programmer shall use the timer on Kahlua to |
| * control the interval of data byte at the |
| * master side. |
| */ |
| static I2CStatus I2C_write( unsigned int eumbbar, |
| unsigned char *buffer_ptr, /* pointer of data to be sent */ |
| unsigned int length, /* number of byte of in the buffer */ |
| unsigned int stop_flag ); /* 1 - signal STOP when buffer is empty |
| * 0 - no STOP signal when buffer is empty |
| */ |
| |
| /* Receive a buffer of data from the sending master. |
| * If stop_flag is set, when the buffer is full and the |
| * sender does not signal STOP, generate a STOP signal. |
| * I2C is the slave performing receiving. |
| * |
| * return I2CSUCCESS if no error. |
| */ |
| static I2CStatus I2C_read(unsigned int eumbbar, |
| unsigned char *buffer_ptr, /* pointer of receiving buffer */ |
| unsigned int length, /* length of the receiving buffer */ |
| unsigned int stop_flag ); /* 1 - signal STOP when buffer is full |
| * 0 - no STOP signal when buffer is full |
| */ |
| #endif /* of if0 for turning off I2C_read & I2C_write */ |
| |
| /* if interrupt is not used, this is the timer event handler. |
| * After each fixed time interval, this function can be called |
| * to check the I2C status and call appropriate function to |
| * handle the status event. |
| */ |
| static I2CStatus I2C_Timer_Event( unsigned int eumbbar, I2CStatus (*handler)( unsigned int ) ); |
| |
| /********************* Kernel API ************************ |
| * Kernel APIs are functions I2C driver provides to the |
| * O.S. |
| *********************************************************/ |
| |
| /******************* device I/O function ***************/ |
| |
| /* Generate a START signal in the desired mode. |
| * I2C is the master. |
| * |
| * return I2CSUCCESS if no error. |
| * I2CERROR if i2c unit is not enabled. |
| * I2CBUSBUSY if bus cannot be granted |
| */ |
| static I2CStatus I2C_Start( unsigned int eumbbar, |
| unsigned char slave_addr, /* address of the receiver */ |
| I2C_MODE mode, /* XMIT(1) - put (write) |
| * RCV(0) - get (read) |
| */ |
| unsigned int is_cnt ); /* 1 - this is a restart, don't check MBB |
| * 0 - this is a new start, check MBB |
| */ |
| |
| /* Generate a STOP signal to terminate the transaction. */ |
| static I2CStatus I2C_Stop( unsigned int eumbbar ); |
| |
| /* Do a one-byte master transmit. |
| * |
| * return I2CBUFFEMPTY if this is the last byte. |
| * Otherwise return I2CSUCCESS |
| */ |
| static I2CStatus I2C_Master_Xmit( unsigned int eumbbar ); |
| |
| /* Do a one-byte master receive. |
| * |
| * return I2CBUFFFULL if this is the last byte. |
| * Otherwise return I2CSUCCESS |
| */ |
| static I2CStatus I2C_Master_Rcv( unsigned int eumbbar ); |
| |
| /* Do a one-byte slave transmit. |
| * |
| * return I2CBUFFEMPTY if this is the last byte. |
| * Otherwise return I2CSUCCESS |
| * |
| */ |
| static I2CStatus I2C_Slave_Xmit( unsigned int eumbbar ); |
| |
| /* Do a one-byte slave receive. |
| * |
| * return I2CBUFFFULL if this is the last byte. |
| * Otherwise return I2CSUCCESS |
| */ |
| static I2CStatus I2C_Slave_Rcv( unsigned int eumbbar ); |
| |
| /* Process slave address phase. |
| * |
| * return I2CADDRESS if this is slave receiver's address phase |
| * Otherwise return the result of slave xmit one byte. |
| */ |
| static I2CStatus I2C_Slave_Addr( unsigned int eumbbar ); |
| |
| /******************* Device Control Fucntion ****************/ |
| /* Initialize I2C unit with desired frequency divider, |
| * driver's slave address w/o interrupt enabled. |
| * |
| * This function must be called before I2C unit can |
| * be used. |
| */ |
| static I2CStatus I2C_Init( unsigned int eumbbar, |
| unsigned char fdr, /* frequency divider */ |
| unsigned char addr, /* driver's address used for receiving */ |
| unsigned int en_int); /* 1 - enable I2C interrupt |
| * 0 - disable I2C interrup |
| */ |
| |
| /* I2C interrupt service routine. |
| * |
| * return I2CADDRESS if it is receiver's (either master or slave) address phase. |
| * return the result of xmit or receive one byte |
| */ |
| static I2CStatus I2C_ISR(unsigned int eumbbar ); |
| |
| /* Set I2C Status, i.e., write to I2CSR */ |
| static void I2C_Set_Stat( unsigned int eumbbar, I2C_STAT stat ); |
| |
| /* Query I2C Status, i.e., read I2CSR */ |
| static I2C_STAT I2C_Get_Stat( unsigned int eumbbar ); |
| |
| /* Change I2C Control bits, i.e., write to I2CCR */ |
| static void I2C_Set_Ctrl( unsigned int eumbbar, I2C_CTRL ); /* new control value */ |
| |
| /* Query I2C Control bits, i.e., read I2CCR */ |
| static I2C_CTRL I2C_Get_Ctrl( unsigned int eumbbar ); |
| |
| /* This function performs the work for I2C_do_transaction. The work is |
| * split into this function to enable I2C_do_transaction to first transmit |
| * the data address to the I2C slave device without putting the data address |
| * into the first byte of the buffer. |
| * |
| * en_int controls interrupt/polling mode |
| * act is the type of transaction |
| * i2c_addr is the I2C address of the slave device |
| * len is the length of data to send or receive |
| * buffer is the address of the data buffer |
| * stop = I2C_NO_STOP, don't signal STOP at end of transaction |
| * I2C_STOP, signal STOP at end of transaction |
| * retry is the timeout retry value, currently ignored |
| * rsta = I2C_NO_RESTART, this is not continuation of existing transaction |
| * I2C_RESTART, this is a continuation of existing transaction |
| */ |
| static I2C_Status I2C_do_buffer( I2C_INTERRUPT_MODE en_int, |
| I2C_TRANSACTION_MODE act, |
| unsigned char i2c_addr, |
| int len, |
| unsigned char *buffer, |
| I2C_STOP_MODE stop, |
| int retry, |
| I2C_RESTART_MODE rsta); |
| #endif |
