]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
401998fa MCC |
2 | /* |
3 | * | |
4 | * V 4 L 2 D R I V E R H E L P E R A P I | |
5 | * | |
6 | * Moved from videodev2.h | |
7 | * | |
8 | * Some commonly needed functions for drivers (v4l2-common.o module) | |
9 | */ | |
10 | #ifndef _V4L2_DEV_H | |
11 | #define _V4L2_DEV_H | |
12 | ||
401998fa MCC |
13 | #include <linux/poll.h> |
14 | #include <linux/fs.h> | |
15 | #include <linux/device.h> | |
7f8ecfab | 16 | #include <linux/cdev.h> |
401998fa | 17 | #include <linux/mutex.h> |
401998fa | 18 | #include <linux/videodev2.h> |
401998fa | 19 | |
2c0ab67b LP |
20 | #include <media/media-entity.h> |
21 | ||
401998fa | 22 | #define VIDEO_MAJOR 81 |
bfa8a273 | 23 | |
401998fa MCC |
24 | #define VFL_TYPE_GRABBER 0 |
25 | #define VFL_TYPE_VBI 1 | |
26 | #define VFL_TYPE_RADIO 2 | |
2096a5dc | 27 | #define VFL_TYPE_SUBDEV 3 |
d42626bd | 28 | #define VFL_TYPE_SDR 4 |
b2fe22d0 ND |
29 | #define VFL_TYPE_TOUCH 5 |
30 | #define VFL_TYPE_MAX 6 | |
401998fa | 31 | |
5c77879f HV |
32 | /* Is this a receiver, transmitter or mem-to-mem? */ |
33 | /* Ignored for VFL_TYPE_SUBDEV. */ | |
34 | #define VFL_DIR_RX 0 | |
35 | #define VFL_DIR_TX 1 | |
36 | #define VFL_DIR_M2M 2 | |
37 | ||
a399810c | 38 | struct v4l2_ioctl_callbacks; |
bec43661 | 39 | struct video_device; |
9bea3514 | 40 | struct v4l2_device; |
0996517c | 41 | struct v4l2_ctrl_handler; |
a399810c | 42 | |
957b4aa9 LP |
43 | /* Flag to mark the video_device struct as registered. |
44 | Drivers can clear this flag if they want to block all future | |
45 | device access. It is cleared by video_unregister_device. */ | |
46 | #define V4L2_FL_REGISTERED (0) | |
b1a873a3 | 47 | /* file->private_data points to struct v4l2_fh */ |
1babcb46 | 48 | #define V4L2_FL_USES_V4L2_FH (1) |
dc93a70c | 49 | |
02265493 HV |
50 | /* Priority helper functions */ |
51 | ||
d9d3d176 MCC |
52 | /** |
53 | * struct v4l2_prio_state - stores the priority states | |
54 | * | |
55 | * @prios: array with elements to store the array priorities | |
56 | * | |
57 | * | |
58 | * .. note:: | |
59 | * The size of @prios array matches the number of priority types defined | |
ffa0441e | 60 | * by enum &v4l2_priority. |
d9d3d176 | 61 | */ |
02265493 HV |
62 | struct v4l2_prio_state { |
63 | atomic_t prios[4]; | |
64 | }; | |
65 | ||
d9d3d176 MCC |
66 | /** |
67 | * v4l2_prio_init - initializes a struct v4l2_prio_state | |
68 | * | |
69 | * @global: pointer to &struct v4l2_prio_state | |
70 | */ | |
02265493 | 71 | void v4l2_prio_init(struct v4l2_prio_state *global); |
d9d3d176 MCC |
72 | |
73 | /** | |
74 | * v4l2_prio_change - changes the v4l2 file handler priority | |
75 | * | |
76 | * @global: pointer to the &struct v4l2_prio_state of the device node. | |
ffa0441e MCC |
77 | * @local: pointer to the desired priority, as defined by enum &v4l2_priority |
78 | * @new: Priority type requested, as defined by enum &v4l2_priority. | |
d9d3d176 MCC |
79 | * |
80 | * .. note:: | |
81 | * This function should be used only by the V4L2 core. | |
82 | */ | |
02265493 HV |
83 | int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local, |
84 | enum v4l2_priority new); | |
d9d3d176 MCC |
85 | |
86 | /** | |
87 | * v4l2_prio_open - Implements the priority logic for a file handler open | |
88 | * | |
89 | * @global: pointer to the &struct v4l2_prio_state of the device node. | |
ffa0441e | 90 | * @local: pointer to the desired priority, as defined by enum &v4l2_priority |
d9d3d176 MCC |
91 | * |
92 | * .. note:: | |
93 | * This function should be used only by the V4L2 core. | |
94 | */ | |
02265493 | 95 | void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local); |
d9d3d176 MCC |
96 | |
97 | /** | |
98 | * v4l2_prio_close - Implements the priority logic for a file handler close | |
99 | * | |
100 | * @global: pointer to the &struct v4l2_prio_state of the device node. | |
ffa0441e | 101 | * @local: priority to be released, as defined by enum &v4l2_priority |
d9d3d176 MCC |
102 | * |
103 | * .. note:: | |
104 | * This function should be used only by the V4L2 core. | |
105 | */ | |
02265493 | 106 | void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local); |
d9d3d176 MCC |
107 | |
108 | /** | |
109 | * v4l2_prio_max - Return the maximum priority, as stored at the @global array. | |
110 | * | |
111 | * @global: pointer to the &struct v4l2_prio_state of the device node. | |
112 | * | |
113 | * .. note:: | |
114 | * This function should be used only by the V4L2 core. | |
115 | */ | |
02265493 | 116 | enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global); |
02265493 | 117 | |
d9d3d176 | 118 | /** |
e383ce07 | 119 | * v4l2_prio_check - Implements the priority logic for a file handler close |
d9d3d176 MCC |
120 | * |
121 | * @global: pointer to the &struct v4l2_prio_state of the device node. | |
ffa0441e | 122 | * @local: desired priority, as defined by enum &v4l2_priority local |
d9d3d176 MCC |
123 | * |
124 | * .. note:: | |
125 | * This function should be used only by the V4L2 core. | |
126 | */ | |
127 | int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local); | |
02265493 | 128 | |
d9d3d176 MCC |
129 | /** |
130 | * struct v4l2_file_operations - fs operations used by a V4L2 device | |
131 | * | |
132 | * @owner: pointer to struct module | |
133 | * @read: operations needed to implement the read() syscall | |
134 | * @write: operations needed to implement the write() syscall | |
135 | * @poll: operations needed to implement the poll() syscall | |
136 | * @unlocked_ioctl: operations needed to implement the ioctl() syscall | |
137 | * @compat_ioctl32: operations needed to implement the ioctl() syscall for | |
138 | * the special case where the Kernel uses 64 bits instructions, but | |
139 | * the userspace uses 32 bits. | |
140 | * @get_unmapped_area: called by the mmap() syscall, used when %!CONFIG_MMU | |
141 | * @mmap: operations needed to implement the mmap() syscall | |
142 | * @open: operations needed to implement the open() syscall | |
143 | * @release: operations needed to implement the release() syscall | |
144 | * | |
145 | * .. note:: | |
146 | * | |
147 | * Those operations are used to implemente the fs struct file_operations | |
148 | * at the V4L2 drivers. The V4L2 core overrides the fs ops with some | |
149 | * extra logic needed by the subsystem. | |
150 | */ | |
bec43661 HV |
151 | struct v4l2_file_operations { |
152 | struct module *owner; | |
153 | ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); | |
154 | ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); | |
155 | unsigned int (*poll) (struct file *, struct poll_table_struct *); | |
bec43661 | 156 | long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); |
b9d0aa6e LP |
157 | #ifdef CONFIG_COMPAT |
158 | long (*compat_ioctl32) (struct file *, unsigned int, unsigned long); | |
159 | #endif | |
ecc6517d BL |
160 | unsigned long (*get_unmapped_area) (struct file *, unsigned long, |
161 | unsigned long, unsigned long, unsigned long); | |
bec43661 HV |
162 | int (*mmap) (struct file *, struct vm_area_struct *); |
163 | int (*open) (struct file *); | |
164 | int (*release) (struct file *); | |
165 | }; | |
166 | ||
401998fa MCC |
167 | /* |
168 | * Newer version of video_device, handled by videodev2.c | |
169 | * This version moves redundant code from video device code to | |
170 | * the common handler | |
171 | */ | |
401998fa | 172 | |
d9d3d176 MCC |
173 | /** |
174 | * struct video_device - Structure used to create and manage the V4L2 device | |
175 | * nodes. | |
176 | * | |
177 | * @entity: &struct media_entity | |
178 | * @intf_devnode: pointer to &struct media_intf_devnode | |
179 | * @pipe: &struct media_pipeline | |
180 | * @fops: pointer to &struct v4l2_file_operations for the video device | |
181 | * @device_caps: device capabilities as used in v4l2_capabilities | |
182 | * @dev: &struct device for the video device | |
183 | * @cdev: character device | |
184 | * @v4l2_dev: pointer to &struct v4l2_device parent | |
185 | * @dev_parent: pointer to &struct device parent | |
186 | * @ctrl_handler: Control handler associated with this device node. | |
187 | * May be NULL. | |
188 | * @queue: &struct vb2_queue associated with this device node. May be NULL. | |
189 | * @prio: pointer to &struct v4l2_prio_state with device's Priority state. | |
190 | * If NULL, then v4l2_dev->prio will be used. | |
191 | * @name: video device name | |
192 | * @vfl_type: V4L device type | |
193 | * @vfl_dir: V4L receiver, transmitter or m2m | |
194 | * @minor: device node 'minor'. It is set to -1 if the registration failed | |
195 | * @num: number of the video device node | |
196 | * @flags: video device flags. Use bitops to set/clear/test flags | |
197 | * @index: attribute to differentiate multiple indices on one physical device | |
198 | * @fh_lock: Lock for all v4l2_fhs | |
199 | * @fh_list: List of &struct v4l2_fh | |
200 | * @dev_debug: Internal device debug flags, not for use by drivers | |
201 | * @tvnorms: Supported tv norms | |
202 | * | |
203 | * @release: video device release() callback | |
204 | * @ioctl_ops: pointer to &struct v4l2_ioctl_ops with ioctl callbacks | |
205 | * | |
206 | * @valid_ioctls: bitmap with the valid ioctls for this device | |
207 | * @disable_locking: bitmap with the ioctls that don't require locking | |
208 | * @lock: pointer to &struct mutex serialization lock | |
209 | * | |
210 | * .. note:: | |
211 | * Only set @dev_parent if that can't be deduced from @v4l2_dev. | |
212 | */ | |
213 | ||
401998fa MCC |
214 | struct video_device |
215 | { | |
2c0ab67b LP |
216 | #if defined(CONFIG_MEDIA_CONTROLLER) |
217 | struct media_entity entity; | |
d9c21e3e | 218 | struct media_intf_devnode *intf_devnode; |
d0a164f5 | 219 | struct media_pipeline pipe; |
2c0ab67b | 220 | #endif |
bec43661 | 221 | const struct v4l2_file_operations *fops; |
401998fa | 222 | |
7bbe7813 HV |
223 | u32 device_caps; |
224 | ||
54bd5b66 | 225 | /* sysfs */ |
d9d3d176 MCC |
226 | struct device dev; |
227 | struct cdev *cdev; | |
9bea3514 | 228 | |
d9d3d176 MCC |
229 | struct v4l2_device *v4l2_dev; |
230 | struct device *dev_parent; | |
54bd5b66 | 231 | |
0996517c HV |
232 | struct v4l2_ctrl_handler *ctrl_handler; |
233 | ||
5a5adf6b HV |
234 | struct vb2_queue *queue; |
235 | ||
0f62fd6a HV |
236 | struct v4l2_prio_state *prio; |
237 | ||
401998fa | 238 | /* device info */ |
401998fa | 239 | char name[32]; |
d9d3d176 MCC |
240 | int vfl_type; |
241 | int vfl_dir; | |
401998fa | 242 | int minor; |
dd89601d | 243 | u16 num; |
dc93a70c | 244 | unsigned long flags; |
539a7555 | 245 | int index; |
401998fa | 246 | |
1babcb46 | 247 | /* V4L2 file handles */ |
d9d3d176 MCC |
248 | spinlock_t fh_lock; |
249 | struct list_head fh_list; | |
1babcb46 | 250 | |
17028cdb | 251 | int dev_debug; |
401998fa | 252 | |
d9d3d176 | 253 | v4l2_std_id tvnorms; |
401998fa MCC |
254 | |
255 | /* callbacks */ | |
dc93a70c | 256 | void (*release)(struct video_device *vdev); |
a399810c | 257 | const struct v4l2_ioctl_ops *ioctl_ops; |
48ea0be0 | 258 | DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE); |
ee6869af | 259 | |
152a3a73 | 260 | DECLARE_BITMAP(disable_locking, BASE_VIDIOC_PRIVATE); |
ee6869af | 261 | struct mutex *lock; |
401998fa MCC |
262 | }; |
263 | ||
6e3ea0e7 LP |
264 | #define media_entity_to_video_device(__e) \ |
265 | container_of(__e, struct video_device, entity) | |
bfa8a273 | 266 | /* dev to video-device */ |
22a04f10 | 267 | #define to_video_device(cd) container_of(cd, struct video_device, dev) |
e90ff923 | 268 | |
d9d3d176 MCC |
269 | /** |
270 | * __video_register_device - register video4linux devices | |
271 | * | |
272 | * @vdev: struct video_device to register | |
273 | * @type: type of device to register | |
274 | * @nr: which device node number is desired: | |
275 | * (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free) | |
276 | * @warn_if_nr_in_use: warn if the desired device node number | |
277 | * was already in use and another number was chosen instead. | |
278 | * @owner: module that owns the video device node | |
279 | * | |
280 | * The registration code assigns minor numbers and device node numbers | |
281 | * based on the requested type and registers the new device node with | |
282 | * the kernel. | |
283 | * | |
284 | * This function assumes that struct video_device was zeroed when it | |
285 | * was allocated and does not contain any stale date. | |
286 | * | |
287 | * An error is returned if no free minor or device node number could be | |
288 | * found, or if the registration of the device node failed. | |
289 | * | |
290 | * Returns 0 on success. | |
291 | * | |
292 | * Valid values for @type are: | |
293 | * | |
294 | * - %VFL_TYPE_GRABBER - A frame grabber | |
295 | * - %VFL_TYPE_VBI - Vertical blank data (undecoded) | |
296 | * - %VFL_TYPE_RADIO - A radio card | |
297 | * - %VFL_TYPE_SUBDEV - A subdevice | |
298 | * - %VFL_TYPE_SDR - Software Defined Radio | |
b2fe22d0 | 299 | * - %VFL_TYPE_TOUCH - A touch sensor |
d9d3d176 MCC |
300 | * |
301 | * .. note:: | |
302 | * | |
303 | * This function is meant to be used only inside the V4L2 core. | |
304 | * Drivers should use video_register_device() or | |
305 | * video_register_device_no_warn(). | |
306 | */ | |
2096a5dc LP |
307 | int __must_check __video_register_device(struct video_device *vdev, int type, |
308 | int nr, int warn_if_nr_in_use, struct module *owner); | |
309 | ||
d9d3d176 MCC |
310 | /** |
311 | * video_register_device - register video4linux devices | |
312 | * | |
313 | * @vdev: struct video_device to register | |
314 | * @type: type of device to register | |
315 | * @nr: which device node number is desired: | |
316 | * (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free) | |
317 | * | |
318 | * Internally, it calls __video_register_device(). Please see its | |
319 | * documentation for more details. | |
320 | * | |
321 | * .. note:: | |
322 | * if video_register_device fails, the release() callback of | |
323 | * &struct video_device structure is *not* called, so the caller | |
324 | * is responsible for freeing any data. Usually that means that | |
325 | * you video_device_release() should be called on failure. | |
326 | */ | |
2096a5dc LP |
327 | static inline int __must_check video_register_device(struct video_device *vdev, |
328 | int type, int nr) | |
329 | { | |
330 | return __video_register_device(vdev, type, nr, 1, vdev->fops->owner); | |
331 | } | |
dc93a70c | 332 | |
d9d3d176 MCC |
333 | /** |
334 | * video_register_device_no_warn - register video4linux devices | |
335 | * | |
336 | * @vdev: struct video_device to register | |
337 | * @type: type of device to register | |
338 | * @nr: which device node number is desired: | |
339 | * (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free) | |
340 | * | |
341 | * This function is identical to video_register_device() except that no | |
342 | * warning is issued if the desired device node number was already in use. | |
343 | * | |
344 | * Internally, it calls __video_register_device(). Please see its | |
345 | * documentation for more details. | |
346 | * | |
347 | * .. note:: | |
348 | * if video_register_device fails, the release() callback of | |
349 | * &struct video_device structure is *not* called, so the caller | |
350 | * is responsible for freeing any data. Usually that means that | |
351 | * you video_device_release() should be called on failure. | |
352 | */ | |
2096a5dc LP |
353 | static inline int __must_check video_register_device_no_warn( |
354 | struct video_device *vdev, int type, int nr) | |
355 | { | |
356 | return __video_register_device(vdev, type, nr, 0, vdev->fops->owner); | |
357 | } | |
6b5270d2 | 358 | |
d9d3d176 MCC |
359 | /** |
360 | * video_unregister_device - Unregister video devices. | |
361 | * | |
362 | * @vdev: &struct video_device to register | |
363 | * | |
364 | * Does nothing if vdev == NULL or if video_is_registered() returns false. | |
365 | */ | |
dc93a70c | 366 | void video_unregister_device(struct video_device *vdev); |
401998fa | 367 | |
d9d3d176 MCC |
368 | /** |
369 | * video_device_alloc - helper function to alloc &struct video_device | |
370 | * | |
371 | * Returns NULL if %-ENOMEM or a &struct video_device on success. | |
372 | */ | |
e138c592 | 373 | struct video_device * __must_check video_device_alloc(void); |
bfa8a273 | 374 | |
d9d3d176 MCC |
375 | /** |
376 | * video_device_release - helper function to release &struct video_device | |
377 | * | |
378 | * @vdev: pointer to &struct video_device | |
379 | * | |
564aaf69 | 380 | * Can also be used for video_device->release\(\). |
d9d3d176 | 381 | */ |
dc93a70c | 382 | void video_device_release(struct video_device *vdev); |
bfa8a273 | 383 | |
d9d3d176 MCC |
384 | /** |
385 | * video_device_release_empty - helper function to implement the | |
564aaf69 | 386 | * video_device->release\(\) callback. |
d9d3d176 MCC |
387 | * |
388 | * @vdev: pointer to &struct video_device | |
389 | * | |
390 | * This release function does nothing. | |
391 | * | |
392 | * It should be used when the video_device is a static global struct. | |
393 | * | |
394 | * .. note:: | |
395 | * Having a static video_device is a dubious construction at best. | |
396 | */ | |
dc93a70c | 397 | void video_device_release_empty(struct video_device *vdev); |
401998fa | 398 | |
d9d3d176 MCC |
399 | /** |
400 | * v4l2_is_known_ioctl - Checks if a given cmd is a known V4L ioctl | |
401 | * | |
402 | * @cmd: ioctl command | |
403 | * | |
404 | * returns true if cmd is a known V4L2 ioctl | |
405 | */ | |
8ab75e3e HV |
406 | bool v4l2_is_known_ioctl(unsigned int cmd); |
407 | ||
d9d3d176 MCC |
408 | /** v4l2_disable_ioctl_locking - mark that a given command |
409 | * shouldn't use core locking | |
410 | * | |
411 | * @vdev: pointer to &struct video_device | |
412 | * @cmd: ioctl command | |
413 | */ | |
414 | static inline void v4l2_disable_ioctl_locking(struct video_device *vdev, | |
415 | unsigned int cmd) | |
8ab75e3e HV |
416 | { |
417 | if (_IOC_NR(cmd) < BASE_VIDIOC_PRIVATE) | |
152a3a73 | 418 | set_bit(_IOC_NR(cmd), vdev->disable_locking); |
8ab75e3e HV |
419 | } |
420 | ||
d9d3d176 MCC |
421 | /** |
422 | * v4l2_disable_ioctl- mark that a given command isn't implemented. | |
423 | * shouldn't use core locking | |
424 | * | |
425 | * @vdev: pointer to &struct video_device | |
426 | * @cmd: ioctl command | |
427 | * | |
428 | * This function allows drivers to provide just one v4l2_ioctl_ops struct, but | |
429 | * disable ioctls based on the specific card that is actually found. | |
430 | * | |
431 | * .. note:: | |
432 | * | |
433 | * This must be called before video_register_device. | |
434 | * See also the comments for determine_valid_ioctls(). | |
435 | */ | |
436 | static inline void v4l2_disable_ioctl(struct video_device *vdev, | |
437 | unsigned int cmd) | |
48ea0be0 HV |
438 | { |
439 | if (_IOC_NR(cmd) < BASE_VIDIOC_PRIVATE) | |
440 | set_bit(_IOC_NR(cmd), vdev->valid_ioctls); | |
441 | } | |
442 | ||
d9d3d176 MCC |
443 | /** |
444 | * video_get_drvdata - gets private data from &struct video_device. | |
445 | * | |
446 | * @vdev: pointer to &struct video_device | |
447 | * | |
448 | * returns a pointer to the private data | |
449 | */ | |
dc93a70c | 450 | static inline void *video_get_drvdata(struct video_device *vdev) |
401998fa | 451 | { |
dc93a70c | 452 | return dev_get_drvdata(&vdev->dev); |
401998fa MCC |
453 | } |
454 | ||
d9d3d176 MCC |
455 | /** |
456 | * video_set_drvdata - sets private data from &struct video_device. | |
457 | * | |
458 | * @vdev: pointer to &struct video_device | |
459 | * @data: private data pointer | |
460 | */ | |
dc93a70c | 461 | static inline void video_set_drvdata(struct video_device *vdev, void *data) |
401998fa | 462 | { |
dc93a70c | 463 | dev_set_drvdata(&vdev->dev, data); |
401998fa | 464 | } |
38ee04f0 | 465 | |
d9d3d176 MCC |
466 | /** |
467 | * video_devdata - gets &struct video_device from struct file. | |
468 | * | |
469 | * @file: pointer to struct file | |
470 | */ | |
bfa8a273 HV |
471 | struct video_device *video_devdata(struct file *file); |
472 | ||
d9d3d176 MCC |
473 | /** |
474 | * video_drvdata - gets private data from &struct video_device using the | |
475 | * struct file. | |
476 | * | |
477 | * @file: pointer to struct file | |
478 | * | |
479 | * This is function combines both video_get_drvdata() and video_devdata() | |
480 | * as this is used very often. | |
481 | */ | |
bfa8a273 HV |
482 | static inline void *video_drvdata(struct file *file) |
483 | { | |
484 | return video_get_drvdata(video_devdata(file)); | |
485 | } | |
401998fa | 486 | |
d9d3d176 MCC |
487 | /** |
488 | * video_device_node_name - returns the video device name | |
489 | * | |
490 | * @vdev: pointer to &struct video_device | |
491 | * | |
492 | * Returns the device name string | |
493 | */ | |
eac8ea53 LP |
494 | static inline const char *video_device_node_name(struct video_device *vdev) |
495 | { | |
496 | return dev_name(&vdev->dev); | |
497 | } | |
498 | ||
d9d3d176 MCC |
499 | /** |
500 | * video_is_registered - returns true if the &struct video_device is registered. | |
501 | * | |
502 | * | |
503 | * @vdev: pointer to &struct video_device | |
504 | */ | |
957b4aa9 | 505 | static inline int video_is_registered(struct video_device *vdev) |
dc93a70c | 506 | { |
957b4aa9 | 507 | return test_bit(V4L2_FL_REGISTERED, &vdev->flags); |
dc93a70c HV |
508 | } |
509 | ||
401998fa | 510 | #endif /* _V4L2_DEV_H */ |