1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Support for Intel Camera Imaging ISP subsystem.
4 * Copyright (c) 2015, Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16 #ifndef __ISP_PRIVATE_H_INCLUDED__
17 #define __ISP_PRIVATE_H_INCLUDED__
18
19 #ifdef HRT_MEMORY_ACCESS
20 #include <hrt/api.h>
21 #endif
22
23 #include "isp_public.h"
24
25 #include "device_access.h"
26
27 #include "assert_support.h"
28 #include "type_support.h"
29
isp_ctrl_store(const isp_ID_t ID,const unsigned int reg,const hrt_data value)30 STORAGE_CLASS_ISP_C void isp_ctrl_store(
31 const isp_ID_t ID,
32 const unsigned int reg,
33 const hrt_data value)
34 {
35 assert(ID < N_ISP_ID);
36 assert(ISP_CTRL_BASE[ID] != (hrt_address) - 1);
37 #if !defined(HRT_MEMORY_ACCESS)
38 ia_css_device_store_uint32(ISP_CTRL_BASE[ID] + reg * sizeof(hrt_data), value);
39 #else
40 hrt_master_port_store_32(ISP_CTRL_BASE[ID] + reg * sizeof(hrt_data), value);
41 #endif
42 return;
43 }
44
isp_ctrl_load(const isp_ID_t ID,const unsigned int reg)45 STORAGE_CLASS_ISP_C hrt_data isp_ctrl_load(
46 const isp_ID_t ID,
47 const unsigned int reg)
48 {
49 assert(ID < N_ISP_ID);
50 assert(ISP_CTRL_BASE[ID] != (hrt_address) - 1);
51 #if !defined(HRT_MEMORY_ACCESS)
52 return ia_css_device_load_uint32(ISP_CTRL_BASE[ID] + reg * sizeof(hrt_data));
53 #else
54 return hrt_master_port_uload_32(ISP_CTRL_BASE[ID] + reg * sizeof(hrt_data));
55 #endif
56 }
57
isp_ctrl_getbit(const isp_ID_t ID,const unsigned int reg,const unsigned int bit)58 STORAGE_CLASS_ISP_C bool isp_ctrl_getbit(
59 const isp_ID_t ID,
60 const unsigned int reg,
61 const unsigned int bit)
62 {
63 hrt_data val = isp_ctrl_load(ID, reg);
64
65 return (val & (1UL << bit)) != 0;
66 }
67
isp_ctrl_setbit(const isp_ID_t ID,const unsigned int reg,const unsigned int bit)68 STORAGE_CLASS_ISP_C void isp_ctrl_setbit(
69 const isp_ID_t ID,
70 const unsigned int reg,
71 const unsigned int bit)
72 {
73 hrt_data data = isp_ctrl_load(ID, reg);
74
75 isp_ctrl_store(ID, reg, (data | (1UL << bit)));
76 return;
77 }
78
isp_ctrl_clearbit(const isp_ID_t ID,const unsigned int reg,const unsigned int bit)79 STORAGE_CLASS_ISP_C void isp_ctrl_clearbit(
80 const isp_ID_t ID,
81 const unsigned int reg,
82 const unsigned int bit)
83 {
84 hrt_data data = isp_ctrl_load(ID, reg);
85
86 isp_ctrl_store(ID, reg, (data & ~(1UL << bit)));
87 return;
88 }
89
isp_dmem_store(const isp_ID_t ID,unsigned int addr,const void * data,const size_t size)90 STORAGE_CLASS_ISP_C void isp_dmem_store(
91 const isp_ID_t ID,
92 unsigned int addr,
93 const void *data,
94 const size_t size)
95 {
96 assert(ID < N_ISP_ID);
97 assert(ISP_DMEM_BASE[ID] != (hrt_address) - 1);
98 #if !defined(HRT_MEMORY_ACCESS)
99 ia_css_device_store(ISP_DMEM_BASE[ID] + addr, data, size);
100 #else
101 hrt_master_port_store(ISP_DMEM_BASE[ID] + addr, data, size);
102 #endif
103 return;
104 }
105
isp_dmem_load(const isp_ID_t ID,const unsigned int addr,void * data,const size_t size)106 STORAGE_CLASS_ISP_C void isp_dmem_load(
107 const isp_ID_t ID,
108 const unsigned int addr,
109 void *data,
110 const size_t size)
111 {
112 assert(ID < N_ISP_ID);
113 assert(ISP_DMEM_BASE[ID] != (hrt_address) - 1);
114 #if !defined(HRT_MEMORY_ACCESS)
115 ia_css_device_load(ISP_DMEM_BASE[ID] + addr, data, size);
116 #else
117 hrt_master_port_load(ISP_DMEM_BASE[ID] + addr, data, size);
118 #endif
119 return;
120 }
121
isp_dmem_store_uint32(const isp_ID_t ID,unsigned int addr,const uint32_t data)122 STORAGE_CLASS_ISP_C void isp_dmem_store_uint32(
123 const isp_ID_t ID,
124 unsigned int addr,
125 const uint32_t data)
126 {
127 assert(ID < N_ISP_ID);
128 assert(ISP_DMEM_BASE[ID] != (hrt_address) - 1);
129 (void)ID;
130 #if !defined(HRT_MEMORY_ACCESS)
131 ia_css_device_store_uint32(ISP_DMEM_BASE[ID] + addr, data);
132 #else
133 hrt_master_port_store_32(ISP_DMEM_BASE[ID] + addr, data);
134 #endif
135 return;
136 }
137
isp_dmem_load_uint32(const isp_ID_t ID,const unsigned int addr)138 STORAGE_CLASS_ISP_C uint32_t isp_dmem_load_uint32(
139 const isp_ID_t ID,
140 const unsigned int addr)
141 {
142 assert(ID < N_ISP_ID);
143 assert(ISP_DMEM_BASE[ID] != (hrt_address) - 1);
144 (void)ID;
145 #if !defined(HRT_MEMORY_ACCESS)
146 return ia_css_device_load_uint32(ISP_DMEM_BASE[ID] + addr);
147 #else
148 return hrt_master_port_uload_32(ISP_DMEM_BASE[ID] + addr);
149 #endif
150 }
151
isp_2w_cat_1w(const u16 x0,const uint16_t x1)152 STORAGE_CLASS_ISP_C uint32_t isp_2w_cat_1w(
153 const u16 x0,
154 const uint16_t x1)
155 {
156 u32 out = ((uint32_t)(x1 & HIVE_ISP_VMEM_MASK) << ISP_VMEM_ELEMBITS)
157 | (x0 & HIVE_ISP_VMEM_MASK);
158 return out;
159 }
160
161 #endif /* __ISP_PRIVATE_H_INCLUDED__ */
162