2 * Samsung TV Mixer driver
4 * Copyright (c) 2010 Samsung Electronics
6 * Tomasz Stanislawski, t.stanislaws@samsung.com
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published
10 * by the Free Software Foundiation. either version 2 of the License,
11 * or (at your option) any later version
16 #include "mixer_reg.h"
18 #include <linux/module.h>
19 #include <linux/platform_device.h>
21 #include <linux/interrupt.h>
22 #include <linux/irq.h>
24 #include <linux/delay.h>
26 MODULE_AUTHOR("Tomasz Stanislawski, t.stanislaws@samsung.com");
27 MODULE_DESCRIPTION("Samsung MIXER");
28 MODULE_LICENSE("GPL");
30 /* --------- DRIVER INITIALIZATION ---------- */
32 static struct platform_driver mxr_driver __refdata;
34 static int __init mxr_init(void)
37 static const char banner[] __initdata = KERN_INFO
38 "Samsung TV Mixer driver, (c) 2010 Samsung Electronics\n";
41 ret = platform_driver_register(&mxr_driver);
43 printk(KERN_ERR "registration of MIXER driver failed\n");
49 late_initcall(mxr_init);
51 static void __exit mxr_exit(void)
53 platform_driver_unregister(&mxr_driver);
55 module_exit(mxr_exit);
57 static int __devinit mxr_acquire_resources(struct mxr_device *mdev,
58 struct platform_device *pdev);
60 static void mxr_release_resources(struct mxr_device *mdev);
62 static int __devinit mxr_acquire_layers(struct mxr_device *mdev,
63 struct mxr_platform_data *pdata);
65 static void mxr_release_layers(struct mxr_device *mxr_dev);
67 static int __devinit mxr_probe(struct platform_device *pdev)
69 struct device *dev = &pdev->dev;
70 struct mxr_platform_data *pdata = dev->platform_data;
71 struct mxr_device *mdev;
74 dev_info(dev, "probe start\n");
77 ret = pdata->init(dev);
82 mdev = kzalloc(sizeof *mdev, GFP_KERNEL);
84 dev_err(dev, "not enough memory.\n");
89 /* setup pointer to master device */
92 mutex_init(&mdev->mutex);
93 spin_lock_init(&mdev->reg_slock);
95 /* acquire resources: regs, irqs */
96 ret = mxr_acquire_resources(mdev, pdev);
100 /* configure resources for video output */
101 ret = mxr_acquire_video(mdev, pdata);
105 /* configure layers */
106 ret = mxr_acquire_layers(mdev, pdata);
110 dev_info(dev, "probe successful\n");
114 mxr_release_video(mdev);
117 mxr_release_resources(mdev);
127 dev_info(dev, "probe failed\n");
131 static int __devexit mxr_remove(struct platform_device *pdev)
133 struct device *dev = &pdev->dev;
134 struct mxr_device *mdev = to_mdev(dev);
135 struct mxr_platform_data *pdata = dev->platform_data;
137 mxr_release_layers(mdev);
138 mxr_release_video(mdev);
139 mxr_release_resources(mdev);
146 dev_info(dev, "remove sucessful\n");
150 static struct platform_driver mxr_driver __refdata = {
152 .remove = __devexit_p(mxr_remove),
154 .name = MXR_DRIVER_NAME,
155 .owner = THIS_MODULE,
159 static int __devinit mxr_acquire_resources(struct mxr_device *mdev,
160 struct platform_device *pdev)
162 struct device *dev = &pdev->dev;
163 struct resource *res;
165 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mxr");
167 dev_err(dev, "get memory resource failed.\n");
172 mdev->mxr_regs = ioremap(res->start, resource_size(res));
173 if (mdev->mxr_regs == NULL) {
174 dev_err(dev, "register mapping failed.\n");
179 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vp");
181 dev_err(dev, "get memory resource failed.\n");
186 mdev->vp_regs = ioremap(res->start, resource_size(res));
187 if (mdev->vp_regs == NULL) {
188 dev_err(dev, "register mapping failed.\n");
193 res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "irq");
195 dev_err(dev, "get interrupt resource failed.\n");
200 ret = request_irq(res->start, mxr_irq_handler, 0, "s5p-mixer", mdev);
202 dev_err(dev, "request interrupt failed.\n");
205 mdev->irq = res->start;
206 dev_info(dev, "resources acquired\n");
211 iounmap(mdev->vp_regs);
214 iounmap(mdev->mxr_regs);
220 static void mxr_release_resources(struct mxr_device *mdev)
222 free_irq(mdev->irq, mdev);
223 iounmap(mdev->vp_regs);
224 iounmap(mdev->mxr_regs);
227 static int __devinit mxr_acquire_layers(struct mxr_device *mdev,
228 struct mxr_platform_data *pdata)
230 mdev->layer[0] = mxr_graph_layer_create(mdev, 0);
231 mdev->layer[1] = mxr_graph_layer_create(mdev, 1);
232 mdev->layer[2] = mxr_vp_layer_create(mdev, 0);
234 if (!mdev->layer[0] || !mdev->layer[1] || !mdev->layer[2]) {
235 dev_err(mdev->dev, "failed to acquire layers\n");
242 mxr_release_layers(mdev);
246 static void mxr_release_layers(struct mxr_device *mdev)
249 for (i = 0; i < ARRAY_SIZE(mdev->layer); ++i)
251 mxr_layer_release(mdev->layer[i]);
254 void mxr_power_get(struct mxr_device *mdev)
256 struct device *dev = mdev->dev;
257 struct mxr_platform_data *pdata = dev->platform_data;
259 mutex_lock(&mdev->mutex);
261 dev_info(mdev->dev, "%s(%d)\n", __func__, mdev->n_power);
262 if (mdev->n_power == 1) {
264 dev_info(dev, "pdata->power_setup = %p\n", pdata->power_setup);
265 if (pdata->power_setup)
266 pdata->power_setup(dev, 1);
267 /* apply default configuration */
269 v4l2_subdev_call(to_outsd(mdev), core, s_power, 1);
271 mutex_unlock(&mdev->mutex);
274 void mxr_power_put(struct mxr_device *mdev)
276 struct device *dev = mdev->dev;
277 struct mxr_platform_data *pdata = dev->platform_data;
279 mutex_lock(&mdev->mutex);
281 dev_info(mdev->dev, "%s(%d)\n", __func__, mdev->n_power);
282 if (mdev->n_power == 0) {
283 /* __mxr_reg_deinit(mdev); */
284 if (pdata->power_setup)
285 pdata->power_setup(dev, 0);
287 v4l2_subdev_call(to_outsd(mdev), core, s_power, 0);
289 WARN(mdev->n_power < 0, "negative number of power users (%d)\n",
291 mutex_unlock(&mdev->mutex);
294 void mxr_get_mbus_fmt(struct mxr_device *mdev,
295 struct v4l2_mbus_framefmt *mbus_fmt)
297 struct v4l2_subdev *sd;
299 mutex_lock(&mdev->mutex);
301 ret = v4l2_subdev_call(sd, video, g_mbus_fmt, mbus_fmt);
302 WARN(ret, "failed to get mbus_fmt for output %s\n", sd->name);
303 mutex_unlock(&mdev->mutex);
306 void mxr_streamer_get(struct mxr_device *mdev)
308 mutex_lock(&mdev->mutex);
310 dev_info(mdev->dev, "%s(%d)\n", __func__, mdev->n_streamer);
311 if (mdev->n_streamer == 1) {
312 struct v4l2_subdev *sd = to_outsd(mdev);
313 struct v4l2_mbus_framefmt mbus_fmt;
315 ret = v4l2_subdev_call(sd, video, g_mbus_fmt, &mbus_fmt);
316 WARN(ret, "failed to get mbus_fmt for output %s\n", sd->name);
317 mxr_reg_set_mbus_fmt(mdev, &mbus_fmt);
318 mxr_reg_streamon(mdev);
319 ret = v4l2_subdev_call(sd, video, s_stream, 1);
320 WARN(ret, "starting stream failed for output %s\n", sd->name);
322 mutex_unlock(&mdev->mutex);
324 /* FIXME: what to do when streaming fails? */
327 void mxr_streamer_put(struct mxr_device *mdev)
329 mutex_lock(&mdev->mutex);
331 dev_info(mdev->dev, "%s(%d)\n", __func__, mdev->n_streamer);
332 if (mdev->n_streamer == 0) {
334 struct v4l2_subdev *sd = to_outsd(mdev);
335 mxr_reg_streamoff(mdev);
336 ret = v4l2_subdev_call(sd, video, s_stream, 0);
337 WARN(ret, "stopping stream failed for output %s\n", sd->name);
339 WARN(mdev->n_streamer < 0, "negative number of streamers (%d)\n",
341 mutex_unlock(&mdev->mutex);
345 void mxr_output_get(struct mxr_device *mdev)
347 mutex_lock(&mdev->mutex);
349 dev_info(mdev->dev, "%s(%d)\n", __func__, mdev->n_output);
350 mutex_unlock(&mdev->mutex);
353 void mxr_output_put(struct mxr_device *mdev)
355 mutex_lock(&mdev->mutex);
357 dev_info(mdev->dev, "%s(%d)\n", __func__, mdev->n_output);
358 WARN(mdev->n_output < 0, "negative number of output users (%d)\n",
360 mutex_unlock(&mdev->mutex);