Add load command to the boot script required for newer novaboot version.
[shark/motorek-5200.git] / motorek.c
1 /*
2  *      Driver for DC motor connected to MPC5200 based boards.
3  *
4  *      The motor is used for education at Czech Technical University
5  *      in Prague.
6  *
7  *      Authors:
8  *      Michal Sojka            <sojkam1@fel.cvut.cz>
9  *
10  *      This program is free software; you can redistribute it and/or
11  *      modify it under the terms of the GNU General Public License
12  *      as published by the Free Software Foundation; either version
13  *      2 of the License, or (at your option) any later version.
14  */
15
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/mod_devicetable.h>
19 #include <linux/of.h>
20 #include <linux/of_platform.h>
21 #include <asm/mpc52xx.h>
22 #include <linux/interrupt.h>
23 #include <linux/slab.h>
24
25 struct motorek {
26         struct mpc52xx_gpt *pwmf, *pwmb, *irca, *ircb;
27         atomic_t pos;
28         int irq;
29         int action;
30         int last_irc_state;
31 };
32
33 static ssize_t show_position(struct device *dev,
34                             struct device_attribute *attr, char *buf)
35 {
36         struct platform_device  *pdev = to_platform_device(dev);
37         struct motorek          *m = platform_get_drvdata(pdev);
38
39         int len = snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&m->pos));
40         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
41 }
42
43 static ssize_t show_action(struct device *dev,
44                            struct device_attribute *attr, char *buf)
45 {
46         struct platform_device  *pdev = to_platform_device(dev);
47         struct motorek          *m = platform_get_drvdata(pdev);
48
49         int len = snprintf(buf, PAGE_SIZE, "%d\n", m->action);
50         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
51 }
52
53 static void motorek_action(struct motorek *m, int action_permile);
54 static ssize_t store_action(struct device *dev, struct device_attribute *attr,
55                             const char *buf, size_t count)
56 {
57         struct platform_device  *pdev = to_platform_device(dev);
58         struct motorek          *m = platform_get_drvdata(pdev);
59
60         int a;
61         sscanf(buf, "%d", &a);
62         motorek_action(m, a);
63         return strnlen(buf, PAGE_SIZE);
64 }
65
66 DEVICE_ATTR(position,0444,show_position,NULL);
67 DEVICE_ATTR(action,0644,show_action,store_action);
68
69 #define MPC52xx_GPT_MODE_DISABLED 0
70 #define MPC52xx_GPT_MODE_INCAPT   1
71 #define MPC52xx_GPT_MODE_OUTCMP   2
72 #define MPC52xx_GPT_MODE_PWM      3
73 #define MPC52xx_GPT_MODE_GPIO     4
74
75 #define MPC52xx_GPT_MODE_GPIO_IN   (0<<4)
76 #define MPC52xx_GPT_MODE_GPIO_OUT0 (2<<4)
77 #define MPC52xx_GPT_MODE_GPIO_OUT1 (1<<4)
78
79 #define MPC52xx_GPT_STATUS_PIN (1<<8)
80
81 #define MPC52xx_GPT_PWM_OP        (1<<8) /* PWM polarity */
82
83 /* Base clock 132 MHz
84  * (/proc/device-tree/cpus/PowerPC,5200@0/bus-frequency) */
85 #define PWM_PERIOD 6600         /* = 132 000 kHz / 20 kHz  */
86
87
88 static void pwm_width(struct mpc52xx_gpt *gpt, u16 width)
89 {
90         out_be32(&gpt->pwm, (width<<16) | MPC52xx_GPT_PWM_OP);
91         //printk("pwm: %p=0x%x\n", gpt, width);
92
93 }
94
95 static void __devinit init_pwn(struct mpc52xx_gpt *gpt)
96 {
97         //while (((unsigned)gpt & 0xff) != 0x50) gpt++;
98         out_be32(&gpt->count, (1<<16) | PWM_PERIOD);
99         pwm_width(gpt, 0);
100         out_be32(&gpt->mode, MPC52xx_GPT_MODE_PWM);
101
102         //out_be32(&gpt->pwm, (500<<16) | MPC52xx_GPT_PWM_OP); /* REMOVE ME */
103
104         //out_be32(&gpt->mode, MPC52xx_GPT_MODE_GPIO | (2<<4));
105         //printk("pwm: %p\n", gpt);
106 }
107
108 static void __devinit init_input(struct mpc52xx_gpt *gpt)
109 {
110         out_be32(&gpt->mode,
111                  MPC52xx_GPT_MODE_GPIO |
112                  MPC52xx_GPT_MODE_GPIO_IN);
113 }
114
115 static void  pwm_done(struct mpc52xx_gpt *gpt)
116 {
117         out_be32(&gpt->mode, 0);
118         out_be32(&gpt->count, 0);
119         pwm_width(gpt, 0);
120 }
121
122 static void motorek_action(struct motorek *m, int action_permile)
123 {
124         m->action = action_permile;
125         if (action_permile >= 0) {
126                 pwm_width(m->pwmb, 0);
127                 pwm_width(m->pwmf, +action_permile*PWM_PERIOD/1000);
128         } else {
129                 pwm_width(m->pwmf, 0);
130                 pwm_width(m->pwmb, -action_permile*PWM_PERIOD/1000);
131         }
132 }
133
134 static int __devinit motorek_init(struct motorek *m)
135 {
136         init_pwn(m->pwmf);
137         init_pwn(m->pwmb);
138         init_input(m->irca);
139         init_input(m->ircb);
140         return 0;
141 }
142
143 static int motorek_done(struct motorek *m)
144 {
145         pwm_done(m->pwmf);
146         pwm_done(m->pwmb);
147         return 0;
148 }
149 #define TRANSITION(old, new) (((old) << 2) | new)
150 static const int table[16] = {
151         [TRANSITION(0,1)] = +1,
152         [TRANSITION(1,3)] = +1,
153         [TRANSITION(3,2)] = +1,
154         [TRANSITION(2,0)] = +1,
155
156         [TRANSITION(1,0)] = -1,
157         [TRANSITION(3,1)] = -1,
158         [TRANSITION(2,3)] = -1,
159         [TRANSITION(0,2)] = -1,
160 };
161
162 static irqreturn_t motorek_irq(int irq, void *dev_id)
163 {
164         struct motorek *m = dev_id;
165         int irc_state =
166                 ((in_be32(&m->irca->status) & MPC52xx_GPT_STATUS_PIN) ? 1 : 0) | \
167                 ((in_be32(&m->ircb->status) & MPC52xx_GPT_STATUS_PIN) ? 2 : 0);
168         atomic_add(table[TRANSITION(m->last_irc_state, irc_state)], &m->pos);
169         m->last_irc_state = irc_state;
170         return IRQ_HANDLED;
171 }
172
173 static struct of_device_id mpc5200_gpt_match[] = {
174         { .compatible = "mpc5200-gpt", },
175         { .compatible = "fsl,mpc5200-gpt", },
176         {},
177 };
178
179 struct mpc52xx_gpt __iomem *iomap_gpt_by_phandle_prop(struct device_node *dn, const char *prop)
180 {
181         struct device_node *np;
182         struct mpc52xx_gpt __iomem *gpt = NULL;
183         const phandle *phandle;
184
185         phandle = of_get_property(dn, prop, NULL);
186         if (!phandle)
187                 return NULL;
188
189         np = of_find_node_by_phandle(*phandle);
190         if (!np)
191                 return NULL;
192
193         if (!of_match_node(mpc5200_gpt_match, np)) {
194                 printk(KERN_ERR "property %s doesn't refer to GPT\n", prop);
195                 goto out;
196         }
197
198         gpt = of_iomap(np, 0);
199 out:
200         of_node_put(np);
201         return gpt;
202 }
203
204 static int __devinit motorek_probe(struct platform_device* dev)
205 {
206         struct device_node *dn = dev->dev.of_node;
207         struct motorek *m;
208         int err;
209
210         m = kzalloc(sizeof(*m), GFP_KERNEL);
211         if (!m)
212                 return -ENOMEM;
213
214         err = -ENODEV;
215
216         m->pwmf = iomap_gpt_by_phandle_prop(dn, "pwmf");
217         if (!m->pwmf)
218                 goto err_free;
219         m->pwmb = iomap_gpt_by_phandle_prop(dn, "pwmb");
220         if (!m->pwmb)
221                 goto err_unmap_pf;
222         m->irca = iomap_gpt_by_phandle_prop(dn, "irca");
223         if (!m->irca)
224                 goto err_unmap_pb;
225         m->ircb = iomap_gpt_by_phandle_prop(dn, "ircb");
226         if (!m->ircb)
227                 goto err_unmap_ia;
228
229         m->irq = irq_of_parse_and_map(dn, 0);
230         if (m->irq == NO_IRQ)
231                 goto err_unmap_ib;
232         err = request_irq(m->irq, motorek_irq, 0, "motorek", m);
233         if (err)
234                 goto err_unmap_ib;
235
236         motorek_init(m);
237
238         platform_set_drvdata(dev, m);
239         err = device_create_file(&dev->dev,&dev_attr_position);
240         if (err)
241                 goto err_irq;
242         err = device_create_file(&dev->dev,&dev_attr_action);
243         if (err)
244                 goto err_irq;
245
246         printk(KERN_NOTICE "Motorek initialized\n");
247
248         return 0;
249
250 err_irq:
251         free_irq(m->irq, m);
252 err_unmap_ib:
253         iounmap(m->pwmb);
254 err_unmap_ia:
255         iounmap(m->pwmf);
256 err_unmap_pb:
257         iounmap(m->pwmb);
258 err_unmap_pf:
259         iounmap(m->pwmf);
260 err_free:
261         kfree(m);
262         return err;
263 }
264
265 static int __devexit motorek_remove(struct platform_device* dev)
266 {
267         struct motorek *m;
268
269         printk(KERN_NOTICE "Removing motorek\n");
270         m = platform_get_drvdata(dev);
271         free_irq(m->irq, m);
272         motorek_done(m);
273         kfree(m);
274         return 0;
275 }
276
277 static struct of_device_id motorek_match[] = {
278         { .type = "motorek", },
279         {},
280 };
281 static struct platform_driver motorek_driver = {
282         .probe          = motorek_probe,
283         .remove         = __devexit_p(motorek_remove),
284         .driver         = {
285                 .name           = "motorek",
286                 .owner          = THIS_MODULE,
287                 .of_match_table = motorek_match,
288         },
289 };
290
291
292 static int __init motorek_init_module(void)
293 {
294         int ret;
295         struct platform_device *dev;
296         struct device_node *dn;
297
298         for_each_node_by_type(dn, "motorek") {
299                 if (!of_find_device_by_node(dn)) {
300                         dev = of_platform_device_create(dn, NULL, NULL);
301                         if (!dev)
302                                 return -ENOMEM;
303                 }
304         };
305
306         ret = platform_driver_register(&motorek_driver);
307         return ret;
308 }
309
310 static void __exit motorek_exit_module(void)
311 {
312         struct platform_device *dev;
313         struct device_node *dn;
314
315         for_each_node_by_type(dn, "motorek") {
316                 while ((dev = of_find_device_by_node(dn))) {
317                         of_device_unregister(dev);
318                 }
319         }
320         platform_driver_unregister(&motorek_driver);
321 }
322
323 module_init(motorek_init_module);
324 module_exit(motorek_exit_module);
325
326
327 MODULE_LICENSE("GPL v2");
328 MODULE_VERSION("0.1");
329 MODULE_AUTHOR("Michal Sojka <sojkam1@fel.cvut.cz>");