← Back to branch summary

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

« back to all changes in this revision

Viewing changes to include/linux/mfd/db8500-prcmu.h

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/linux/mfd/db8500-prcmu.h
11
11
#define __MFD_DB8500_PRCMU_H
12
12
 
13
13
#include <linux/interrupt.h>
14
 
#include <linux/notifier.h>
15
14
 
16
15
/* This portion previously known as <mach/prcmu-fw-defs_v1.h> */
17
16
 
133
132
 * @APEXECUTE_TO_APIDLE: Power state transition from ApExecute to ApIdle
134
133
 */
135
134
enum ap_pwrst_trans {
136
 
        NO_TRANSITION                   = 0x00,
 
135
        PRCMU_AP_NO_CHANGE              = 0x00,
137
136
        APEXECUTE_TO_APSLEEP            = 0x01,
138
137
        APIDLE_TO_APSLEEP               = 0x02, /* To be removed */
139
138
        PRCMU_AP_SLEEP                  = 0x01,
146
145
};
147
146
 
148
147
/**
149
 
 * enum ddr_pwrst - DDR power states definition
150
 
 * @DDR_PWR_STATE_UNCHANGED: SDRAM and DDR controller state is unchanged
151
 
 * @DDR_PWR_STATE_ON:
152
 
 * @DDR_PWR_STATE_OFFLOWLAT:
153
 
 * @DDR_PWR_STATE_OFFHIGHLAT:
154
 
 */
155
 
enum ddr_pwrst {
156
 
        DDR_PWR_STATE_UNCHANGED     = 0x00,
157
 
        DDR_PWR_STATE_ON            = 0x01,
158
 
        DDR_PWR_STATE_OFFLOWLAT     = 0x02,
159
 
        DDR_PWR_STATE_OFFHIGHLAT    = 0x03
160
 
};
161
 
 
162
 
/**
163
 
 * enum arm_opp - ARM OPP states definition
164
 
 * @ARM_OPP_INIT:
165
 
 * @ARM_NO_CHANGE: The ARM operating point is unchanged
166
 
 * @ARM_100_OPP: The new ARM operating point is arm100opp
167
 
 * @ARM_50_OPP: The new ARM operating point is arm50opp
168
 
 * @ARM_MAX_OPP: Operating point is "max" (more than 100)
169
 
 * @ARM_MAX_FREQ100OPP: Set max opp if available, else 100
170
 
 * @ARM_EXTCLK: The new ARM operating point is armExtClk
171
 
 */
172
 
enum arm_opp {
173
 
        ARM_OPP_INIT = 0x00,
174
 
        ARM_NO_CHANGE = 0x01,
175
 
        ARM_100_OPP = 0x02,
176
 
        ARM_50_OPP = 0x03,
177
 
        ARM_MAX_OPP = 0x04,
178
 
        ARM_MAX_FREQ100OPP = 0x05,
179
 
        ARM_EXTCLK = 0x07
180
 
};
181
 
 
182
 
/**
183
 
 * enum ape_opp - APE OPP states definition
184
 
 * @APE_OPP_INIT:
185
 
 * @APE_NO_CHANGE: The APE operating point is unchanged
186
 
 * @APE_100_OPP: The new APE operating point is ape100opp
187
 
 * @APE_50_OPP: 50%
188
 
 */
189
 
enum ape_opp {
190
 
        APE_OPP_INIT = 0x00,
191
 
        APE_NO_CHANGE = 0x01,
192
 
        APE_100_OPP = 0x02,
193
 
        APE_50_OPP = 0x03
194
 
};
195
 
 
196
 
/**
197
148
 * enum hw_acc_state - State definition for hardware accelerator
198
149
 * @HW_NO_CHANGE: The hardware accelerator state must remain unchanged
199
150
 * @HW_OFF: The hardware accelerator must be switched off
469
420
 
470
421
/* End of file previously known as prcmu-fw-defs_v1.h */
471
422
 
472
 
/* PRCMU Wakeup defines */
473
 
enum prcmu_wakeup_index {
474
 
        PRCMU_WAKEUP_INDEX_RTC,
475
 
        PRCMU_WAKEUP_INDEX_RTT0,
476
 
