Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
suspend.c
Go to the documentation of this file.
1 /*
2  * MPC83xx suspend support
3  *
4  * Author: Scott Wood <[email protected]>
5  *
6  * Copyright (c) 2006-2007 Freescale Semiconductor, Inc.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License version 2 as published
10  * by the Free Software Foundation.
11  */
12 
13 #include <linux/init.h>
14 #include <linux/pm.h>
15 #include <linux/types.h>
16 #include <linux/ioport.h>
17 #include <linux/interrupt.h>
18 #include <linux/wait.h>
19 #include <linux/kthread.h>
20 #include <linux/freezer.h>
21 #include <linux/suspend.h>
22 #include <linux/fsl_devices.h>
23 #include <linux/of_platform.h>
24 #include <linux/export.h>
25 
26 #include <asm/reg.h>
27 #include <asm/io.h>
28 #include <asm/time.h>
29 #include <asm/mpc6xx.h>
30 #include <asm/switch_to.h>
31 
32 #include <sysdev/fsl_soc.h>
33 
34 #define PMCCR1_NEXT_STATE 0x0C /* Next state for power management */
35 #define PMCCR1_NEXT_STATE_SHIFT 2
36 #define PMCCR1_CURR_STATE 0x03 /* Current state for power management*/
37 #define IMMR_SYSCR_OFFSET 0x100
38 #define IMMR_RCW_OFFSET 0x900
39 #define RCW_PCI_HOST 0x80000000
40 
42 
43 struct mpc83xx_pmc {
45 #define PMCCR_DLPEN 2 /* DDR SDRAM low power enable */
46 #define PMCCR_SLPEN 1 /* System low power enable */
47 
50 /* All but PMCI are deep-sleep only */
51 #define PMCER_GPIO 0x100
52 #define PMCER_PCI 0x080
53 #define PMCER_USB 0x040
54 #define PMCER_ETSEC1 0x020
55 #define PMCER_ETSEC2 0x010
56 #define PMCER_TIMER 0x008
57 #define PMCER_INT1 0x004
58 #define PMCER_INT2 0x002
59 #define PMCER_PMCI 0x001
60 #define PMCER_ALL 0x1FF
61 
62  /* deep-sleep only */
64 #define PMCCR1_USE_STATE 0x80000000
65 #define PMCCR1_PME_EN 0x00000080
66 #define PMCCR1_ASSERT_PME 0x00000040
67 #define PMCCR1_POWER_OFF 0x00000020
68 
69  /* deep-sleep only */
71 };
72 
73 struct mpc83xx_rcw {
76 };
77 
78 struct mpc83xx_clock {
82 };
83 
84 struct mpc83xx_syscr {
88  __be32 :32;
92 };
93 
94 struct mpc83xx_saved {
98 };
99 
100 struct pmc_type {
102 };
103 
104 static struct platform_device *pmc_dev;
105 static int has_deep_sleep, deep_sleeping;
106 static int pmc_irq;
107 static struct mpc83xx_pmc __iomem *pmc_regs;
108 static struct mpc83xx_clock __iomem *clock_regs;
109 static struct mpc83xx_syscr __iomem *syscr_regs;
110 static struct mpc83xx_saved saved_regs;
111 static int is_pci_agent, wake_from_pci;
112 static phys_addr_t immrbase;
113 static int pci_pm_state;
114 static DECLARE_WAIT_QUEUE_HEAD(agent_wq);
115 
116 int fsl_deep_sleep(void)
117 {
118  return deep_sleeping;
119 }
121 
122 static int mpc83xx_change_state(void)
123 {
124  u32 curr_state;
125  u32 reg_cfg1 = in_be32(&pmc_regs->config1);
126 
127  if (is_pci_agent) {
128  pci_pm_state = (reg_cfg1 & PMCCR1_NEXT_STATE) >>
130  curr_state = reg_cfg1 & PMCCR1_CURR_STATE;
131 
132  if (curr_state != pci_pm_state) {
133  reg_cfg1 &= ~PMCCR1_CURR_STATE;
134  reg_cfg1 |= pci_pm_state;
135  out_be32(&pmc_regs->config1, reg_cfg1);
136 
137  wake_up(&agent_wq);
138  return 1;
139  }
140  }
141 
142  return 0;
143 }
144 
145 static irqreturn_t pmc_irq_handler(int irq, void *dev_id)
146 {
147  u32 event = in_be32(&pmc_regs->event);
148  int ret = IRQ_NONE;
149 
150  if (mpc83xx_change_state())
151  ret = IRQ_HANDLED;
152 
153  if (event) {
154  out_be32(&pmc_regs->event, event);
155  ret = IRQ_HANDLED;
156  }
157 
158  return ret;
159 }
160 
161 static void mpc83xx_suspend_restore_regs(void)
162 {
163  out_be32(&syscr_regs->sicrl, saved_regs.sicrl);
164  out_be32(&syscr_regs->sicrh, saved_regs.sicrh);
165  out_be32(&clock_regs->sccr, saved_regs.sccr);
166 }
167 
168 static void mpc83xx_suspend_save_regs(void)
169 {
170  saved_regs.sicrl = in_be32(&syscr_regs->sicrl);
171  saved_regs.sicrh = in_be32(&syscr_regs->sicrh);
172  saved_regs.sccr = in_be32(&clock_regs->sccr);
173 }
174 
175 static int mpc83xx_suspend_enter(suspend_state_t state)
176 {
177  int ret = -EAGAIN;
178 
179  /* Don't go to sleep if there's a race where pci_pm_state changes
180  * between the agent thread checking it and the PM code disabling
181  * interrupts.
182  */
183  if (wake_from_pci) {
184  if (pci_pm_state != (deep_sleeping ? 3 : 2))
185  goto out;
186 
187  out_be32(&pmc_regs->config1,
188  in_be32(&pmc_regs->config1) | PMCCR1_PME_EN);
189  }
190 
191  /* Put the system into low-power mode and the RAM
192  * into self-refresh mode once the core goes to
193  * sleep.
194  */
195 
196  out_be32(&pmc_regs->config, PMCCR_SLPEN | PMCCR_DLPEN);
197 
198  /* If it has deep sleep (i.e. it's an 831x or compatible),
199  * disable power to the core upon entering sleep mode. This will
200  * require going through the boot firmware upon a wakeup event.
201  */
202 
203  if (deep_sleeping) {
204  mpc83xx_suspend_save_regs();
205 
206  out_be32(&pmc_regs->mask, PMCER_ALL);
207 
208  out_be32(&pmc_regs->config1,
209  in_be32(&pmc_regs->config1) | PMCCR1_POWER_OFF);
210 
212 
213  mpc83xx_enter_deep_sleep(immrbase);
214 
215  out_be32(&pmc_regs->config1,
216  in_be32(&pmc_regs->config1) & ~PMCCR1_POWER_OFF);
217 
218  out_be32(&pmc_regs->mask, PMCER_PMCI);
219 
220  mpc83xx_suspend_restore_regs();
221  } else {
222  out_be32(&pmc_regs->mask, PMCER_PMCI);
223 
225  }
226 
227  ret = 0;
228 
229 out:
230  out_be32(&pmc_regs->config1,
231  in_be32(&pmc_regs->config1) & ~PMCCR1_PME_EN);
232 
233  return ret;
234 }
235 
236 static void mpc83xx_suspend_end(void)
237 {
238  deep_sleeping = 0;
239 }
240 
241 static int mpc83xx_suspend_valid(suspend_state_t state)
242 {
243  return state == PM_SUSPEND_STANDBY || state == PM_SUSPEND_MEM;
244 }
245 
246 static int mpc83xx_suspend_begin(suspend_state_t state)
247 {
248  switch (state) {
249  case PM_SUSPEND_STANDBY:
250  deep_sleeping = 0;
251  return 0;
252 
253  case PM_SUSPEND_MEM:
254  if (has_deep_sleep)
255  deep_sleeping = 1;
256 
257  return 0;
258 
259  default:
260  return -EINVAL;
261  }
262 }
263 
264 static int agent_thread_fn(void *data)
265 {
266  while (1) {
267  wait_event_interruptible(agent_wq, pci_pm_state >= 2);
268  try_to_freeze();
269 
270  if (signal_pending(current) || pci_pm_state < 2)
271  continue;
272 
273  /* With a preemptible kernel (or SMP), this could race with
274  * a userspace-driven suspend request. It's probably best
275  * to avoid mixing the two with such a configuration (or
276  * else fix it by adding a mutex to state_store that we can
277  * synchronize with).
278  */
279 
280  wake_from_pci = 1;
281 
282  pm_suspend(pci_pm_state == 3 ? PM_SUSPEND_MEM :
284 
285  wake_from_pci = 0;
286  }
287 
288  return 0;
289 }
290 
291 static void mpc83xx_set_agent(void)
292 {
293  out_be32(&pmc_regs->config1, PMCCR1_USE_STATE);
294  out_be32(&pmc_regs->mask, PMCER_PMCI);
295 
296  kthread_run(agent_thread_fn, NULL, "PCI power mgt");
297 }
298 
299 static int mpc83xx_is_pci_agent(void)
300 {
301  struct mpc83xx_rcw __iomem *rcw_regs;
302  int ret;
303 
304  rcw_regs = ioremap(get_immrbase() + IMMR_RCW_OFFSET,
305  sizeof(struct mpc83xx_rcw));
306 
307  if (!rcw_regs)
308  return -ENOMEM;
309 
310  ret = !(in_be32(&rcw_regs->rcwhr) & RCW_PCI_HOST);
311 
312  iounmap(rcw_regs);
313  return ret;
314 }
315 
316 static const struct platform_suspend_ops mpc83xx_suspend_ops = {
317  .valid = mpc83xx_suspend_valid,
318  .begin = mpc83xx_suspend_begin,
319  .enter = mpc83xx_suspend_enter,
320  .end = mpc83xx_suspend_end,
321 };
322 
323 static struct of_device_id pmc_match[];
324 static int pmc_probe(struct platform_device *ofdev)
325 {
326  const struct of_device_id *match;
327  struct device_node *np = ofdev->dev.of_node;
328  struct resource res;
329  const struct pmc_type *type;
330  int ret = 0;
331 
332  match = of_match_device(pmc_match, &ofdev->dev);
333  if (!match)
334  return -EINVAL;
335 
336  type = match->data;
337 
338  if (!of_device_is_available(np))
339  return -ENODEV;
340 
342  immrbase = get_immrbase();
343  pmc_dev = ofdev;
344 
345  is_pci_agent = mpc83xx_is_pci_agent();
346  if (is_pci_agent < 0)
347  return is_pci_agent;
348 
349  ret = of_address_to_resource(np, 0, &res);
350  if (ret)
351  return -ENODEV;
352 
353  pmc_irq = irq_of_parse_and_map(np, 0);
354  if (pmc_irq != NO_IRQ) {
355  ret = request_irq(pmc_irq, pmc_irq_handler, IRQF_SHARED,
356  "pmc", ofdev);
357 
358  if (ret)
359  return -EBUSY;
360  }
361 
362  pmc_regs = ioremap(res.start, sizeof(struct mpc83xx_pmc));
363 
364  if (!pmc_regs) {
365  ret = -ENOMEM;
366  goto out;
367  }
368 
369  ret = of_address_to_resource(np, 1, &res);
370  if (ret) {
371  ret = -ENODEV;
372  goto out_pmc;
373  }
374 
375  clock_regs = ioremap(res.start, sizeof(struct mpc83xx_pmc));
376 
377  if (!clock_regs) {
378  ret = -ENOMEM;
379  goto out_pmc;
380  }
381 
382  if (has_deep_sleep) {
383  syscr_regs = ioremap(immrbase + IMMR_SYSCR_OFFSET,
384  sizeof(*syscr_regs));
385  if (!syscr_regs) {
386  ret = -ENOMEM;
387  goto out_syscr;
388  }
389  }
390 
391  if (is_pci_agent)
392  mpc83xx_set_agent();
393 
394  suspend_set_ops(&mpc83xx_suspend_ops);
395  return 0;
396 
397 out_syscr:
398  iounmap(clock_regs);
399 out_pmc:
400  iounmap(pmc_regs);
401 out:
402  if (pmc_irq != NO_IRQ)
403  free_irq(pmc_irq, ofdev);
404 
405  return ret;
406 }
407 
408 static int pmc_remove(struct platform_device *ofdev)
409 {
410  return -EPERM;
411 };
412 
413 static struct pmc_type pmc_types[] = {
414  {
415  .has_deep_sleep = 1,
416  },
417  {
418  .has_deep_sleep = 0,
419  }
420 };
421 
422 static struct of_device_id pmc_match[] = {
423  {
424  .compatible = "fsl,mpc8313-pmc",
425  .data = &pmc_types[0],
426  },
427  {
428  .compatible = "fsl,mpc8349-pmc",
429  .data = &pmc_types[1],
430  },
431  {}
432 };
433 
434 static struct platform_driver pmc_driver = {
435  .driver = {
436  .name = "mpc83xx-pmc",
437  .owner = THIS_MODULE,
438  .of_match_table = pmc_match,
439  },
440  .probe = pmc_probe,
441  .remove = pmc_remove
442 };
443 
444 static int pmc_init(void)
445 {
446  return platform_driver_register(&pmc_driver);
447 }
448 
449 module_init(pmc_init);