Lines Matching defs:ac
181 #define AC_READ(ac, reg) ((ac)->bops->read((ac)->dev, reg))
182 #define AC_WRITE(ac, reg, val) ((ac)->bops->write((ac)->dev, reg, val))
238 static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis)
242 ac->bops->read_block(ac->dev, DATAX0, DATAZ1 - DATAX0 + 1, buf);
244 mutex_lock(&ac->mutex);
245 ac->saved.x = (s16) le16_to_cpu(buf[0]);
246 axis->x = ac->saved.x;
248 ac->saved.y = (s16) le16_to_cpu(buf[1]);
249 axis->y = ac->saved.y;
251 ac->saved.z = (s16) le16_to_cpu(buf[2]);
252 axis->z = ac->saved.z;
253 mutex_unlock(&ac->mutex);
256 static void adxl34x_service_ev_fifo(struct adxl34x *ac)
258 struct adxl34x_platform_data *pdata = &ac->pdata;
261 adxl34x_get_triple(ac, &axis);
263 input_event(ac->input, pdata->ev_type, pdata->ev_code_x,
264 axis.x - ac->swcal.x);
265 input_event(ac->input, pdata->ev_type, pdata->ev_code_y,
266 axis.y - ac->swcal.y);
267 input_event(ac->input, pdata->ev_type, pdata->ev_code_z,
268 axis.z - ac->swcal.z);
278 static void adxl34x_send_key_events(struct adxl34x *ac,
285 input_report_key(ac->input,
290 static void adxl34x_do_tap(struct adxl34x *ac,
293 adxl34x_send_key_events(ac, pdata, status, true);
294 input_sync(ac->input);
295 adxl34x_send_key_events(ac, pdata, status, false);
300 struct adxl34x *ac = handle;
301 struct adxl34x_platform_data *pdata = &ac->pdata;
310 tap_stat = AC_READ(ac, ACT_TAP_STATUS);
314 int_stat = AC_READ(ac, INT_SOURCE);
317 adxl34x_report_key_single(ac->input, pdata->ev_code_ff);
320 dev_dbg(ac->dev, "OVERRUN\n");
323 adxl34x_do_tap(ac, pdata, tap_stat);
326 adxl34x_do_tap(ac, pdata, tap_stat);
331 input_report_key(ac->input,
334 input_report_key(ac->input,
342 orient = AC_READ(ac, ORIENT);
348 if (ac->orient2d_saved != orient_code) {
349 ac->orient2d_saved = orient_code;
350 adxl34x_report_key_single(ac->input,
360 if (ac->orient3d_saved != orient_code) {
361 ac->orient3d_saved = orient_code;
362 adxl34x_report_key_single(ac->input,
371 samples = ENTRIES(AC_READ(ac, FIFO_STATUS)) + 1;
376 adxl34x_service_ev_fifo(ac);
391 if (ac->fifo_delay && (samples > 1))
396 input_sync(ac->input);
401 static void __adxl34x_disable(struct adxl34x *ac)
407 AC_WRITE(ac, POWER_CTL, 0);
410 static void __adxl34x_enable(struct adxl34x *ac)
412 AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
415 void adxl34x_suspend(struct adxl34x *ac)
417 mutex_lock(&ac->mutex);
419 if (!ac->suspended && !ac->disabled && ac->opened)
420 __adxl34x_disable(ac);
422 ac->suspended = true;
424 mutex_unlock(&ac->mutex);
428 void adxl34x_resume(struct adxl34x *ac)
430 mutex_lock(&ac->mutex);
432 if (ac->suspended && !ac->disabled && ac->opened)
433 __adxl34x_enable(ac);
435 ac->suspended = false;
437 mutex_unlock(&ac->mutex);
444 struct adxl34x *ac = dev_get_drvdata(dev);
446 return sprintf(buf, "%u\n", ac->disabled);
453 struct adxl34x *ac = dev_get_drvdata(dev);
461 mutex_lock(&ac->mutex);
463 if (!ac->suspended && ac->opened) {
465 if (!ac->disabled)
466 __adxl34x_disable(ac);
468 if (ac->disabled)
469 __adxl34x_enable(ac);
473 ac->disabled = !!val;
475 mutex_unlock(&ac->mutex);
485 struct adxl34x *ac = dev_get_drvdata(dev);
488 mutex_lock(&ac->mutex);
490 ac->hwcal.x * 4 + ac->swcal.x,
491 ac->hwcal.y * 4 + ac->swcal.y,
492 ac->hwcal.z * 4 + ac->swcal.z);
493 mutex_unlock(&ac->mutex);
502 struct adxl34x *ac = dev_get_drvdata(dev);
509 mutex_lock(&ac->mutex);
510 ac->hwcal.x -= (ac->saved.x / 4);
511 ac->swcal.x = ac->saved.x % 4;
513 ac->hwcal.y -= (ac->saved.y / 4);
514 ac->swcal.y = ac->saved.y % 4;
516 ac->hwcal.z -= (ac->saved.z / 4);
517 ac->swcal.z = ac->saved.z % 4;
519 AC_WRITE(ac, OFSX, (s8) ac->hwcal.x);
520 AC_WRITE(ac, OFSY, (s8) ac->hwcal.y);
521 AC_WRITE(ac, OFSZ, (s8) ac->hwcal.z);
522 mutex_unlock(&ac->mutex);
533 struct adxl34x *ac = dev_get_drvdata(dev);
535 return sprintf(buf, "%u\n", RATE(ac->pdata.data_rate));
542 struct adxl34x *ac = dev_get_drvdata(dev);
550 mutex_lock(&ac->mutex);
552 ac->pdata.data_rate = RATE(val);
553 AC_WRITE(ac, BW_RATE,
554 ac->pdata.data_rate |
555 (ac->pdata.low_power_mode ? LOW_POWER : 0));
557 mutex_unlock(&ac->mutex);
567 struct adxl34x *ac = dev_get_drvdata(dev);
570 ac->pdata.power_mode & (PCTL_AUTO_SLEEP | PCTL_LINK) ? 1 : 0);
577 struct adxl34x *ac = dev_get_drvdata(dev);
585 mutex_lock(&ac->mutex);
588 ac->pdata.power_mode |= (PCTL_AUTO_SLEEP | PCTL_LINK);
590 ac->pdata.power_mode &= ~(PCTL_AUTO_SLEEP | PCTL_LINK);
592 if (!ac->disabled && !ac->suspended && ac->opened)
593 AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
595 mutex_unlock(&ac->mutex);
606 struct adxl34x *ac = dev_get_drvdata(dev);
609 mutex_lock(&ac->mutex);
611 ac->saved.x, ac->saved.y, ac->saved.z);
612 mutex_unlock(&ac->mutex);
624 struct adxl34x *ac = dev_get_drvdata(dev);
635 mutex_lock(&ac->mutex);
636 AC_WRITE(ac, val >> 8, val & 0xFF);
637 mutex_unlock(&ac->mutex);
663 struct adxl34x *ac = input_get_drvdata(input);
665 mutex_lock(&ac->mutex);
667 if (!ac->suspended && !ac->disabled)
668 __adxl34x_enable(ac);
670 ac->opened = true;
672 mutex_unlock(&ac->mutex);
679 struct adxl34x *ac = input_get_drvdata(input);
681 mutex_lock(&ac->mutex);
683 if (!ac->suspended && !ac->disabled)
684 __adxl34x_disable(ac);
686 ac->opened = false;
688 mutex_unlock(&ac->mutex);
695 struct adxl34x *ac;
707 ac = kzalloc(sizeof(*ac), GFP_KERNEL);
709 if (!ac || !input_dev) {
714 ac->fifo_delay = fifo_delay_default;
723 ac->pdata = *pdata;
724 pdata = &ac->pdata;
726 ac->input = input_dev;
727 ac->dev = dev;
728 ac->irq = irq;
729 ac->bops = bops;
731 mutex_init(&ac->mutex);
734 revid = ac->bops->read(dev, DEVID);
738 ac->model = 345;
741 ac->model = 346;
749 snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(dev));
751 input_dev->phys = ac->phys;
753 input_dev->id.product = ac->model;
758 input_set_drvdata(input_dev, ac);
760 __set_bit(ac->pdata.ev_type, input_dev->evbit);
762 if (ac->pdata.ev_type == EV_REL) {
788 ac->int_mask = FREE_FALL;
795 ac->int_mask |= ACTIVITY | INACTIVITY;
798 ac->int_mask |= WATERMARK;
800 ac->pdata.fifo_mode |= FIFO_STREAM;
802 ac->int_mask |= DATA_READY;
806 ac->int_mask |= SINGLE_TAP | DOUBLE_TAP;
809 ac->fifo_delay = false;
811 ac->bops->write(dev, POWER_CTL, 0);
813 err = request_threaded_irq(ac->irq, NULL, adxl34x_irq,
815 dev_name(dev), ac);
817 dev_err(dev, "irq %d busy?\n", ac->irq);
829 AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
830 AC_WRITE(ac, OFSX, pdata->x_axis_offset);
831 ac->hwcal.x = pdata->x_axis_offset;
832 AC_WRITE(ac, OFSY, pdata->y_axis_offset);
833 ac->hwcal.y = pdata->y_axis_offset;
834 AC_WRITE(ac, OFSZ, pdata->z_axis_offset);
835 ac->hwcal.z = pdata->z_axis_offset;
836 AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
837 AC_WRITE(ac, DUR, pdata->tap_duration);
838 AC_WRITE(ac, LATENT, pdata->tap_latency);
839 AC_WRITE(ac, WINDOW, pdata->tap_window);
840 AC_WRITE(ac, THRESH_ACT, pdata->activity_threshold);
841 AC_WRITE(ac, THRESH_INACT, pdata->inactivity_threshold);
842 AC_WRITE(ac, TIME_INACT, pdata->inactivity_time);
843 AC_WRITE(ac, THRESH_FF, pdata->free_fall_threshold);
844 AC_WRITE(ac, TIME_FF, pdata->free_fall_time);
845 AC_WRITE(ac, TAP_AXES, pdata->tap_axis_control);
846 AC_WRITE(ac, ACT_INACT_CTL, pdata->act_axis_control);
847 AC_WRITE(ac, BW_RATE, RATE(ac->pdata.data_rate) |
849 AC_WRITE(ac, DATA_FORMAT, pdata->data_range);
850 AC_WRITE(ac, FIFO_CTL, FIFO_MODE(pdata->fifo_mode) |
855 AC_WRITE(ac, INT_MAP, ac->int_mask | OVERRUN);
858 AC_WRITE(ac, INT_MAP, 0);
861 if (ac->model == 346 && ac->pdata.orientation_enable) {
862 AC_WRITE(ac, ORIENT_CONF,
863 ORIENT_DEADZONE(ac->pdata.deadzone_angle) |
864 ORIENT_DIVISOR(ac->pdata.divisor_length));
866 ac->orient2d_saved = 1234;
867 ac->orient3d_saved = 1234;
879 ac->pdata.orientation_enable = 0;
882 AC_WRITE(ac, INT_ENABLE, ac->int_mask | OVERRUN);
884 ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK);
886 return ac;
891 free_irq(ac->irq, ac);
894 kfree(ac);
900 int adxl34x_remove(struct adxl34x *ac)
902 sysfs_remove_group(&ac->dev->kobj, &adxl34x_attr_group);
903 free_irq(ac->irq, ac);
904 input_unregister_device(ac->input);
905 dev_dbg(ac->dev, "unregistered accelerometer\n");
906 kfree(ac);