Merge branch 'linus' into stackprotector
[linux-2.6] / arch / powerpc / platforms / 44x / warp.c
1 /*
2  * PIKA Warp(tm) board specific routines
3  *
4  * Copyright (c) 2008 PIKA Technologies
5  *   Sean MacLennan <smaclennan@pikatech.com>
6  *
7  * This program is free software; you can redistribute  it and/or modify it
8  * under  the terms of  the GNU General  Public License as published by the
9  * Free Software Foundation;  either version 2 of the  License, or (at your
10  * option) any later version.
11  */
12 #include <linux/init.h>
13 #include <linux/of_platform.h>
14 #include <linux/kthread.h>
15 #include <linux/i2c.h>
16 #include <linux/interrupt.h>
17 #include <linux/delay.h>
18
19 #include <asm/machdep.h>
20 #include <asm/prom.h>
21 #include <asm/udbg.h>
22 #include <asm/time.h>
23 #include <asm/uic.h>
24 #include <asm/ppc4xx.h>
25
26 static __initdata struct of_device_id warp_of_bus[] = {
27         { .compatible = "ibm,plb4", },
28         { .compatible = "ibm,opb", },
29         { .compatible = "ibm,ebc", },
30         {},
31 };
32
33 static int __init warp_device_probe(void)
34 {
35         of_platform_bus_probe(NULL, warp_of_bus, NULL);
36         return 0;
37 }
38 machine_device_initcall(warp, warp_device_probe);
39
40 static int __init warp_probe(void)
41 {
42         unsigned long root = of_get_flat_dt_root();
43
44         return of_flat_dt_is_compatible(root, "pika,warp");
45 }
46
47 define_machine(warp) {
48         .name           = "Warp",
49         .probe          = warp_probe,
50         .progress       = udbg_progress,
51         .init_IRQ       = uic_init_tree,
52         .get_irq        = uic_get_irq,
53         .restart        = ppc4xx_reset_system,
54         .calibrate_decr = generic_calibrate_decr,
55 };
56
57
58 /* I am not sure this is the best place for this... */
59 static int __init warp_post_info(void)
60 {
61         struct device_node *np;
62         void __iomem *fpga;
63         u32 post1, post2;
64
65         /* Sighhhh... POST information is in the sd area. */
66         np = of_find_compatible_node(NULL, NULL, "pika,fpga-sd");
67         if (np == NULL)
68                 return -ENOENT;
69
70         fpga = of_iomap(np, 0);
71         of_node_put(np);
72         if (fpga == NULL)
73                 return -ENOENT;
74
75         post1 = in_be32(fpga + 0x40);
76         post2 = in_be32(fpga + 0x44);
77
78         iounmap(fpga);
79
80         if (post1 || post2)
81                 printk(KERN_INFO "Warp POST %08x %08x\n", post1, post2);
82         else
83                 printk(KERN_INFO "Warp POST OK\n");
84
85         return 0;
86 }
87 machine_late_initcall(warp, warp_post_info);
88
89
90 #ifdef CONFIG_SENSORS_AD7414
91
92 static LIST_HEAD(dtm_shutdown_list);
93 static void __iomem *dtm_fpga;
94 static void __iomem *gpio_base;
95
96
97 struct dtm_shutdown {
98         struct list_head list;
99         void (*func)(void *arg);
100         void *arg;
101 };
102
103
104 int pika_dtm_register_shutdown(void (*func)(void *arg), void *arg)
105 {
106         struct dtm_shutdown *shutdown;
107
108         shutdown = kmalloc(sizeof(struct dtm_shutdown), GFP_KERNEL);
109         if (shutdown == NULL)
110                 return -ENOMEM;
111
112         shutdown->func = func;
113         shutdown->arg = arg;
114
115         list_add(&shutdown->list, &dtm_shutdown_list);
116
117         return 0;
118 }
119
120 int pika_dtm_unregister_shutdown(void (*func)(void *arg), void *arg)
121 {
122         struct dtm_shutdown *shutdown;
123
124         list_for_each_entry(shutdown, &dtm_shutdown_list, list)
125                 if (shutdown->func == func && shutdown->arg == arg) {
126                         list_del(&shutdown->list);
127                         kfree(shutdown);
128                         return 0;
129                 }
130
131         return -EINVAL;
132 }
133
134 static irqreturn_t temp_isr(int irq, void *context)
135 {
136         struct dtm_shutdown *shutdown;
137
138         local_irq_disable();
139
140         /* Run through the shutdown list. */
141         list_for_each_entry(shutdown, &dtm_shutdown_list, list)
142                 shutdown->func(shutdown->arg);
143
144         printk(KERN_EMERG "\n\nCritical Temperature Shutdown\n");
145
146         while (1) {
147                 if (dtm_fpga) {
148                         unsigned reset = in_be32(dtm_fpga + 0x14);
149                         out_be32(dtm_fpga + 0x14, reset);
150                 }
151
152                 if (gpio_base) {
153                         unsigned leds = in_be32(gpio_base);
154
155                         /* green off, red toggle */
156                         leds &= ~0x80000000;
157                         leds ^=  0x40000000;
158
159                         out_be32(gpio_base, leds);
160                 }
161
162                 mdelay(500);
163         }
164 }
165
166 static int pika_setup_leds(void)
167 {
168         struct device_node *np;
169         const u32 *gpios;
170         int len;
171
172         np = of_find_compatible_node(NULL, NULL, "linux,gpio-led");
173         if (!np) {
174                 printk(KERN_ERR __FILE__ ": Unable to find gpio-led\n");
175                 return -ENOENT;
176         }
177
178         gpios = of_get_property(np, "gpios", &len);
179         of_node_put(np);
180         if (!gpios || len < 4) {
181                 printk(KERN_ERR __FILE__
182                        ": Unable to get gpios property (%d)\n", len);
183                 return -ENOENT;
184         }
185
186         np = of_find_node_by_phandle(gpios[0]);
187         if (!np) {
188                 printk(KERN_ERR __FILE__ ": Unable to find gpio\n");
189                 return -ENOENT;
190         }
191
192         gpio_base = of_iomap(np, 0);
193         of_node_put(np);
194         if (!gpio_base) {
195                 printk(KERN_ERR __FILE__ ": Unable to map gpio");
196                 return -ENOMEM;
197         }
198
199         return 0;
200 }
201
202 static void pika_setup_critical_temp(struct i2c_client *client)
203 {
204         struct device_node *np;
205         int irq, rc;
206
207         /* Do this before enabling critical temp interrupt since we
208          * may immediately interrupt.
209          */
210         pika_setup_leds();
211
212         /* These registers are in 1 degree increments. */
213         i2c_smbus_write_byte_data(client, 2, 65); /* Thigh */
214         i2c_smbus_write_byte_data(client, 3,  0); /* Tlow */
215
216         np = of_find_compatible_node(NULL, NULL, "adi,ad7414");
217         if (np == NULL) {
218                 printk(KERN_ERR __FILE__ ": Unable to find ad7414\n");
219                 return;
220         }
221
222         irq = irq_of_parse_and_map(np, 0);
223         of_node_put(np);
224         if (irq  == NO_IRQ) {
225                 printk(KERN_ERR __FILE__ ": Unable to get ad7414 irq\n");
226                 return;
227         }
228
229         rc = request_irq(irq, temp_isr, 0, "ad7414", NULL);
230         if (rc) {
231                 printk(KERN_ERR __FILE__
232                        ": Unable to request ad7414 irq %d = %d\n", irq, rc);
233                 return;
234         }
235 }
236
237 static inline void pika_dtm_check_fan(void __iomem *fpga)
238 {
239         static int fan_state;
240         u32 fan = in_be32(fpga + 0x34) & (1 << 14);
241
242         if (fan_state != fan) {
243                 fan_state = fan;
244                 if (fan)
245                         printk(KERN_WARNING "Fan rotation error detected."
246                                    " Please check hardware.\n");
247         }
248 }
249
250 static int pika_dtm_thread(void __iomem *fpga)
251 {
252         struct i2c_adapter *adap;
253         struct i2c_client *client;
254
255         /* We loop in case either driver was compiled as a module and
256          * has not been insmoded yet.
257          */
258         while (!(adap = i2c_get_adapter(0))) {
259                 set_current_state(TASK_INTERRUPTIBLE);
260                 schedule_timeout(HZ);
261         }
262
263         while (1) {
264                 list_for_each_entry(client, &adap->clients, list)
265                         if (client->addr == 0x4a)
266                                 goto found_it;
267
268                 set_current_state(TASK_INTERRUPTIBLE);
269                 schedule_timeout(HZ);
270         }
271
272 found_it:
273         i2c_put_adapter(adap);
274
275         pika_setup_critical_temp(client);
276
277         printk(KERN_INFO "PIKA DTM thread running.\n");
278
279         while (!kthread_should_stop()) {
280                 int val;
281
282                 val = i2c_smbus_read_word_data(client, 0);
283                 if (val < 0)
284                         dev_dbg(&client->dev, "DTM read temp failed.\n");
285                 else {
286                         s16 temp = swab16(val);
287                         out_be32(fpga + 0x20, temp);
288                 }
289
290                 pika_dtm_check_fan(fpga);
291
292                 set_current_state(TASK_INTERRUPTIBLE);
293                 schedule_timeout(HZ);
294         }
295
296         return 0;
297 }
298
299
300 static int __init pika_dtm_start(void)
301 {
302         struct task_struct *dtm_thread;
303         struct device_node *np;
304
305         np = of_find_compatible_node(NULL, NULL, "pika,fpga");
306         if (np == NULL)
307                 return -ENOENT;
308
309         dtm_fpga = of_iomap(np, 0);
310         of_node_put(np);
311         if (dtm_fpga == NULL)
312                 return -ENOENT;
313
314         dtm_thread = kthread_run(pika_dtm_thread, dtm_fpga, "pika-dtm");
315         if (IS_ERR(dtm_thread)) {
316                 iounmap(dtm_fpga);
317                 return PTR_ERR(dtm_thread);
318         }
319
320         return 0;
321 }
322 machine_late_initcall(warp, pika_dtm_start);
323
324 #else /* !CONFIG_SENSORS_AD7414 */
325
326 int pika_dtm_register_shutdown(void (*func)(void *arg), void *arg)
327 {
328         return 0;
329 }
330
331 int pika_dtm_unregister_shutdown(void (*func)(void *arg), void *arg)
332 {
333         return 0;
334 }
335
336 #endif
337
338 EXPORT_SYMBOL(pika_dtm_register_shutdown);
339 EXPORT_SYMBOL(pika_dtm_unregister_shutdown);