        PRCMU_WAKEUP_INDEX_RTT1,
477
 
        PRCMU_WAKEUP_INDEX_HSI0,
478
 
        PRCMU_WAKEUP_INDEX_HSI1,
479
 
        PRCMU_WAKEUP_INDEX_USB,
480
 
        PRCMU_WAKEUP_INDEX_ABB,
481
 
        PRCMU_WAKEUP_INDEX_ABB_FIFO,
482
 
        PRCMU_WAKEUP_INDEX_ARM,
483
 
        NUM_PRCMU_WAKEUP_INDICES
484
 
};
485
 
#define PRCMU_WAKEUP(_name) (BIT(PRCMU_WAKEUP_INDEX_##_name))
486
 
 
487
 
/* PRCMU QoS APE OPP class */
488
 
#define PRCMU_QOS_APE_OPP 1
489
 
#define PRCMU_QOS_DDR_OPP 2
490
 
#define PRCMU_QOS_DEFAULT_VALUE -1
491
 
 
492
423
/**
493
424
 * enum hw_acc_dev - enum for hw accelerators
494
425
 * @HW_ACC_SVAMMDSP: for SVAMMDSP
527
458
};
528
459
 
529
460
/*
530
 
 * Ids for all EPODs (power domains)
531
 
 * - EPOD_ID_SVAMMDSP: power domain for SVA MMDSP
532
 
 * - EPOD_ID_SVAPIPE: power domain for SVA pipe
533
 
 * - EPOD_ID_SIAMMDSP: power domain for SIA MMDSP
534
 
 * - EPOD_ID_SIAPIPE: power domain for SIA pipe
535
 
 * - EPOD_ID_SGA: power domain for SGA
536
 
 * - EPOD_ID_B2R2_MCDE: power domain for B2R2 and MCDE
537
 
 * - EPOD_ID_ESRAM12: power domain for ESRAM 1 and 2
538
 
 * - EPOD_ID_ESRAM34: power domain for ESRAM 3 and 4
539
 
 * - NUM_EPOD_ID: number of power domains
540
 
 */
541
 
#define EPOD_ID_SVAMMDSP        0
542
 
#define EPOD_ID_SVAPIPE         1
543
 
#define EPOD_ID_SIAMMDSP        2
544
 
#define EPOD_ID_SIAPIPE         3
545
 
#define EPOD_ID_SGA             4
546
 
#define EPOD_ID_B2R2_MCDE       5
547
 
#define EPOD_ID_ESRAM12         6
548
 
#define EPOD_ID_ESRAM34         7
549
 
#define NUM_EPOD_ID             8
550
 
 
551
 
/*
552
 
 * state definition for EPOD (power domain)
553
 
 * - EPOD_STATE_NO_CHANGE: The EPOD should remain unchanged
554
 
 * - EPOD_STATE_OFF: The EPOD is switched off
555
 
 * - EPOD_STATE_RAMRET: The EPOD is switched off with its internal RAM in
556
 
 *                         retention
557
 
 * - EPOD_STATE_ON_CLK_OFF: The EPOD is switched on, clock is still off
558
 
 * - EPOD_STATE_ON: Same as above, but with clock enabled
559
 
 */
560
 
#define EPOD_STATE_NO_CHANGE    0x00
561
 
#define EPOD_STATE_OFF          0x01
562
 
#define EPOD_STATE_RAMRET       0x02
563
 
#define EPOD_STATE_ON_CLK_OFF   0x03
564
 
#define EPOD_STATE_ON           0x04
565
 
 
566
 
/*
567
 
 * CLKOUT sources
568
 
 */
569
 
#define PRCMU_CLKSRC_CLK38M             0x00
570
 
#define PRCMU_CLKSRC_ACLK               0x01
571
 
#define PRCMU_CLKSRC_SYSCLK             0x02
572
 
#define PRCMU_CLKSRC_LCDCLK             0x03
573
 
#define PRCMU_CLKSRC_SDMMCCLK           0x04
574
 
#define PRCMU_CLKSRC_TVCLK              0x05
575
 
#define PRCMU_CLKSRC_TIMCLK             0x06
576
 
#define PRCMU_CLKSRC_CLK009             0x07
577
 
