lpc177x_8x_i2c.c

LPC1788的USBHOST的FATFS移植

								I2Cx->CONCLR = I2C_I2CONCLR_AAC | I2C_I2CONCLR_SIC;
							}
							// Don't need issue an repeat start, just goto send SLA+R
							else
							{
								goto send_slar;
							}
					}
					// no more data send, the go to end stage now
					else
					{
						// success, goto end stage
						txrx_setup->status |= I2C_SETUP_STATUS_DONE;

						goto end_stage;
					}
				}
				break;

			/* SLA+W has been transmitted, NACK has been received ----------------------*/
			case I2C_I2STAT_M_TX_SLAW_NACK:

			/* Data has been transmitted, NACK has been received -----------------------*/
			case I2C_I2STAT_M_TX_DAT_NACK:
				// update status
				txrx_setup->status |= I2C_SETUP_STATUS_NOACKF;
				goto retry;

			/* Arbitration lost in SLA+R/W or Data bytes -------------------------------*/
			case I2C_I2STAT_M_TX_ARB_LOST:
				// update status
				txrx_setup->status |= I2C_SETUP_STATUS_ARBF;

			default:
				goto retry;
		}
	}

	/* ----------------------------- RECEIVE PHASE --------------------------*/
	else if (i2cdat[i2cId].dir == 1)
	{
		switch (returnCode)
		{
				/* A start/repeat start condition has been transmitted ---------------------*/
			case I2C_I2STAT_M_RX_START:

			case I2C_I2STAT_M_RX_RESTART:
				I2Cx->CONCLR = I2C_I2CONCLR_STAC;
				/*
				 * If there's any receive data, then start to
				 * send SLA+R right now, otherwise check whether if there's
				 * any receive data for end of state.
				 */
				if ((txrx_setup->rx_data != NULL) && (txrx_setup->rx_length != 0))
				{
	send_slar:
					I2Cx->DAT = (txrx_setup->sl_addr7bit << 1) | 0x01;
					I2Cx->CONCLR = I2C_I2CONCLR_SIC;
				}
				else
				{
					// Success, goto end stage
					txrx_setup->status |= I2C_SETUP_STATUS_DONE;
					goto end_stage;
				}

				break;

			/* SLA+R has been transmitted, ACK has been received -----------------*/
			case I2C_I2STAT_M_RX_SLAR_ACK:
				if (txrx_setup->rx_count < (txrx_setup->rx_length - 1))
				{
					/*Data will be received,  ACK will be return*/
					I2Cx->CONSET = I2C_I2CONSET_AA;
				}
				else
				{
					/*Last data will be received,  NACK will be return*/
					I2Cx->CONCLR = I2C_I2CONSET_AA;
				}

				I2Cx->CONCLR = I2C_I2CONCLR_SIC;
				break;

			/* Data has been received, ACK has been returned ----------------------*/
			case I2C_I2STAT_M_RX_DAT_ACK:
				// Note save data and increase counter first, then check later
				/* Save data  */
				if ((txrx_setup->rx_data != NULL) && (txrx_setup->rx_count < txrx_setup->rx_length))
				{
					*(uint8_t *)(txrx_setup->rx_data + txrx_setup->rx_count) = (I2Cx->DAT & I2C_I2DAT_BITMASK);

					txrx_setup->rx_count++;
				}
				if (txrx_setup->rx_count < (txrx_setup->rx_length - 1))
				{
					/*Data will be received,  ACK will be return*/
					I2Cx->CONSET = I2C_I2CONSET_AA;
				}
				else
				{
					/*Last data will be received,  NACK will be return*/
					I2Cx->CONCLR = I2C_I2CONSET_AA;
				}

				I2Cx->CONCLR = I2C_I2CONCLR_SIC;
				break;

			/* Data has been received, NACK has been return -------------------------*/
			case I2C_I2STAT_M_RX_DAT_NACK:
				/* Save the last data */
				if ((txrx_setup->rx_data != NULL) && (txrx_setup->rx_count < txrx_setup->rx_length))
				{
					*(uint8_t *)(txrx_setup->rx_data + txrx_setup->rx_count) = (I2Cx->DAT & I2C_I2DAT_BITMASK);

					txrx_setup->rx_count++;
				}
				// success, go to end stage
				txrx_setup->status |= I2C_SETUP_STATUS_DONE;

				goto end_stage;

			/* SLA+R has been transmitted, NACK has been received ------------------*/
			case I2C_I2STAT_M_RX_SLAR_NACK:
				// update status
				txrx_setup->status |= I2C_SETUP_STATUS_NOACKF;
				goto retry;

			/* Arbitration lost ----------------------------------------------------*/
			case I2C_I2STAT_M_RX_ARB_LOST:
				// update status
				txrx_setup->status |= I2C_SETUP_STATUS_ARBF;

			default:
	retry:
				// check if retransmission is available
				if (txrx_setup->retransmissions_count < txrx_setup->retransmissions_max)
				{
					// Clear tx count
					txrx_setup->tx_count = 0;

					I2Cx->CONSET = I2C_I2CONSET_STA;

					I2Cx->CONCLR = I2C_I2CONCLR_AAC | I2C_I2CONCLR_SIC;

					txrx_setup->retransmissions_count++;
				}
				// End of stage
				else
				{
	end_stage:
					// Disable interrupt
					I2C_IntCmd(i2cId, 0);

					// Send stop
					I2C_Stop(I2Cx);

					I2C_MasterComplete[i2cId] = TRUE;
				}
				break;
		}
	}
}


