msm: cvp: Enable async ICA (16166276) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/media/platform/msm/cvp/cvp_hfi.c

+24 −2

Original line number	Original line	Diff line number	Diff line
	@@ -329,6 +329,27 @@ int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr)
	return -EINVAL;		return -EINVAL;
	}		}

			int set_feature_bitmask(int pkt_idx, unsigned long *bitmask)
			{
			if (!bitmask) {
			dprintk(CVP_ERR, "%s: invalid bitmask\n", __func__);
			return -EINVAL;
			}

			if (cvp_hfi_defs[pkt_idx].type == HFI_CMD_SESSION_CVP_DME_FRAME) {
			set_bit(DME_BIT_OFFSET, bitmask);
			return 0;
			}

			if (cvp_hfi_defs[pkt_idx].type == HFI_CMD_SESSION_CVP_ICA_FRAME) {
			set_bit(ICA_BIT_OFFSET, bitmask);
			return 0;
			}

			dprintk(CVP_ERR, "%s: invalid pkt_idx %d\n", __func__, pkt_idx);
			return -EINVAL;
			}

	int get_signal_from_pkt_type(unsigned int type)		int get_signal_from_pkt_type(unsigned int type)
	{		{
	int i, pkt_num = ARRAY_SIZE(cvp_hfi_defs);		int i, pkt_num = ARRAY_SIZE(cvp_hfi_defs);
	@@ -1261,7 +1282,7 @@ static inline int __boot_firmware(struct iris_hfi_device *device)
	rc = -ENODEV;		rc = -ENODEV;
	}		}

	/* Enable interrupt before sending commands to venus */		/* Enable interrupt before sending commands to tensilica */
	__write_register(device, CVP_CPU_CS_H2XSOFTINTEN, 0x1);		__write_register(device, CVP_CPU_CS_H2XSOFTINTEN, 0x1);
	__write_register(device, CVP_CPU_CS_X2RPMh, 0x0);		__write_register(device, CVP_CPU_CS_X2RPMh, 0x0);

	@@ -2836,7 +2857,7 @@ static void venus_hfi_pm_handler(struct work_struct *work)
	break;		break;
	case -EBUSY:		case -EBUSY:
	device->skip_pc_count = 0;		device->skip_pc_count = 0;
	dprintk(CVP_DBG, "%s: retry PC as dsp is busy\n", __func__);		dprintk(CVP_DBG, "%s: retry PC as cvp is busy\n", __func__);
	queue_delayed_work(device->venus_pm_workq,		queue_delayed_work(device->venus_pm_workq,
	&venus_hfi_pm_work, msecs_to_jiffies(		&venus_hfi_pm_work, msecs_to_jiffies(
	device->res->msm_cvp_pwr_collapse_delay));		device->res->msm_cvp_pwr_collapse_delay));
	@@ -3124,6 +3145,7 @@ static void *get_session_id(struct msm_cvp_cb_info info)
	case HAL_SESSION_DME_BASIC_CONFIG_CMD_DONE:		case HAL_SESSION_DME_BASIC_CONFIG_CMD_DONE:
	case HAL_SESSION_DFS_FRAME_CMD_DONE:		case HAL_SESSION_DFS_FRAME_CMD_DONE:
	case HAL_SESSION_DME_FRAME_CMD_DONE:		case HAL_SESSION_DME_FRAME_CMD_DONE:
			case HAL_SESSION_ICA_FRAME_CMD_DONE:
	case HAL_SESSION_PERSIST_CMD_DONE:		case HAL_SESSION_PERSIST_CMD_DONE:
	case HAL_SESSION_PROPERTY_INFO:		case HAL_SESSION_PROPERTY_INFO:
	session_id = &info->response.cmd.session_id;		session_id = &info->response.cmd.session_id;

drivers/media/platform/msm/cvp/cvp_hfi.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -187,6 +187,9 @@
	#define HFI_MSG_SESSION_CVP_FTEXT\		#define HFI_MSG_SESSION_CVP_FTEXT\
	(HFI_MSG_SESSION_CVP_START + 0x00A)		(HFI_MSG_SESSION_CVP_START + 0x00A)

			#define HFI_MSG_SESSION_CVP_ICA\
			(HFI_MSG_SESSION_CVP_START + 0x014)

	#define HFI_MSG_SESSION_CVP_DME\		#define HFI_MSG_SESSION_CVP_DME\
	(HFI_MSG_SESSION_CVP_START + 0x023)		(HFI_MSG_SESSION_CVP_START + 0x023)
	#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x030)		#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x030)

