static int ak7343_read(struct i2c_client *client,
			unsigned long reg, unsigned long *val)
{
	unsigned long mfp_pin[2];
	unsigned long i2c0_mfps[] = {
		GPIO053_GPIO_53,		/* SCL */
		GPIO054_GPIO_54,		/* SDA */
	};
	unsigned long scl, sda;
	int ret = 0;
	scl = MFP_PIN_GPIO53;
	sda = MFP_PIN_GPIO54;
	i2c_lock_adapter(client->adapter);
	if (gpio_request(scl, "SCL")) {
		pr_err("Failed to request GPIO for SCL pin!\n");
		ret = -1;
		goto out0;
	}
	if (gpio_request(sda, "SDA")) {
		pr_err("Failed to request GPIO for SDA pin!\n");
		ret = -1;
		goto out1;
	};
	mfp_pin[0] = mfp_read(MFP_PIN_GPIO53);
	mfp_pin[1] = mfp_read(MFP_PIN_GPIO54);
	mfp_config(i2c0_mfps, ARRAY_SIZE(i2c0_mfps));
	i2c_start(scl, sda);
	if (i2c_sendbyte(scl, sda, (client->addr<<1) | 1) < 0) {
		ret = -1;
		goto out2;
	}
	if (i2c_sendbyte(scl, sda, (u8)reg) < 0) {
		ret = -1;
		goto out2;
	}
	if (i2c_rcvbyte(scl, sda, (u8 *)val) < 0) {
		ret = -1;
		goto out2;
	}
out2:
	i2c_stop(scl, sda);
	mfp_write(MFP_PIN_GPIO53, mfp_pin[0]);
	mfp_write(MFP_PIN_GPIO54, mfp_pin[1]);
	gpio_free(sda);
out1:
	gpio_free(scl);
out0:
	i2c_unlock_adapter(client->adapter);
	return ret;
}

unsigned int8 RTCRead(unsigned int8 address)
{
    int1 nack;
    unsigned int8 value = 0;

	i2c_start();
    nack = i2c_write(PCF8583_WRITE);
    if (nack) {
     i2c_stop();
     printf("rtcread nack 1\n\r");
    } else {
     nack = i2c_write(address);
     if (!nack) {
      i2c_start();
      nack = i2c_write(PCF8583_READ);
      if (!nack) {
       value  = i2c_read();
      } else      printf("rtcread nack 3\n\r");
     } else      printf("rtcread nack 2\n\r");
     i2c_stop();
    }
    return value;
}

// Read a byte, store in "value".
int8_t i2c_read_byte(uint8_t address, uint8_t *value)
{
  uint8_t ret=0;
  if (i2c_start()!=0)                                //I2C START
    return(1);                                  //Stop and return 0 if START fail
  ret |= i2c_write((address<<1)|I2C_READ_BIT);                // Write the I2C 7-bit address with R bit
  if (ret != 0)                                   // Returns 1 if failed
    return(1);

  *value = i2c_read(WITH_NACK);                           // Read byte from I2C Bus with NAK
  i2c_stop();                                     //I2C STOP
  return(0);                                      // Return success

}

void doI2CWrite(char** argv, char argc)
{
	if(argc == 3)
	{
		i2c_start();
		i2c_write(0x98);
		i2c_write(strtoint(argv[1]));
		i2c_write(strtoint(argv[2]));
		i2c_stop();
		printf("OK\n");
	}
	else
		printf("err: addr1 val1 addr2 val2\n");
}

void rtc_write_page(uint8_t start_register, uint8_t *buffer, uint8_t size)
{
  uint8_t i;

  i2c_start(); // 1

  i2c_write(RTC_ADDRESS | I2C_WRITE); // 2+3
  i2c_write(start_register); // 4+5

  for(i = 0; i < size; i++)
    i2c_write(buffer[i]); // 8+9

  i2c_stop(); // 6
}

uint8_t i2c_WriteBuffer(uint8_t nAddress, uint8_t *pByte, uint8_t nLen)
{
    uint8_t stat = 0;

    stat = i2c_start( nAddress, TW_WRITE );
    while ( nLen && !stat) {

        stat = i2c_write( *pByte );
    }
    i2c_stop();

    return stat;

}

static long read_mbbi(mbbiRecord *prec) {

epicsMutexLock(mutex);
   i2c_start();
   i2c_write_byte(PCA9571_RD_ADDR);
   prec->rval = i2c_read_byte(ACK);
   i2c_stop();
epicsMutexUnlock(mutex);

   if(prec->rval == 255)
      prec->rval = 0;

   return(0);
}

