← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/staging/iio/gyro/adis16260_core.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/gyro/adis16260_core.c
8
8
 
9
9
#include <linux/interrupt.h>
10
10
#include <linux/irq.h>
11
 
#include <linux/gpio.h>
12
11
#include <linux/delay.h>
13
12
#include <linux/mutex.h>
14
13
#include <linux/device.h>
17
16
#include <linux/slab.h>
18
17
#include <linux/sysfs.h>
19
18
#include <linux/list.h>
 
19
#include <linux/module.h>
20
20
 
21
21
#include "../iio.h"
22
22
#include "../sysfs.h"
23
 
#include "../ring_generic.h"
24
 
#include "../adc/adc.h"
25
 
#include "gyro.h"
 
23
#include "../buffer_generic.h"
26
24
 
27
25
#include "adis16260.h"
28
26
 
41
39
                u8 val)
42
40
{
43
41
        int ret;
44
 
        struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
 
42
        struct adis16260_state *st = iio_priv(indio_dev);
45
43
 
46
44
        mutex_lock(&st->buf_lock);
47
45
        st->tx[0] = ADIS16260_WRITE_REG(reg_address);
66
64
{
67
65
        int ret;
68
66
        struct spi_message msg;
69
 
        struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
 
67
        struct adis16260_state *st = iio_priv(indio_dev);
70
68
        struct spi_transfer xfers[] = {
71
69
                {
72
70
                        .tx_buf = st->tx,
109
107
                u16 *val)
110
108
{
111
109
        struct spi_message msg;
112
 
        struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
 
110
        struct adis16260_state *st = iio_priv(indio_dev);
113
111
        int ret;
114
112
        struct spi_transfer xfers[] = {
115
113
                {
152
150
                                                  char *buf)
153
151
{
154
152
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
155
 
        struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
 
153
        struct adis16260_state *st = iio_priv(indio_dev);
156
154
        if (spi_get_device_id(st->us)->driver_data)
157
155
                return sprintf(buf, "%s\n", "0.129 ~ 256");
158
156
        else
164
162
                char *buf)
165
163
{
166
164
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
167
 
        struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
 
165
        struct adis16260_state *st = iio_priv(indio_dev);
168
166
        int ret, len = 0;
169
167
        u16 t;
170
168
        int sps;
189
187
                size_t len)
190
188
{
191
189
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
192
 
        struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
 
190
        struct adis16260_state *st = iio_priv(indio_dev);
193
191
        long val;
194
192
        int ret;
195
193
        u8 t;
391
389
};
392
390
#define ADIS16260_GYRO_CHANNEL_SET(axis, mod)                           \
393
391
        struct iio_chan_spec adis16260_channels_##axis[] = {            \
394
 
                IIO_CHAN(IIO_GYRO, 1, 0, 0, NULL, 0, mod,               \
 
392
                IIO_CHAN(IIO_ANGL_VEL, 1, 0, 0, NULL, 0, mod,           \
395
393
                         (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |      \
396
394
                         (1 << IIO_CHAN_INFO_CALIBSCALE_SEPARATE) |     \
397
395
                         (1 << IIO_CHAN_INFO_SCALE_SEPARATE),           \
406
404
                         (1 << IIO_CHAN_INFO_SCALE_SEPARATE),           \
407
405
                         temp, ADIS16260_SCAN_TEMP,                     \
408
406
                         IIO_ST('u', 12, 16, 0), 0),                    \
409
 
                IIO_CHAN(IIO_IN, 0, 1, 0, "supply", 0, 0,               \
 
407
                IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, "supply", 0, 0,          \
410
408
                         (1 << IIO_CHAN_INFO_SCALE_SEPARATE),           \
411
409
                         in_supply, ADIS16260_SCAN_SUPPLY,              \
412
410
                         IIO_ST('u', 12, 16, 0), 0),                    \
413
 
                IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,                   \
 
411
                IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, NULL, 1, 0,              \
414
412
                         (1 << IIO_CHAN_INFO_SCALE_SEPARATE),           \
415
413
                         in_aux, ADIS16260_SCAN_AUX_ADC,                \
416
414
                         IIO_ST('u', 12, 16, 0), 0),                    \
435
433
                              int *val, int *val2,
436
434
                              long mask)
437
435
{
438
 
        struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
 
436
        struct adis16260_state *st = iio_priv(indio_dev);
439
437
        int ret;
440
438
        int bits;
441
439
        u8 addr;
446
444
                mutex_lock(&indio_dev->mlock);
447
445
                addr = adis16260_addresses[chan->address][0];
448
446
                ret = adis16260_spi_read_reg_16(indio_dev, addr, &val16);
449
 
                if (ret)
 
447
                if (ret) {
 
448
                        mutex_unlock(&indio_dev->mlock);
450
449
                        return ret;
 
450
                }
451
451
 
452
452
                if (val16 & ADIS16260_ERROR_ACTIVE) {
453
453
                        ret = adis16260_check_status(indio_dev);
454
 
                        if (ret)
 
454
                        if (ret) {
 
455
                                mutex_unlock(&indio_dev->mlock);
455
456
                                return ret;
 
457
                        }
456
458
                }
457
459
                val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
458
460
                if (chan->scan_type.sign == 's')
465
467
        case (1 << IIO_CHAN_INFO_SCALE_SEPARATE):
466
468
        case (1 << IIO_CHAN_INFO_SCALE_SHARED):
467
469
                switch (chan->type) {
468
 
                case IIO_GYRO:
 
470
                case IIO_ANGL_VEL:
469
471
                        *val = 0;
470
472
                        if (spi_get_device_id(st->us)->driver_data)
471
473
                                *val2 = 320;
472
474
                        else
473
475
                                *val2 = 1278;
474
476
                        return IIO_VAL_INT_PLUS_MICRO;
475
 
                case IIO_IN:
 
477
                case IIO_VOLTAGE:
476
478
                        *val = 0;
477
479
                        if (chan->channel == 0)
478
480
                                *val2 = 18315;
492
494
                return IIO_VAL_INT;
493
495
        case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
494
496
                switch (chan->type) {
495
 
                case IIO_GYRO:
 
497
                case IIO_ANGL_VEL:
496
498
                        bits = 12;
497
499
                        break;
498
500
                default:
512
514
                return IIO_VAL_INT;
513
515
        case (1 << IIO_CHAN_INFO_CALIBSCALE_SEPARATE):
514
516
                switch (chan->type) {
515
 
                case IIO_GYRO:
 
517
                case IIO_ANGL_VEL:
516
518
                        bits = 12;
517
519
                        break;
518
520
                default:
574
576
 
575
577
static int __devinit adis16260_probe(struct spi_device *spi)
576
578
{
577
 
        int ret, regdone = 0;
 
579
        int ret;
578
580
        struct adis16260_platform_data *pd = spi->dev.platform_data;
579
 
        struct adis16260_state *st = kzalloc(sizeof *st, GFP_KERNEL);
580
 
        if (!st) {
581
 
                ret =  -ENOMEM;
 
581
        struct adis16260_state *st;
 
582
        struct iio_dev *indio_dev;
 
583
 
 
584
        /* setup the industrialio driver allocated elements */
 
585
        indio_dev = iio_allocate_device(sizeof(*st));
 
586
        if (indio_dev == NULL) {
 
587
                ret = -ENOMEM;
582
588
                goto error_ret;
583
589
        }
 
590
        st = iio_priv(indio_dev);
584
591
        if (pd)
585
592
                st->negate = pd->negate;
586
593
        /* this is only used for removal purposes */
587
594
        spi_set_drvdata(spi, st);
588
595
 
589
 
        /* Allocate the comms buffers */
590
 
        st->rx = kzalloc(sizeof(*st->rx)*ADIS16260_MAX_RX, GFP_KERNEL);
591
 
        if (st->rx == NULL) {
592
 
                ret = -ENOMEM;
593
 
                goto error_free_st;
594
 
        }
595
 
        st->tx = kzalloc(sizeof(*st->tx)*ADIS16260_MAX_TX, GFP_KERNEL);
596
 
        if (st->tx == NULL) {
597
 
                ret = -ENOMEM;
598
 
                goto error_free_rx;
599
 
        }
600
596
        st->us = spi;
601
597
        mutex_init(&st->buf_lock);
602
 
        /* setup the industrialio driver allocated elements */
603
 
        st->indio_dev = iio_allocate_device(0);
604
 
        if (st->indio_dev == NULL) {
605
 
                ret = -ENOMEM;
606
 
                goto error_free_tx;
607
 
        }
608
598
 
609
 
        st->indio_dev->name = spi_get_device_id(st->us)->name;
610
 
        st->indio_dev->dev.parent = &spi->dev;
611
 
        st->indio_dev->info = &adis16260_info;
612
 
        st->indio_dev->num_channels
 
599
        indio_dev->name = spi_get_device_id(st->us)->name;
 
600
        indio_dev->dev.parent = &spi->dev;
 
601
        indio_dev->info = &adis16260_info;
 
602
        indio_dev->num_channels
613
603
                = ARRAY_SIZE(adis16260_channels_x);
614
604
        if (pd && pd->direction)
615
605
                switch (pd->direction) {
616
606
                case 'x':
617
 
                        st->indio_dev->channels = adis16260_channels_x;
 
607
                        indio_dev->channels = adis16260_channels_x;
618
608
                        break;
619
609
                case 'y':
620
 
                        st->indio_dev->channels = adis16260_channels_y;
 
610
                        indio_dev->channels = adis16260_channels_y;
621
611
                        break;
622
612
                case 'z':
623
 
                        st->indio_dev->channels = adis16260_channels_z;
 
613
                        indio_dev->channels = adis16260_channels_z;
624
614
                        break;
625
615
                default:
626
616
                        return -EINVAL;
627
617
                }
628
618
        else
629
 
                st->indio_dev->channels = adis16260_channels_x;
630
 
 
631
 
        st->indio_dev->dev_data = (void *)(st);
632
 
        st->indio_dev->modes = INDIO_DIRECT_MODE;
633
 
 
634
 
        ret = adis16260_configure_ring(st->indio_dev);
 
619
                indio_dev->channels = adis16260_channels_x;
 
620
        indio_dev->num_channels = ARRAY_SIZE(adis16260_channels_x);
 
621
        indio_dev->modes = INDIO_DIRECT_MODE;
 
622
 
 
623
        ret = adis16260_configure_ring(indio_dev);
635
624
        if (ret)
636
625
                goto error_free_dev;
637
626
 
638
 
        ret = iio_device_register(st->indio_dev);
639
 
        if (ret)
640
 
                goto error_unreg_ring_funcs;
641
 
        regdone = 1;
642
 
        ret = iio_ring_buffer_register_ex(st->indio_dev->ring, 0,
643
 
                                          st->indio_dev->channels,
644
 
                                          ARRAY_SIZE(adis16260_channels_x));
 
627
        ret = iio_buffer_register(indio_dev,
 
628
                                  indio_dev->channels,
 
629
                                  ARRAY_SIZE(adis16260_channels_x));
645
630
        if (ret) {
646
631
                printk(KERN_ERR "failed to initialize the ring\n");
647
632
                goto error_unreg_ring_funcs;
648
633
        }
649
 
 
 
634
        if (indio_dev->buffer) {
 
635
                /* Set default scan mode */
 
636
                iio_scan_mask_set(indio_dev->buffer, ADIS16260_SCAN_SUPPLY);
 
637
                iio_scan_mask_set(indio_dev->buffer, ADIS16260_SCAN_GYRO);
 
638
                iio_scan_mask_set(indio_dev->buffer, ADIS16260_SCAN_AUX_ADC);
 
639
                iio_scan_mask_set(indio_dev->buffer, ADIS16260_SCAN_TEMP);
 
640
                iio_scan_mask_set(indio_dev->buffer, ADIS16260_SCAN_ANGL);
 
641
        }
650
642
        if (spi->irq) {
651
 
                ret = adis16260_probe_trigger(st->indio_dev);
 
643
                ret = adis16260_probe_trigger(indio_dev);
652
644
                if (ret)
653
645
                        goto error_uninitialize_ring;
654
646
        }
655
647
 
656
648
        /* Get the device into a sane initial state */
657
 
        ret = adis16260_initial_setup(st->indio_dev);
658
 
        if (ret)
659
 
                goto error_remove_trigger;
 
649
        ret = adis16260_initial_setup(indio_dev);
 
650
        if (ret)
 
651
                goto error_remove_trigger;
 
652
        ret = iio_device_register(indio_dev);
 
653
        if (ret)
 
654
                goto error_remove_trigger;
 
655
 
660
656
        return 0;
661
657
 
662
658
error_remove_trigger:
663
 
        adis16260_remove_trigger(st->indio_dev);
 
659
        adis16260_remove_trigger(indio_dev);
664
660
error_uninitialize_ring:
665
 
        iio_ring_buffer_unregister(st->indio_dev->ring);
 
661
        iio_buffer_unregister(indio_dev);
666
662
error_unreg_ring_funcs:
667
 
        adis16260_unconfigure_ring(st->indio_dev);
 
663
        adis16260_unconfigure_ring(indio_dev);
668
664
error_free_dev:
669
 
        if (regdone)
670
 
                iio_device_unregister(st->indio_dev);
671
 
        else
672
 
                iio_free_device(st->indio_dev);
673
 
error_free_tx:
674
 
        kfree(st->tx);
675
 
error_free_rx:
676
 
        kfree(st->rx);
677
 
error_free_st:
678
 
        kfree(st);
 
665
        iio_free_device(indio_dev);
679
666
error_ret:
680
667
        return ret;
681
668
}
683
670
static int adis16260_remove(struct spi_device *spi)
684
671
{
685
672
        int ret;
686
 
        struct adis16260_state *st = spi_get_drvdata(spi);
687
 
        struct iio_dev *indio_dev = st->indio_dev;
 
673
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
 
674
 
 
675
        iio_device_unregister(indio_dev);
688
676
 
689
677
        ret = adis16260_stop_device(indio_dev);
690
678
        if (ret)
693
681
        flush_scheduled_work();
694
682
 
695
683
        adis16260_remove_trigger(indio_dev);
696
 
 
697
 
        iio_ring_buffer_unregister(st->indio_dev->ring);
698
 
        iio_device_unregister(indio_dev);
 
684
        iio_buffer_unregister(indio_dev);
699
685
        adis16260_unconfigure_ring(indio_dev);
700
 
        kfree(st->tx);
701
 
        kfree(st->rx);
702
 
        kfree(st);
 
686
        iio_free_device(indio_dev);
703
687
 
704
688
err_ret:
705
689
        return ret;