← Back to branch summary

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

« back to all changes in this revision

Viewing changes to drivers/mfd/twl-core.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/mfd/twl-core.c
110
110
#endif
111
111
 
112
112
#if defined(CONFIG_TWL4030_CODEC) || defined(CONFIG_TWL4030_CODEC_MODULE) ||\
113
 
        defined(CONFIG_SND_SOC_TWL6040) || defined(CONFIG_SND_SOC_TWL6040_MODULE)
 
113
        defined(CONFIG_TWL6040_CORE) || defined(CONFIG_TWL6040_CORE_MODULE)
114
114
#define twl_has_codec() true
115
115
#else
116
116
#define twl_has_codec() false
198
198
#define TWL6030_BASEADD_GASGAUGE        0x00C0
199
199
#define TWL6030_BASEADD_PIH             0x00D0
200
200
#define TWL6030_BASEADD_CHARGER         0x00E0
 
201
#define TWL6025_BASEADD_CHARGER         0x00DA
201
202
 
202
203
/* subchip/slave 2 0x4A - DFT */
203
204
#define TWL6030_BASEADD_DIEID           0x00C0
230
231
/* is driver active, bound to a chip? */
231
232
static bool inuse;
232
233
 
 
234
/* TWL IDCODE Register value */
 
235
static u32 twl_idcode;
 
236
 
233
237
static unsigned int twl_id;
234
238
unsigned int twl_rev(void)
235
239
{
329
333
 
330
334
        { SUB_CHIP_ID0, TWL6030_BASEADD_RTC },
331
335
        { SUB_CHIP_ID0, TWL6030_BASEADD_MEM },
 
336
        { SUB_CHIP_ID1, TWL6025_BASEADD_CHARGER },
332
337
};
333
338
 
334
339
/*----------------------------------------------------------------------*/
488
493
 
489
494
/*----------------------------------------------------------------------*/
490
495
 
 
496
/**
 
497
 * twl_read_idcode_register - API to read the IDCODE register.
 
498
 *
 
499
 * Unlocks the IDCODE register and read the 32 bit value.
 
500
 */
 
501
static int twl_read_idcode_register(void)
 
502
{
 
503
        int err;
 
504
 
 
505
        err = twl_i2c_write_u8(TWL4030_MODULE_INTBR, TWL_EEPROM_R_UNLOCK,
 
506
                                                REG_UNLOCK_TEST_REG);
 
507
        if (err) {
 
508
                pr_err("TWL4030 Unable to unlock IDCODE registers -%d\n", err);
 
509
                goto fail;
 
510
        }
 
511
 
 
512
        err = twl_i2c_read(TWL4030_MODULE_INTBR, (u8 *)(&twl_idcode),
 
513
                                                REG_IDCODE_7_0, 4);
 
514
        if (err) {
 
515
                pr_err("TWL4030: unable to read IDCODE -%d\n", err);
 
516
                goto fail;
 
517
        }
 
518
 
 
519
        err = twl_i2c_write_u8(TWL4030_MODULE_INTBR, 0x0, REG_UNLOCK_TEST_REG);
 
520
        if (err)
 
521
                pr_err("TWL4030 Unable to relock IDCODE registers -%d\n", err);
 
522
fail:
 
523
        return err;
 
524
}
 
525
 
 
526
/**
 
527
 * twl_get_type - API to get TWL Si type.
 
528
 *
 
529
 * Api to get the TWL Si type from IDCODE value.
 
530
 */
 
531
int twl_get_type(void)
 
532
{
 
533
        return TWL_SIL_TYPE(twl_idcode);
 
534
}
 
535
EXPORT_SYMBOL_GPL(twl_get_type);
 
536
 
 
537
/**
 
538
 * twl_get_version - API to get TWL Si version.
 
539
 *
 
540
 * Api to get the TWL Si version from IDCODE value.
 
541
 */
 
542
int twl_get_version(void)
 
543
{
 
544
        return TWL_SIL_REV(twl_idcode);
 
545
}
 
546
EXPORT_SYMBOL_GPL(twl_get_version);
 
547
 
491
548
static struct device *
492
549
add_numbered_child(unsigned chip, const char *name, int num,
493
550
                void *pdata, unsigned pdata_len,
550
607
static struct device *
551
608
add_regulator_linked(int num, struct regulator_init_data *pdata,
552
609
                struct regulator_consumer_supply *consumers,
553
 
                unsigned num_consumers)
 
610
                unsigned num_consumers, unsigned long features)
