Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/mfd/ab8500-sysctrl.c

  1 /*
  2  * AB8500 system control driver
  3  *
  4  * Copyright (C) ST-Ericsson SA 2010
  5  * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com> for ST Ericsson.
  6  * License terms: GNU General Public License (GPL) version 2
  7  */
  8 
  9 #include <linux/err.h>
 10 #include <linux/init.h>
 11 #include <linux/export.h>
 12 #include <linux/platform_device.h>
 13 #include <linux/pm.h>
 14 #include <linux/reboot.h>
 15 #include <linux/signal.h>
 16 #include <linux/power_supply.h>
 17 #include <linux/mfd/abx500.h>
 18 #include <linux/mfd/abx500/ab8500.h>
 19 #include <linux/mfd/abx500/ab8500-sysctrl.h>
 20 
 21 /* RtcCtrl bits */
 22 #define AB8500_ALARM_MIN_LOW  0x08
 23 #define AB8500_ALARM_MIN_MID 0x09
 24 #define RTC_CTRL 0x0B
 25 #define RTC_ALARM_ENABLE 0x4
 26 
 27 static struct device *sysctrl_dev;
 28 
 29 static void ab8500_power_off(void)
 30 {
 31         sigset_t old;
 32         sigset_t all;
 33         static const char * const pss[] = {"ab8500_ac", "pm2301", "ab8500_usb"};
 34         int i;
 35         bool charger_present = false;
 36         union power_supply_propval val;
 37         struct power_supply *psy;
 38         int ret;
 39 
 40         if (sysctrl_dev == NULL) {
 41                 pr_err("%s: sysctrl not initialized\n", __func__);
 42                 return;
 43         }
 44 
 45         /*
 46          * If we have a charger connected and we're powering off,
 47          * reboot into charge-only mode.
 48          */
 49 
 50         for (i = 0; i < ARRAY_SIZE(pss); i++) {
 51                 psy = power_supply_get_by_name(pss[i]);
 52                 if (!psy)
 53                         continue;
 54 
 55                 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_ONLINE,
 56                                 &val);
 57                 power_supply_put(psy);
 58 
 59                 if (!ret && val.intval) {
 60                         charger_present = true;
 61                         break;
 62                 }
 63         }
 64 
 65         if (!charger_present)
 66                 goto shutdown;
 67 
 68         /* Check if battery is known */
 69         psy = power_supply_get_by_name("ab8500_btemp");
 70         if (psy) {
 71                 ret = power_supply_get_property(psy,
 72                                 POWER_SUPPLY_PROP_TECHNOLOGY, &val);
 73                 if (!ret && val.intval != POWER_SUPPLY_TECHNOLOGY_UNKNOWN) {
 74                         pr_info("Charger '%s' is connected with known battery",
 75                                 pss[i]);
 76                         pr_info(" - Rebooting.\n");
 77                         machine_restart("charging");
 78                 }
 79                 power_supply_put(psy);
 80         }
 81 
 82 shutdown:
 83         sigfillset(&all);
 84 
 85         if (!sigprocmask(SIG_BLOCK, &all, &old)) {
 86                 (void)ab8500_sysctrl_set(AB8500_STW4500CTRL1,
 87                                          AB8500_STW4500CTRL1_SWOFF |
 88                                          AB8500_STW4500CTRL1_SWRESET4500N);
 89                 (void)sigprocmask(SIG_SETMASK, &old, NULL);
 90         }
 91 }
 92 
 93 static inline bool valid_bank(u8 bank)
 94 {
 95         return ((bank == AB8500_SYS_CTRL1_BLOCK) ||
 96                 (bank == AB8500_SYS_CTRL2_BLOCK));
 97 }
 98 
 99 int ab8500_sysctrl_read(u16 reg, u8 *value)
100 {
101         u8 bank;
102 
103         if (sysctrl_dev == NULL)
104                 return -EINVAL;
105 
106         bank = (reg >> 8);
107         if (!valid_bank(bank))
108                 return -EINVAL;
109 
110         return abx500_get_register_interruptible(sysctrl_dev, bank,
111                 (u8)(reg & 0xFF), value);
112 }
113 EXPORT_SYMBOL(ab8500_sysctrl_read);
114 
115 int ab8500_sysctrl_write(u16 reg, u8 mask, u8 value)
116 {
117         u8 bank;
118 
119         if (sysctrl_dev == NULL)
120                 return -EINVAL;
121 
122         bank = (reg >> 8);
123         if (!valid_bank(bank))
124                 return -EINVAL;
125 
126         return abx500_mask_and_set_register_interruptible(sysctrl_dev, bank,
127                 (u8)(reg & 0xFF), mask, value);
128 }
129 EXPORT_SYMBOL(ab8500_sysctrl_write);
130 
131 static int ab8500_sysctrl_probe(struct platform_device *pdev)
132 {
133         sysctrl_dev = &pdev->dev;
134 
135         if (!pm_power_off)
136                 pm_power_off = ab8500_power_off;
137 
138         return 0;
139 }
140 
141 static int ab8500_sysctrl_remove(struct platform_device *pdev)
142 {
143         sysctrl_dev = NULL;
144 
145         if (pm_power_off == ab8500_power_off)
146                 pm_power_off = NULL;
147 
148         return 0;
149 }
150 
151 static struct platform_driver ab8500_sysctrl_driver = {
152         .driver = {
153                 .name = "ab8500-sysctrl",
154         },
155         .probe = ab8500_sysctrl_probe,
156         .remove = ab8500_sysctrl_remove,
157 };
158 
159 static int __init ab8500_sysctrl_init(void)
160 {
161         return platform_driver_register(&ab8500_sysctrl_driver);
162 }
163 arch_initcall(ab8500_sysctrl_init);
164 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us