/*********************************************************************//**
 * @brief 		General Slave Interrupt handler for I2C peripheral
 * @param[in]	I2Cx	I2C peripheral selected, should be:
 *  			- LPC_I2C0
 *  			- LPC_I2C1
 *  			- LPC_I2C2
 * @return 		None
 **********************************************************************/
void I2C_SlaveHandler (uint8_t i2cId)
{
	LPC_I2C_TypeDef* I2Cx = I2C_GetPointer(i2cId);

	uint8_t returnCode;
	I2C_S_SETUP_Type *txrx_setup;
	uint32_t timeout;

	txrx_setup = (I2C_S_SETUP_Type *) i2cdat[i2cId].txrx_setup;

	returnCode = (I2Cx->STAT & I2C_STAT_CODE_BITMASK);
	// Save current status
	txrx_setup->status = returnCode;
	// there's no relevant information
	if (returnCode == I2C_I2STAT_NO_INF)
	{
		I2Cx->CONCLR = I2C_I2CONCLR_SIC;

		return;
	}


	switch (returnCode)
	{

		/* No status information */
		case I2C_I2STAT_NO_INF:
			I2Cx->CONSET = I2C_I2CONSET_AA;
			I2Cx->CONCLR = I2C_I2CONCLR_SIC;
			break;

		/* Reading phase -------------------------------------------------------- */
		/* Own SLA+R has been received, ACK has been returned */
		case I2C_I2STAT_S_RX_SLAW_ACK:

		/* General call address has been received, ACK has been returned */
		case I2C_I2STAT_S_RX_GENCALL_ACK:
			I2Cx->CONSET = I2C_I2CONSET_AA;
			I2Cx->CONCLR = I2C_I2CONCLR_SIC;
			break;

		/* Previously addressed with own SLA;
		 * DATA byte has been received;
		 * ACK has been returned */
		case I2C_I2STAT_S_RX_PRE_SLA_DAT_ACK:

		/* DATA has been received, ACK hasn been return */
		case I2C_I2STAT_S_RX_PRE_GENCALL_DAT_ACK:
			/*
			 * All data bytes that over-flow the specified receive
			 * data length, just ignore them.
			 */
			if ((txrx_setup->rx_count < txrx_setup->rx_length) && (txrx_setup->rx_data != NULL))
			{
				*(uint8_t *)(txrx_setup->rx_data + txrx_setup->rx_count) = (uint8_t)I2Cx->DAT;

				txrx_setup->rx_count++;
			}

			I2Cx->CONSET = I2C_I2CONSET_AA;
			I2Cx->CONCLR = I2C_I2CONCLR_SIC;

			break;

		/* Previously addressed with own SLA;
		 * DATA byte has been received;
		 * NOT ACK has been returned */
		case I2C_I2STAT_S_RX_PRE_SLA_DAT_NACK:

		/* DATA has been received, NOT ACK has been returned */
		case I2C_I2STAT_S_RX_PRE_GENCALL_DAT_NACK:
			I2Cx->CONCLR = I2C_I2CONCLR_SIC;
			break;

		/*
		 * Note that: Return code only let us know a stop condition mixed
		 * with a repeat start condition in the same code value.
		 * So we should provide a time-out. In case this is really a stop
		 * condition, this will return back after time out condition. Otherwise,
		 * next session that is slave receive data will be completed.
		 */

		/* A Stop or a repeat start condition */
		case I2C_I2STAT_S_RX_STA_STO_SLVREC_SLVTRX:
			// Temporally lock the interrupt for timeout condition
			I2C_IntCmd(i2cId, 0);

			I2Cx->CONCLR = I2C_I2CONCLR_SIC;
			// enable time out
			timeout = I2C_SLAVE_TIME_OUT;
			while(1)
			{
				if (I2Cx->CONSET & I2C_I2CONSET_SI)
				{
					// re-Enable interrupt
					I2C_IntCmd(i2cId, 1);

					break;
				}
				else
				{
					timeout--;

					if (timeout == 0)
					{
						// timeout occur, it's really a stop condition
						txrx_setup->status |= I2C_SETUP_STATUS_DONE;

						goto s_int_end;
					}
				}
			}
			break;

		/* Writing phase -------------------------------------------------------- */
		/* Own SLA+R has been received, ACK has been returned */
		case I2C_I2STAT_S_TX_SLAR_ACK:

		/* Data has been transmitted, ACK has been received */
		case I2C_I2STAT_S_TX_DAT_ACK:
			/*
			 * All data bytes that over-flow the specified receive
			 * data length, just ignore them.
			 */
			if ((txrx_setup->tx_count < txrx_setup->tx_length) && (txrx_setup->tx_data != NULL))
			{
				I2Cx->DAT = *(uint8_t *) (txrx_setup->tx_data + txrx_setup->tx_count);

				txrx_setup->tx_count++;
			}

			I2Cx->CONSET = I2C_I2CONSET_AA;
			I2Cx->CONCLR = I2C_I2CONCLR_SIC;

			break;

		/* Data has been transmitted, NACK has been received,
		 * that means there's no more data to send, exit now */
		/*
		 * Note: Don't wait for stop event since in slave transmit mode,
		 * since there no proof lets us know when a stop signal has been received
		 * on slave side.
		 */
		case I2C_I2STAT_S_TX_DAT_NACK:
			I2Cx->CONSET = I2C_I2CONSET_AA;
			I2Cx->CONCLR = I2C_I2CONCLR_SIC;
			txrx_setup->status |= I2C_SETUP_STATUS_DONE;
			goto s_int_end;

		// Other status must be captured
		default:
	s_int_end:
			// Disable interrupt
			I2C_IntCmd(i2cId, 0);

			I2Cx->CONCLR = I2C_I2CONCLR_AAC | I2C_I2CONCLR_SIC | I2C_I2CONCLR_STAC;

			I2C_SlaveComplete[i2cId] = TRUE;
			break;
	}
}