void Lcd::write(uint8_t value)
{
    // If it is a new line, set the cursor to the next line (1,0)
    if (value == '\n')
        setCursor(1,0);
    else
    {
        i2c_start(m_i2cAddress);
        i2c_write(RAM_WRITE_CMD);
        i2c_write(value);
        i2c_stop ();
        delay_ms (m_charDelay);
    }
}

uint8 accel_read(uint8 reg_addr) {
    uint8 result;

    i2c_start();
    i2c_write((MMA7455_I2CADDR << 1) | I2C_WRITE);
    i2c_write(reg_addr);
    i2c_repeated_restart();
    i2c_write((MMA7455_I2CADDR << 1) | I2C_READ);
    result = i2c_read();
    i2c_nack();
    i2c_stop();

    return result;
}

// Sende in Array MD49commands gesetzte Befehle für MD49 an AVR_Slave_DriveControl
// im Master-Transmitter-Mode
void sendMD49commands(void){
	uint8_t i;
	if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))){		// Slave bereit zum schreiben?
		i2c_write(0x00);  							// Buffer Startadresse setzen
		for (i=0;i<15;i++){
			i2c_write(MD49commands[i]);
		}
		i2c_stop();       							// Zugriff beenden
	}
	else
	{
	//		/* Fehlerbehandlung... */
	}
}

void show_version_msg()
{

  // show version message
  i2c_start(LCD_I2C_DEVICE_ID);
  i2c_tx(10);
  i2c_tx(2);
  i2c_tx(6);
  i=0;
  while (pgm_read_byte(&msg_version[i]) != '\0')
  i2c_tx(pgm_read_byte(&msg_version[i++])); 
  i2c_stop(); 	
	
}

void rtc_w(void)
{

   i2c_start();          // issue start signal
   i2c_wb(0xA2);         // address PCF8563
   i2c_wb(0);            // start from word at address 0 (configuration word)
   i2c_wb(0x20);         // write $20 to config. (pause counter...)
   i2c_wb(0);            // write 0 to cents word
   i2c_wb(0x20);         // write $20 to seconds word
   i2c_wb(0x34);         // write $30 to minutes word
   i2c_wb(0x11);         // write $11 to hours word
   i2c_wb(0x24);         // write $24 to day word
   i2c_wb(0x04);         // write $04 to weekday
   i2c_wb(0x02);         // write $08 to month
   i2c_wb(0x14);         // write $08 to year
   i2c_stop();           // issue stop signal
   i2c_start();          // issue start signal
   i2c_wb(0xA2);         // address PCF8530
   i2c_wb(0);            // start from word at address 0
   i2c_wb(0);            // write 0 to config word (enable counting)
   i2c_stop();           // issue stop signal

}

int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{
    I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
    I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
    int timeout;
    int count;
    int value;

    i2c_start(obj);

    // Wait until SB flag is set
    timeout = FLAG_TIMEOUT;
    while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
        timeout--;
        if (timeout == 0) {
            return -1;
        }
    }

    i2c->DR = __HAL_I2C_7BIT_ADD_READ(address);


    // Wait address is acknowledged
    timeout = FLAG_TIMEOUT;
    while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == RESET) {
        timeout--;
        if (timeout == 0) {
            return -1;
        }
    }
    __HAL_I2C_CLEAR_ADDRFLAG(&I2cHandle);

    // Read all bytes except last one
    for (count = 0; count < (length - 1); count++) {
        value = i2c_byte_read(obj, 0);
        data[count] = (char)value;
    }

    // If not repeated start, send stop.
    // Warning: must be done BEFORE the data is read.
    if (stop) {
        i2c_stop(obj);
    }

    // Read the last byte
    value = i2c_byte_read(obj, 1);
    data[count] = (char)value;

    return length;
}

// le do endereco de 8 bits, com endereco de 8 bytes (2k bit max)
unsigned char I2C_EEIN (unsigned char address)
{
    unsigned char data;

    i2c_start();
    i2c_write(0xA0);
    i2c_write(address);
    i2c_repStart();
    i2c_write(0xA1);
    data=i2c_read(0);
    i2c_stop();
    return(data);

}

/**
 * Set the speed of the motors
 *
 * @param motor_a Speed of motor 1
 * @param motor_b Speed of motor 2
 * @param motor_c Speed of motor 3
 * @param motor_d Speed of motor 4
 * @return If the setting was successful
 */
uint8_t motorcontrol_set_motors(uint8_t motor_a, uint8_t motor_b, uint8_t motor_c, uint8_t motor_d) {
#ifdef MOTORCONTROL_AVAILABLE
    if (i2c_start(I2C_ADDR_MOTORCONTROL + I2C_WRITE)) {
        i2c_write(MC_MOTOR_1_SPEED);
        i2c_write(motor_a);
        i2c_write(motor_b);
        i2c_write(motor_c);
        i2c_write(motor_d);
        i2c_stop();
        return 1;
    }
#endif /* MOTORCONTROL_AVAILABLE */
    return 0;
}