drivers/media/platform/msm/cvp/cvp_hfi_api.h

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -91,6 +91,11 @@
	#define HFI_PYS_HCD_BUFFERS_OFFSET 14		#define HFI_PYS_HCD_BUFFERS_OFFSET 14
	#define HFI_PYS_HCD_BUF_NUM 26		#define HFI_PYS_HCD_BUF_NUM 26

			#define DFS_BIT_OFFSET (CVP_KMD_HFI_DFS_FRAME_CMD - CVP_KMD_CMD_START)
			#define DME_BIT_OFFSET (CVP_KMD_HFI_DME_FRAME_CMD - CVP_KMD_CMD_START)
			#define PERSIST_BIT_OFFSET (CVP_KMD_HFI_PERSIST_CMD - CVP_KMD_CMD_START)
			#define ICA_BIT_OFFSET (CVP_KMD_HFI_ICA_FRAME_CMD - CVP_KMD_CMD_START)

	enum cvp_status {		enum cvp_status {
	CVP_ERR_NONE = 0x0,		CVP_ERR_NONE = 0x0,
	CVP_ERR_FAIL = 0x80000000,		CVP_ERR_FAIL = 0x80000000,
	@@ -326,6 +331,7 @@ enum hal_command_response {
	HAL_SESSION_DCM_CONFIG_CMD_DONE,		HAL_SESSION_DCM_CONFIG_CMD_DONE,
	HAL_SESSION_PYS_HCD_CONFIG_CMD_DONE,		HAL_SESSION_PYS_HCD_CONFIG_CMD_DONE,
	HAL_SESSION_PERSIST_CMD_DONE,		HAL_SESSION_PERSIST_CMD_DONE,
			HAL_SESSION_ICA_FRAME_CMD_DONE,
	HAL_SESSION_PROPERTY_INFO,		HAL_SESSION_PROPERTY_INFO,
	HAL_SESSION_ERROR,		HAL_SESSION_ERROR,
	HAL_RESPONSE_UNUSED = 0x10000000,		HAL_RESPONSE_UNUSED = 0x10000000,
	@@ -571,6 +577,7 @@ void cvp_hfi_deinitialize(enum msm_cvp_hfi_type hfi_type,

	int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr);		int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr);
	int get_signal_from_pkt_type(unsigned int type);		int get_signal_from_pkt_type(unsigned int type);
			int set_feature_bitmask(int pkt_index, unsigned long *bitmask);
	extern const struct msm_cvp_hfi_defs cvp_hfi_defs[];		extern const struct msm_cvp_hfi_defs cvp_hfi_defs[];

	#endif /__CVP_HFI_API_H__ /		#endif /__CVP_HFI_API_H__ /

drivers/media/platform/msm/cvp/hfi_response_handler.c

+15 −21

Original line number	Original line	Diff line number	Diff line
	@@ -16,10 +16,6 @@
	#include "cvp_hfi.h"		#include "cvp_hfi.h"
	#include "msm_cvp_common.h"		#include "msm_cvp_common.h"

	#define DFS_BIT_OFFSET (CVP_KMD_HFI_DFS_FRAME_CMD - CVP_KMD_CMD_START)
	#define DME_BIT_OFFSET (CVP_KMD_HFI_DME_FRAME_CMD - CVP_KMD_CMD_START)
	#define PERSIST_BIT_OFFSET (CVP_KMD_HFI_PERSIST_CMD - CVP_KMD_CMD_START)

	extern struct msm_cvp_drv *cvp_driver;		extern struct msm_cvp_drv *cvp_driver;

	static int _deprecated_hfi_msg_process(u32 device_id,		static int _deprecated_hfi_msg_process(u32 device_id,
	@@ -543,12 +539,11 @@ static int hfi_process_session_cvp_msg(u32 device_id,
	if (inst->deprecate_bitmask) {		if (inst->deprecate_bitmask) {
	if (pkt->packet_type == HFI_MSG_SESSION_CVP_DFS		if (pkt->packet_type == HFI_MSG_SESSION_CVP_DFS
	\|\| pkt->packet_type == HFI_MSG_SESSION_CVP_DME		\|\| pkt->packet_type == HFI_MSG_SESSION_CVP_DME
	\|\| pkt->packet_type ==		\|\| pkt->packet_type == HFI_MSG_SESSION_CVP_ICA)
	HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS)
	return _deprecated_hfi_msg_process(device_id,		return _deprecated_hfi_msg_process(device_id,
	pkt, info, inst);		pkt, info, inst);

	dprintk(CVP_ERR, "Invalid deprecate_bitmask %lx\n",		dprintk(CVP_ERR, "Invalid deprecate_bitmask %#x\n",
	inst->deprecate_bitmask);		inst->deprecate_bitmask);
	}		}

	@@ -606,7 +601,7 @@ static int hfi_process_session_cvp_dme(u32 device_id,
	cmd_done.size = 0;		cmd_done.size = 0;

	dprintk(CVP_DBG,		dprintk(CVP_DBG,
	"%s: device_id=%d cmd_done.status=%d sessionid=%pK\n",		"%s: device_id=%d cmd_done.status=%d sessionid=%#x\n",
	__func__, device_id, cmd_done.status, cmd_done.session_id);		__func__, device_id, cmd_done.status, cmd_done.session_id);
	info->response_type = HAL_SESSION_DME_FRAME_CMD_DONE;		info->response_type = HAL_SESSION_DME_FRAME_CMD_DONE;
	info->response.cmd = cmd_done;		info->response.cmd = cmd_done;
	@@ -614,8 +609,8 @@ static int hfi_process_session_cvp_dme(u32 device_id,
	return 0;		return 0;
	}		}

	static int hfi_process_session_cvp_persist(u32 device_id,		static int hfi_process_session_cvp_ica(u32 device_id,
	struct cvp_hfi_msg_session_persist_packet_type *pkt,		struct cvp_hfi_msg_session_dme_packet_type *pkt,
	struct msm_cvp_cb_info *info)		struct msm_cvp_cb_info *info)
	{		{
	struct msm_cvp_cb_cmd_done cmd_done = {0};		struct msm_cvp_cb_cmd_done cmd_done = {0};
	@@ -623,9 +618,8 @@ static int hfi_process_session_cvp_persist(u32 device_id,
	if (!pkt) {		if (!pkt) {
	dprintk(CVP_ERR, "%s: invalid param\n", __func__);		dprintk(CVP_ERR, "%s: invalid param\n", __func__);
	return -EINVAL;		return -EINVAL;
	} else if (pkt->size < sizeof(*pkt)) {		} else if (pkt->size > sizeof(*pkt)) {
	dprintk(CVP_ERR,		dprintk(CVP_ERR, "%s: bad_pkt_size %d\n", __func__, pkt->size);
	"%s: bad_pkt_size\n", __func__);
	return -E2BIG;		return -E2BIG;
	}		}

	@@ -635,9 +629,9 @@ static int hfi_process_session_cvp_persist(u32 device_id,
	cmd_done.size = 0;		cmd_done.size = 0;

	dprintk(CVP_DBG,		dprintk(CVP_DBG,
	"%s: device_id=%d cmd_done.status=%d sessionid=%pK\n",		"%s: device_id=%d cmd_done.status=%d sessionid=%#x\n",
	__func__, device_id, cmd_done.status, cmd_done.session_id);		__func__, device_id, cmd_done.status, cmd_done.session_id);
	info->response_type = HAL_SESSION_PERSIST_CMD_DONE,		info->response_type = HAL_SESSION_ICA_FRAME_CMD_DONE;
	info->response.cmd = cmd_done;		info->response.cmd = cmd_done;

	return 0;		return 0;
	@@ -660,10 +654,10 @@ static int _deprecated_hfi_msg_process(u32 device_id,
	return hfi_process_session_cvp_dme(		return hfi_process_session_cvp_dme(
	device_id, (void *)pkt, info);		device_id, (void *)pkt, info);

	if (pkt->packet_type == HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS)		if (pkt->packet_type == HFI_MSG_SESSION_CVP_ICA)
	if (test_and_clear_bit(PERSIST_BIT_OFFSET,		if (test_and_clear_bit(ICA_BIT_OFFSET,
	&inst->deprecate_bitmask))		&inst->deprecate_bitmask))
	return hfi_process_session_cvp_persist(		return hfi_process_session_cvp_ica(
	device_id, (void *)pkt, info);		device_id, (void *)pkt, info);

	dprintk(CVP_ERR, "Deprecatd MSG doesn't match bitmask %x %lx\n",		dprintk(CVP_ERR, "Deprecatd MSG doesn't match bitmask %x %lx\n",
	@@ -760,7 +754,7 @@ int cvp_hfi_process_msg_packet(u32 device_id,
	return -EINVAL;		return -EINVAL;
	}		}

	dprintk(CVP_DBG, "Received HFI MSG with type %d\n", msg_hdr->packet);		dprintk(CVP_DBG, "Received HFI MSG with type %#x\n", msg_hdr->packet);
	switch (msg_hdr->packet) {		switch (msg_hdr->packet) {
	case HFI_MSG_EVENT_NOTIFY:		case HFI_MSG_EVENT_NOTIFY:
	pkt_func = (pkt_func_def)hfi_process_event_notify;		pkt_func = (pkt_func_def)hfi_process_event_notify;
	@@ -797,7 +791,7 @@ int cvp_hfi_process_msg_packet(u32 device_id,
	pkt_func = (pkt_func_def)hfi_process_session_cvp_msg;		pkt_func = (pkt_func_def)hfi_process_session_cvp_msg;
	break;		break;
	default:		default:
	dprintk(CVP_DBG, "Unable to parse message: %#x\n",		dprintk(CVP_DBG, "Use default msg handler: %#x\n",
	msg_hdr->packet);		msg_hdr->packet);
	pkt_func = (pkt_func_def)hfi_process_session_cvp_msg;		pkt_func = (pkt_func_def)hfi_process_session_cvp_msg;
	break;		break;

drivers/media/platform/msm/cvp/msm_cvp.c

+135 −6

Original line number	Original line	Diff line number	Diff line
	@@ -4,6 +4,7 @@
	*/		*/

	#include "msm_cvp.h"		#include "msm_cvp.h"
			#include "cvp_hfi.h"
	#include <synx_api.h>		#include <synx_api.h>

	#define MSM_CVP_NOMINAL_CYCLES (444 * 1000 * 1000)		#define MSM_CVP_NOMINAL_CYCLES (444 * 1000 * 1000)
	@@ -405,7 +406,7 @@ static int msm_cvp_session_receive_hfi(struct msm_cvp_inst *inst,

	if (wait_event_timeout(sq->wq,		if (wait_event_timeout(sq->wq,
	_cvp_msg_pending(inst, sq, &msg), wait_time) == 0) {		_cvp_msg_pending(inst, sq, &msg), wait_time) == 0) {
	dprintk(CVP_ERR, "session queue wait timeout\n");		dprintk(CVP_DBG, "session queue wait timeout\n");
	return -ETIMEDOUT;		return -ETIMEDOUT;
	}		}

	@@ -555,6 +556,8 @@ static int msm_cvp_thread_fence_run(void *data)
	struct cvp_kmd_hfi_packet *in_pkt;		struct cvp_kmd_hfi_packet *in_pkt;
	struct msm_cvp_inst *inst;		struct msm_cvp_inst *inst;
	int *fence;		int *fence;
			int ica_enabled = 0;
			int pkt_idx;

	if (!data) {		if (!data) {
	dprintk(CVP_ERR, "%s Wrong input data %pK\n", __func__, data);		dprintk(CVP_ERR, "%s Wrong input data %pK\n", __func__, data);
	@@ -571,12 +574,22 @@ static int msm_cvp_thread_fence_run(void *data)
	in_fence_pkt = (struct cvp_kmd_hfi_fence_packet *)		in_fence_pkt = (struct cvp_kmd_hfi_fence_packet *)
	&fence_thread_data->in_fence_pkt;		&fence_thread_data->in_fence_pkt;
	in_pkt = (struct cvp_kmd_hfi_packet *)(in_fence_pkt);		in_pkt = (struct cvp_kmd_hfi_packet *)(in_fence_pkt);
			pkt_idx = get_pkt_index((struct cvp_hal_session_cmd_pkt *)in_pkt);

			if (pkt_idx < 0) {
			dprintk(CVP_ERR, "%s incorrect packet %d, %x\n", __func__,
			in_pkt->pkt_data[0],
			in_pkt->pkt_data[1]);
			rc = pkt_idx;
			goto exit;
			}

	fence = (int *)(in_fence_pkt->fence_data);		fence = (int *)(in_fence_pkt->fence_data);
	hdev = inst->core->device;		hdev = inst->core->device;

	//wait on synx before signaling HFI		//wait on synx before signaling HFI
	switch (fence_thread_data->arg_type) {		switch (cvp_hfi_defs[pkt_idx].type) {
	case CVP_KMD_HFI_DME_FRAME_FENCE_CMD:		case HFI_CMD_SESSION_CVP_DME_FRAME:
	{		{
	for (i = 0; i < HFI_DME_BUF_NUM-1; i++) {		for (i = 0; i < HFI_DME_BUF_NUM-1; i++) {
	if (fence[(i<<1)]) {		if (fence[(i<<1)]) {
	@@ -602,6 +615,14 @@ static int msm_cvp_thread_fence_run(void *data)
	__func__);		__func__);
	goto exit;		goto exit;
	}		}
			if (i == 0) {
			ica_enabled = 1;
			/*
			* Increase loop count to skip fence
			* waiting on downscale image.
			*/
			i = i+1;
			}
	}		}
	}		}

	@@ -622,6 +643,36 @@ static int msm_cvp_thread_fence_run(void *data)
	__func__, rc);		__func__, rc);
	goto exit;		goto exit;
	}		}

			if (ica_enabled) {
			rc = synx_import(fence[2], fence[3], &synx_obj);
			if (rc) {
			dprintk(CVP_ERR, "%s: synx_import failed\n",
			__func__);
			goto exit;
			}
			rc = synx_signal(synx_obj,
			SYNX_STATE_SIGNALED_SUCCESS);
			if (rc) {
			dprintk(CVP_ERR, "%s: synx_signal failed\n",
			__func__);
			goto exit;
			}
			if (synx_get_status(synx_obj) !=
			SYNX_STATE_SIGNALED_SUCCESS) {
			dprintk(CVP_ERR,
			"%s: synx_get_status failed\n",
			__func__);
			goto exit;
			}
			rc = synx_release(synx_obj);
			if (rc) {
			dprintk(CVP_ERR, "%s: synx_release failed\n",
			__func__);
			goto exit;
			}
			}

	rc = synx_import(fence[((HFI_DME_BUF_NUM-1)<<1)],		rc = synx_import(fence[((HFI_DME_BUF_NUM-1)<<1)],
	fence[((HFI_DME_BUF_NUM-1)<<1)+1],		fence[((HFI_DME_BUF_NUM-1)<<1)+1],
	&synx_obj);		&synx_obj);
	@@ -640,6 +691,83 @@ static int msm_cvp_thread_fence_run(void *data)
	goto exit;		goto exit;
	}		}
	rc = synx_release(synx_obj);		rc = synx_release(synx_obj);
			if (rc) {
			dprintk(CVP_ERR, "%s: synx_release failed\n",
			__func__);
			goto exit;
			}
			break;
			}
			case HFI_CMD_SESSION_CVP_ICA_FRAME:
			{
			for (i = 0; i < cvp_hfi_defs[pkt_idx].buf_num-1; i++) {
			if (fence[(i<<1)]) {
			rc = synx_import(fence[(i<<1)],
			fence[((i<<1)+1)], &synx_obj);
			if (rc) {
			dprintk(CVP_ERR,
			"%s: synx_import failed\n",
			__func__);
			goto exit;
			}
			rc = synx_wait(synx_obj, timeout_ms);
			if (rc) {
			dprintk(CVP_ERR,
			"%s: synx_wait failed\n",
			__func__);
			goto exit;
			}
			rc = synx_release(synx_obj);
			if (rc) {
			dprintk(CVP_ERR,
			"%s: synx_release failed\n",
			__func__);
			goto exit;
			}
			if (i == 0) {
			/*
			* Increase loop count to skip fence
			* waiting on output corrected image.
			*/
			i = i+1;
			}
			}
			}

			rc = call_hfi_op(hdev, session_send,
			(void *)inst->session, in_pkt);
			if (rc) {
			dprintk(CVP_ERR,
			"%s: Failed in call_hfi_op %d, %x\n",
			__func__, in_pkt->pkt_data[0],
			in_pkt->pkt_data[1]);
			goto exit;
			}

			rc = wait_for_sess_signal_receipt(inst,
			HAL_SESSION_ICA_FRAME_CMD_DONE);
			if (rc) {
			dprintk(CVP_ERR, "%s: wait for signal failed, rc %d\n",
			__func__, rc);
			goto exit;
			}

			rc = synx_import(fence[2], fence[3], &synx_obj);
			if (rc) {
			dprintk(CVP_ERR, "%s: synx_import failed\n", __func__);
			goto exit;
			}
			rc = synx_signal(synx_obj, SYNX_STATE_SIGNALED_SUCCESS);
			if (rc) {
			dprintk(CVP_ERR, "%s: synx_signal failed\n", __func__);
			goto exit;
			}
			if (synx_get_status(synx_obj) != SYNX_STATE_SIGNALED_SUCCESS) {
			dprintk(CVP_ERR, "%s: synx_get_status failed\n",
			__func__);
			goto exit;
			}
			rc = synx_release(synx_obj);
	if (rc) {		if (rc) {
	dprintk(CVP_ERR, "%s: synx_release failed\n", __func__);		dprintk(CVP_ERR, "%s: synx_release failed\n", __func__);
	goto exit;		goto exit;
	@@ -857,7 +985,7 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
	print_client_buffer(CVP_DBG, "register", inst, buf);		print_client_buffer(CVP_DBG, "register", inst, buf);

	if (!buf->index) {		if (!buf->index) {
	dprintk(CVP_WARN,		dprintk(CVP_INFO,
	"%s: CPU path register buffer is deprecated!",		"%s: CPU path register buffer is deprecated!",
	__func__);		__func__);
	return 0;		return 0;
	@@ -876,7 +1004,7 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
	print_client_buffer(CVP_DBG, "unregister", inst, buf);		print_client_buffer(CVP_DBG, "unregister", inst, buf);

	if (!buf->index) {		if (!buf->index) {
	dprintk(CVP_WARN,		dprintk(CVP_INFO,
	"%s CPU path unregister buffer is deprecated!\n",		"%s CPU path unregister buffer is deprecated!\n",
	__func__);		__func__);
	return 0;		return 0;
	@@ -1056,6 +1184,7 @@ int msm_cvp_handle_syscall(struct msm_cvp_inst inst, struct cvp_kmd_arg arg)
	break;		break;
	}		}
	case CVP_KMD_HFI_DME_FRAME_FENCE_CMD:		case CVP_KMD_HFI_DME_FRAME_FENCE_CMD:
			case CVP_KMD_SEND_FENCE_CMD_PKT:
	{		{
	rc = msm_cvp_session_process_hfi_fence(inst, arg);		rc = msm_cvp_session_process_hfi_fence(inst, arg);
	break;		break;
	@@ -1064,7 +1193,7 @@ int msm_cvp_handle_syscall(struct msm_cvp_inst inst, struct cvp_kmd_arg arg)
	rc = msm_cvp_session_ctrl(inst, arg);		rc = msm_cvp_session_ctrl(inst, arg);
	break;		break;
	default:		default:
	dprintk(CVP_ERR, "%s: unknown arg type 0x%x\n",		dprintk(CVP_DBG, "%s: unknown arg type %#x\n",
	__func__, arg->type);		__func__, arg->type);
	rc = -ENOTSUPP;		rc = -ENOTSUPP;
	break;		break;