/* These are only valid for CLKOUT1: */
578
 
#define PRCMU_CLKSRC_SIAMMDSPCLK        0x40
579
 
#define PRCMU_CLKSRC_I2CCLK             0x41
580
 
#define PRCMU_CLKSRC_MSP02CLK           0x42
581
 
#define PRCMU_CLKSRC_ARMPLL_OBSCLK      0x43
582
 
#define PRCMU_CLKSRC_HSIRXCLK           0x44
583
 
#define PRCMU_CLKSRC_HSITXCLK           0x45
584
 
#define PRCMU_CLKSRC_ARMCLKFIX          0x46
585
 
#define PRCMU_CLKSRC_HDMICLK            0x47
586
 
 
587
 
/*
588
461
 * Definitions for autonomous power management configuration.
589
462
 */
590
463
 
620
493
        u8 sva_policy;
621
494
};
622
495
 
623
 
/**
624
 
 * enum ddr_opp - DDR OPP states definition
625
 
 * @DDR_100_OPP: The new DDR operating point is ddr100opp
626
 
 * @DDR_50_OPP: The new DDR operating point is ddr50opp
627
 
 * @DDR_25_OPP: The new DDR operating point is ddr25opp
628
 
 */
629
 
enum ddr_opp {
630
 
        DDR_100_OPP = 0x00,
631
 
        DDR_50_OPP = 0x01,
632
 
        DDR_25_OPP = 0x02,
633
 
};
634
 
 
635
 
/*
636
 
 * Clock identifiers.
637
 
 */
638
 
enum prcmu_clock {
639
 
        PRCMU_SGACLK,
640
 
        PRCMU_UARTCLK,
641
 
        PRCMU_MSP02CLK,
642
 
        PRCMU_MSP1CLK,
643
 
        PRCMU_I2CCLK,
644
 
        PRCMU_SDMMCCLK,
645
 
        PRCMU_SLIMCLK,
646
 
        PRCMU_PER1CLK,
647
 
        PRCMU_PER2CLK,
648
 
        PRCMU_PER3CLK,
649
 
        PRCMU_PER5CLK,
650
 
        PRCMU_PER6CLK,
651
 
        PRCMU_PER7CLK,
652
 
        PRCMU_LCDCLK,
653
 
        PRCMU_BMLCLK,
654
 
        PRCMU_HSITXCLK,
655
 
        PRCMU_HSIRXCLK,
656
 
        PRCMU_HDMICLK,
657
 
        PRCMU_APEATCLK,
658
 
        PRCMU_APETRACECLK,
659
 
        PRCMU_MCDECLK,
660
 
        PRCMU_IPI2CCLK,
661
 
        PRCMU_DSIALTCLK,
662
 
        PRCMU_DMACLK,
663
 
        PRCMU_B2R2CLK,
664
 
        PRCMU_TVCLK,
665
 
        PRCMU_SSPCLK,
666
 
        PRCMU_RNGCLK,
667
 
        PRCMU_UICCCLK,
668
 
        PRCMU_NUM_REG_CLOCKS,
669
 
        PRCMU_SYSCLK = PRCMU_NUM_REG_CLOCKS,
670
 
        PRCMU_TIMCLK,
671
 
};
672
 
 
673
 
/*
674
 
 * Definitions for controlling ESRAM0 in deep sleep.
675
 
 */
676
 
#define ESRAM0_DEEP_SLEEP_STATE_OFF 1
677
 
#define ESRAM0_DEEP_SLEEP_STATE_RET 2
678
 
 
679
 
#ifdef CONFIG_MFD_DB8500_PRCMU
680
 
void __init prcmu_early_init(void);
681
 
int prcmu_set_display_clocks(void);
682
 
int prcmu_disable_dsipll(void);
683
 
int prcmu_enable_dsipll(void);
684
 
#else
685
 
static inline void __init prcmu_early_init(void) {}
686
 
#endif
687
 
 
688
 
#ifdef CONFIG_MFD_DB8500_PRCMU
689
 
 
 
496
#ifdef CONFIG_MFD_DB8500_PRCMU
 
