Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dbx500-prcmu.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) ST-Ericsson SA 2010
3  *
4  * License Terms: GNU General Public License v2
5  * Authors: Sundar Iyer <[email protected]> for ST-Ericsson
6  * Bengt Jonsson <[email protected]> for ST-Ericsson
7  *
8  * UX500 common part of Power domain regulators
9  */
10 
11 #include <linux/kernel.h>
12 #include <linux/err.h>
13 #include <linux/regulator/driver.h>
14 #include <linux/debugfs.h>
15 #include <linux/seq_file.h>
16 #include <linux/slab.h>
17 
18 #include "dbx500-prcmu.h"
19 
20 /*
21  * power state reference count
22  */
23 static int power_state_active_cnt; /* will initialize to zero */
24 static DEFINE_SPINLOCK(power_state_active_lock);
25 
27 {
28  unsigned long flags;
29  int cnt;
30 
31  spin_lock_irqsave(&power_state_active_lock, flags);
32  cnt = power_state_active_cnt;
33  spin_unlock_irqrestore(&power_state_active_lock, flags);
34 
35  return cnt;
36 }
37 
39 {
40  unsigned long flags;
41 
42  spin_lock_irqsave(&power_state_active_lock, flags);
43  power_state_active_cnt++;
44  spin_unlock_irqrestore(&power_state_active_lock, flags);
45 }
46 
48 {
49  int ret = 0;
50  unsigned long flags;
51 
52  spin_lock_irqsave(&power_state_active_lock, flags);
53  if (power_state_active_cnt <= 0) {
54  pr_err("power state: unbalanced enable/disable calls\n");
55  ret = -EINVAL;
56  goto out;
57  }
58 
59  power_state_active_cnt--;
60 out:
61  spin_unlock_irqrestore(&power_state_active_lock, flags);
62  return ret;
63 }
64 
65 #ifdef CONFIG_REGULATOR_DEBUG
66 
67 static struct ux500_regulator_debug {
68  struct dentry *dir;
69  struct dentry *status_file;
70  struct dentry *power_state_cnt_file;
71  struct dbx500_regulator_info *regulator_array;
72  int num_regulators;
73  u8 *state_before_suspend;
74  u8 *state_after_suspend;
75 } rdebug;
76 
77 void ux500_regulator_suspend_debug(void)
78 {
79  int i;
80  for (i = 0; i < rdebug.num_regulators; i++)
81  rdebug.state_before_suspend[i] =
82  rdebug.regulator_array[i].is_enabled;
83 }
84 
85 void ux500_regulator_resume_debug(void)
86 {
87  int i;
88  for (i = 0; i < rdebug.num_regulators; i++)
89  rdebug.state_after_suspend[i] =
90  rdebug.regulator_array[i].is_enabled;
91 }
92 
93 static int ux500_regulator_power_state_cnt_print(struct seq_file *s, void *p)
94 {
95  struct device *dev = s->private;
96  int err;
97 
98  /* print power state count */
99  err = seq_printf(s, "ux500-regulator power state count: %i\n",
101  if (err < 0)
102  dev_err(dev, "seq_printf overflow\n");
103 
104  return 0;
105 }
106 
107 static int ux500_regulator_power_state_cnt_open(struct inode *inode,
108  struct file *file)
109 {
110  return single_open(file, ux500_regulator_power_state_cnt_print,
111  inode->i_private);
112 }
113 
114 static const struct file_operations ux500_regulator_power_state_cnt_fops = {
115  .open = ux500_regulator_power_state_cnt_open,
116  .read = seq_read,
117  .llseek = seq_lseek,
118  .release = single_release,
119  .owner = THIS_MODULE,
120 };
121 
122 static int ux500_regulator_status_print(struct seq_file *s, void *p)
123 {
124  struct device *dev = s->private;
125  int err;
126  int i;
127 
128  /* print dump header */
129  err = seq_printf(s, "ux500-regulator status:\n");
130  if (err < 0)
131  dev_err(dev, "seq_printf overflow\n");
132 
133  err = seq_printf(s, "%31s : %8s : %8s\n", "current",
134  "before", "after");
135  if (err < 0)
136  dev_err(dev, "seq_printf overflow\n");
137 
138  for (i = 0; i < rdebug.num_regulators; i++) {
139  struct dbx500_regulator_info *info;
140  /* Access per-regulator data */
141  info = &rdebug.regulator_array[i];
142 
143  /* print status */
144  err = seq_printf(s, "%20s : %8s : %8s : %8s\n", info->desc.name,
145  info->is_enabled ? "enabled" : "disabled",
146  rdebug.state_before_suspend[i] ? "enabled" : "disabled",
147  rdebug.state_after_suspend[i] ? "enabled" : "disabled");
148  if (err < 0)
149  dev_err(dev, "seq_printf overflow\n");
150  }
151 
152  return 0;
153 }
154 
155 static int ux500_regulator_status_open(struct inode *inode, struct file *file)
156 {
157  return single_open(file, ux500_regulator_status_print,
158  inode->i_private);
159 }
160 
161 static const struct file_operations ux500_regulator_status_fops = {
162  .open = ux500_regulator_status_open,
163  .read = seq_read,
164  .llseek = seq_lseek,
165  .release = single_release,
166  .owner = THIS_MODULE,
167 };
168 
169 int __attribute__((weak)) dbx500_regulator_testcase(
170  struct dbx500_regulator_info *regulator_info,
171  int num_regulators)
172 {
173  return 0;
174 }
175 
176 int __devinit
177 ux500_regulator_debug_init(struct platform_device *pdev,
178  struct dbx500_regulator_info *regulator_info,
179  int num_regulators)
180 {
181  /* create directory */
182  rdebug.dir = debugfs_create_dir("ux500-regulator", NULL);
183  if (!rdebug.dir)
184  goto exit_no_debugfs;
185 
186  /* create "status" file */
187  rdebug.status_file = debugfs_create_file("status",
188  S_IRUGO, rdebug.dir, &pdev->dev,
189  &ux500_regulator_status_fops);
190  if (!rdebug.status_file)
191  goto exit_destroy_dir;
192 
193  /* create "power-state-count" file */
194  rdebug.power_state_cnt_file = debugfs_create_file("power-state-count",
195  S_IRUGO, rdebug.dir, &pdev->dev,
196  &ux500_regulator_power_state_cnt_fops);
197  if (!rdebug.power_state_cnt_file)
198  goto exit_destroy_status;
199 
200  rdebug.regulator_array = regulator_info;
201  rdebug.num_regulators = num_regulators;
202 
203  rdebug.state_before_suspend = kzalloc(num_regulators, GFP_KERNEL);
204  if (!rdebug.state_before_suspend) {
205  dev_err(&pdev->dev,
206  "could not allocate memory for saving state\n");
207  goto exit_destroy_power_state;
208  }
209 
210  rdebug.state_after_suspend = kzalloc(num_regulators, GFP_KERNEL);
211  if (!rdebug.state_after_suspend) {
212  dev_err(&pdev->dev,
213  "could not allocate memory for saving state\n");
214  goto exit_free;
215  }
216 
217  dbx500_regulator_testcase(regulator_info, num_regulators);
218  return 0;
219 
220 exit_free:
221  kfree(rdebug.state_before_suspend);
222 exit_destroy_power_state:
223  debugfs_remove(rdebug.power_state_cnt_file);
224 exit_destroy_status:
225  debugfs_remove(rdebug.status_file);
226 exit_destroy_dir:
227  debugfs_remove(rdebug.dir);
228 exit_no_debugfs:
229  dev_err(&pdev->dev, "failed to create debugfs entries.\n");
230  return -ENOMEM;
231 }
232 
233 int __devexit ux500_regulator_debug_exit(void)
234 {
235  debugfs_remove_recursive(rdebug.dir);
236  kfree(rdebug.state_after_suspend);
237  kfree(rdebug.state_before_suspend);
238 
239  return 0;
240 }
241 #endif