/*********************************************************************//**
 * @brief 		Transmit and Receive data in master mode
 * @param[in]	I2Cx			I2C peripheral selected, should be:
 *  			- LPC_I2C0
 * 				- LPC_I2C1
 * 				- LPC_I2C2
 * @param[in]	TransferCfg		Pointer to a I2C_M_SETUP_Type structure that
 * 								contains specified information about the
 * 								configuration for master transfer.
 * @param[in]	Opt				a I2C_TRANSFER_OPT_Type type that selected for
 * 								interrupt or polling mode.
 * @return 		SUCCESS or ERROR
 *
 * Note:
 * - In case of using I2C to transmit data only, either transmit length set to 0
 * or transmit data pointer set to NULL.
 * - In case of using I2C to receive data only, either receive length set to 0
 * or receive data pointer set to NULL.
 * - In case of using I2C to transmit followed by receive data, transmit length,
 * transmit data pointer, receive length and receive data pointer should be set
 * corresponding.
 **********************************************************************/
Status I2C_MasterTransferData(uint8_t i2cId, I2C_M_SETUP_Type *TransferCfg,
																	I2C_TRANSFER_OPT_Type Opt)
{
	LPC_I2C_TypeDef* I2Cx = I2C_GetPointer(i2cId);

	uint8_t *txdat;
	uint8_t *rxdat;
	uint32_t CodeStatus;
	uint8_t tmp;

	// reset all default state
	txdat = (uint8_t *) TransferCfg->tx_data;
	rxdat = (uint8_t *) TransferCfg->rx_data;

	// Reset I2C setup value to default state
	TransferCfg->tx_count = 0;
	TransferCfg->rx_count = 0;
	TransferCfg->status = 0;

	if (Opt == I2C_TRANSFER_POLLING)
	{
		/* First Start condition -------------------------------------------------------------- */
		TransferCfg->retransmissions_count = 0;
retry:
		// reset all default state
		txdat = (uint8_t *) TransferCfg->tx_data;
		rxdat = (uint8_t *) TransferCfg->rx_data;

		// Reset I2C setup value to default state
		TransferCfg->tx_count = 0;
		TransferCfg->rx_count = 0;

		CodeStatus = 0;

		// Start command
		CodeStatus = I2C_Start(I2Cx);

		if ((CodeStatus != I2C_I2STAT_M_TX_START) && (CodeStatus != I2C_I2STAT_M_TX_RESTART))
		{
			TransferCfg->retransmissions_count++;
			if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max)
			{
				// save status
				TransferCfg->status = CodeStatus;

				goto error;
			}
			else
			{
				goto retry;
			}
		}

		/* In case of sending data first --------------------------------------------------- */
		if ((TransferCfg->tx_length != 0) && (TransferCfg->tx_data != NULL))
		{
			/* Send slave address + WR direction bit = 0 ----------------------------------- */
			CodeStatus = I2C_SendByte(I2Cx, (TransferCfg->sl_addr7bit << 1));

			if (CodeStatus != I2C_I2STAT_M_TX_SLAW_ACK)
			{
				TransferCfg->retransmissions_count++;

				if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max)
				{
					// save status
					TransferCfg->status = CodeStatus | I2C_SETUP_STATUS_NOACKF;

					goto error;
				}
				else
				{
					goto retry;
				}
			}

			/* Send a number of data bytes ---------------------------------------- */
			while (TransferCfg->tx_count < TransferCfg->tx_length)
			{
				CodeStatus = I2C_SendByte(I2Cx, *txdat);

				if (CodeStatus != I2C_I2STAT_M_TX_DAT_ACK)
				{
					TransferCfg->retransmissions_count++;

					if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max)
					{
						// save status
						TransferCfg->status = CodeStatus | I2C_SETUP_STATUS_NOACKF;

						goto error;
					}
					else
					{
						goto retry;
					}
				}

				txdat++;

				TransferCfg->tx_count++;
			}
		}

		/* Second Start condition (Repeat Start) ------------------------------------------- */
		if ((TransferCfg->tx_length != 0) && (TransferCfg->tx_data != NULL) \
				&& (TransferCfg->rx_length != 0) && (TransferCfg->rx_data != NULL))
		{
			CodeStatus = I2C_Start(I2Cx);

			if ((CodeStatus != I2C_I2STAT_M_RX_START) \
					&& (CodeStatus != I2C_I2STAT_M_RX_RESTART))
			{
				TransferCfg->retransmissions_count++;

				if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max)
				{
					// Update status
					TransferCfg->status = CodeStatus;
					goto error;
				}
				else
				{
					goto retry;
				}
			}
		}

		/* Then, start reading after sending data -------------------------------------- */
		if ((TransferCfg->rx_length != 0) && (TransferCfg->rx_data != NULL))
		{
			/* Send slave address + RD direction bit = 1 ----------------------------------- */

			CodeStatus = I2C_SendByte(I2Cx, ((TransferCfg->sl_addr7bit << 1) | 0x01));

			if (CodeStatus != I2C_I2STAT_M_RX_SLAR_ACK)
			{
				TransferCfg->retransmissions_count++;

				if (TransferCfg->retransmissions_count > TransferCfg->retransmissions_max)
				{
					// update status
					TransferCfg->status = CodeStatus | I2C_SETUP_STATUS_NOACKF;

					goto error;
				}
				else
				{
					goto retry;
				}
			}

			/* Receive a number of data bytes ------------------------------------------------- */
			while (TransferCfg->rx_count < TransferCfg->rx_length)
			{
				/*
				 * Note that: if data length is only one, the master should not
				 * issue an ACK signal on bus after reading to avoid of next data frame
				 * on slave side
				 */
				if (TransferCfg->rx_count < (TransferCfg->rx_length - 1))
				{
					// Issue an ACK signal for next data frame
					CodeStatus = I2C_GetByte(I2Cx, &tmp, 1);

					if (CodeStatus != I2C_I2STAT_M_RX_DAT_ACK)
					{
						TransferCfg->retransmissions_count++;