497
 
 
498
void db8500_prcmu_early_init(void);
690
499
int prcmu_set_rc_a2p(enum romcode_write);
691
500
enum romcode_read prcmu_get_rc_p2a(void);
692
501
enum ap_pwrst prcmu_get_xp70_current_state(void);
693
 
int prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll);
694
 
 
695
 
void prcmu_enable_wakeups(u32 wakeups);
696
 
static inline void prcmu_disable_wakeups(void)
697
 
{
698
 
        prcmu_enable_wakeups(0);
699
 
}
700
 
 
701
 
void prcmu_config_abb_event_readout(u32 abb_events);
702
 
void prcmu_get_abb_event_buffer(void __iomem **buf);
703
 
int prcmu_set_arm_opp(u8 opp);
704
 
int prcmu_get_arm_opp(void);
705
502
bool prcmu_has_arm_maxopp(void);
706
503
bool prcmu_is_u8400(void);
707
504
int prcmu_set_ape_opp(u8 opp);
710
507
int prcmu_release_usb_wakeup_state(void);
711
508
int prcmu_set_ddr_opp(u8 opp);
712
509
int prcmu_get_ddr_opp(void);
713
 
unsigned long prcmu_qos_get_cpufreq_opp_delay(void);
714
 
void prcmu_qos_set_cpufreq_opp_delay(unsigned long);
715
510
/* NOTE! Use regulator framework instead */
716
511
int prcmu_set_hwacc(u16 hw_acc_dev, u8 state);
717
 
int prcmu_set_epod(u16 epod_id, u8 epod_state);
718
512
void prcmu_configure_auto_pm(struct prcmu_auto_pm_config *sleep,
719
513
        struct prcmu_auto_pm_config *idle);
720
514
bool prcmu_is_auto_pm_enabled(void);
721
515
 
722
516
int prcmu_config_clkout(u8 clkout, u8 source, u8 div);
723
 
int prcmu_request_clock(u8 clock, bool enable);
724
517
int prcmu_set_clock_divider(u8 clock, u8 divider);
725
 
int prcmu_config_esram0_deep_sleep(u8 state);
726
518
int prcmu_config_hotdog(u8 threshold);
727
519
int prcmu_config_hotmon(u8 low, u8 high);
728
520
int prcmu_start_temp_sense(u16 cycles32k);
732
524
 
733
525
void prcmu_ac_wake_req(void);
734
526
void prcmu_ac_sleep_req(void);
735
 
void prcmu_system_reset(u16 reset_code);
736
527
void prcmu_modem_reset(void);
737
 
bool prcmu_is_ac_wake_requested(void);
738
528
void prcmu_enable_spi2(void);
739
529
void prcmu_disable_spi2(void);
740
530
 
 
531
int prcmu_config_a9wdog(u8 num, bool sleep_auto_off);
 
532
int prcmu_enable_a9wdog(u8 id);
 
533
int prcmu_disable_a9wdog(u8 id);
 
534
int prcmu_kick_a9wdog(u8 id);
 
535
int prcmu_load_a9wdog(u8 id, u32 val);
 
536
 
 
537
void db8500_prcmu_system_reset(u16 reset_code);
 
538
int db8500_prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll);
 
539
void db8500_prcmu_enable_wakeups(u32 wakeups);
 
540
int db8500_prcmu_set_epod(u16 epod_id, u8 epod_state);
 
541
int db8500_prcmu_request_clock(u8 clock, bool enable);
 
542
int db8500_prcmu_set_display_clocks(void);
 
543
int db8500_prcmu_disable_dsipll(void);
 
544
int db8500_prcmu_enable_dsipll(void);
 
545
void db8500_prcmu_config_abb_event_readout(u32 abb_events);
 
546
void db8500_prcmu_get_abb_event_buffer(void __iomem **buf);
 
547
int db8500_prcmu_config_esram0_deep_sleep(u8 state);
 
548
u16 db8500_prcmu_get_reset_code(void);
 
549
bool db8500_prcmu_is_ac_wake_requested(void);
 
550
int db8500_prcmu_set_arm_opp(u8 opp);
 
551
int db8500_prcmu_get_arm_opp(void);
 
552
 
741
553
#else /* !CONFIG_MFD_DB8500_PRCMU */
742
554
 
 
555
static inline void db8500_prcmu_early_init(void) {}
 
