/*
* Raise scl line, and do checking for delays. This is necessary for slower
* devices.
*/
static int sclhi(struct i2c_algo_bit_data *adap)
{
unsigned long start;
setscl(adap, 1);
/* Not all adapters have scl sense line... */
if (!adap->getscl)
goto done;
start = jiffies;
while (!getscl(adap)) {
/* This hw knows how to read the clock line, so we wait
* until it actually gets high. This is safer as some
* chips may hold it low ("clock stretching") while they
* are processing data internally.
*/
<<<<<<< HEAD
if (time_after(jiffies, start + adap->timeout)) {
/* Test one last time, as we may have been preempted
* between last check and timeout test.
*/
if (getscl(adap))
break;
return -ETIMEDOUT;
}
=======
if (time_after(jiffies, start + adap->timeout))
/* I2C receiving of bytes - does not send an offset byte */
int efx_i2c_recv_bytes(struct efx_i2c_interface *i2c, u8 device_id,
u8 *bytes, 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(len < 1);
/* Select device */
i2c_start(i2c);
/* Read data from device */
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 */
bytes[i] = i2c_recv_byte(i2c, 1);
/* Read last byte with no acknowledgement */
bytes[i] = i2c_recv_byte(i2c, 0);
out:
i2c_stop(i2c);
i2c_release(i2c);
return rc;
}
/* This performs a fast write of one or more consecutive bytes to an
* I2C device. Not all devices support consecutive writes of more
* than one byte; for these devices use efx_i2c_write() instead.
*/
int efx_i2c_fast_write(struct efx_i2c_interface *i2c,
u8 device_id, u8 offset,
const 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(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;
/* Write data to device */
for (i = 0; i < len; i++) {
rc = i2c_send_byte(i2c, data[i]);
if (rc)
goto out;
}
out:
i2c_stop(i2c);
i2c_release(i2c);
return rc;
}
static inline void i2c_release(struct efx_i2c_interface *i2c)
{
EFX_WARN_ON_PARANOID(!i2c->scl);
EFX_WARN_ON_PARANOID(!i2c->sda);
/* Devices may time out if operations do not end */
setscl(i2c, 1);
setsda(i2c, 1);
EFX_BUG_ON_PARANOID(getsda(i2c) != 1);
EFX_BUG_ON_PARANOID(getscl(i2c) != 1);
}
/*
* We shouldn't simply set the SCL pin to high. Like SDA, the SCL line is
* bidirectional too. According to the I2C spec, the slave is allowed to
* pull down the SCL line to slow down the clock, so we need to check this.
* Generally, we'd need a timeout here, but in our case, we just check the
* line, assuming the RTC chip behaves well.
*/
static int sclhi(void)
{
gpio_direction_input(scl_index);
udelay(ADAP_DELAY);
if (!getscl()) {
printk(KERN_ERR "SCL pin should be low\n");
return -ETIMEDOUT;
}
return 0;
}
int efx_i2c_check_presence(struct efx_i2c_interface *i2c, u8 device_id)
{
int rc;
/* If someone is driving the bus low we just give up. */
if (getsda(i2c) == 0 || getscl(i2c) == 0) {
EFX_ERR(i2c->efx, "%s someone is holding the I2C bus low."
" Giving up.\n", __func__);
return -EFAULT;
}
/* Pretend to initiate a device write */
i2c_start(i2c);
rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
if (rc)
goto out;
out:
i2c_stop(i2c);
i2c_release(i2c);
return rc;
}
/* initialize the length of axis and the number of tics */
void vp_axis_init (const sf_file in)
{
float ftmp, num;
bool want;
char *stmp, *label, *unit;
size_t len;
struct Axis axis;
if (!sf_getint ("axisfat",&axisfat)) axisfat=0;
if (!sf_getint ("axiscol",&axiscol)) axiscol=7;
if (!sf_getint ("labelfat",&labelfat)) labelfat=0;
if (!sf_getfloat ("labelsz",&labelsz)) labelsz=8.;
if ((NULL == (label=sf_getstring("label1"))) &&
(NULL == (label=sf_histstring(in,"label1")))) {
axis1.label = blank;
} else if ((NULL == (unit=sf_getstring("unit1"))) &&
(NULL == (unit=sf_histstring(in,"unit1")))) {
axis1.label = label;
} else {
len = strlen(label)+strlen(unit)+4;
axis1.label = sf_charalloc(len);
snprintf(axis1.label,len,"%s (%s)",label,unit);
free(label);
free(unit);
}
if ((NULL == (label=sf_getstring("label2"))) &&
(NULL == (label=sf_histstring(in,"label2")))) {
axis2.label = blank;
} else if ((NULL == (unit=sf_getstring("unit2"))) &&
(NULL == (unit=sf_histstring(in,"unit2")))) {
axis2.label = label;
} else {
len = strlen(label)+strlen(unit)+4;
axis2.label = sf_charalloc(len);
snprintf(axis2.label,len,"%s (%s)",label,unit);
free(label);
free(unit);
}
where1 = (NULL != (stmp = sf_getstring ("wherexlabel")) &&
'b' == *stmp);
where2 = (NULL != (stmp = sf_getstring ("whereylabel")) &&
'r' == *stmp);
/* checking to see if wantaxis is fetched */
if (!sf_getbool ("wantaxis", &want)) {
/* setting the default to put the axes on the plot */
want = true;
axis1.want = true;
axis2.want = true;
} else if (!want) {
axis1.want = false;
axis2.want = false;
} else {
if (!sf_getbool ("wantaxis1",&(axis1.want)))
axis1.want = true;
if (!sf_getbool ("wantaxis2",&(axis2.want)))
axis2.want = true;
}
/* frame or axis */
wheretics = NULL != (stmp = sf_getstring ("wheretics")) &&
'a' == *stmp;
if (!sf_getfloat ("axisor1",&(axis1.or)))
axis1.or = where1? min2: max2;
if (!sf_getfloat ("axisor2",&(axis2.or)))
axis2.or = where2? min1: max1;
if (!sf_getint ("n1tic",&(axis1.ntic))) axis1.ntic = 1;
if (!sf_getint ("n2tic",&(axis2.ntic))) axis2.ntic = 1;
if (!sf_getfloat ("d1num", &(axis1.dnum))) getscl (&axis1);
if (!sf_getfloat ("d2num", &(axis2.dnum))) getscl (&axis2);
if (0. == axis1.dnum) sf_error("%s: zero d1num",__FILE__);
if (0. == axis2.dnum) sf_error("%s: zero d2num",__FILE__);
if (!sf_getfloat("o1num",&(axis1.num0))) {
ftmp = (min1 < max1)? min1: max1;
for (num = floorf(ftmp / axis1.dnum) * axis1.dnum - axis1.dnum;
num < ftmp; num += axis1.dnum) ;
axis1.num0 = num;
}
if (!sf_getfloat("o2num",&(axis2.num0))) {
ftmp = (min2 < max2)? min2: max2;
for (num = floorf(ftmp / axis2.dnum) * axis2.dnum - axis2.dnum;
num < ftmp; num += axis2.dnum) ;
axis2.num0 = num;
}
axis1.dtic = axis1.dnum / axis1.ntic ;
ftmp = (min1 < max1)? min1: max1;
for (num = axis1.num0 - axis1.ntic * axis1.dtic;
num < ftmp; num += axis1.dtic);
axis1.tic0 = num;
axis2.dtic = axis2.dnum / axis2.ntic ;
ftmp = (min2 < max2)? min2: max2;
for (num = axis2.num0 - axis2.ntic * axis2.dtic;
num < ftmp; num += axis2.dtic);
axis2.tic0 = num;
if (transp) { /* swap */
axis = axis1;
axis1 = axis2;
axis2 = axis;
}
if(yreverse) axis1.or = (min2+max2)-axis1.or;
if(xreverse) axis2.or = (min1+max1)-axis2.or;
}
