← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/iio/meter/ade7759.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/meter/ade7759.c
23
23
#include "meter.h"
24
24
#include "ade7759.h"
25
25
 
26
 
int ade7759_spi_write_reg_8(struct device *dev,
 
26
static int ade7759_spi_write_reg_8(struct device *dev,
27
27
                u8 reg_address,
28
28
                u8 val)
29
29
{
46
46
                u16 value)
47
47
{
48
48
        int ret;
49
 
        struct spi_message msg;
50
49
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
51
50
        struct ade7759_state *st = iio_dev_get_devdata(indio_dev);
52
 
        struct spi_transfer xfers[] = {
53
 
                {
54
 
                        .tx_buf = st->tx,
55
 
                        .bits_per_word = 8,
56
 
                        .len = 3,
57
 
                }
58
 
        };
59
51
 
60
52
        mutex_lock(&st->buf_lock);
61
53
        st->tx[0] = ADE7759_WRITE_REG(reg_address);
62
54
        st->tx[1] = (value >> 8) & 0xFF;
63
55
        st->tx[2] = value & 0xFF;
64
 
 
65
 
        spi_message_init(&msg);
66
 
        spi_message_add_tail(xfers, &msg);
67
 
        ret = spi_sync(st->us, &msg);
 
56
        ret = spi_write(st->us, st->tx, 3);
68
57
        mutex_unlock(&st->buf_lock);
69
58
 
70
59
        return ret;
74
63
                u8 reg_address,
75
64
                u8 *val)
76
65
{
77
 
        struct spi_message msg;
78
66
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
79
67
        struct ade7759_state *st = iio_dev_get_devdata(indio_dev);
80
68
        int ret;
81
 
        struct spi_transfer xfers[] = {
82
 
                {
83
 
                        .tx_buf = st->tx,
84
 
                        .rx_buf = st->rx,
85
 
                        .bits_per_word = 8,
86
 
                        .len = 2,
87
 
                },
88
 
        };
89
 
 
90
 
        mutex_lock(&st->buf_lock);
91
 
        st->tx[0] = ADE7759_READ_REG(reg_address);
92
 
        st->tx[1] = 0;
93
 
 
94
 
        spi_message_init(&msg);
95
 
        spi_message_add_tail(xfers, &msg);
96
 
        ret = spi_sync(st->us, &msg);
97
 
        if (ret) {
 
69
 
 
70
        ret = spi_w8r8(st->us, ADE7759_READ_REG(reg_address));
 
71
        if (ret < 0) {
98
72
                dev_err(&st->us->dev, "problem when reading 8 bit register 0x%02X",
99
73
                                reg_address);
100
 
                goto error_ret;
 
74
                return ret;
101
75
        }
102
 
        *val = st->rx[1];
 
76
        *val = ret;
103
77
 
104
 
error_ret:
105
 
        mutex_unlock(&st->buf_lock);
106
 
        return ret;
 
78
        return 0;
107
79
}
108
80
 
109
81
static int ade7759_spi_read_reg_16(struct device *dev,
110
82
                u8 reg_address,
111
83
                u16 *val)
112
84
{
113
 
        struct spi_message msg;
114
85
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
115
86
        struct ade7759_state *st = iio_dev_get_devdata(indio_dev);
116
87
        int ret;
117
 
        struct spi_transfer xfers[] = {
118
 
                {
119
 
                        .tx_buf = st->tx,
120
 
                        .rx_buf = st->rx,
121
 
                        .bits_per_word = 8,
122
 
                        .len = 3,
123
 
                },
124
 
        };
125
 
 
126
 
        mutex_lock(&st->buf_lock);
127
 
        st->tx[0] = ADE7759_READ_REG(reg_address);
128
 
        st->tx[1] = 0;
129
 
        st->tx[2] = 0;
130
 
 
131
 
        spi_message_init(&msg);
132
 
        spi_message_add_tail(xfers, &msg);
133
 
        ret = spi_sync(st->us, &msg);
134
 
        if (ret) {
 
88
 
 
89
        ret = spi_w8r16(st->us, ADE7759_READ_REG(reg_address));
 
90
        if (ret < 0) {
135
91
                dev_err(&st->us->dev, "problem when reading 16 bit register 0x%02X",
136
 
                                reg_address);
137
 
                goto error_ret;
 
92
                        reg_address);
 
93
                return ret;
138
94
        }
139
 
        *val = (st->rx[1] << 8) | st->rx[2];
140
 
 
141
 
error_ret:
142
 
        mutex_unlock(&st->buf_lock);
143
 
        return ret;
 
95
 
 
96
        *val = ret;
 
97
        *val = be16_to_cpup(val);
 
98
 
 
99
        return 0;
144
100
}
145
101
 
146
102
static int ade7759_spi_read_reg_40(struct device *dev,
354
310
                irqen &= ~(1 << 3);
355
311
 
356
312
        ret = ade7759_spi_write_reg_8(dev, ADE7759_IRQEN, irqen);
357
 
        if (ret)
358
 
                goto error_ret;
359
313
 
360
314
error_ret:
361
315
        return ret;
362
316
}
363
317
 
364
318
/* Power down the device */
365
 
int ade7759_stop_device(struct device *dev)
 
319
static int ade7759_stop_device(struct device *dev)
366
320
{
367
 
        int ret;
368
321
        u16 val;
 
322
 
369
323
        ade7759_spi_read_reg_16(dev,
370
324
                        ADE7759_MODE,
371
325
                        &val);
372
326
        val |= 1 << 4;  /* AD converters can be turned off */
373
 
        ret = ade7759_spi_write_reg_16(dev,
374
 
                        ADE7759_MODE,
375
 
                        val);
376
327
 
377
 
        return ret;
 
328
        return ade7759_spi_write_reg_16(dev, ADE7759_MODE, val);
378
329
}
379
330
 
380
331
static int ade7759_initial_setup(struct ade7759_state *st)
404
355
                struct device_attribute *attr,
405
356
                char *buf)
406
357
{
407
 
        int ret, len = 0;
 
358
        int ret;
408
359
        u16 t;
409
360
        int sps;
410
361
        ret = ade7759_spi_read_reg_16(dev,
416
367
        t = (t >> 3) & 0x3;
417
368
        sps = 27900 / (1 + t);
418
369
 
419
 
        len = sprintf(buf, "%d SPS\n", sps);
420
 
        return len;
 
370
        return sprintf(buf, "%d\n", sps);
421
371
}
422
372
 
423
373
static ssize_t ade7759_write_frequency(struct device *dev,
446
396
        else
447
397
                st->us->max_speed_hz = ADE7759_SPI_FAST;
448
398
 
449
 
        ret = ade7759_spi_read_reg_16(dev,
450
 
                        ADE7759_MODE,
451
 
                        &reg);
 
399
        ret = ade7759_spi_read_reg_16(dev, ADE7759_MODE, &reg);
452
400
        if (ret)
453
401
                goto out;
454
402
 
455
403
        reg &= ~(3 << 13);
456
404
        reg |= t << 13;
457
405
 
458
 
        ret = ade7759_spi_write_reg_16(dev,
459
 
                        ADE7759_MODE,
460
 
                        reg);
 
406
        ret = ade7759_spi_write_reg_16(dev, ADE7759_MODE, reg);
461
407
 
462
408
out:
463
409
        mutex_unlock(&indio_dev->mlock);
476
422
 
477
423
static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("27900 14000 7000 3500");
478
424
 
479
 
static IIO_CONST_ATTR(name, "ade7759");
480
 
 
481
 
static struct attribute *ade7759_event_attributes[] = {
482
 
        NULL
483
 
};
484
 
 
485
 
static struct attribute_group ade7759_event_attribute_group = {
486
 
        .attrs = ade7759_event_attributes,
487
 
};
488
 
 
489
425
static struct attribute *ade7759_attributes[] = {
490
426
        &iio_dev_attr_temp_raw.dev_attr.attr,
491
427
        &iio_const_attr_temp_offset.dev_attr.attr,
493
429
        &iio_dev_attr_sampling_frequency.dev_attr.attr,
494
430
        &iio_const_attr_sampling_frequency_available.dev_attr.attr,
495
431
        &iio_dev_attr_reset.dev_attr.attr,
496
 
        &iio_const_attr_name.dev_attr.attr,
497
432
        &iio_dev_attr_phcal.dev_attr.attr,
498
433
        &iio_dev_attr_cfden.dev_attr.attr,
499
434
        &iio_dev_attr_aenergy.dev_attr.attr,
515
450
        .attrs = ade7759_attributes,
516
451
};
517
452
 
 
453
static const struct iio_info ade7759_info = {
 
454
        .attrs = &ade7759_attribute_group,
 
455
        .driver_module = THIS_MODULE,
 
456
};
 
457
 
518
458
static int __devinit ade7759_probe(struct spi_device *spi)
519
459
{
520
 
        int ret, regdone = 0;
 
460
        int ret;
521
461
        struct ade7759_state *st = kzalloc(sizeof *st, GFP_KERNEL);
522
462
        if (!st) {
523
463
                ret =  -ENOMEM;
540
480
        st->us = spi;
541
481
        mutex_init(&st->buf_lock);
542
482
        /* setup the industrialio driver allocated elements */
543
 
        st->indio_dev = iio_allocate_device();
 
483
        st->indio_dev = iio_allocate_device(0);
544
484
        if (st->indio_dev == NULL) {
545
485
                ret = -ENOMEM;
546
486
                goto error_free_tx;
547
487
        }
548
488
 
 
489
        st->indio_dev->name = spi->dev.driver->name;
549
490
        st->indio_dev->dev.parent = &spi->dev;
550
 
        st->indio_dev->num_interrupt_lines = 1;
551
 
        st->indio_dev->event_attrs = &ade7759_event_attribute_group;
552
 
        st->indio_dev->attrs = &ade7759_attribute_group;
 
491
 
 
492
        st->indio_dev->info = &ade7759_info;
553
493
        st->indio_dev->dev_data = (void *)(st);
554
 
        st->indio_dev->driver_module = THIS_MODULE;
555
494
        st->indio_dev->modes = INDIO_DIRECT_MODE;
556
495
 
557
 
        ret = ade7759_configure_ring(st->indio_dev);
 
496
        ret = iio_device_register(st->indio_dev);
558
497
        if (ret)
559
498
                goto error_free_dev;
560
499
 
561
 
        ret = iio_device_register(st->indio_dev);
562
 
        if (ret)
563
 
                goto error_unreg_ring_funcs;
564
 
        regdone = 1;
565
 
 
566
 
        ret = ade7759_initialize_ring(st->indio_dev->ring);
567
 
        if (ret) {
568
 
                printk(KERN_ERR "failed to initialize the ring\n");
569
 
                goto error_unreg_ring_funcs;
570
 
        }
571
 
 
572
 
        if (spi->irq) {
573
 
                ret = iio_register_interrupt_line(spi->irq,
574
 
                                st->indio_dev,
575
 
                                0,
576
 
                                IRQF_TRIGGER_FALLING,
577
 
                                "ade7759");
578
 
                if (ret)
579
 
                        goto error_uninitialize_ring;
580
 
 
581
 
                ret = ade7759_probe_trigger(st->indio_dev);
582
 
                if (ret)
583
 
                        goto error_unregister_line;
584
 
        }
585
 
 
586
500
        /* Get the device into a sane initial state */
587
501
        ret = ade7759_initial_setup(st);
588
502
        if (ret)
589
 
                goto error_remove_trigger;
 
503
                goto error_unreg_dev;
590
504
        return 0;
591
505
 
592
 
error_remove_trigger:
593
 
        if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
594
 
                ade7759_remove_trigger(st->indio_dev);
595
 
error_unregister_line:
596
 
        if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
597
 
                iio_unregister_interrupt_line(st->indio_dev, 0);
598
 
error_uninitialize_ring:
599
 
        ade7759_uninitialize_ring(st->indio_dev->ring);
600
 
error_unreg_ring_funcs:
601
 
        ade7759_unconfigure_ring(st->indio_dev);
 
506
 
 
507
error_unreg_dev:
 
508
        iio_device_unregister(st->indio_dev);
602
509
error_free_dev:
603
 
        if (regdone)
604
 
                iio_device_unregister(st->indio_dev);
605
 
        else
606
 
                iio_free_device(st->indio_dev);
 
510
        iio_free_device(st->indio_dev);
607
511
error_free_tx:
608
512
        kfree(st->tx);
609
513
error_free_rx:
625
529
        if (ret)
626
530
                goto err_ret;
627
531
 
628
 
        flush_scheduled_work();
629
 
 
630
 
        ade7759_remove_trigger(indio_dev);
631
 
        if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0)
632
 
                iio_unregister_interrupt_line(indio_dev, 0);
633
 
 
634
 
        ade7759_uninitialize_ring(indio_dev->ring);
635
 
        ade7759_unconfigure_ring(indio_dev);
636
532
        iio_device_unregister(indio_dev);
637
533
        kfree(st->tx);
638
534
        kfree(st->rx);