554
611
{
555
612
        unsigned sub_chip_id;
556
613
        /* regulator framework demands init_data ... */
562
619
                pdata->num_consumer_supplies = num_consumers;
563
620
        }
564
621
 
 
622
        pdata->driver_data = (void *)features;
 
623
 
565
624
        /* NOTE:  we currently ignore regulator IRQs, e.g. for short circuits */
566
625
        sub_chip_id = twl_map[TWL_MODULE_PM_MASTER].sid;
567
626
        return add_numbered_child(sub_chip_id, "twl_reg", num,
569
628
}
570
629
 
571
630
static struct device *
572
 
add_regulator(int num, struct regulator_init_data *pdata)
 
631
add_regulator(int num, struct regulator_init_data *pdata,
 
632
                unsigned long features)
573
633
{
574
 
        return add_regulator_linked(num, pdata, NULL, 0);
 
634
        return add_regulator_linked(num, pdata, NULL, 0, features);
575
635
}
576
636
 
577
637
/*
651
711
                        };
652
712
 
653
713
                        child = add_regulator_linked(TWL4030_REG_VUSB1V5,
654
 
                                                      &usb_fixed, &usb1v5, 1);
 
714
                                                      &usb_fixed, &usb1v5, 1,
 
715
                                                      features);
655
716
                        if (IS_ERR(child))
656
717
                                return PTR_ERR(child);
657
718
 
658
719
                        child = add_regulator_linked(TWL4030_REG_VUSB1V8,
659
 
                                                      &usb_fixed, &usb1v8, 1);
 
720
                                                      &usb_fixed, &usb1v8, 1,
 
721
                                                      features);
660
722
                        if (IS_ERR(child))
661
723
                                return PTR_ERR(child);
662
724
 
663
725
                        child = add_regulator_linked(TWL4030_REG_VUSB3V1,
664
 
                                                      &usb_fixed, &usb3v1, 1);
 
726
                                                      &usb_fixed, &usb3v1, 1,
 
727
                                                      features);
665
728
                        if (IS_ERR(child))
666
729
                                return PTR_ERR(child);
667
730
 
686
749
        }
687
750
        if (twl_has_usb() && pdata->usb && twl_class_is_6030()) {
688
751
 
689
 
                static struct regulator_consumer_supply usb3v3 = {
690
 
                        .supply =       "vusb",
691
 
                };
 
752
                static struct regulator_consumer_supply usb3v3;
 
753
                int regulator;
692
754
 
693
755
                if (twl_has_regulator()) {
694
756
                        /* this is a template that gets copied */
701
763
                                        | REGULATOR_CHANGE_STATUS,
702
764
                        };
703
765
 
704
 
                        child = add_regulator_linked(TWL6030_REG_VUSB,
705
 
                                                      &usb_fixed, &usb3v3, 1);
 
766
                        if (features & TWL6025_SUBCLASS) {
 
767
                                usb3v3.supply = "ldousb";
 
768
                                regulator = TWL6025_REG_LDOUSB;
 
769
                        } else {
 
770
                                usb3v3.supply = "vusb";
 
771
                                regulator = TWL6030_REG_VUSB;
 
772
                        }
 
773
                        child = add_regulator_linked(regulator, &usb_fixed,
 
774
                                                        &usb3v3, 1,
 
775
                                                        features);
706
776
                        if (IS_ERR(child))
707
777
                                return PTR_ERR(child);
708
778
                }
709
779
 
 
780
                pdata->usb->features = features;
 
781
 
710
782
                child = add_child(0, "twl6030_usb",
711
783
                        pdata->usb, sizeof(*pdata->usb),
712
784
                        true,
719
791
                /* we need to connect regulators to this transceiver */
720
792
                if (twl_has_regulator() && child)
721
793
                        usb3v3.dev = child;
 
794
        } else if (twl_has_regulator() && twl_class_is_6030()) {
 
795
                if (features & TWL6025_SUBCLASS)
 
796
                        child = add_regulator(TWL6025_REG_LDOUSB,
 
797
                                                pdata->ldousb, features);
 
798
                else
 
799
                        child = add_regulator(TWL6030_REG_VUSB,
 
800
                                                pdata->vusb, features);
722
801
 
 
802
                        if (IS_ERR(child))
 
803
                                        return PTR_ERR(child);
723
804
        }
