static int max14688_read_left_impedence (struct device *dev)
{
struct max14688 *me = dev_get_drvdata(dev);
u8 adcconversion = 0;
u8 adcstatus = 0;
int rc;
rc = max14688_read(me, ADCCONVERSION, &adcconversion);
if (unlikely(rc)) {
log_err("ADCCONVERSION read error [%d]\n", rc);
goto out;
}
log_dbg("%s[adc value = %d]\n", __func__, adcconversion);
/* Greater than 2.69k(ohm) resistor is connected, read the EOC bit in the ADCSTATUS address */
max14688_read(me, ADCSTATUS, &adcstatus);
if (!(BITS_GET(adcstatus, ADCSTATUS_EOC))) {
log_dbg("%s[ADC_VAL_MAX = %d]\n", __func__, (int)ADC_VAL_MAX);
rc = (int)ADC_VAL_MAX;
} else {
rc = (int)adcconversion;
}
out:
return rc;
}
/**
*******************************************************************************
*
* @brief
* Reads next numbits number of bits from the bitstream this updates the
* bitstream offset and consumes the bits
*
* @par Description:
* Extract required number of bits from cur_word & nxt_word return these
* bits
*
* @param[in] ps_bitstrm
* Pointer to bitstream structure
*
* @param[in] u4_numbits
* Number of bits
*
* @returns Bits read
*
* @remarks
*
*
*******************************************************************************
*/
UWORD32 ihevcd_bits_get(bitstrm_t *ps_bitstrm, UWORD32 u4_numbits)
{
UWORD32 u4_bits_read;
BITS_GET(u4_bits_read,
ps_bitstrm->pu4_buf,
ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word,
ps_bitstrm->u4_nxt_word,
u4_numbits);
return u4_bits_read;
}
static int max14688_read_device_id (struct max14688 *me, u8 *id, u8 *rev)
{
u8 deviceid = 0;
int rc;
rc = max14688_read(me, DEVICEID, &deviceid);
if (unlikely(rc)) {
log_err("DEVICEID read error [%d]\n", rc);
goto out;
}
if (likely(id)) {
*id = BITS_GET(deviceid, DEVICEID_CHIPID);
}
if (likely(rev)) {
*rev = BITS_GET(deviceid, DEVICEID_CHIPREV);
}
out:
return rc;
}
static void __UsartIsr(UsartCtrl* usartCtrl)
{
USART_TypeDef* usart = usartCtrl->usart;
/* Check for RX interrupt flag. */
if (BITS_GET(usart->SR, USART_SR_RXNE))
{
/* Read the received data. */
usartCtrl->rxBuffer[usartCtrl->rxBufferEnd] = usart->DR;
usartCtrl->rxBufferEnd = ((usartCtrl->rxBufferEnd + 1U) % usartCtrl->rxBufferSize);
/* Clear the interrupt flag. */
BITS_CLEAR(usart->SR, USART_SR_RXNE);
}
/*
* NOTE: The other interrupts should not occur since they are never enabled by this driver.
*/
}
static int max14688_read_mode1 (struct max14688 *me, int *mode1)
{
u8 pincontrol1 = 0;
int rc;
rc = max14688_read(me, PINCONTROL1, &pincontrol1);
if (unlikely(rc)) {
log_err("PINCONTROL1 read error [%d]\n", rc);
goto out;
}
if (likely(mode1)) {
*mode1 = BITS_GET(pincontrol1, PINCONTROL1_MODE1);
}
out:
return rc;
}
/**
*******************************************************************************
*
* @brief
* Reads signed integer 0-th order exp-golomb-coded syntax element from the
* bitstream. Function similar to get_uev Section: 9.2.1
*
* @par Description:
* Extract required number of bits from cur_word & nxt_word return these
* bits
*
* @param[in] ps_bitstrm
* Pointer to bitstream structure
*
* @returns UEV decoded syntax element
*
* @remarks
*
*
*******************************************************************************
*/
WORD32 ihevcd_sev(bitstrm_t *ps_bitstrm)
{
UWORD32 u4_bits_read;
UWORD32 u4_clz;
UWORD32 u4_abs_val;
/***************************************************************/
/* Find leading zeros in next 32 bits */
/***************************************************************/
BITS_NXT32(u4_bits_read,
ps_bitstrm->pu4_buf,
ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word,
ps_bitstrm->u4_nxt_word);
u4_clz = CLZ(u4_bits_read);
BITS_FLUSH(ps_bitstrm->pu4_buf,
ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word,
ps_bitstrm->u4_nxt_word,
(u4_clz + 1));
u4_bits_read = 0;
if(u4_clz)
{
BITS_GET(u4_bits_read,
ps_bitstrm->pu4_buf,
ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word,
ps_bitstrm->u4_nxt_word,
u4_clz);
}
u4_abs_val = ((1 << u4_clz) + u4_bits_read) >> 1;
if(u4_bits_read & 0x1)
return (-(WORD32)u4_abs_val);
else
return (u4_abs_val);
}
/**
*******************************************************************************
*
* @brief
* Reads unsigned integer 0-th order exp-golomb-coded syntax element from
* the bitstream Section: 9.2
*
* @par Description:
* Extract required number of bits from cur_word & nxt_word return these
* bits
*
* @param[in] ps_bitstrm
* Pointer to bitstream structure
*
* @returns UEV decoded syntax element
*
* @remarks
*
*
*******************************************************************************
*/
UWORD32 ihevcd_uev(bitstrm_t *ps_bitstrm)
{
UWORD32 u4_bits_read;
UWORD32 u4_clz;
/***************************************************************/
/* Find leading zeros in next 32 bits */
/***************************************************************/
BITS_NXT32(u4_bits_read,
ps_bitstrm->pu4_buf,
ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word,
ps_bitstrm->u4_nxt_word);
u4_clz = CLZ(u4_bits_read);
BITS_FLUSH(ps_bitstrm->pu4_buf,
ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word,
ps_bitstrm->u4_nxt_word,
(u4_clz + 1));
u4_bits_read = 0;
if(u4_clz)
{
BITS_GET(u4_bits_read,
ps_bitstrm->pu4_buf,
ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word,
ps_bitstrm->u4_nxt_word,
u4_clz);
}
return ((1 << u4_clz) + u4_bits_read - 1);
}
static ssize_t max14688_monitor_show (struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct max14688 *me = dev_get_drvdata(dev);
unsigned long flags;
u8 irq_unmask, irq_saved, reg_val;
int rc = 0;
__lock(me);
spin_lock_irqsave(&me->irq_lock, flags);
irq_unmask = me->irq_unmask;
irq_saved = me->irq_saved;
spin_unlock_irqrestore(&me->irq_lock, flags);
/**************************************************************************/
reg_val = 0;
max14688_read(me, ADCCONVERSION, ®_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"Latest ADC conversion %u (code %02Xh)\n", reg_val, reg_val);
/**************************************************************************/
reg_val = 0;
max14688_read(me, ADCSTATUS, ®_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"ADCSTATUS register %02Xh\n", reg_val);
/**************************************************************************/
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"Saved Status %02Xh\n", me->status);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" Headset is %s\n",
BITS_GET(me->status, STATUS_DET) ? "not detected" : "detected");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" Swtich is %s\n",
BITS_GET(me->status, STATUS_SWD) ? "pressed" : "not pressed");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" INT output is %s\n",
BITS_GET(me->status, STATUS_INT) ? "driven high" : "not driven");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" MICIN switch is %s\n",
BITS_GET(me->status, STATUS_MICIN) ? "closed" : "open");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" DETIN is %s\n",
BITS_GET(me->status, STATUS_DETIN) ? "detected" : "not detected");
/**************************************************************************/
reg_val = 0;
max14688_read(me, MASK, ®_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"MASK register %02Xh\n", reg_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" EOC %u DET %u SWD %u INT %u MICIN %u DETIN %u\n",
!!(reg_val & IRQ_EOC),
!!(reg_val & IRQ_DET),
!!(reg_val & IRQ_SWD),
!!(reg_val & IRQ_INT),
!!(reg_val & IRQ_MICIN),
!!(reg_val & IRQ_DETIN));
/**************************************************************************/
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"Saved interrupt flags %02Xh\n", irq_saved);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" EOC %u DET %u SWD %u INT %u MICIN %u DETIN %u\n",
!!(irq_saved & IRQ_EOC),
!!(irq_saved & IRQ_DET),
!!(irq_saved & IRQ_SWD),
!!(irq_saved & IRQ_INT),
!!(irq_saved & IRQ_MICIN),
!!(irq_saved & IRQ_DETIN));
/**************************************************************************/
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"Enabled interrupt flags %02Xh\n", irq_unmask);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" EOC %u DET %u SWD %u INT %u MICIN %u DETIN %u\n",
!!(irq_unmask & IRQ_EOC),
!!(irq_unmask & IRQ_DET),
!!(irq_unmask & IRQ_SWD),
!!(irq_unmask & IRQ_INT),
!!(irq_unmask & IRQ_MICIN),
!!(irq_unmask & IRQ_DETIN));
/**************************************************************************/
reg_val = 0;
max14688_read(me, PINCONTROL1, ®_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"Pin control 1 %02Xh\n", reg_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" INT follows %s %s\n",
BITS_GET(reg_val, PINCONTROL1_MANUALINT) ?
"Force INT bit" : "the chip-internal decision",
BITS_GET(reg_val, PINCONTROL1_MANUALINT) ?
BITS_GET(reg_val, PINCONTROL1_FORCEINT) ?
"INT is low" : "INT is high" :
"");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" MIC_SW follows %s %s\n",
BITS_GET(reg_val, PINCONTROL1_MANUALMICSW) ?
"Force MIC_SW bit" : "the chip-internal decision",
BITS_GET(reg_val, PINCONTROL1_MANUALINT) ?
BITS_GET(reg_val, PINCONTROL1_FORCEINT) ?
"MIC_SW is open" : "MIC_SW is closed" :
"");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" MODE1 (Accessory Power) is %s\n",
BITS_GET(reg_val, PINCONTROL1_MODE1) == 0b00 ? "low" :
BITS_GET(reg_val, PINCONTROL1_MODE1) == 0b11 ? "high" :
"in high Z");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" MODE0 (Microphone Bias) is %s\n",
BITS_GET(reg_val, PINCONTROL1_MODE0) == 0b00 ? "low" :
BITS_GET(reg_val, PINCONTROL1_MODE0) == 0b11 ? "high" :
"in high Z");
reg_val = 0;
max14688_read(me, PINCONTROL2, ®_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"Pin control 2 %02Xh\n", reg_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" INT %s\n",
BITS_GET(reg_val, PINCONTROL2_INTAUTO) ?
"is forced high during Z detection regardless of MODE0/1" :
"follows the chip-internal decision");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" MIC bias output %s\n",
BITS_GET(reg_val, PINCONTROL2_MICOUTDELAY) ?
"delayed until Z detection after DET going low" :
"follows the MODE0/1 after DET going low");
/**************************************************************************/
reg_val = 0;
max14688_read(me, ADCCONTROL, ®_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
"ADC control %02Xh\n", reg_val);
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" Manual control of ADC is %s\n",
(u8)BITS_GET(reg_val, ADCCONTROL_MANUALADC) ? "on" : "off");
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" Force ADC start bit is %u\n",
(u8)BITS_GET(reg_val, ADCCONTROL_FORCEADC));
rc += (int)snprintf(buf+rc, PAGE_SIZE,
" ADC control mode is %u\n",
(u8)BITS_GET(reg_val, ADCCONTROL_ADCCTL));
__unlock(me);
return (ssize_t)rc;
}
static ssize_t max14688_adc_refresh_store (struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct max14688 *me = dev_get_drvdata(dev);
unsigned long timeout;
unsigned int delay;
u8 adcstatus, adccontrol_save, adccontrol;
int rc;
__lock(me);
adccontrol = 0;
rc = max14688_read(me, ADCCONTROL, &adccontrol);
if (unlikely(rc)) {
log_err("ADCCONTROL read error [%d]\n", rc);
goto out;
}
/* Save original ADCCONTROL value */
adccontrol_save = adccontrol;
delay = (unsigned int)simple_strtoul(buf, NULL, 10);
if (likely(delay > 0)) {
__msleep(delay);
}
adccontrol |= ADCCONTROL_FORCEADC;
adccontrol |= ADCCONTROL_MANUALADC;
rc = max14688_write(me, ADCCONTROL, adccontrol);
if (unlikely(rc)) {
log_err("ADCCONTROL write error [%d]\n", rc);
goto out;
}
timeout = jiffies +
usecs_to_jiffies(MAX14688_IDETIN_RISE_TIME) +
usecs_to_jiffies(MAX14688_IDETIN_FALL_TIME) +
usecs_to_jiffies(MAX14688_IDETIN_ON_TIME);
do {
if (unlikely(time_after(jiffies, timeout))) {
log_err("AD conversion timed out\n");
goto out;
}
__msleep(1);
adcstatus = 0;
max14688_read(me, ADCSTATUS, &adcstatus);
} while (likely(!BITS_GET(adcstatus, ADCSTATUS_EOC)));
/* Restore ADCCONTROL value and make sure FORCEADC bit cleared */
adccontrol_save &= ~ADCCONTROL_FORCEADC;
rc = max14688_write(me, ADCCONTROL, adccontrol_save);
if (unlikely(rc)) {
log_err("ADCCONTROL write error [%d]\n", rc);
goto out;
}
out:
__unlock(me);
return (ssize_t)count;
}