//----------------------------------------------------------
// EEPROM書き込み
// 引数（スレーブアドレス,アドレス,データ,バイト数）
void i2c_2_write(
    unsigned char addr,
    unsigned char* data,
    unsigned char bytecnt)
{
    i2c_start();
    i2c_writebyte(0xD0);     // SLA + W
    i2c_writebyte(addr);    // address(high 8bits)
    while(bytecnt > 0){
        i2c_writebyte(*data++);
        bytecnt--;
    }
    i2c_stop();
}

//New version WH, Tested OK for Start and Repeated Start
//Old version was Wrong: Calls i2c_start without setting address, i2c_do_read continues before checking status, status check for wrong value
int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {
    int count, status;
    
    //Store the address+RD and then generate STA
    I2C_DAT(obj) = address | 0x01;
    i2c_start(obj);    

    // Wait for completion of STA and Sending of SlaveAddress+RD and first Read byte
    i2c_wait_SI(obj);
    status = i2c_status(obj);    
    if (status == 0x03) { // NAK on SlaveAddress
        i2c_stop(obj);
        return I2C_ERROR_NO_SLAVE;
    }

    // Read in all except last byte
    for (count = 0; count < (length-1); count++) {
        
      // Wait for it to arrive, note that first byte read after address+RD is already waiting
      i2c_wait_SI(obj);
      status = i2c_status(obj);
      if (status != 0x01) { // RX RDY
        i2c_stop(obj);
        return count;
      }
      data[count] = I2C_DAT(obj) & 0xFF; // Store read byte

      obj->i2c->MSTCTL = (1 << 0); // Send ACK and Continue to read
    }
    
    // Read final byte
    // Wait for it to arrive
    i2c_wait_SI(obj);

    status = i2c_status(obj);
    if (status != 0x01) { // RX RDY
      i2c_stop(obj);
      return count;
    }
    data[count] = I2C_DAT(obj) & 0xFF; // Store final read byte

    // If not repeated start, send stop.
    if (stop) {
        i2c_stop(obj); // Also sends NAK for last read byte
    } else {
        repeated_start = 1;
    }
   
    return length;
}

void write_nineAxisMag(uint8_t address, uint8_t byte) {
    unsigned char ret;
    ret = i2c_start(NineAxisMag+I2C_WRITE);       // set device address and write mode
    if ( ret ) {
        /* failed to issue start condition, possibly no device found */
    	printString("Could not write to Nine-Axis Mag !!!\r\n");
        i2c_stop();
    } else {
        /* issuing start condition ok, device accessible */
        i2c_write(address);                    // write register address
        i2c_write(byte);                       // ret=0 -> OK, ret=1 -> no ACK
        i2c_stop();                            // set stop conditon = release bus
    }
}

int16_t lm75_gettemp(uint8_t device){
    device = LM75_BASE + (device << 1);
    if(i2c_start(device + 1)){
        return 100;
    }else{
        int16_t a = i2c_readAck() << 1;
        uint8_t b = i2c_readNak() >> 7;
        i2c_stop();
        if(a & 256)
            a |= 0xfe00;
        return a+b;
        //return 50*2+1;
    }
}

/* This performs a fast read of one or more consecutive bytes from an
 * I2C device.  Not all devices support consecutive reads of more than
 * one byte; for these devices use efx_i2c_read() instead.
 */
int efx_i2c_fast_read(struct efx_i2c_interface *i2c,
		      u8 device_id, u8 offset, u8 *data, unsigned int len)
{
	int i;
	int rc;

	EFX_WARN_ON_PARANOID(getsda(i2c) != 1);
	EFX_WARN_ON_PARANOID(getscl(i2c) != 1);
	EFX_WARN_ON_PARANOID(data == NULL);
	EFX_WARN_ON_PARANOID(len < 1);

	/* Select device and starting offset */
	i2c_start(i2c);
	rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
	if (rc)
		goto out;
	rc = i2c_send_byte(i2c, offset);
	if (rc)
		goto out;

	/* Read data from device */
	i2c_start(i2c);
	rc = i2c_send_byte(i2c, i2c_read_cmd(device_id));
	if (rc)
		goto out;
	for (i = 0; i < (len - 1); i++)
		/* Read and acknowledge all but the last byte */
		data[i] = i2c_recv_byte(i2c, 1);
	/* Read last byte with no acknowledgement */
	data[i] = i2c_recv_byte(i2c, 0);

 out:
	i2c_stop(i2c);
	i2c_release(i2c);

	return rc;
}