]>
Commit | Line | Data |
---|---|---|
67a8dbbc JC |
1 | /* |
2 | * Support for the camera device found on Marvell MMP processors; known | |
3 | * to work with the Armada 610 as used in the OLPC 1.75 system. | |
4 | * | |
5 | * Copyright 2011 Jonathan Corbet <corbet@lwn.net> | |
6 | * | |
7 | * This file may be distributed under the terms of the GNU General | |
8 | * Public License, version 2. | |
9 | */ | |
10 | ||
11 | #include <linux/init.h> | |
12 | #include <linux/kernel.h> | |
13 | #include <linux/module.h> | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/i2c-gpio.h> | |
16 | #include <linux/interrupt.h> | |
17 | #include <linux/spinlock.h> | |
18 | #include <linux/slab.h> | |
19 | #include <linux/videodev2.h> | |
20 | #include <media/v4l2-device.h> | |
21 | #include <media/v4l2-chip-ident.h> | |
22 | #include <media/mmp-camera.h> | |
23 | #include <linux/device.h> | |
24 | #include <linux/platform_device.h> | |
25 | #include <linux/gpio.h> | |
26 | #include <linux/io.h> | |
27 | #include <linux/delay.h> | |
28 | #include <linux/list.h> | |
bb0a896e | 29 | #include <linux/pm.h> |
67a8dbbc JC |
30 | |
31 | #include "mcam-core.h" | |
32 | ||
e27412f5 | 33 | MODULE_ALIAS("platform:mmp-camera"); |
67a8dbbc JC |
34 | MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>"); |
35 | MODULE_LICENSE("GPL"); | |
36 | ||
37 | struct mmp_camera { | |
38 | void *power_regs; | |
39 | struct platform_device *pdev; | |
40 | struct mcam_camera mcam; | |
41 | struct list_head devlist; | |
42 | int irq; | |
43 | }; | |
44 | ||
45 | static inline struct mmp_camera *mcam_to_cam(struct mcam_camera *mcam) | |
46 | { | |
47 | return container_of(mcam, struct mmp_camera, mcam); | |
48 | } | |
49 | ||
50 | /* | |
51 | * A silly little infrastructure so we can keep track of our devices. | |
52 | * Chances are that we will never have more than one of them, but | |
53 | * the Armada 610 *does* have two controllers... | |
54 | */ | |
55 | ||
56 | static LIST_HEAD(mmpcam_devices); | |
57 | static struct mutex mmpcam_devices_lock; | |
58 | ||
59 | static void mmpcam_add_device(struct mmp_camera *cam) | |
60 | { | |
61 | mutex_lock(&mmpcam_devices_lock); | |
62 | list_add(&cam->devlist, &mmpcam_devices); | |
63 | mutex_unlock(&mmpcam_devices_lock); | |
64 | } | |
65 | ||
66 | static void mmpcam_remove_device(struct mmp_camera *cam) | |
67 | { | |
68 | mutex_lock(&mmpcam_devices_lock); | |
69 | list_del(&cam->devlist); | |
70 | mutex_unlock(&mmpcam_devices_lock); | |
71 | } | |
72 | ||
73 | /* | |
74 | * Platform dev remove passes us a platform_device, and there's | |
75 | * no handy unused drvdata to stash a backpointer in. So just | |
76 | * dig it out of our list. | |
77 | */ | |
78 | static struct mmp_camera *mmpcam_find_device(struct platform_device *pdev) | |
79 | { | |
80 | struct mmp_camera *cam; | |
81 | ||
82 | mutex_lock(&mmpcam_devices_lock); | |
83 | list_for_each_entry(cam, &mmpcam_devices, devlist) { | |
84 | if (cam->pdev == pdev) { | |
85 | mutex_unlock(&mmpcam_devices_lock); | |
86 | return cam; | |
87 | } | |
88 | } | |
89 | mutex_unlock(&mmpcam_devices_lock); | |
90 | return NULL; | |
91 | } | |
92 | ||
93 | ||
94 | ||
95 | ||
96 | /* | |
97 | * Power-related registers; this almost certainly belongs | |
98 | * somewhere else. | |
99 | * | |
100 | * ARMADA 610 register manual, sec 7.2.1, p1842. | |
101 | */ | |
102 | #define CPU_SUBSYS_PMU_BASE 0xd4282800 | |
103 | #define REG_CCIC_DCGCR 0x28 /* CCIC dyn clock gate ctrl reg */ | |
104 | #define REG_CCIC_CRCR 0x50 /* CCIC clk reset ctrl reg */ | |
105 | ||
106 | /* | |
107 | * Power control. | |
108 | */ | |
4a0abfaa JC |
109 | static void mmpcam_power_up_ctlr(struct mmp_camera *cam) |
110 | { | |
111 | iowrite32(0x3f, cam->power_regs + REG_CCIC_DCGCR); | |
112 | iowrite32(0x3805b, cam->power_regs + REG_CCIC_CRCR); | |
113 | mdelay(1); | |
114 | } | |
115 | ||
67a8dbbc JC |
116 | static void mmpcam_power_up(struct mcam_camera *mcam) |
117 | { | |
118 | struct mmp_camera *cam = mcam_to_cam(mcam); | |
119 | struct mmp_camera_platform_data *pdata; | |
120 | /* | |
121 | * Turn on power and clocks to the controller. | |
122 | */ | |
4a0abfaa | 123 | mmpcam_power_up_ctlr(cam); |
67a8dbbc JC |
124 | /* |
125 | * Provide power to the sensor. | |
126 | */ | |
127 | mcam_reg_write(mcam, REG_CLKCTRL, 0x60000002); | |
128 | pdata = cam->pdev->dev.platform_data; | |
129 | gpio_set_value(pdata->sensor_power_gpio, 1); | |
130 | mdelay(5); | |
131 | mcam_reg_clear_bit(mcam, REG_CTRL1, 0x10000000); | |
132 | gpio_set_value(pdata->sensor_reset_gpio, 0); /* reset is active low */ | |
133 | mdelay(5); | |
134 | gpio_set_value(pdata->sensor_reset_gpio, 1); /* reset is active low */ | |
135 | mdelay(5); | |
136 | } | |
137 | ||
138 | static void mmpcam_power_down(struct mcam_camera *mcam) | |
139 | { | |
140 | struct mmp_camera *cam = mcam_to_cam(mcam); | |
141 | struct mmp_camera_platform_data *pdata; | |
142 | /* | |
143 | * Turn off clocks and set reset lines | |
144 | */ | |
145 | iowrite32(0, cam->power_regs + REG_CCIC_DCGCR); | |
146 | iowrite32(0, cam->power_regs + REG_CCIC_CRCR); | |
147 | /* | |
148 | * Shut down the sensor. | |
149 | */ | |
150 | pdata = cam->pdev->dev.platform_data; | |
151 | gpio_set_value(pdata->sensor_power_gpio, 0); | |
152 | gpio_set_value(pdata->sensor_reset_gpio, 0); | |
153 | } | |
154 | ||
155 | ||
156 | static irqreturn_t mmpcam_irq(int irq, void *data) | |
157 | { | |
158 | struct mcam_camera *mcam = data; | |
159 | unsigned int irqs, handled; | |
160 | ||
161 | spin_lock(&mcam->dev_lock); | |
162 | irqs = mcam_reg_read(mcam, REG_IRQSTAT); | |
163 | handled = mccic_irq(mcam, irqs); | |
164 | spin_unlock(&mcam->dev_lock); | |
165 | return IRQ_RETVAL(handled); | |
166 | } | |
167 | ||
168 | ||
169 | static int mmpcam_probe(struct platform_device *pdev) | |
170 | { | |
171 | struct mmp_camera *cam; | |
172 | struct mcam_camera *mcam; | |
173 | struct resource *res; | |
174 | struct mmp_camera_platform_data *pdata; | |
175 | int ret; | |
176 | ||
177 | cam = kzalloc(sizeof(*cam), GFP_KERNEL); | |
178 | if (cam == NULL) | |
179 | return -ENOMEM; | |
180 | cam->pdev = pdev; | |
181 | INIT_LIST_HEAD(&cam->devlist); | |
182 | ||
183 | mcam = &cam->mcam; | |
67a8dbbc JC |
184 | mcam->plat_power_up = mmpcam_power_up; |
185 | mcam->plat_power_down = mmpcam_power_down; | |
186 | mcam->dev = &pdev->dev; | |
187 | mcam->use_smbus = 0; | |
188 | mcam->chip_id = V4L2_IDENT_ARMADA610; | |
28720944 | 189 | mcam->buffer_mode = B_DMA_sg; |
67a8dbbc JC |
190 | spin_lock_init(&mcam->dev_lock); |
191 | /* | |
192 | * Get our I/O memory. | |
193 | */ | |
194 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
195 | if (res == NULL) { | |
196 | dev_err(&pdev->dev, "no iomem resource!\n"); | |
197 | ret = -ENODEV; | |
198 | goto out_free; | |
199 | } | |
200 | mcam->regs = ioremap(res->start, resource_size(res)); | |
201 | if (mcam->regs == NULL) { | |
202 | dev_err(&pdev->dev, "MMIO ioremap fail\n"); | |
203 | ret = -ENODEV; | |
204 | goto out_free; | |
205 | } | |
206 | /* | |
207 | * Power/clock memory is elsewhere; get it too. Perhaps this | |
208 | * should really be managed outside of this driver? | |
209 | */ | |
210 | res = platform_get_resource(pdev, IORESOURCE_MEM, 1); | |
211 | if (res == NULL) { | |
212 | dev_err(&pdev->dev, "no power resource!\n"); | |
213 | ret = -ENODEV; | |
214 | goto out_unmap1; | |
215 | } | |
216 | cam->power_regs = ioremap(res->start, resource_size(res)); | |
217 | if (cam->power_regs == NULL) { | |
218 | dev_err(&pdev->dev, "power MMIO ioremap fail\n"); | |
219 | ret = -ENODEV; | |
220 | goto out_unmap1; | |
221 | } | |
222 | /* | |
223 | * Find the i2c adapter. This assumes, of course, that the | |
224 | * i2c bus is already up and functioning. | |
225 | */ | |
226 | pdata = pdev->dev.platform_data; | |
227 | mcam->i2c_adapter = platform_get_drvdata(pdata->i2c_device); | |
228 | if (mcam->i2c_adapter == NULL) { | |
229 | ret = -ENODEV; | |
230 | dev_err(&pdev->dev, "No i2c adapter\n"); | |
231 | goto out_unmap2; | |
232 | } | |
233 | /* | |
234 | * Sensor GPIO pins. | |
235 | */ | |
236 | ret = gpio_request(pdata->sensor_power_gpio, "cam-power"); | |
237 | if (ret) { | |
238 | dev_err(&pdev->dev, "Can't get sensor power gpio %d", | |
239 | pdata->sensor_power_gpio); | |
240 | goto out_unmap2; | |
241 | } | |
242 | gpio_direction_output(pdata->sensor_power_gpio, 0); | |
243 | ret = gpio_request(pdata->sensor_reset_gpio, "cam-reset"); | |
244 | if (ret) { | |
245 | dev_err(&pdev->dev, "Can't get sensor reset gpio %d", | |
246 | pdata->sensor_reset_gpio); | |
247 | goto out_gpio; | |
248 | } | |
249 | gpio_direction_output(pdata->sensor_reset_gpio, 0); | |
250 | /* | |
251 | * Power the device up and hand it off to the core. | |
252 | */ | |
253 | mmpcam_power_up(mcam); | |
254 | ret = mccic_register(mcam); | |
255 | if (ret) | |
256 | goto out_gpio2; | |
257 | /* | |
258 | * Finally, set up our IRQ now that the core is ready to | |
259 | * deal with it. | |
260 | */ | |
261 | res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | |
262 | if (res == NULL) { | |
263 | ret = -ENODEV; | |
264 | goto out_unregister; | |
265 | } | |
266 | cam->irq = res->start; | |
267 | ret = request_irq(cam->irq, mmpcam_irq, IRQF_SHARED, | |
268 | "mmp-camera", mcam); | |
269 | if (ret == 0) { | |
270 | mmpcam_add_device(cam); | |
271 | return 0; | |
272 | } | |
273 | ||
274 | out_unregister: | |
275 | mccic_shutdown(mcam); | |
67a8dbbc | 276 | out_gpio2: |
221a8248 | 277 | mmpcam_power_down(mcam); |
67a8dbbc JC |
278 | gpio_free(pdata->sensor_reset_gpio); |
279 | out_gpio: | |
280 | gpio_free(pdata->sensor_power_gpio); | |
281 | out_unmap2: | |
282 | iounmap(cam->power_regs); | |
283 | out_unmap1: | |
284 | iounmap(mcam->regs); | |
285 | out_free: | |
286 | kfree(cam); | |
287 | return ret; | |
288 | } | |
289 | ||
290 | ||
291 | static int mmpcam_remove(struct mmp_camera *cam) | |
292 | { | |
293 | struct mcam_camera *mcam = &cam->mcam; | |
294 | struct mmp_camera_platform_data *pdata; | |
295 | ||
296 | mmpcam_remove_device(cam); | |
297 | free_irq(cam->irq, mcam); | |
298 | mccic_shutdown(mcam); | |
299 | mmpcam_power_down(mcam); | |
300 | pdata = cam->pdev->dev.platform_data; | |
301 | gpio_free(pdata->sensor_reset_gpio); | |
302 | gpio_free(pdata->sensor_power_gpio); | |
303 | iounmap(cam->power_regs); | |
304 | iounmap(mcam->regs); | |
305 | kfree(cam); | |
306 | return 0; | |
307 | } | |
308 | ||
309 | static int mmpcam_platform_remove(struct platform_device *pdev) | |
310 | { | |
311 | struct mmp_camera *cam = mmpcam_find_device(pdev); | |
312 | ||
313 | if (cam == NULL) | |
314 | return -ENODEV; | |
315 | return mmpcam_remove(cam); | |
316 | } | |
317 | ||
bb0a896e JC |
318 | /* |
319 | * Suspend/resume support. | |
320 | */ | |
321 | #ifdef CONFIG_PM | |
322 | ||
323 | static int mmpcam_suspend(struct platform_device *pdev, pm_message_t state) | |
324 | { | |
325 | struct mmp_camera *cam = mmpcam_find_device(pdev); | |
326 | ||
327 | if (state.event != PM_EVENT_SUSPEND) | |
328 | return 0; | |
329 | mccic_suspend(&cam->mcam); | |
330 | return 0; | |
331 | } | |
332 | ||
333 | static int mmpcam_resume(struct platform_device *pdev) | |
334 | { | |
335 | struct mmp_camera *cam = mmpcam_find_device(pdev); | |
336 | ||
337 | /* | |
338 | * Power up unconditionally just in case the core tries to | |
339 | * touch a register even if nothing was active before; trust | |
340 | * me, it's better this way. | |
341 | */ | |
4a0abfaa | 342 | mmpcam_power_up_ctlr(cam); |
bb0a896e JC |
343 | return mccic_resume(&cam->mcam); |
344 | } | |
345 | ||
346 | #endif | |
347 | ||
67a8dbbc JC |
348 | |
349 | static struct platform_driver mmpcam_driver = { | |
350 | .probe = mmpcam_probe, | |
351 | .remove = mmpcam_platform_remove, | |
bb0a896e JC |
352 | #ifdef CONFIG_PM |
353 | .suspend = mmpcam_suspend, | |
354 | .resume = mmpcam_resume, | |
355 | #endif | |
67a8dbbc JC |
356 | .driver = { |
357 | .name = "mmp-camera", | |
358 | .owner = THIS_MODULE | |
359 | } | |
360 | }; | |
361 | ||
362 | ||
363 | static int __init mmpcam_init_module(void) | |
364 | { | |
365 | mutex_init(&mmpcam_devices_lock); | |
366 | return platform_driver_register(&mmpcam_driver); | |
367 | } | |
368 | ||
369 | static void __exit mmpcam_exit_module(void) | |
370 | { | |
371 | platform_driver_unregister(&mmpcam_driver); | |
372 | /* | |
373 | * platform_driver_unregister() should have emptied the list | |
374 | */ | |
375 | if (!list_empty(&mmpcam_devices)) | |
376 | printk(KERN_ERR "mmp_camera leaving devices behind\n"); | |
377 | } | |
378 | ||
379 | module_init(mmpcam_init_module); | |
380 | module_exit(mmpcam_exit_module); |