556
 
743
557
static inline int prcmu_set_rc_a2p(enum romcode_write code)
744
558
{
745
559
        return 0;
755
569
        return AP_EXECUTE;
756
570
}
757
571
 
758
 
static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
759
 
        bool keep_ap_pll)
760
 
{
761
 
        return 0;
762
 
}
763
 
 
764
 
static inline void prcmu_enable_wakeups(u32 wakeups) {}
765
 
 
766
 
static inline void prcmu_disable_wakeups(void) {}
767
 
 
768
 
static inline void prcmu_config_abb_event_readout(u32 abb_events) {}
769
 
 
770
 
static inline int prcmu_set_arm_opp(u8 opp)
771
 
{
772
 
        return 0;
773
 
}
774
 
 
775
 
static inline int prcmu_get_arm_opp(void)
776
 
{
777
 
        return ARM_100_OPP;
778
 
}
779
 
 
780
 
static bool prcmu_has_arm_maxopp(void)
 
572
static inline bool prcmu_has_arm_maxopp(void)
781
573
{
782
574
        return false;
783
575
}
784
576
 
785
 
static bool prcmu_is_u8400(void)
 
577
static inline bool prcmu_is_u8400(void)
786
578
{
787
579
        return false;
788
580
}
817
609
        return DDR_100_OPP;
818
610
}
819
611
 
820
 
static inline unsigned long prcmu_qos_get_cpufreq_opp_delay(void)
821
 
{
822
 
        return 0;
823
 
}
824
 
 
825
 
static inline void prcmu_qos_set_cpufreq_opp_delay(unsigned long n) {}
826
 
 
827
612
static inline int prcmu_set_hwacc(u16 hw_acc_dev, u8 state)
828
613
{
829
614
        return 0;
844
629
        return 0;
845
630
}
846
631
 
847
 
static inline int prcmu_request_clock(u8 clock, bool enable)
848
 
{
849
 
        return 0;
850
 
}
851
 
 
852
632
static inline int prcmu_set_clock_divider(u8 clock, u8 divider)
853
633
{
854
634
        return 0;
855
635
}
856
636
 
857
 
int prcmu_config_esram0_deep_sleep(u8 state)
858
 
