← Back to branch summary

~diwic/sound-2.6/filtered

« back to all changes in this revision

Viewing changes to soc/codecs/wm8741.c

  • Committer: Takashi Iwai
  • Date: 2011-08-12 17:48:16 UTC
  • mfrom: (2927.505.40)
  • Revision ID: git-v1:2b3eb625c1695190b9e9bad701b026d53606f4c6
Merge branch 'topic/asoc'

Show diffs side-by-side

added added

removed removed

Lines of Context:
soc/codecs/wm8741.c
17
17
#include <linux/delay.h>
18
18
#include <linux/pm.h>
19
19
#include <linux/i2c.h>
 
20
#include <linux/spi/spi.h>
20
21
#include <linux/platform_device.h>
21
22
#include <linux/regulator/consumer.h>
22
23
#include <linux/slab.h>
422
423
{
423
424
        struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
424
425
        int ret = 0;
 
426
        int i;
 
427
 
 
428
        for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
 
429
                wm8741->supplies[i].supply = wm8741_supply_names[i];
 
430
 
 
431
        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8741->supplies),
 
432
                                 wm8741->supplies);
 
433
        if (ret != 0) {
 
434
                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
 
435
                goto err;
 
436
        }
 
437
 
 
438
        ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies),
 
439
                                    wm8741->supplies);
 
440
        if (ret != 0) {
 
441
                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
 
442
                goto err_get;
 
443
        }
425
444
 
426
445
        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8741->control_type);
427
446
        if (ret != 0) {
428
447
                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
429
 
                return ret;
 
448
                goto err_enable;
430
449
        }
431
450
 
432
451
        ret = wm8741_reset(codec);
433
452
        if (ret < 0) {
434
453
                dev_err(codec->dev, "Failed to issue reset\n");
435
 
                return ret;
 
454
                goto err_enable;
436
455
        }
437
456
 
438
457
        /* Change some default settings - latch VU */
451
470
 
452
471
        dev_dbg(codec->dev, "Successful registration\n");
453
472
        return ret;
 
473
 
 
474
err_enable:
 
475
        regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
 
476
err_get:
 
477
        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
 
478
err:
 
479
        return ret;
 
480
}
 
481
 
 
482
static int wm8741_remove(struct snd_soc_codec *codec)
 
483
{
 
484
        struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
 
485
 
 
486
        regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
 
487
        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
 
488
 
 
489
        return 0;
454
490
}
455
491
 
456
492
static struct snd_soc_codec_driver soc_codec_dev_wm8741 = {
457
493
        .probe =        wm8741_probe,
 
494
        .remove =       wm8741_remove,
458
495
        .resume =       wm8741_resume,
459
496
        .reg_cache_size = ARRAY_SIZE(wm8741_reg_defaults),
460
497
        .reg_word_size = sizeof(u16),
466
503
                            const struct i2c_device_id *id)
467
504
{
468
505
        struct wm8741_priv *wm8741;
469
 
        int ret, i;
 
506
        int ret;
470
507
 
471
508
        wm8741 = kzalloc(sizeof(struct wm8741_priv), GFP_KERNEL);
472
509
        if (wm8741 == NULL)
473
510
                return -ENOMEM;
474
511
 
475
 
        for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
476
 
                wm8741->supplies[i].supply = wm8741_supply_names[i];
477
 
 
478
 
        ret = regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8741->supplies),
479
 
                                 wm8741->supplies);
480
 
        if (ret != 0) {
481
 
                dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
482
 
                goto err;
483
 
        }
484
 
 
485
 
        ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies),
486
 
                                    wm8741->supplies);
487
 
        if (ret != 0) {
488
 
                dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
489
 
                goto err_get;
490
 
        }
491
 
 
492
512
        i2c_set_clientdata(i2c, wm8741);
493
513
        wm8741->control_type = SND_SOC_I2C;
494
514
 