724
805
 
725
806
        if (twl_has_watchdog() && twl_class_is_4030()) {
735
816
                        return PTR_ERR(child);
736
817
        }
737
818
 
738
 
        if (twl_has_codec() && pdata->codec && twl_class_is_4030()) {
 
819
        if (twl_has_codec() && pdata->audio && twl_class_is_4030()) {
739
820
                sub_chip_id = twl_map[TWL_MODULE_AUDIO_VOICE].sid;
740
821
                child = add_child(sub_chip_id, "twl4030-audio",
741
 
                                pdata->codec, sizeof(*pdata->codec),
 
822
                                pdata->audio, sizeof(*pdata->audio),
742
823
                                false, 0, 0);
743
824
                if (IS_ERR(child))
744
825
                        return PTR_ERR(child);
745
826
        }
746
827
 
747
 
        /* Phoenix codec driver is probed directly atm */
748
 
        if (twl_has_codec() && pdata->codec && twl_class_is_6030()) {
 
828
        if (twl_has_codec() && pdata->audio && twl_class_is_6030()) {
749
829
                sub_chip_id = twl_map[TWL_MODULE_AUDIO_VOICE].sid;
750
 
                child = add_child(sub_chip_id, "twl6040-audio",
751
 
                                pdata->codec, sizeof(*pdata->codec),
 
830
                child = add_child(sub_chip_id, "twl6040",
 
831
                                pdata->audio, sizeof(*pdata->audio),
752
832
                                false, 0, 0);
753
833
                if (IS_ERR(child))
754
834
                        return PTR_ERR(child);
756
836
 
757
837
        /* twl4030 regulators */
758
838
        if (twl_has_regulator() && twl_class_is_4030()) {
759
 
                child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1);
760
 
                if (IS_ERR(child))
761
 
                        return PTR_ERR(child);
762
 
 
763
 
                child = add_regulator(TWL4030_REG_VIO, pdata->vio);
764
 
                if (IS_ERR(child))
765
 
                        return PTR_ERR(child);
766
 
 
767
 
                child = add_regulator(TWL4030_REG_VDD1, pdata->vdd1);
768
 
                if (IS_ERR(child))
769
 
                        return PTR_ERR(child);
770
 
 
771
 
                child = add_regulator(TWL4030_REG_VDD2, pdata->vdd2);
772
 
                if (IS_ERR(child))
773
 
                        return PTR_ERR(child);
774
 
 
775
 
                child = add_regulator(TWL4030_REG_VMMC1, pdata->vmmc1);
776
 
                if (IS_ERR(child))
777
 
                        return PTR_ERR(child);
778
 
 
779
 
                child = add_regulator(TWL4030_REG_VDAC, pdata->vdac);
 
839
                child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1,
 
840
                                        features);
 
841
                if (IS_ERR(child))
 
842
                        return PTR_ERR(child);
 
843
 
 
844
                child = add_regulator(TWL4030_REG_VIO, pdata->vio,
 
845
                                        features);
 
846
                if (IS_ERR(child))
 
847
                        return PTR_ERR(child);
 
848
 
 
849
                child = add_regulator(TWL4030_REG_VDD1, pdata->vdd1,
 
850
                                        features);
 
851
                if (IS_ERR(child))
 
852
                        return PTR_ERR(child);
 
853
 
 
854
                child = add_regulator(TWL4030_REG_VDD2, pdata->vdd2,
 
855
                                        features);
 
856
                if (IS_ERR(child))
 
857
                        return PTR_ERR(child);
 
858
 
 
859
                child = add_regulator(TWL4030_REG_VMMC1, pdata->vmmc1,
 
860
                                        features);
 
861
                if (IS_ERR(child))
 
862
                        return PTR_ERR(child);
 
863
 
 
864
                child = add_regulator(TWL4030_REG_VDAC, pdata->vdac,
 
865
                                        features);
780
866
                if (IS_ERR(child))
781
867
                        return PTR_ERR(child);
782
868
 
783
869
                child = add_regulator((features & TWL4030_VAUX2)
784
870
                                        ? TWL4030_REG_VAUX2_4030
785
871
                                        : TWL4030_REG_VAUX2,
786
 
                                pdata->vaux2);
787
 
                if (IS_ERR(child))
788
 
                        return PTR_ERR(child);
789
 
 
790
 
                child = add_regulator(TWL4030_REG_VINTANA1, pdata->vintana1);
791
 
                if (IS_ERR(child))
792
 
                        return PTR_ERR(child);
793
 
 
794
 
                child = add_regulator(TWL4030_REG_VINTANA2, pdata->vintana2);
795
 
                if (IS_ERR(child))
796
 
                        return PTR_ERR(child);
797
 
 
798
 
                child = add_regulator(TWL4030_REG_VINTDIG, pdata->vintdig);
 
872
                                pdata->vaux2, features);
 
873
                if (IS_ERR(child))
 
874
                        return PTR_ERR(child);
 
875
 
 
876
                child = add_regulator(TWL4030_REG_VINTANA1, pdata->vintana1,
 
877
                                        features);
 
878
                if (IS_ERR(child))
 
879
                        return PTR_ERR(child);
 
880
 
 
881
                child = add_regulator(TWL4030_REG_VINTANA2, pdata->vintana2,
 
882
                                        features);
 
883
                if (IS_ERR(child))
 
884
                        return PTR_ERR(child);
 
885
 
 
886
                child = add_regulator(TWL4030_REG_VINTDIG, pdata->vintdig,
 
887
                                        features);
799
888
                if (IS_ERR(child))
800
889
                        return PTR_ERR(child);
801
890
        }
803
892
        /* maybe add LDOs that are omitted on cost-reduced parts */
804
893
        if (twl_has_regulator() && !(features & TPS_SUBSET)
805
894
          && twl_class_is_4030()) {
806
 
                child = add_regulator(TWL4030_REG_VPLL2, pdata->vpll2);
807
 
                if (IS_ERR(child))
808
 
                        return PTR_ERR(child);
809
 
 
810
 
                child = add_regulator(TWL4030_REG_VMMC2, pdata->vmmc2);
811
 
                if (IS_ERR(child))
812
 
                        return PTR_ERR(child);
813
 
 
814
 
                child = add_regulator(TWL4030_REG_VSIM, pdata->vsim);
815
 
                if (IS_ERR(child))
816
 
                        return PTR_ERR(child);
817
 
 
818
 
                child = add_regulator(TWL4030_REG_VAUX1, pdata->vaux1);
819
 
                if (IS_ERR(child))
820
 
                        return PTR_ERR(child);
821
 
 
822
 
                child = add_regulator(TWL4030_REG_VAUX3, pdata->vaux3);
823
 
                if (IS_ERR(child))
824
 
                        return PTR_ERR(child);
825
 
 
826
 
                child = add_regulator(TWL4030_REG_VAUX4, pdata->vaux4);
 
895
                child = add_regulator(TWL4030_REG_VPLL2, pdata->vpll2,
 
896
                                        features);
 
897
                if (IS_ERR(child))
 
898
                        return PTR_ERR(child);
 
899
 
 
900
                child = add_regulator(TWL4030_REG_VMMC2, pdata->vmmc2,
 
901
                                        features);
 
902
                if (IS_ERR(child))
 
903
                        return PTR_ERR(child);
 
904
 
 
905
                child = add_regulator(TWL4030_REG_VSIM, pdata->vsim,
 
906
                                        features);
 
907
                if (IS_ERR(child))
 
908
                        return PTR_ERR(child);
 
909
 
 
910
                child = add_regulator(TWL4030_REG_VAUX1, pdata->vaux1,
 
911
                                        features);
 
912
                if (IS_ERR(child))
 
913
                        return PTR_ERR(child);
 
914
 
 
915
                child = add_regulator(TWL4030_REG_VAUX3, pdata->vaux3,
 
916
                                        features);
 
917
                if (IS_ERR(child))
 
918
                        return PTR_ERR(child);
 
919
 
 
920
                child = add_regulator(TWL4030_REG_VAUX4, pdata->vaux4,
 
921
                                        features);
827
922
                if (IS_ERR(child))
828
923
                        return PTR_ERR(child);
829
924
        }
830
925
 
831
926
        /* twl6030 regulators */
 
927
        if (twl_has_regulator() && twl_class_is_6030() &&
 
928
                        !(features & TWL6025_SUBCLASS)) {
 
929
                child = add_regulator(TWL6030_REG_VMMC, pdata->vmmc,
 
930
                                        features);
 
931
                if (IS_ERR(child))
 
932
                        return PTR_ERR(child);
 
933
 
 
934
                child = add_regulator(TWL6030_REG_VPP, pdata->vpp,
 
935
                                        features);
 
936
                if (IS_ERR(child))
 
937
                        return PTR_ERR(child);
 
938
 
 
939
                child = add_regulator(TWL6030_REG_VUSIM, pdata->vusim,
 
940
                                        features);
 
941
                if (IS_ERR(child))
 
942
                        return PTR_ERR(child);
 
943
 
 
944
                child = add_regulator(TWL6030_REG_VCXIO, pdata->vcxio,
 
945
                                        features);
 
946
                if (IS_ERR(child))
 
947
                        return PTR_ERR(child);
 
948
 
 
949
                child = add_regulator(TWL6030_REG_VDAC, pdata->vdac,
 
950
                                        features);
 
951
                if (IS_ERR(child))
 
952
                        return PTR_ERR(child);
 
953
 
 
954
                child = add_regulator(TWL6030_REG_VAUX1_6030, pdata->vaux1,
 
955
                                        features);
 
956
                if (IS_ERR(child))
 
957
                        return PTR_ERR(child);
 
958
 
 
959
                child = add_regulator(TWL6030_REG_VAUX2_6030, pdata->vaux2,
 
960
                                        features);
 
961
                if (IS_ERR(child))
 
962
                        return PTR_ERR(child);
 
963
 
 
964
                child = add_regulator(TWL6030_REG_VAUX3_6030, pdata->vaux3,
 
965
                                        features);
 
966
                if (IS_ERR(child))
 
967
                        return PTR_ERR(child);
 
968
 
 
969
                child = add_regulator(TWL6030_REG_CLK32KG, pdata->clk32kg,
 
970
                                        features);
 
971
                if (IS_ERR(child))
 
972
                        return PTR_ERR(child);
 
973
        }
 
974
 
 
975
        /* 6030 and 6025 share this regulator */
832
976
        if (twl_has_regulator() && twl_class_is_6030()) {
833
 
                child = add_regulator(TWL6030_REG_VMMC, pdata->vmmc);
834
 
                if (IS_ERR(child))
835
 
                        return PTR_ERR(child);
836
 
 
837
 
                child = add_regulator(TWL6030_REG_VPP, pdata->vpp);
838
 
                if (IS_ERR(child))
839
 
                        return PTR_ERR(child);
840
 
 
841
 
                child = add_regulator(TWL6030_REG_VUSIM, pdata->vusim);
842
 
                if (IS_ERR(child))
843
 
                        return PTR_ERR(child);
844
 
 
845
 
                child = add_regulator(TWL6030_REG_VANA, pdata->vana);
846
 
                if (IS_ERR(child))
847
 
                        return PTR_ERR(child);
848
 
 
849
 
                child = add_regulator(TWL6030_REG_VCXIO, pdata->vcxio);
850
 
                if (IS_ERR(child))
851
 
                        return PTR_ERR(child);
852
 
 
853
 
                child = add_regulator(TWL6030_REG_VDAC, pdata->vdac);
854
 
                if (IS_ERR(child))
855
 
                        return PTR_ERR(child);
856
 
 
857
 
                child = add_regulator(TWL6030_REG_VAUX1_6030, pdata->vaux1);
858
 
                if (IS_ERR(child))
859
 
                        return PTR_ERR(child);
860
 
 
861
 
                child = add_regulator(TWL6030_REG_VAUX2_6030, pdata->vaux2);
862
 
                if (IS_ERR(child))
863
 
                        return PTR_ERR(child);
864
 
 
865
 
                child = add_regulator(TWL6030_REG_VAUX3_6030, pdata->vaux3);
866
 
                if (IS_ERR(child))
867
 
                        return PTR_ERR(child);
868
 
 
869
 
                child = add_regulator(TWL6030_REG_CLK32KG, pdata->clk32kg);
870
 
                if (IS_ERR(child))
871
 
                        return PTR_ERR(child);
 
977
                child = add_regulator(TWL6030_REG_VANA, pdata->vana,
 
978
                                        features);
 
979
                if (IS_ERR(child))
 
980
                        return PTR_ERR(child);
 
981
        }
 
982
 
 
983
        /* twl6025 regulators */
 
984
        if (twl_has_regulator() && twl_class_is_6030() &&
 
985
                        (features & TWL6025_SUBCLASS)) {
 
986
                child = add_regulator(TWL6025_REG_LDO5, pdata->ldo5,
 
987
                                        features);
 
988
                if (IS_ERR(child))
 
989
                        return PTR_ERR(child);
 
990
 
 
991
                child = add_regulator(TWL6025_REG_LDO1, pdata->ldo1,
 
992
                                        features);
 
993
                if (IS_ERR(child))
 
994
                        return PTR_ERR(child);
 
995
 
 
996
                child = add_regulator(TWL6025_REG_LDO7, pdata->ldo7,
 
997
                                        features);
 
998
                if (IS_ERR(child))
 
999
                        return PTR_ERR(child);
 
1000
 
 
1001
                child = add_regulator(TWL6025_REG_LDO6, pdata->ldo6,
 
1002
                                        features);
 
1003
                if (IS_ERR(child))
 
1004
                        return PTR_ERR(child);
 
1005
 
 
1006
                child = add_regulator(TWL6025_REG_LDOLN, pdata->ldoln,
 
1007
                                        features);
 
1008
                if (IS_ERR(child))
 
1009
                        return PTR_ERR(child);
 
1010
 
 
1011
                child = add_regulator(TWL6025_REG_LDO2, pdata->ldo2,
 
1012
                                        features);
 
1013
                if (IS_ERR(child))
 
1014
                        return PTR_ERR(child);
 
1015
 
 
1016
                child = add_regulator(TWL6025_REG_LDO4, pdata->ldo4,
 
1017
                                        features);
 
1018
                if (IS_ERR(child))
 
1019
                        return PTR_ERR(child);
 
1020
 
 
1021
                child = add_regulator(TWL6025_REG_LDO3, pdata->ldo3,
 
1022
                                        features);
 
1023
                if (IS_ERR(child))
 
1024
                        return PTR_ERR(child);
 
1025
 
 
1026
                child = add_regulator(TWL6025_REG_SMPS3, pdata->smps3,
 
1027
                                        features);
 
1028
                if (IS_ERR(child))
 
1029
                        return PTR_ERR(child);
 
1030
 
 
1031
                child = add_regulator(TWL6025_REG_SMPS4, pdata->smps4,
 
1032
                                        features);
 
1033
                if (IS_ERR(child))
 
1034
                        return PTR_ERR(child);
 
1035
 
 
1036
                child = add_regulator(TWL6025_REG_VIO, pdata->vio6025,
 
1037
                                        features);
 
1038
                if (IS_ERR(child))
 
1039
                        return PTR_ERR(child);
 
1040
 
872
1041
        }
873
1042
 
874
1043
        if (twl_has_bci() && pdata->bci &&
1015
1184
        unsigned                        i;
1016
1185
        struct twl4030_platform_data    *pdata = client->dev.platform_data;
1017
1186
        u8 temp;
 
1187
        int ret = 0;
1018
1188
 
1019
1189
        if (!pdata) {
1020
1190
                dev_dbg(&client->dev, "no platform data?\n");
1061
1231
        /* setup clock framework */
1062
1232
        clocks_init(&client->dev, pdata->clock);
1063
1233
 
 
1234
        /* read TWL IDCODE Register */
 
1235
        if (twl_id == TWL4030_CLASS_ID) {
 
1236
                ret = twl_read_idcode_register();
 
1237
                WARN(ret < 0, "Error: reading twl_idcode register value\n");
 
1238
        }
 
1239
 
1064
1240
        /* load power event scripts */
1065
1241
        if (twl_has_power() && pdata->power)
1066
1242
                twl4030_power_init(pdata->power);
1112
1288
        { "tps65930", TPS_SUBSET },     /* fewer LDOs and DACs; no charger */
1113
1289
        { "tps65920", TPS_SUBSET },     /* fewer LDOs; no codec or charger */
1114
1290
        { "twl6030", TWL6030_CLASS },   /* "Phoenix power chip" */
 
1291
        { "twl6025", TWL6030_CLASS | TWL6025_SUBCLASS }, /* "Phoenix lite" */
1115
1292
        { /* end of list */ },
1116
1293
};
1117
1294
MODULE_DEVICE_TABLE(i2c, twl_ids);