| /linux-4.4.14/drivers/media/platform/exynos-gsc/ |
| H A D | Makefile | 1 exynos-gsc-objs := gsc-core.o gsc-m2m.o gsc-regs.o
3 obj-$(CONFIG_VIDEO_SAMSUNG_EXYNOS_GSC) += exynos-gsc.o
|
| H A D | gsc-m2m.c | 29 #include "gsc-core.h"
34 struct gsc_dev *gsc = ctx->gsc_dev; gsc_m2m_ctx_stop_req() local
37 curr_ctx = v4l2_m2m_get_curr_priv(gsc->m2m.m2m_dev); gsc_m2m_ctx_stop_req()
38 if (!gsc_m2m_pending(gsc) || (curr_ctx != ctx)) gsc_m2m_ctx_stop_req()
42 ret = wait_event_timeout(gsc->irq_queue, gsc_m2m_ctx_stop_req()
136 struct gsc_dev *gsc; gsc_m2m_device_run() local
144 gsc = ctx->gsc_dev; gsc_m2m_device_run()
145 spin_lock_irqsave(&gsc->slock, flags); gsc_m2m_device_run()
147 set_bit(ST_M2M_PEND, &gsc->state); gsc_m2m_device_run()
150 if (gsc->m2m.ctx != ctx) { gsc_m2m_device_run()
151 pr_debug("gsc->m2m.ctx = 0x%p, current_ctx = 0x%p", gsc_m2m_device_run()
152 gsc->m2m.ctx, ctx); gsc_m2m_device_run()
154 gsc->m2m.ctx = ctx; gsc_m2m_device_run()
161 wake_up(&gsc->irq_queue); gsc_m2m_device_run()
171 gsc_set_prefbuf(gsc, &ctx->s_frame); gsc_m2m_device_run()
172 gsc_hw_set_input_addr(gsc, &ctx->s_frame.addr, GSC_M2M_BUF_NUM); gsc_m2m_device_run()
173 gsc_hw_set_output_addr(gsc, &ctx->d_frame.addr, GSC_M2M_BUF_NUM); gsc_m2m_device_run()
176 gsc_hw_set_input_buf_masking(gsc, GSC_M2M_BUF_NUM, false); gsc_m2m_device_run()
177 gsc_hw_set_output_buf_masking(gsc, GSC_M2M_BUF_NUM, false); gsc_m2m_device_run()
178 gsc_hw_set_frm_done_irq_mask(gsc, false); gsc_m2m_device_run()
179 gsc_hw_set_gsc_irq_enable(gsc, true); gsc_m2m_device_run()
204 gsc_hw_enable_control(gsc, true); gsc_m2m_device_run()
206 spin_unlock_irqrestore(&gsc->slock, flags); gsc_m2m_device_run()
211 spin_unlock_irqrestore(&gsc->slock, flags); gsc_m2m_device_run()
281 struct gsc_dev *gsc = ctx->gsc_dev; gsc_m2m_querycap() local
283 strlcpy(cap->driver, gsc->pdev->name, sizeof(cap->driver)); gsc_m2m_querycap()
284 strlcpy(cap->card, gsc->pdev->name, sizeof(cap->card)); gsc_m2m_querycap()
365 struct gsc_dev *gsc = ctx->gsc_dev; gsc_m2m_reqbufs() local
369 gsc->variant->in_buf_cnt : gsc->variant->out_buf_cnt; gsc_m2m_reqbufs()
615 struct gsc_dev *gsc = video_drvdata(file); gsc_m2m_open() local
619 pr_debug("pid: %d, state: 0x%lx", task_pid_nr(current), gsc->state); gsc_m2m_open()
621 if (mutex_lock_interruptible(&gsc->lock)) gsc_m2m_open()
630 v4l2_fh_init(&ctx->fh, gsc->m2m.vfd); gsc_m2m_open()
640 ctx->gsc_dev = gsc; gsc_m2m_open()
650 ctx->m2m_ctx = v4l2_m2m_ctx_init(gsc->m2m.m2m_dev, ctx, queue_init); gsc_m2m_open()
657 if (gsc->m2m.refcnt++ == 0) gsc_m2m_open()
658 set_bit(ST_M2M_OPEN, &gsc->state); gsc_m2m_open()
660 pr_debug("gsc m2m driver is opened, ctx(0x%p)", ctx); gsc_m2m_open()
662 mutex_unlock(&gsc->lock); gsc_m2m_open()
672 mutex_unlock(&gsc->lock); gsc_m2m_open()
679 struct gsc_dev *gsc = ctx->gsc_dev; gsc_m2m_release() local
682 task_pid_nr(current), gsc->state, gsc->m2m.refcnt); gsc_m2m_release()
684 mutex_lock(&gsc->lock); gsc_m2m_release()
691 if (--gsc->m2m.refcnt <= 0) gsc_m2m_release()
692 clear_bit(ST_M2M_OPEN, &gsc->state); gsc_m2m_release()
695 mutex_unlock(&gsc->lock); gsc_m2m_release()
703 struct gsc_dev *gsc = ctx->gsc_dev; gsc_m2m_poll() local
706 if (mutex_lock_interruptible(&gsc->lock)) gsc_m2m_poll()
710 mutex_unlock(&gsc->lock); gsc_m2m_poll()
718 struct gsc_dev *gsc = ctx->gsc_dev; gsc_m2m_mmap() local
721 if (mutex_lock_interruptible(&gsc->lock)) gsc_m2m_mmap()
725 mutex_unlock(&gsc->lock); gsc_m2m_mmap()
744 int gsc_register_m2m_device(struct gsc_dev *gsc) gsc_register_m2m_device() argument
749 if (!gsc) gsc_register_m2m_device()
752 pdev = gsc->pdev; gsc_register_m2m_device()
754 gsc->vdev.fops = &gsc_m2m_fops; gsc_register_m2m_device()
755 gsc->vdev.ioctl_ops = &gsc_m2m_ioctl_ops; gsc_register_m2m_device()
756 gsc->vdev.release = video_device_release_empty; gsc_register_m2m_device()
757 gsc->vdev.lock = &gsc->lock; gsc_register_m2m_device()
758 gsc->vdev.vfl_dir = VFL_DIR_M2M; gsc_register_m2m_device()
759 gsc->vdev.v4l2_dev = &gsc->v4l2_dev; gsc_register_m2m_device()
760 snprintf(gsc->vdev.name, sizeof(gsc->vdev.name), "%s.%d:m2m", gsc_register_m2m_device()
761 GSC_MODULE_NAME, gsc->id); gsc_register_m2m_device()
763 video_set_drvdata(&gsc->vdev, gsc); gsc_register_m2m_device()
765 gsc->m2m.vfd = &gsc->vdev; gsc_register_m2m_device()
766 gsc->m2m.m2m_dev = v4l2_m2m_init(&gsc_m2m_ops); gsc_register_m2m_device()
767 if (IS_ERR(gsc->m2m.m2m_dev)) { gsc_register_m2m_device()
769 ret = PTR_ERR(gsc->m2m.m2m_dev); gsc_register_m2m_device()
773 ret = video_register_device(&gsc->vdev, VFL_TYPE_GRABBER, -1); gsc_register_m2m_device()
780 pr_debug("gsc m2m driver registered as /dev/video%d", gsc->vdev.num); gsc_register_m2m_device()
784 v4l2_m2m_release(gsc->m2m.m2m_dev); gsc_register_m2m_device()
786 video_device_release(gsc->m2m.vfd); gsc_register_m2m_device()
791 void gsc_unregister_m2m_device(struct gsc_dev *gsc) gsc_unregister_m2m_device() argument
793 if (gsc) gsc_unregister_m2m_device()
794 v4l2_m2m_release(gsc->m2m.m2m_dev); gsc_unregister_m2m_device()
|
| H A D | gsc-core.c | 29 #include "gsc-core.h"
340 void gsc_set_prefbuf(struct gsc_dev *gsc, struct gsc_frame *frm) gsc_set_prefbuf() argument
392 struct gsc_dev *gsc = ctx->gsc_dev; gsc_try_fmt_mplane() local
393 struct gsc_variant *variant = gsc->variant; gsc_try_fmt_mplane()
522 struct gsc_dev *gsc = ctx->gsc_dev; gsc_try_crop() local
523 struct gsc_variant *variant = gsc->variant; gsc_try_crop()
702 struct gsc_dev *gsc = ctx->gsc_dev; __gsc_s_ctrl() local
703 struct gsc_variant *variant = gsc->variant; __gsc_s_ctrl()
866 struct gsc_dev *gsc = priv; gsc_irq_handler() local
870 gsc_irq = gsc_hw_get_irq_status(gsc); gsc_irq_handler()
871 gsc_hw_clear_irq(gsc, gsc_irq); gsc_irq_handler()
878 spin_lock(&gsc->slock); gsc_irq_handler()
880 if (test_and_clear_bit(ST_M2M_PEND, &gsc->state)) { gsc_irq_handler()
882 gsc_hw_enable_control(gsc, false); gsc_irq_handler()
884 if (test_and_clear_bit(ST_M2M_SUSPENDING, &gsc->state)) { gsc_irq_handler()
885 set_bit(ST_M2M_SUSPENDED, &gsc->state); gsc_irq_handler()
886 wake_up(&gsc->irq_queue); gsc_irq_handler()
889 ctx = v4l2_m2m_get_curr_priv(gsc->m2m.m2m_dev); gsc_irq_handler()
894 spin_unlock(&gsc->slock); gsc_irq_handler()
900 wake_up(&gsc->irq_queue); gsc_irq_handler()
906 spin_unlock(&gsc->slock); gsc_irq_handler()
972 .name = "exynos-gsc",
981 .compatible = "samsung,exynos5-gsc",
1006 static void gsc_clk_put(struct gsc_dev *gsc) gsc_clk_put() argument
1008 if (!IS_ERR(gsc->clock)) gsc_clk_put()
1009 clk_unprepare(gsc->clock); gsc_clk_put()
1012 static int gsc_clk_get(struct gsc_dev *gsc) gsc_clk_get() argument
1016 dev_dbg(&gsc->pdev->dev, "gsc_clk_get Called\n"); gsc_clk_get()
1018 gsc->clock = devm_clk_get(&gsc->pdev->dev, GSC_CLOCK_GATE_NAME); gsc_clk_get()
1019 if (IS_ERR(gsc->clock)) { gsc_clk_get()
1020 dev_err(&gsc->pdev->dev, "failed to get clock~~~: %s\n", gsc_clk_get()
1022 return PTR_ERR(gsc->clock); gsc_clk_get()
1025 ret = clk_prepare(gsc->clock); gsc_clk_get()
1027 dev_err(&gsc->pdev->dev, "clock prepare failed for clock: %s\n", gsc_clk_get()
1029 gsc->clock = ERR_PTR(-EINVAL); gsc_clk_get()
1036 static int gsc_m2m_suspend(struct gsc_dev *gsc) gsc_m2m_suspend() argument
1041 spin_lock_irqsave(&gsc->slock, flags); gsc_m2m_suspend()
1042 if (!gsc_m2m_pending(gsc)) { gsc_m2m_suspend()
1043 spin_unlock_irqrestore(&gsc->slock, flags); gsc_m2m_suspend()
1046 clear_bit(ST_M2M_SUSPENDED, &gsc->state); gsc_m2m_suspend()
1047 set_bit(ST_M2M_SUSPENDING, &gsc->state); gsc_m2m_suspend()
1048 spin_unlock_irqrestore(&gsc->slock, flags); gsc_m2m_suspend()
1050 timeout = wait_event_timeout(gsc->irq_queue, gsc_m2m_suspend()
1051 test_bit(ST_M2M_SUSPENDED, &gsc->state), gsc_m2m_suspend()
1054 clear_bit(ST_M2M_SUSPENDING, &gsc->state); gsc_m2m_suspend()
1058 static int gsc_m2m_resume(struct gsc_dev *gsc) gsc_m2m_resume() argument
1063 spin_lock_irqsave(&gsc->slock, flags); gsc_m2m_resume()
1065 ctx = gsc->m2m.ctx; gsc_m2m_resume()
1066 gsc->m2m.ctx = NULL; gsc_m2m_resume()
1067 spin_unlock_irqrestore(&gsc->slock, flags); gsc_m2m_resume()
1069 if (test_and_clear_bit(ST_M2M_SUSPENDED, &gsc->state)) gsc_m2m_resume()
1077 struct gsc_dev *gsc; gsc_probe() local
1083 gsc = devm_kzalloc(dev, sizeof(struct gsc_dev), GFP_KERNEL); gsc_probe()
1084 if (!gsc) gsc_probe()
1088 gsc->id = of_alias_get_id(pdev->dev.of_node, "gsc"); gsc_probe()
1090 gsc->id = pdev->id; gsc_probe()
1092 if (gsc->id >= drv_data->num_entities) { gsc_probe()
1093 dev_err(dev, "Invalid platform device id: %d\n", gsc->id); gsc_probe()
1097 gsc->variant = drv_data->variant[gsc->id]; gsc_probe()
1098 gsc->pdev = pdev; gsc_probe()
1099 gsc->pdata = dev->platform_data; gsc_probe()
1101 init_waitqueue_head(&gsc->irq_queue); gsc_probe()
1102 spin_lock_init(&gsc->slock); gsc_probe()
1103 mutex_init(&gsc->lock); gsc_probe()
1104 gsc->clock = ERR_PTR(-EINVAL); gsc_probe()
1107 gsc->regs = devm_ioremap_resource(dev, res); gsc_probe()
1108 if (IS_ERR(gsc->regs)) gsc_probe()
1109 return PTR_ERR(gsc->regs); gsc_probe()
1117 ret = gsc_clk_get(gsc); gsc_probe()
1122 0, pdev->name, gsc); gsc_probe()
1128 ret = v4l2_device_register(dev, &gsc->v4l2_dev); gsc_probe()
1132 ret = gsc_register_m2m_device(gsc); gsc_probe()
1136 platform_set_drvdata(pdev, gsc); gsc_probe()
1143 gsc->alloc_ctx = vb2_dma_contig_init_ctx(dev); gsc_probe()
1144 if (IS_ERR(gsc->alloc_ctx)) { gsc_probe()
1145 ret = PTR_ERR(gsc->alloc_ctx); gsc_probe()
1149 dev_dbg(dev, "gsc-%d registered successfully\n", gsc->id); gsc_probe()
1156 gsc_unregister_m2m_device(gsc); gsc_probe()
1158 v4l2_device_unregister(&gsc->v4l2_dev); gsc_probe()
1160 gsc_clk_put(gsc); gsc_probe()
1166 struct gsc_dev *gsc = platform_get_drvdata(pdev); gsc_remove() local
1168 gsc_unregister_m2m_device(gsc); gsc_remove()
1169 v4l2_device_unregister(&gsc->v4l2_dev); gsc_remove()
1171 vb2_dma_contig_cleanup_ctx(gsc->alloc_ctx); gsc_remove()
1173 gsc_clk_put(gsc); gsc_remove()
1181 struct gsc_dev *gsc = dev_get_drvdata(dev); gsc_runtime_resume() local
1184 pr_debug("gsc%d: state: 0x%lx", gsc->id, gsc->state); gsc_runtime_resume()
1186 ret = clk_enable(gsc->clock); gsc_runtime_resume()
1190 gsc_hw_set_sw_reset(gsc); gsc_runtime_resume()
1191 gsc_wait_reset(gsc); gsc_runtime_resume()
1193 return gsc_m2m_resume(gsc); gsc_runtime_resume()
1198 struct gsc_dev *gsc = dev_get_drvdata(dev); gsc_runtime_suspend() local
1201 ret = gsc_m2m_suspend(gsc); gsc_runtime_suspend()
1203 clk_disable(gsc->clock); gsc_runtime_suspend()
1205 pr_debug("gsc%d: state: 0x%lx", gsc->id, gsc->state); gsc_runtime_suspend()
1211 struct gsc_dev *gsc = dev_get_drvdata(dev); gsc_resume() local
1214 pr_debug("gsc%d: state: 0x%lx", gsc->id, gsc->state); gsc_resume()
1217 spin_lock_irqsave(&gsc->slock, flags); gsc_resume()
1218 if (!test_and_clear_bit(ST_SUSPEND, &gsc->state) || gsc_resume()
1219 !gsc_m2m_opened(gsc)) { gsc_resume()
1220 spin_unlock_irqrestore(&gsc->slock, flags); gsc_resume()
1223 spin_unlock_irqrestore(&gsc->slock, flags); gsc_resume()
1233 struct gsc_dev *gsc = dev_get_drvdata(dev); gsc_suspend() local
1235 pr_debug("gsc%d: state: 0x%lx", gsc->id, gsc->state); gsc_suspend()
1237 if (test_and_set_bit(ST_SUSPEND, &gsc->state)) gsc_suspend()
|
| H A D | gsc-core.h | 29 #include "gsc-regs.h"
32 #define GSC_MODULE_NAME "exynos-gsc"
385 void gsc_set_prefbuf(struct gsc_dev *gsc, struct gsc_frame *frm);
386 int gsc_register_m2m_device(struct gsc_dev *gsc);
387 void gsc_unregister_m2m_device(struct gsc_dev *gsc);
|
| H A D | gsc-regs.c | 16 #include "gsc-core.h"
|
| /linux-4.4.14/drivers/parisc/ |
| H A D | gsc.h | 2 * drivers/parisc/gsc.h
3 * Declarations for functions in gsc.c
29 struct parisc_device *gsc; member in struct:gsc_asic
|
| H A D | gsc.c | 27 #include "gsc.h"
210 gsc_asic->gsc = parent; gsc_common_setup()
|
| H A D | asp.c | 22 #include "gsc.h"
|
| H A D | wax.c | 25 #include "gsc.h"
|
| H A D | lasi.c | 29 #include "gsc.h"
|
| H A D | dino.c | 61 #include "gsc.h"
|
| /linux-4.4.14/drivers/gpu/drm/exynos/ |
| H A D | exynos_drm_gsc.c | 22 #include "regs-gsc.h"
124 * A structure of gsc context.
130 * @gsc_clk: gsc gate clock.
132 * @id: gsc id.
416 DRM_ERROR("failed to reset gsc h/w.\n"); gsc_sw_reset()
1234 DRM_DEBUG_KMS("gsc id[%d]\n", ctx->id); gsc_get_src_buf_index()
1269 DRM_DEBUG_KMS("gsc id[%d]\n", ctx->id); gsc_get_dst_buf_index()
1308 DRM_DEBUG_KMS("gsc id[%d]\n", ctx->id); gsc_irq_handler()
1669 dev_err(dev, "failed to get gsc clock.\n"); gsc_probe()
1721 dev_err(dev, "failed to register drm gsc device.\n"); gsc_probe()
1725 dev_info(dev, "drm gsc registered successfully.\n"); gsc_probe()
1804 .name = "exynos-drm-gsc",
|
| H A D | regs-gsc.h | 1 /* linux/drivers/gpu/drm/exynos/regs-gsc.h
|
| /linux-4.4.14/arch/parisc/kernel/ |
| H A D | setup.c | 51 /* Intended for ccio/sba/cpu statistics under /proc/bus/{runway|gsc} */
222 proc_gsc_root = proc_mkdir("bus/gsc", NULL); parisc_proc_mkdir()
246 * I'm assuming they have neither gsc nor runway */ parisc_proc_mkdir()
|
| H A D | pci-dma.c | 399 proc_gsc_root = proc_mkdir("gsc", NULL); pcxl_dma_init()
402 "pcxl_dma_init: Unable to create gsc /proc dir entry\n"); pcxl_dma_init()
|
| /linux-4.4.14/drivers/scsi/ |
| H A D | zalon.c | 13 #include "../parisc/gsc.h"
|
| /linux-4.4.14/drivers/input/serio/ |
| H A D | gscps2.c | 359 snprintf(serio->name, sizeof(serio->name), "gsc-ps2-%s", gscps2_probe()
|