1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2020 Invensense, Inc.
4  */
5 
6 #include <linux/kernel.h>
7 #include <linux/device.h>
8 #include <linux/mutex.h>
9 #include <linux/pm_runtime.h>
10 #include <linux/regmap.h>
11 #include <linux/delay.h>
12 
13 #include <linux/iio/buffer.h>
14 #include <linux/iio/common/inv_sensors_timestamp.h>
15 #include <linux/iio/iio.h>
16 
17 #include "inv_icm42600.h"
18 #include "inv_icm42600_buffer.h"
19 
20 /* FIFO header: 1 byte */
21 #define INV_ICM42600_FIFO_HEADER_MSG		BIT(7)
22 #define INV_ICM42600_FIFO_HEADER_ACCEL		BIT(6)
23 #define INV_ICM42600_FIFO_HEADER_GYRO		BIT(5)
24 #define INV_ICM42600_FIFO_HEADER_TMST_FSYNC	GENMASK(3, 2)
25 #define INV_ICM42600_FIFO_HEADER_ODR_ACCEL	BIT(1)
26 #define INV_ICM42600_FIFO_HEADER_ODR_GYRO	BIT(0)
27 
28 struct inv_icm42600_fifo_1sensor_packet {
29 	uint8_t header;
30 	struct inv_icm42600_fifo_sensor_data data;
31 	int8_t temp;
32 } __packed;
33 #define INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE		8
34 
35 struct inv_icm42600_fifo_2sensors_packet {
36 	uint8_t header;
37 	struct inv_icm42600_fifo_sensor_data accel;
38 	struct inv_icm42600_fifo_sensor_data gyro;
39 	int8_t temp;
40 	__be16 timestamp;
41 } __packed;
42 #define INV_ICM42600_FIFO_2SENSORS_PACKET_SIZE		16
43 
44 ssize_t inv_icm42600_fifo_decode_packet(const void *packet, const void **accel,
45 					const void **gyro, const int8_t **temp,
46 					const void **timestamp, unsigned int *odr)
47 {
48 	const struct inv_icm42600_fifo_1sensor_packet *pack1 = packet;
49 	const struct inv_icm42600_fifo_2sensors_packet *pack2 = packet;
50 	uint8_t header = *((const uint8_t *)packet);
51 
52 	/* FIFO empty */
53 	if (header & INV_ICM42600_FIFO_HEADER_MSG) {
54 		*accel = NULL;
55 		*gyro = NULL;
56 		*temp = NULL;
57 		*timestamp = NULL;
58 		*odr = 0;
59 		return 0;
60 	}
61 
62 	/* handle odr flags */
63 	*odr = 0;
64 	if (header & INV_ICM42600_FIFO_HEADER_ODR_GYRO)
65 		*odr |= INV_ICM42600_SENSOR_GYRO;
66 	if (header & INV_ICM42600_FIFO_HEADER_ODR_ACCEL)
67 		*odr |= INV_ICM42600_SENSOR_ACCEL;
68 
69 	/* accel + gyro */
70 	if ((header & INV_ICM42600_FIFO_HEADER_ACCEL) &&
71 	    (header & INV_ICM42600_FIFO_HEADER_GYRO)) {
72 		*accel = &pack2->accel;
73 		*gyro = &pack2->gyro;
74 		*temp = &pack2->temp;
75 		*timestamp = &pack2->timestamp;
76 		return INV_ICM42600_FIFO_2SENSORS_PACKET_SIZE;
77 	}
78 
79 	/* accel only */
80 	if (header & INV_ICM42600_FIFO_HEADER_ACCEL) {
81 		*accel = &pack1->data;
82 		*gyro = NULL;
83 		*temp = &pack1->temp;
84 		*timestamp = NULL;
85 		return INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE;
86 	}
87 
88 	/* gyro only */
89 	if (header & INV_ICM42600_FIFO_HEADER_GYRO) {
90 		*accel = NULL;
91 		*gyro = &pack1->data;
92 		*temp = &pack1->temp;
93 		*timestamp = NULL;
94 		return INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE;
95 	}
96 
97 	/* invalid packet if here */
98 	return -EINVAL;
99 }
100 
101 void inv_icm42600_buffer_update_fifo_period(struct inv_icm42600_state *st)
102 {
103 	uint32_t period_gyro, period_accel, period;
104 
105 	if (st->fifo.en & INV_ICM42600_SENSOR_GYRO)
106 		period_gyro = inv_icm42600_odr_to_period(st->conf.gyro.odr);
107 	else
108 		period_gyro = U32_MAX;
109 
110 	if (st->fifo.en & INV_ICM42600_SENSOR_ACCEL)
111 		period_accel = inv_icm42600_odr_to_period(st->conf.accel.odr);
112 	else
113 		period_accel = U32_MAX;
114 
115 	if (period_gyro <= period_accel)
116 		period = period_gyro;
117 	else
118 		period = period_accel;
119 
120 	st->fifo.period = period;
121 }
122 
123 int inv_icm42600_buffer_set_fifo_en(struct inv_icm42600_state *st,
124 				    unsigned int fifo_en)
125 {
126 	unsigned int mask, val;
127 	int ret;
128 
129 	/* update only FIFO EN bits */
130 	mask = INV_ICM42600_FIFO_CONFIG1_TMST_FSYNC_EN |
131 		INV_ICM42600_FIFO_CONFIG1_TEMP_EN |
132 		INV_ICM42600_FIFO_CONFIG1_GYRO_EN |
133 		INV_ICM42600_FIFO_CONFIG1_ACCEL_EN;
134 
135 	val = 0;
136 	if (fifo_en & INV_ICM42600_SENSOR_GYRO)
137 		val |= INV_ICM42600_FIFO_CONFIG1_GYRO_EN;
138 	if (fifo_en & INV_ICM42600_SENSOR_ACCEL)
139 		val |= INV_ICM42600_FIFO_CONFIG1_ACCEL_EN;
140 	if (fifo_en & INV_ICM42600_SENSOR_TEMP)
141 		val |= INV_ICM42600_FIFO_CONFIG1_TEMP_EN;
142 
143 	ret = regmap_update_bits(st->map, INV_ICM42600_REG_FIFO_CONFIG1, mask, val);
144 	if (ret)
145 		return ret;
146 
147 	st->fifo.en = fifo_en;
148 	inv_icm42600_buffer_update_fifo_period(st);
149 
150 	return 0;
151 }
152 
153 static size_t inv_icm42600_get_packet_size(unsigned int fifo_en)
154 {
155 	size_t packet_size;
156 
157 	if ((fifo_en & INV_ICM42600_SENSOR_GYRO) &&
158 	    (fifo_en & INV_ICM42600_SENSOR_ACCEL))
159 		packet_size = INV_ICM42600_FIFO_2SENSORS_PACKET_SIZE;
160 	else
161 		packet_size = INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE;
162 
163 	return packet_size;
164 }
165 
166 static unsigned int inv_icm42600_wm_truncate(unsigned int watermark,
167 					     size_t packet_size)
168 {
169 	size_t wm_size;
170 	unsigned int wm;
171 
172 	wm_size = watermark * packet_size;
173 	if (wm_size > INV_ICM42600_FIFO_WATERMARK_MAX)
174 		wm_size = INV_ICM42600_FIFO_WATERMARK_MAX;
175 
176 	wm = wm_size / packet_size;
177 
178 	return wm;
179 }
180 
181 /**
182  * inv_icm42600_buffer_update_watermark - update watermark FIFO threshold
183  * @st:	driver internal state
184  *
185  * Returns 0 on success, a negative error code otherwise.
186  *
187  * FIFO watermark threshold is computed based on the required watermark values
188  * set for gyro and accel sensors. Since watermark is all about acceptable data
189  * latency, use the smallest setting between the 2. It means choosing the
190  * smallest latency but this is not as simple as choosing the smallest watermark
191  * value. Latency depends on watermark and ODR. It requires several steps:
192  * 1) compute gyro and accel latencies and choose the smallest value.
193  * 2) adapt the choosen latency so that it is a multiple of both gyro and accel
194  *    ones. Otherwise it is possible that you don't meet a requirement. (for
195  *    example with gyro @100Hz wm 4 and accel @100Hz with wm 6, choosing the
196  *    value of 4 will not meet accel latency requirement because 6 is not a
197  *    multiple of 4. You need to use the value 2.)
198  * 3) Since all periods are multiple of each others, watermark is computed by
199  *    dividing this computed latency by the smallest period, which corresponds
200  *    to the FIFO frequency. Beware that this is only true because we are not
201  *    using 500Hz frequency which is not a multiple of the others.
202  */
203 int inv_icm42600_buffer_update_watermark(struct inv_icm42600_state *st)
204 {
205 	size_t packet_size, wm_size;
206 	unsigned int wm_gyro, wm_accel, watermark;
207 	uint32_t period_gyro, period_accel, period;
208 	uint32_t latency_gyro, latency_accel, latency;
209 	bool restore;
210 	__le16 raw_wm;
211 	int ret;
212 
213 	packet_size = inv_icm42600_get_packet_size(st->fifo.en);
214 
215 	/* compute sensors latency, depending on sensor watermark and odr */
216 	wm_gyro = inv_icm42600_wm_truncate(st->fifo.watermark.gyro, packet_size);
217 	wm_accel = inv_icm42600_wm_truncate(st->fifo.watermark.accel, packet_size);
218 	/* use us for odr to avoid overflow using 32 bits values */
219 	period_gyro = inv_icm42600_odr_to_period(st->conf.gyro.odr) / 1000UL;
220 	period_accel = inv_icm42600_odr_to_period(st->conf.accel.odr) / 1000UL;
221 	latency_gyro = period_gyro * wm_gyro;
222 	latency_accel = period_accel * wm_accel;
223 
224 	/* 0 value for watermark means that the sensor is turned off */
225 	if (latency_gyro == 0) {
226 		watermark = wm_accel;
227 	} else if (latency_accel == 0) {
228 		watermark = wm_gyro;
229 	} else {
230 		/* compute the smallest latency that is a multiple of both */
231 		if (latency_gyro <= latency_accel)
232 			latency = latency_gyro - (latency_accel % latency_gyro);
233 		else
234 			latency = latency_accel - (latency_gyro % latency_accel);
235 		/* use the shortest period */
236 		if (period_gyro <= period_accel)
237 			period = period_gyro;
238 		else
239 			period = period_accel;
240 		/* all this works because periods are multiple of each others */
241 		watermark = latency / period;
242 		if (watermark < 1)
243 			watermark = 1;
244 	}
245 
246 	/* compute watermark value in bytes */
247 	wm_size = watermark * packet_size;
248 
249 	/* changing FIFO watermark requires to turn off watermark interrupt */
250 	ret = regmap_update_bits_check(st->map, INV_ICM42600_REG_INT_SOURCE0,
251 				       INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN,
252 				       0, &restore);
253 	if (ret)
254 		return ret;
255 
256 	raw_wm = INV_ICM42600_FIFO_WATERMARK_VAL(wm_size);
257 	memcpy(st->buffer, &raw_wm, sizeof(raw_wm));
258 	ret = regmap_bulk_write(st->map, INV_ICM42600_REG_FIFO_WATERMARK,
259 				st->buffer, sizeof(raw_wm));
260 	if (ret)
261 		return ret;
262 
263 	/* restore watermark interrupt */
264 	if (restore) {
265 		ret = regmap_update_bits(st->map, INV_ICM42600_REG_INT_SOURCE0,
266 					 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN,
267 					 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN);
268 		if (ret)
269 			return ret;
270 	}
271 
272 	return 0;
273 }
274 
275 static int inv_icm42600_buffer_preenable(struct iio_dev *indio_dev)
276 {
277 	struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev);
278 	struct device *dev = regmap_get_device(st->map);
279 	struct inv_sensors_timestamp *ts = iio_priv(indio_dev);
280 
281 	pm_runtime_get_sync(dev);
282 
283 	mutex_lock(&st->lock);
284 	inv_sensors_timestamp_reset(ts);
285 	mutex_unlock(&st->lock);
286 
287 	return 0;
288 }
289 
290 /*
291  * update_scan_mode callback is turning sensors on and setting data FIFO enable
292  * bits.
293  */
294 static int inv_icm42600_buffer_postenable(struct iio_dev *indio_dev)
295 {
296 	struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev);
297 	int ret;
298 
299 	mutex_lock(&st->lock);
300 
301 	/* exit if FIFO is already on */
302 	if (st->fifo.on) {
303 		ret = 0;
304 		goto out_on;
305 	}
306 
307 	/* set FIFO threshold interrupt */
308 	ret = regmap_update_bits(st->map, INV_ICM42600_REG_INT_SOURCE0,
309 				 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN,
310 				 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN);
311 	if (ret)
312 		goto out_unlock;
313 
314 	/* flush FIFO data */
315 	ret = regmap_write(st->map, INV_ICM42600_REG_SIGNAL_PATH_RESET,
316 			   INV_ICM42600_SIGNAL_PATH_RESET_FIFO_FLUSH);
317 	if (ret)
318 		goto out_unlock;
319 
320 	/* set FIFO in streaming mode */
321 	ret = regmap_write(st->map, INV_ICM42600_REG_FIFO_CONFIG,
322 			   INV_ICM42600_FIFO_CONFIG_STREAM);
323 	if (ret)
324 		goto out_unlock;
325 
326 	/* workaround: first read of FIFO count after reset is always 0 */
327 	ret = regmap_bulk_read(st->map, INV_ICM42600_REG_FIFO_COUNT, st->buffer, 2);
328 	if (ret)
329 		goto out_unlock;
330 
331 out_on:
332 	/* increase FIFO on counter */
333 	st->fifo.on++;
334 out_unlock:
335 	mutex_unlock(&st->lock);
336 	return ret;
337 }
338 
339 static int inv_icm42600_buffer_predisable(struct iio_dev *indio_dev)
340 {
341 	struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev);
342 	int ret;
343 
344 	mutex_lock(&st->lock);
345 
346 	/* exit if there are several sensors using the FIFO */
347 	if (st->fifo.on > 1) {
348 		ret = 0;
349 		goto out_off;
350 	}
351 
352 	/* set FIFO in bypass mode */
353 	ret = regmap_write(st->map, INV_ICM42600_REG_FIFO_CONFIG,
354 			   INV_ICM42600_FIFO_CONFIG_BYPASS);
355 	if (ret)
356 		goto out_unlock;
357 
358 	/* flush FIFO data */
359 	ret = regmap_write(st->map, INV_ICM42600_REG_SIGNAL_PATH_RESET,
360 			   INV_ICM42600_SIGNAL_PATH_RESET_FIFO_FLUSH);
361 	if (ret)
362 		goto out_unlock;
363 
364 	/* disable FIFO threshold interrupt */
365 	ret = regmap_update_bits(st->map, INV_ICM42600_REG_INT_SOURCE0,
366 				 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN, 0);
367 	if (ret)
368 		goto out_unlock;
369 
370 out_off:
371 	/* decrease FIFO on counter */
372 	st->fifo.on--;
373 out_unlock:
374 	mutex_unlock(&st->lock);
375 	return ret;
376 }
377 
378 static int inv_icm42600_buffer_postdisable(struct iio_dev *indio_dev)
379 {
380 	struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev);
381 	struct device *dev = regmap_get_device(st->map);
382 	unsigned int sensor;
383 	unsigned int *watermark;
384 	struct inv_icm42600_sensor_conf conf = INV_ICM42600_SENSOR_CONF_INIT;
385 	unsigned int sleep_temp = 0;
386 	unsigned int sleep_sensor = 0;
387 	unsigned int sleep;
388 	int ret;
389 
390 	if (indio_dev == st->indio_gyro) {
391 		sensor = INV_ICM42600_SENSOR_GYRO;
392 		watermark = &st->fifo.watermark.gyro;
393 	} else if (indio_dev == st->indio_accel) {
394 		sensor = INV_ICM42600_SENSOR_ACCEL;
395 		watermark = &st->fifo.watermark.accel;
396 	} else {
397 		return -EINVAL;
398 	}
399 
400 	mutex_lock(&st->lock);
401 
402 	ret = inv_icm42600_buffer_set_fifo_en(st, st->fifo.en & ~sensor);
403 	if (ret)
404 		goto out_unlock;
405 
406 	*watermark = 0;
407 	ret = inv_icm42600_buffer_update_watermark(st);
408 	if (ret)
409 		goto out_unlock;
410 
411 	conf.mode = INV_ICM42600_SENSOR_MODE_OFF;
412 	if (sensor == INV_ICM42600_SENSOR_GYRO)
413 		ret = inv_icm42600_set_gyro_conf(st, &conf, &sleep_sensor);
414 	else
415 		ret = inv_icm42600_set_accel_conf(st, &conf, &sleep_sensor);
416 	if (ret)
417 		goto out_unlock;
418 
419 	/* if FIFO is off, turn temperature off */
420 	if (!st->fifo.on)
421 		ret = inv_icm42600_set_temp_conf(st, false, &sleep_temp);
422 
423 out_unlock:
424 	mutex_unlock(&st->lock);
425 
426 	/* sleep maximum required time */
427 	if (sleep_sensor > sleep_temp)
428 		sleep = sleep_sensor;
429 	else
430 		sleep = sleep_temp;
431 	if (sleep)
432 		msleep(sleep);
433 
434 	pm_runtime_mark_last_busy(dev);
435 	pm_runtime_put_autosuspend(dev);
436 
437 	return ret;
438 }
439 
440 const struct iio_buffer_setup_ops inv_icm42600_buffer_ops = {
441 	.preenable = inv_icm42600_buffer_preenable,
442 	.postenable = inv_icm42600_buffer_postenable,
443 	.predisable = inv_icm42600_buffer_predisable,
444 	.postdisable = inv_icm42600_buffer_postdisable,
445 };
446 
447 int inv_icm42600_buffer_fifo_read(struct inv_icm42600_state *st,
448 				  unsigned int max)
449 {
450 	size_t max_count;
451 	__be16 *raw_fifo_count;
452 	ssize_t i, size;
453 	const void *accel, *gyro, *timestamp;
454 	const int8_t *temp;
455 	unsigned int odr;
456 	int ret;
457 
458 	/* reset all samples counters */
459 	st->fifo.count = 0;
460 	st->fifo.nb.gyro = 0;
461 	st->fifo.nb.accel = 0;
462 	st->fifo.nb.total = 0;
463 
464 	/* compute maximum FIFO read size */
465 	if (max == 0)
466 		max_count = sizeof(st->fifo.data);
467 	else
468 		max_count = max * inv_icm42600_get_packet_size(st->fifo.en);
469 
470 	/* read FIFO count value */
471 	raw_fifo_count = (__be16 *)st->buffer;
472 	ret = regmap_bulk_read(st->map, INV_ICM42600_REG_FIFO_COUNT,
473 			       raw_fifo_count, sizeof(*raw_fifo_count));
474 	if (ret)
475 		return ret;
476 	st->fifo.count = be16_to_cpup(raw_fifo_count);
477 
478 	/* check and clamp FIFO count value */
479 	if (st->fifo.count == 0)
480 		return 0;
481 	if (st->fifo.count > max_count)
482 		st->fifo.count = max_count;
483 
484 	/* read all FIFO data in internal buffer */
485 	ret = regmap_noinc_read(st->map, INV_ICM42600_REG_FIFO_DATA,
486 				st->fifo.data, st->fifo.count);
487 	if (ret)
488 		return ret;
489 
490 	/* compute number of samples for each sensor */
491 	for (i = 0; i < st->fifo.count; i += size) {
492 		size = inv_icm42600_fifo_decode_packet(&st->fifo.data[i],
493 				&accel, &gyro, &temp, &timestamp, &odr);
494 		if (size <= 0)
495 			break;
496 		if (gyro != NULL && inv_icm42600_fifo_is_data_valid(gyro))
497 			st->fifo.nb.gyro++;
498 		if (accel != NULL && inv_icm42600_fifo_is_data_valid(accel))
499 			st->fifo.nb.accel++;
500 		st->fifo.nb.total++;
501 	}
502 
503 	return 0;
504 }
505 
506 int inv_icm42600_buffer_fifo_parse(struct inv_icm42600_state *st)
507 {
508 	struct inv_sensors_timestamp *ts;
509 	int ret;
510 
511 	if (st->fifo.nb.total == 0)
512 		return 0;
513 
514 	/* handle gyroscope timestamp and FIFO data parsing */
515 	ts = iio_priv(st->indio_gyro);
516 	inv_sensors_timestamp_interrupt(ts, st->fifo.period, st->fifo.nb.total,
517 					st->fifo.nb.gyro, st->timestamp.gyro);
518 	if (st->fifo.nb.gyro > 0) {
519 		ret = inv_icm42600_gyro_parse_fifo(st->indio_gyro);
520 		if (ret)
521 			return ret;
522 	}
523 
524 	/* handle accelerometer timestamp and FIFO data parsing */
525 	ts = iio_priv(st->indio_accel);
526 	inv_sensors_timestamp_interrupt(ts, st->fifo.period, st->fifo.nb.total,
527 					st->fifo.nb.accel, st->timestamp.accel);
528 	if (st->fifo.nb.accel > 0) {
529 		ret = inv_icm42600_accel_parse_fifo(st->indio_accel);
530 		if (ret)
531 			return ret;
532 	}
533 
534 	return 0;
535 }
536 
537 int inv_icm42600_buffer_hwfifo_flush(struct inv_icm42600_state *st,
538 				     unsigned int count)
539 {
540 	struct inv_sensors_timestamp *ts;
541 	int64_t gyro_ts, accel_ts;
542 	int ret;
543 
544 	gyro_ts = iio_get_time_ns(st->indio_gyro);
545 	accel_ts = iio_get_time_ns(st->indio_accel);
546 
547 	ret = inv_icm42600_buffer_fifo_read(st, count);
548 	if (ret)
549 		return ret;
550 
551 	if (st->fifo.nb.total == 0)
552 		return 0;
553 
554 	if (st->fifo.nb.gyro > 0) {
555 		ts = iio_priv(st->indio_gyro);
556 		inv_sensors_timestamp_interrupt(ts, st->fifo.period,
557 						st->fifo.nb.total, st->fifo.nb.gyro,
558 						gyro_ts);
559 		ret = inv_icm42600_gyro_parse_fifo(st->indio_gyro);
560 		if (ret)
561 			return ret;
562 	}
563 
564 	if (st->fifo.nb.accel > 0) {
565 		ts = iio_priv(st->indio_accel);
566 		inv_sensors_timestamp_interrupt(ts, st->fifo.period,
567 						st->fifo.nb.total, st->fifo.nb.accel,
568 						accel_ts);
569 		ret = inv_icm42600_accel_parse_fifo(st->indio_accel);
570 		if (ret)
571 			return ret;
572 	}
573 
574 	return 0;
575 }
576 
577 int inv_icm42600_buffer_init(struct inv_icm42600_state *st)
578 {
579 	unsigned int val;
580 	int ret;
581 
582 	/*
583 	 * Default FIFO configuration (bits 7 to 5)
584 	 * - use invalid value
585 	 * - FIFO count in bytes
586 	 * - FIFO count in big endian
587 	 */
588 	val = INV_ICM42600_INTF_CONFIG0_FIFO_COUNT_ENDIAN;
589 	ret = regmap_update_bits(st->map, INV_ICM42600_REG_INTF_CONFIG0,
590 				 GENMASK(7, 5), val);
591 	if (ret)
592 		return ret;
593 
594 	/*
595 	 * Enable FIFO partial read and continuous watermark interrupt.
596 	 * Disable all FIFO EN bits.
597 	 */
598 	val = INV_ICM42600_FIFO_CONFIG1_RESUME_PARTIAL_RD |
599 	      INV_ICM42600_FIFO_CONFIG1_WM_GT_TH;
600 	return regmap_update_bits(st->map, INV_ICM42600_REG_FIFO_CONFIG1,
601 				  GENMASK(6, 5) | GENMASK(3, 0), val);
602 }
603