495
 
        ret =  snd_soc_register_codec(&i2c->dev,
496
 
                        &soc_codec_dev_wm8741, &wm8741_dai, 1);
497
 
        if (ret < 0)
498
 
                goto err_enable;
 
515
        ret = snd_soc_register_codec(&i2c->dev,
 
516
                                     &soc_codec_dev_wm8741, &wm8741_dai, 1);
 
517
        if (ret != 0)
 
518
                goto err;
 
519
 
499
520
        return ret;
500
521
 
501
 
err_enable:
502
 
        regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
503
 
 
504
 
err_get:
505
 
        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
506
522
err:
507
523
        kfree(wm8741);
508
524
        return ret;
510
526
 
511
527
static int wm8741_i2c_remove(struct i2c_client *client)
512
528
{
513
 
        struct wm8741_priv *wm8741 = i2c_get_clientdata(client);
514
 
 
515
529
        snd_soc_unregister_codec(&client->dev);
516
 
        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
517
530
        kfree(i2c_get_clientdata(client));
518
531
        return 0;
519
532
}
526
539
 
527
540
static struct i2c_driver wm8741_i2c_driver = {
528
541
        .driver = {
529
 
                .name = "wm8741-codec",
 
542
                .name = "wm8741",
530
543
                .owner = THIS_MODULE,
531
544
        },
532
545
        .probe =    wm8741_i2c_probe,
535
548
};
536
549
#endif
537
550
 
 
551
#if defined(CONFIG_SPI_MASTER)
 
552
static int __devinit wm8741_spi_probe(struct spi_device *spi)
 
553
{
 
554
        struct wm8741_priv *wm8741;
 
555
        int ret;
 
556
 
 
557
        wm8741 = kzalloc(sizeof(struct wm8741_priv), GFP_KERNEL);
 
558
        if (wm8741 == NULL)
 
559
                return -ENOMEM;
 
560
 
 
561
        wm8741->control_type = SND_SOC_SPI;
 
562
        spi_set_drvdata(spi, wm8741);
 
563
 
 
564
        ret = snd_soc_register_codec(&spi->dev,
 
565
                        &soc_codec_dev_wm8741, &wm8741_dai, 1);
 
566
        if (ret < 0)
 
567
                kfree(wm8741);
 
568
        return ret;
 
569
}
 
570
 
 
571
static int __devexit wm8741_spi_remove(struct spi_device *spi)
 
572
{
 
573
        snd_soc_unregister_codec(&spi->dev);
 
574
        kfree(spi_get_drvdata(spi));
 
575
        return 0;
 
576
}
 
577
 
 
578
static struct spi_driver wm8741_spi_driver = {
 
579
        .driver = {
 
580
                .name   = "wm8741",
 
581
                .owner  = THIS_MODULE,
 
582
        },
 
583
        .probe          = wm8741_spi_probe,
 
584
        .remove         = __devexit_p(wm8741_spi_remove),
 
585
};
 
586
#endif /* CONFIG_SPI_MASTER */
 
587
 
538
588
static int __init wm8741_modinit(void)
539
589
{
540
590
        int ret = 0;
544
594
        if (ret != 0)
545
595
                pr_err("Failed to register WM8741 I2C driver: %d\n", ret);
546
596
#endif
 
597
#if defined(CONFIG_SPI_MASTER)
 
598
        ret = spi_register_driver(&wm8741_spi_driver);
 
599
        if (ret != 0) {
 
600
                printk(KERN_ERR "Failed to register wm8741 SPI driver: %d\n",
 
601
                       ret);
 
602
        }
 
603
#endif
547
604
 
548
605
        return ret;
549
606
}
551
608
 
552
609
static void __exit wm8741_exit(void)
553
610
{
 
611
#if defined(CONFIG_SPI_MASTER)
 
612
        spi_unregister_driver(&wm8741_spi_driver);
 
613
#endif
554
614
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
555
615
        i2c_del_driver(&wm8741_i2c_driver);
556
616
#endif