void clear_interrupt_status_work_func(struct work_struct *work) { struct stml0xx_data *ps_stml0xx = container_of(work, struct stml0xx_data, clear_interrupt_status_work); uint8_t buf[3]; dev_dbg(&ps_stml0xx->spi->dev, "clear_interrupt_status_work_func"); mutex_lock(&ps_stml0xx->lock); if (ps_stml0xx->mode == BOOTMODE) goto EXIT; if (ps_stml0xx->is_suspended) goto EXIT; stml0xx_wake(ps_stml0xx); /* read interrupt mask register to clear any interrupt during suspend state */ stml0xx_spi_send_read_reg(INTERRUPT_STATUS, buf, 3); stml0xx_sleep(ps_stml0xx); EXIT: mutex_unlock(&ps_stml0xx->lock); }
void stml0xx_irq_wake_work_func(struct work_struct *work) { int err; unsigned short irq_status; u32 irq2_status; struct stml0xx_work_struct *stm_ws = (struct stml0xx_work_struct *)work; struct stml0xx_data *ps_stml0xx = stml0xx_misc_data; unsigned char buf[SPI_MSG_SIZE]; dev_dbg(&stml0xx_misc_data->spi->dev, "stml0xx_irq_wake_work_func"); mutex_lock(&ps_stml0xx->lock); if (ps_stml0xx->mode == BOOTMODE) goto EXIT_NO_WAKE; if (ps_stml0xx->is_suspended) { dev_dbg(&stml0xx_misc_data->spi->dev, "setting pending_wake_work [true]"); ps_stml0xx->pending_wake_work = true; goto EXIT_NO_WAKE; } stml0xx_wake(ps_stml0xx); err = stml0xx_spi_read_msg_data(SPI_MSG_TYPE_READ_WAKE_IRQ_DATA, buf, sizeof(buf), RESET_ALLOWED); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading from stml0xx failed"); goto EXIT; } /* read interrupt mask register */ irq_status = (buf[WAKE_IRQ_IDX_STATUS_MED] << 8) | buf[WAKE_IRQ_IDX_STATUS_LO]; /* read algorithm interrupt status register */ irq2_status = (buf[WAKE_IRQ_IDX_ALGO_STATUS_HI] << 16) | (buf[WAKE_IRQ_IDX_ALGO_STATUS_MED] << 8) | buf[WAKE_IRQ_IDX_ALGO_STATUS_LO]; /* Check all other status bits */ if (irq_status & M_PROXIMITY) { stml0xx_as_data_buffer_write( ps_stml0xx, DT_PROX, &buf[WAKE_IRQ_IDX_PROX], 1, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Proximity distance %d", buf[WAKE_IRQ_IDX_PROX]); } if (irq_status & M_COVER) { int state = 0; if (buf[WAKE_IRQ_IDX_COVER] == STML0XX_HALL_NORTH) state = 1; else state = 0; input_report_switch(ps_stml0xx->input_dev, SW_LID, state); input_sync(ps_stml0xx->input_dev); dev_err(&stml0xx_misc_data->spi->dev, "Cover status: %d", state); } if (irq_status & M_HEADSET) { uint8_t new_state; new_state = buf[WAKE_IRQ_IDX_HEADSET]; switch (Headset_State) { case SH_HEADSET_BUTTON_1: if (!(new_state & SH_HEADSET_BUTTON_1_DOWN)) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 1 released"); Headset_State = SH_HEADSET_INSERTED; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_1_keycode, 0); input_sync(ps_stml0xx->input_dev); } break; case SH_HEADSET_BUTTON_2: if (!(new_state & SH_HEADSET_BUTTON_2_DOWN)) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 2 released"); Headset_State = SH_HEADSET_INSERTED; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_2_keycode, 0); input_sync(ps_stml0xx->input_dev); } break; case SH_HEADSET_BUTTON_3: if (!(new_state & SH_HEADSET_BUTTON_3_DOWN)) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 3 released"); Headset_State = SH_HEADSET_INSERTED; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_3_keycode, 0); input_sync(ps_stml0xx->input_dev); } break; case SH_HEADSET_BUTTON_4: if (!(new_state & SH_HEADSET_BUTTON_4_DOWN)) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 4 released"); Headset_State = SH_HEADSET_INSERTED; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_4_keycode, 0); input_sync(ps_stml0xx->input_dev); } break; default: break; } if (Headset_State == SH_HEADPHONE_INSERTED) { if (!(new_state & SH_HEADPHONE_DETECTED)) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headphone removed"); Headset_State = SH_HEADSET_REMOVED; input_report_switch(ps_stml0xx->input_dev, SW_HEADPHONE_INSERT, 0); input_sync(ps_stml0xx->input_dev); } } else if (Headset_State == SH_HEADSET_INSERTED) { if (!(new_state & SH_HEADSET_DETECTED)) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset removed"); Headset_State = SH_HEADSET_REMOVED; input_report_switch(ps_stml0xx->input_dev, SW_HEADPHONE_INSERT, 0); input_report_switch(ps_stml0xx->input_dev, SW_MICROPHONE_INSERT, 0); input_sync(ps_stml0xx->input_dev); } } if (Headset_State == SH_HEADSET_REMOVED) { if (new_state & SH_HEADPHONE_DETECTED) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headphone inserted"); Headset_State = SH_HEADPHONE_INSERTED; input_report_switch(ps_stml0xx->input_dev, SW_HEADPHONE_INSERT, 1); input_sync(ps_stml0xx->input_dev); } else if (new_state & SH_HEADSET_DETECTED) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset inserted"); Headset_State = SH_HEADSET_INSERTED; input_report_switch(ps_stml0xx->input_dev, SW_HEADPHONE_INSERT, 1); input_report_switch(ps_stml0xx->input_dev, SW_MICROPHONE_INSERT, 1); input_sync(ps_stml0xx->input_dev); } } if (Headset_State == SH_HEADSET_INSERTED) { if (new_state & SH_HEADSET_BUTTON_1_DOWN) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 1 pressed"); Headset_State = SH_HEADSET_BUTTON_1; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_1_keycode, 1); input_sync(ps_stml0xx->input_dev); } else if (new_state & SH_HEADSET_BUTTON_2_DOWN) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 2 pressed"); Headset_State = SH_HEADSET_BUTTON_2; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_2_keycode, 1); input_sync(ps_stml0xx->input_dev); } else if (new_state & SH_HEADSET_BUTTON_3_DOWN) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 3 pressed"); Headset_State = SH_HEADSET_BUTTON_3; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_3_keycode, 1); input_sync(ps_stml0xx->input_dev); } else if (new_state & SH_HEADSET_BUTTON_4_DOWN) { dev_dbg(&stml0xx_misc_data->spi->dev, "Headset button 4 pressed"); Headset_State = SH_HEADSET_BUTTON_4; input_report_key(ps_stml0xx->input_dev, stml0xx_misc_data->pdata->headset_button_4_keycode, 1); input_sync(ps_stml0xx->input_dev); } } } if (irq_status & M_FLATUP) { stml0xx_as_data_buffer_write( ps_stml0xx, DT_FLAT_UP, &buf[WAKE_IRQ_IDX_FLAT], 1, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Flat up %d", buf[WAKE_IRQ_IDX_FLAT]); } if (irq_status & M_FLATDOWN) { stml0xx_as_data_buffer_write(ps_stml0xx, DT_FLAT_DOWN, &buf[WAKE_IRQ_IDX_FLAT], 1, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Flat down %d", buf[WAKE_IRQ_IDX_FLAT]); } if (irq_status & M_STOWED) { stml0xx_as_data_buffer_write( ps_stml0xx, DT_STOWED, &buf[WAKE_IRQ_IDX_STOWED], 1, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Stowed status %d", buf[WAKE_IRQ_IDX_STOWED]); } if (irq_status & M_CAMERA_ACT) { stml0xx_as_data_buffer_write(ps_stml0xx, DT_CAMERA_ACT, &buf[WAKE_IRQ_IDX_CAMERA], 2, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Camera: %d", STM16_TO_HOST(CAMERA_VALUE, &buf[WAKE_IRQ_IDX_CAMERA])); input_report_key(ps_stml0xx->input_dev, KEY_CAMERA, 1); input_report_key(ps_stml0xx->input_dev, KEY_CAMERA, 0); input_sync(ps_stml0xx->input_dev); dev_dbg(&stml0xx_misc_data->spi->dev, "Report camkey toggle"); } if (irq_status & M_SIM) { stml0xx_as_data_buffer_write( ps_stml0xx, DT_SIM, &buf[WAKE_IRQ_IDX_SIM], 2, 0, stm_ws->ts_ns); /* This is one shot sensor */ stml0xx_g_wake_sensor_state &= (~M_SIM); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending SIM Value=%d", STM16_TO_HOST(SIM_DATA, &buf[WAKE_IRQ_IDX_SIM])); } if (irq2_status & M_MMOVEME) { unsigned char status; /* Client recieving action will be upper 2 most significant */ /* bits of the least significant byte of status. */ status = (irq2_status & STML0XX_CLIENT_MASK) | M_MMOVEME; stml0xx_ms_data_buffer_write(ps_stml0xx, DT_MMMOVE, &status, 1); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending meaningful movement event"); } if (irq2_status & M_NOMMOVE) { unsigned char status; /* Client recieving action will be upper 2 most significant */ /* bits of the least significant byte of status. */ status = (irq2_status & STML0XX_CLIENT_MASK) | M_NOMMOVE; stml0xx_ms_data_buffer_write(ps_stml0xx, DT_NOMOVE, &status, 1); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending no meaningful movement event"); } if (irq2_status & M_ALGO_MODALITY) { buf[WAKE_IRQ_IDX_MODALITY + ALGO_TYPE] = STML0XX_IDX_MODALITY; stml0xx_ms_data_buffer_write(ps_stml0xx, DT_ALGO_EVT, &buf[WAKE_IRQ_IDX_MODALITY], 8); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending modality event"); } if (irq2_status & M_ALGO_ORIENTATION) { buf[WAKE_IRQ_IDX_MODALITY_ORIENT + ALGO_TYPE] = STML0XX_IDX_ORIENTATION; stml0xx_ms_data_buffer_write(ps_stml0xx, DT_ALGO_EVT, &buf[WAKE_IRQ_IDX_MODALITY_ORIENT], 8); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending orientation event"); } if (irq2_status & M_ALGO_STOWED) { buf[WAKE_IRQ_IDX_MODALITY_STOWED + ALGO_TYPE] = STML0XX_IDX_STOWED; stml0xx_ms_data_buffer_write(ps_stml0xx, DT_ALGO_EVT, &buf[WAKE_IRQ_IDX_MODALITY_STOWED], 8); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending stowed event"); } if (irq2_status & M_ALGO_ACCUM_MODALITY) { buf[WAKE_IRQ_IDX_MODALITY_ACCUM + ALGO_TYPE] = STML0XX_IDX_ACCUM_MODALITY; stml0xx_ms_data_buffer_write(ps_stml0xx, DT_ALGO_EVT, &buf[WAKE_IRQ_IDX_MODALITY_ACCUM], 8); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending accum modality event"); } if (irq2_status & M_ALGO_ACCUM_MVMT) { buf[WAKE_IRQ_IDX_MODALITY_ACCUM_MVMT + ALGO_TYPE] = STML0XX_IDX_ACCUM_MVMT; stml0xx_ms_data_buffer_write(ps_stml0xx, DT_ALGO_EVT, &buf[WAKE_IRQ_IDX_MODALITY_ACCUM_MVMT], 8); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending accum mvmt event"); } /* check for log messages */ if (irq_status & M_LOG_MSG) { memcpy(stat_string, &buf[WAKE_IRQ_IDX_LOG_MSG], LOG_MSG_SIZE); stat_string[LOG_MSG_SIZE] = 0; dev_err(&stml0xx_misc_data->spi->dev, "sensorhub : %s", stat_string); } if (irq_status & M_INIT_COMPLETE) { /* set the init complete register, */ /* to let the hub know it was received */ buf[0] = 0x01; err = stml0xx_spi_send_write_reg(INIT_COMPLETE_REG, buf, 1); queue_work(ps_stml0xx->irq_work_queue, &ps_stml0xx->initialize_work); dev_err(&stml0xx_misc_data->spi->dev, "Sensor Hub reports reset"); stml0xx_g_booted = 1; } /* check for a reset request */ if (irq_status & M_HUB_RESET) { unsigned char status = 0x01; stml0xx_as_data_buffer_write(ps_stml0xx, DT_RESET, &status, 1, 0, stm_ws->ts_ns); stml0xx_reset(stml0xx_misc_data->pdata); dev_err(&stml0xx_misc_data->spi->dev, "STML0XX requested a reset"); } EXIT: stml0xx_sleep(ps_stml0xx); EXIT_NO_WAKE: mutex_unlock(&ps_stml0xx->lock); kfree(stm_ws); }
void stml0xx_irq_work_func(struct work_struct *work) { int err; u32 irq_status; struct stml0xx_work_struct *stm_ws = (struct stml0xx_work_struct *)work; struct stml0xx_data *ps_stml0xx = stml0xx_misc_data; unsigned char buf[SPI_MSG_SIZE]; dev_dbg(&stml0xx_misc_data->spi->dev, "stml0xx_irq_work_func"); mutex_lock(&ps_stml0xx->lock); stml0xx_wake(ps_stml0xx); if (!stml0xx_g_booted) goto EXIT; if (ps_stml0xx->is_suspended) goto EXIT; err = stml0xx_spi_read_msg_data(SPI_MSG_TYPE_READ_IRQ_DATA, buf, SPI_RX_PAYLOAD_LEN, RESET_ALLOWED); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading from stml0xx failed"); goto EXIT; } irq_status = (buf[IRQ_IDX_STATUS_HI] << 16) | (buf[IRQ_IDX_STATUS_MED] << 8) | buf[IRQ_IDX_STATUS_LO]; if (irq_status & M_ACCEL) { int head = 0; int tail = 0; int first_accel_sample = 0; uint64_t ts_ns = 0; unsigned char *data_buf = 0; unsigned char *accel_buf = 0; uint8_t delay_ms = 0; data_buf = &buf[IRQ_IDX_ACCEL1]; ts_ns = stm_ws->ts_ns; head = data_buf[28]; tail = data_buf[32]; for ( first_accel_sample = 1, accel_buf = data_buf + 7*tail; tail != head; tail = (tail + 1) % 4, accel_buf = data_buf + 7*tail) { delay_ms = accel_buf[6]; if (first_accel_sample) first_accel_sample = 0; else ts_ns += delay_ms * 1000000LL; stml0xx_as_data_buffer_write( ps_stml0xx, DT_ACCEL, accel_buf, 6, 0, ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending acc(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(ACCEL_RD_X, accel_buf), STM16_TO_HOST(ACCEL_RD_Y, accel_buf), STM16_TO_HOST(ACCEL_RD_Z, accel_buf)); } } if (irq_status & M_ACCEL2) { stml0xx_as_data_buffer_write(ps_stml0xx, DT_ACCEL2, &buf[IRQ_IDX_ACCEL2], 6, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending acc2(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(ACCEL_RD_X, &buf[IRQ_IDX_ACCEL2]), STM16_TO_HOST(ACCEL_RD_Y, &buf[IRQ_IDX_ACCEL2]), STM16_TO_HOST(ACCEL_RD_Z, &buf[IRQ_IDX_ACCEL2])); } if (irq_status & M_ALS) { stml0xx_as_data_buffer_write( ps_stml0xx, DT_ALS, &buf[IRQ_IDX_ALS], 2, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending ALS %d", STM16_TO_HOST(ALS_VALUE, &buf[IRQ_IDX_ALS])); } if (irq_status & M_DISP_ROTATE) { stml0xx_as_data_buffer_write(ps_stml0xx, DT_DISP_ROTATE, &buf[IRQ_IDX_DISP_ROTATE], 1, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending disp_rotate(x)value: %d", buf[IRQ_IDX_DISP_ROTATE]); } if (irq_status & M_DISP_BRIGHTNESS) { stml0xx_as_data_buffer_write(ps_stml0xx, DT_DISP_BRIGHT, &buf[IRQ_IDX_DISP_BRIGHTNESS], 1, 0, stm_ws->ts_ns); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Display Brightness %d", buf[IRQ_IDX_DISP_BRIGHTNESS]); } EXIT: kfree((void *)stm_ws); stml0xx_sleep(ps_stml0xx); /* For now HAE needs events even if the activity is still */ mutex_unlock(&ps_stml0xx->lock); }
void stml0xx_irq_work_func(struct work_struct *work) { int err; u32 irq_status; struct stml0xx_data *ps_stml0xx = stml0xx_misc_data; unsigned char buf[SPI_MSG_SIZE]; dev_dbg(&stml0xx_misc_data->spi->dev, "stml0xx_irq_work_func"); mutex_lock(&ps_stml0xx->lock); stml0xx_wake(ps_stml0xx); if (ps_stml0xx->mode == BOOTMODE) goto EXIT; if (ps_stml0xx->is_suspended) goto EXIT; /* read interrupt mask register */ err = stml0xx_spi_send_read_reg(INTERRUPT_STATUS, buf, 3); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading from stml0xx failed"); goto EXIT; } irq_status = (buf[IRQ_NOWAKE_HI] << 16) | (buf[IRQ_NOWAKE_MED] << 8) | buf[IRQ_NOWAKE_LO]; if (irq_status & M_ACCEL) { /* read accelerometer values from STML0XX */ err = stml0xx_spi_send_read_reg(ACCEL_X, buf, 6); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Accel from stml0xx failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_ACCEL, buf, 6, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending acc(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(ACCEL_RD_X), STM16_TO_HOST(ACCEL_RD_Y), STM16_TO_HOST(ACCEL_RD_Z)); } if (irq_status & M_ACCEL2) { /* read 2nd accelerometer values from STML0XX */ err = stml0xx_spi_send_read_reg(ACCEL2_X, buf, 6); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading 2nd Accel from stml0xx failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_ACCEL2, buf, 6, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending acc2(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(ACCEL_RD_X), STM16_TO_HOST(ACCEL_RD_Y), STM16_TO_HOST(ACCEL_RD_Z)); } if (irq_status & M_LIN_ACCEL) { dev_err(&stml0xx_misc_data->spi->dev, "Invalid M_LIN_ACCEL bit set. irq_status = 0x%06x", irq_status); /* read linear accelerometer values from STML0XX */ err = stml0xx_spi_send_read_reg(LIN_ACCEL_X, buf, 6); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Linear Accel from stml0xx failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_LIN_ACCEL, buf, 6, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending lin_acc(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(ACCEL_RD_X), STM16_TO_HOST(ACCEL_RD_Y), STM16_TO_HOST(ACCEL_RD_Z)); } if (irq_status & M_ECOMPASS) { unsigned char status; /*Read orientation values */ err = stml0xx_spi_send_read_reg(MAG_HX, buf, 13); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Ecompass failed"); goto EXIT; } status = buf[COMPASS_STATUS]; stml0xx_as_data_buffer_write(ps_stml0xx, DT_MAG, buf, 6, status); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending mag(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(MAG_X), STM16_TO_HOST(MAG_Y), STM16_TO_HOST(MAG_Z)); stml0xx_as_data_buffer_write(ps_stml0xx, DT_ORIENT, buf + 6, 6, status); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending orient(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(ORIENT_X), STM16_TO_HOST(ORIENT_Y), STM16_TO_HOST(ORIENT_Z)); } if (irq_status & M_GYRO) { err = stml0xx_spi_send_read_reg(GYRO_X, buf, 6); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Gyroscope failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_GYRO, buf, 6, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending gyro(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(GYRO_RD_X), STM16_TO_HOST(GYRO_RD_Y), STM16_TO_HOST(GYRO_RD_Z)); } /*MODIFIED UNCALIBRATED GYRO */ if (irq_status & M_UNCALIB_GYRO) { err = stml0xx_spi_send_read_reg(UNCALIB_GYRO_X, buf, 12); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Gyroscope failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_UNCALIB_GYRO, buf, 12, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Gyro uncalib(x,y,z)values:%d,%d,%d;%d,%d,%d", STM16_TO_HOST(GYRO_RD_X), STM16_TO_HOST(GYRO_RD_Y), STM16_TO_HOST(GYRO_RD_Z), STM16_TO_HOST(GYRO_UNCALIB_X), STM16_TO_HOST(GYRO_UNCALIB_Y), STM16_TO_HOST(GYRO_UNCALIB_Z)); } if (irq_status & M_UNCALIB_MAG) { err = stml0xx_spi_send_read_reg(UNCALIB_MAG_X, buf, 12); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Gyroscope failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_UNCALIB_MAG, buf, 12, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Gyro uncalib(x,y,z)values:%d,%d,%d;%d,%d,%d", STM16_TO_HOST(MAG_X), STM16_TO_HOST(MAG_Y), STM16_TO_HOST(MAG_Z), STM16_TO_HOST(MAG_UNCALIB_X), STM16_TO_HOST(MAG_UNCALIB_Y), STM16_TO_HOST(MAG_UNCALIB_Z)); } if (irq_status & M_ALS) { err = stml0xx_spi_send_read_reg(ALS_LUX, buf, 2); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading ALS from stml0xx failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_ALS, buf, 2, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending ALS %d", STM16_TO_HOST(ALS_VALUE)); } if (irq_status & M_TEMPERATURE) { /* Read temperature value */ err = stml0xx_spi_send_read_reg(TEMPERATURE_DATA, buf, 2); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Temperature failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_TEMP, buf, 2, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending temp(x)value:%d", STM16_TO_HOST(TEMP_VALUE)); } if (irq_status & M_PRESSURE) { dev_err(&stml0xx_misc_data->spi->dev, "Invalid M_PRESSURE bit set. irq_status = 0x%06x", irq_status); /* Read pressure value */ err = stml0xx_spi_send_read_reg(CURRENT_PRESSURE, buf, 4); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Pressure failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_PRESSURE, buf, 4, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending pressure %d", STM32_TO_HOST(PRESSURE_VALUE)); } if (irq_status & M_GRAVITY) { dev_err(&stml0xx_misc_data->spi->dev, "Invalid M_GRAVITY bit set. irq_status = 0x%06x", irq_status); /* read gravity values from STML0XX */ err = stml0xx_spi_send_read_reg(GRAVITY_X, buf, 6); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Gravity from stml0xx failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_GRAVITY, buf, 6, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending gravity(x,y,z)values:x=%d,y=%d,z=%d", STM16_TO_HOST(GRAV_X), STM16_TO_HOST(GRAV_Y), STM16_TO_HOST(GRAV_Z)); } if (irq_status & M_DISP_ROTATE) { /* Read Display Rotate value */ err = stml0xx_spi_send_read_reg(DISP_ROTATE_DATA, buf, 1); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading disp_rotate failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_DISP_ROTATE, buf, 1, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending disp_rotate(x)value: %d", buf[DISP_VALUE]); } if (irq_status & M_DISP_BRIGHTNESS) { err = stml0xx_spi_send_read_reg(DISPLAY_BRIGHTNESS, buf, 1); if (err < 0) { dev_err(&stml0xx_misc_data->spi->dev, "Reading Display Brightness failed"); goto EXIT; } stml0xx_as_data_buffer_write(ps_stml0xx, DT_DISP_BRIGHT, buf, 1, 0); dev_dbg(&stml0xx_misc_data->spi->dev, "Sending Display Brightness %d", buf[DISP_VALUE]); } EXIT: stml0xx_sleep(ps_stml0xx); /* For now HAE needs events even if the activity is still */ mutex_unlock(&ps_stml0xx->lock); wake_unlock(&ps_stml0xx->wakelock); }