{
859
 
        return 0;
860
 
}
861
 
 
862
637
static inline int prcmu_config_hotdog(u8 threshold)
863
638
{
864
639
        return 0;
893
668
 
894
669
static inline void prcmu_ac_sleep_req(void) {}
895
670
 
896
 
static inline void prcmu_system_reset(u16 reset_code) {}
897
 
 
898
671
static inline void prcmu_modem_reset(void) {}
899
672
 
900
 
static inline bool prcmu_is_ac_wake_requested(void)
901
 
{
902
 
        return false;
903
 
}
904
 
 
905
 
#ifndef CONFIG_UX500_SOC_DB5500
906
 
static inline int prcmu_set_display_clocks(void)
907
 
{
908
 
        return 0;
909
 
}
910
 
 
911
 
static inline int prcmu_disable_dsipll(void)
912
 
{
913
 
        return 0;
914
 
}
915
 
 
916
 
static inline int prcmu_enable_dsipll(void)
917
 
{
918
 
        return 0;
919
 
}
920
 
#endif
921
 
 
922
673
static inline int prcmu_enable_spi2(void)
923
674
{
924
675
        return 0;
929
680
        return 0;
930
681
}
931
682
 
 
683
static inline void db8500_prcmu_system_reset(u16 reset_code) {}
 
684
 
 
685
static inline int db8500_prcmu_set_power_state(u8 state, bool keep_ulp_clk,
 
686
        bool keep_ap_pll)
 
687
{
 
688
        return 0;
 
689
}
 
690
 
 
691
static inline void db8500_prcmu_enable_wakeups(u32 wakeups) {}
 
692
 
 
693
static inline int db8500_prcmu_set_epod(u16 epod_id, u8 epod_state)
 
694
{
 
695
        return 0;
 
696
}
 
697
 
 
698
static inline int db8500_prcmu_request_clock(u8 clock, bool enable)
 
699
{
 
700
        return 0;
 
701
}
 
702
 
 
703
static inline int db8500_prcmu_set_display_clocks(void)
 
704
{
 
705
        return 0;
 
706
}
 
707
 
 
708
static inline int db8500_prcmu_disable_dsipll(void)
 
709
{
 
710
        return 0;
 
711
}
 
712
 
 
713
static inline int db8500_prcmu_enable_dsipll(void)
 
714
{
 
715
        return 0;
 
716
}
 
717
 
 
718
static inline int db8500_prcmu_config_esram0_deep_sleep(u8 state)
 
719
{
 
720
        return 0;
 
721
}
 
722
 
 
723
static inline void db8500_prcmu_config_abb_event_readout(u32 abb_events) {}
 
724
 
 
725
static inline void db8500_prcmu_get_abb_event_buffer(void __iomem **buf) {}
 
726
 
 
727
static inline u16 db8500_prcmu_get_reset_code(void)
 
728
{
 
729
        return 0;
 
730
}
 
731
 
 
732
static inline int prcmu_config_a9wdog(u8 num, bool sleep_auto_off)
 
733
{
 
734
        return 0;
 
735
}
 
736
 
 
737
static inline int prcmu_enable_a9wdog(u8 id)
 
738
{
 
739
        return 0;
 
740
}
 
741
 
 
742
static inline int prcmu_disable_a9wdog(u8 id)
 
743
{
 
744
        return 0;
 
745
}
 
746
 
 
747
static inline int prcmu_kick_a9wdog(u8 id)
 
748
{
 
749
        return 0;
 
750
}
 
751
 
 
752
static inline int prcmu_load_a9wdog(u8 id, u32 val)
 
753
{
 
754
        return 0;
 
755
}
 
756
 
 
757
static inline bool db8500_prcmu_is_ac_wake_requested(void)
 
758
{
 
759
        return 0;
 
760
}
 
761
 
 
762
static inline int db8500_prcmu_set_arm_opp(u8 opp)
 
763
{
 
764
        return 0;
 
765
}
 
766
 
 
767
static inline int db8500_prcmu_get_arm_opp(void)
 
768
{
 
769
        return 0;
 
770
}
 
771
 
932
772
#endif /* !CONFIG_MFD_DB8500_PRCMU */
933
773
 
934
 
#ifdef CONFIG_UX500_PRCMU_QOS_POWER
935
 
int prcmu_qos_requirement(int pm_qos_class);
936
 
int prcmu_qos_add_requirement(int pm_qos_class, char *name, s32 value);
937
 
int prcmu_qos_update_requirement(int pm_qos_class, char *name, s32 new_value);
938
 
void prcmu_qos_remove_requirement(int pm_qos_class, char *name);
939
 
int prcmu_qos_add_notifier(int prcmu_qos_class,
940
 
                           struct notifier_block *notifier);
941
 
int prcmu_qos_remove_notifier(int prcmu_qos_class,
942
 
                              struct notifier_block *notifier);
943
 
#else
944
 
static inline int prcmu_qos_requirement(int prcmu_qos_class)
945
 
{
946
 
        return 0;
947
 
}
948
 
 
949
 
static inline int prcmu_qos_add_requirement(int prcmu_qos_class,
950
 
                                            char *name, s32 value)
951
 
{
952
 
        return 0;
953
 
}
954
 
 
955
 
static inline int prcmu_qos_update_requirement(int prcmu_qos_class,
956
 
                                               char *name, s32 new_value)
957
 
{
958
 
        return 0;
959
 
}
960
 
 
961
 
static inline void prcmu_qos_remove_requirement(int prcmu_qos_class, char *name)
962
 
{
963
 
}
964
 
 
965
 
static inline int prcmu_qos_add_notifier(int prcmu_qos_class,
966
 
                                         struct notifier_block *notifier)
967
 
{
968
 
        return 0;
969
 
}
970
 
static inline int prcmu_qos_remove_notifier(int prcmu_qos_class,
971
 
                                            struct notifier_block *notifier)
972
 
{
973
 
        return 0;
974
 
}
975
 
 
976
 
#endif
977
 
 
978
774
#endif /* __MFD_DB8500_PRCMU_H */