ALSA: asihpi - Remove controlex structs and associated special data transfer code

Some cobranet control data would not fit in an original HPI message.
Now that HPI is able to transfer larger messages, this special handling
is no longer required.

Signed-off-by: Eliot Blennerhassett <eblennerhassett@audioscience.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

3 files changed, 76 insertions, 160 deletions

diff --git a/sound/pci/asihpi/hpi6205.c b/sound/pci/asihpi/hpi6205.c
index 8831a6f179e3..d011932c952f 100644
--- a/sound/pci/asihpi/hpi6205.c
+++ b/sound/pci/asihpi/hpi6205.c
@@ -402,7 +402,6 @@ void _HPI_6205(struct hpi_adapter_obj *pao, struct hpi_message *phm,
                         adapter_message(pao, phm, phr);
                         break;
 
-                case HPI_OBJ_CONTROLEX:
                 case HPI_OBJ_CONTROL:
                         control_message(pao, phm, phr);
                         break;
@@ -2204,23 +2203,6 @@ static void hw_message(struct hpi_adapter_obj *pao, struct hpi_message *phm,
                         phm->u.d.u.data.data_size, H620_HIF_GET_DATA);
                 break;
 
-        case HPI_CONTROL_SET_STATE:
-                if (phm->object == HPI_OBJ_CONTROLEX
-                        && phm->u.cx.attribute == HPI_COBRANET_SET_DATA)
-                        err = hpi6205_transfer_data(pao,
-                                phm->u.cx.u.cobranet_bigdata.pb_data,
-                                phm->u.cx.u.cobranet_bigdata.byte_count,
-                                H620_HIF_SEND_DATA);
-                break;
-
-        case HPI_CONTROL_GET_STATE:
-                if (phm->object == HPI_OBJ_CONTROLEX
-                        && phm->u.cx.attribute == HPI_COBRANET_GET_DATA)
-                        err = hpi6205_transfer_data(pao,
-                                phm->u.cx.u.cobranet_bigdata.pb_data,
-                                phr->u.cx.u.cobranet_data.byte_count,
-                                H620_HIF_GET_DATA);
-                break;
         }
         phr->error = err;
 
diff --git a/sound/pci/asihpi/hpi_internal.h b/sound/pci/asihpi/hpi_internal.h
index ce5d7cda6dad..848fb7596ae4 100644
--- a/sound/pci/asihpi/hpi_internal.h
+++ b/sound/pci/asihpi/hpi_internal.h
@@ -226,8 +226,8 @@ enum HPI_CONTROL_ATTRIBUTES {
 
         HPI_COBRANET_SET = HPI_CTL_ATTR(COBRANET, 1),
         HPI_COBRANET_GET = HPI_CTL_ATTR(COBRANET, 2),
-        HPI_COBRANET_SET_DATA = HPI_CTL_ATTR(COBRANET, 3),
-        HPI_COBRANET_GET_DATA = HPI_CTL_ATTR(COBRANET, 4),
+        /*HPI_COBRANET_SET_DATA         = HPI_CTL_ATTR(COBRANET, 3), */
+        /*HPI_COBRANET_GET_DATA         = HPI_CTL_ATTR(COBRANET, 4), */
         HPI_COBRANET_GET_STATUS = HPI_CTL_ATTR(COBRANET, 5),
         HPI_COBRANET_SEND_PACKET = HPI_CTL_ATTR(COBRANET, 6),
         HPI_COBRANET_GET_PACKET = HPI_CTL_ATTR(COBRANET, 7),
@@ -383,7 +383,7 @@ enum HPI_OBJECT_TYPES {
         HPI_OBJ_WATCHDOG = 10,
         HPI_OBJ_CLOCK = 11,
         HPI_OBJ_PROFILE = 12,
-        HPI_OBJ_CONTROLEX = 13,
+        /* HPI_ OBJ_ CONTROLEX  = 13, */
         HPI_OBJ_ASYNCEVENT = 14
 #define HPI_OBJ_MAXINDEX 14
 };
@@ -912,95 +912,13 @@ union hpi_control_union_res {
                 u32 remaining_chars;
         } chars8;
         char c_data12[12];
-};
-
-/* HPI_CONTROLX_STRUCTURES */
-
-/* Message */
-
-/** Used for all HMI variables where max length <= 8 bytes
-*/
-struct hpi_controlx_msg_cobranet_data {
-        u32 hmi_address;
-        u32 byte_count;
-        u32 data[2];
-};
-
-/** Used for string data, and for packet bridge
-*/
-struct hpi_controlx_msg_cobranet_bigdata {
-        u32 hmi_address;
-        u32 byte_count;
-        u8 *pb_data;
-#ifndef HPI64BIT
-        u32 padding;
-#endif
-};
-
-/** Used for PADS control reading of string fields.
-*/
-struct hpi_controlx_msg_pad_data {
-        u32 field;
-        u32 byte_count;
-        u8 *pb_data;
-#ifndef HPI64BIT
-        u32 padding;
-#endif
-};
-
-/** Used for generic data
-*/
-
-struct hpi_controlx_msg_generic {
-        u32 param1;
-        u32 param2;
-};
-
-struct hpi_controlx_msg {
-        u16 attribute;          /* control attribute or property */
-        u16 saved_index;
         union {
-                struct hpi_controlx_msg_cobranet_data cobranet_data;
-                struct hpi_controlx_msg_cobranet_bigdata cobranet_bigdata;
-                struct hpi_controlx_msg_generic generic;
-                struct hpi_controlx_msg_pad_data pad_data;
-                /*struct param_value universal_value; */
-                /* nothing extra to send for status read */
-        } u;
-};
-
-/* Response */
-/**
-*/
-struct hpi_controlx_res_cobranet_data {
-        u32 byte_count;
-        u32 data[2];
-};
-
-struct hpi_controlx_res_cobranet_bigdata {
-        u32 byte_count;
-};
-
-struct hpi_controlx_res_cobranet_status {
-        u32 status;
-        u32 readable_size;
-        u32 writeable_size;
-};
-
-struct hpi_controlx_res_generic {
-        u32 param1;
-        u32 param2;
-};
-
-struct hpi_controlx_res {
-        union {
-                struct hpi_controlx_res_cobranet_bigdata cobranet_bigdata;
-                struct hpi_controlx_res_cobranet_data cobranet_data;
-                struct hpi_controlx_res_cobranet_status cobranet_status;
-                struct hpi_controlx_res_generic generic;
-                /*struct param_info universal_info; */
-                /*struct param_value universal_value; */
-        } u;
+                struct {
+                        u32 status;
+                        u32 readable_size;
+                        u32 writeable_size;
+                } status;
+        } cobranet;
 };
 
 struct hpi_nvmemory_msg {
@@ -1126,7 +1044,6 @@ struct hpi_message {
                 /* identical to struct hpi_control_msg,
                    but field naming is improved */
                 struct hpi_control_union_msg cu;
-                struct hpi_controlx_msg cx;     /* extended mixer control; */
                 struct hpi_nvmemory_msg n;
                 struct hpi_gpio_msg l;  /* digital i/o */
                 struct hpi_watchdog_msg w;
@@ -1151,7 +1068,7 @@ struct hpi_message {
         sizeof(struct hpi_message_header) + sizeof(struct hpi_watchdog_msg),\
         sizeof(struct hpi_message_header) + sizeof(struct hpi_clock_msg),\
         sizeof(struct hpi_message_header) + sizeof(struct hpi_profile_msg),\
-        sizeof(struct hpi_message_header) + sizeof(struct hpi_controlx_msg),\
+        sizeof(struct hpi_message_header), /* controlx obj removed */ \
         sizeof(struct hpi_message_header) + sizeof(struct hpi_async_msg) \
 }
 
@@ -1188,7 +1105,6 @@ struct hpi_response {
                 struct hpi_control_res c;       /* mixer control; */
                 /* identical to hpi_control_res, but field naming is improved */
                 union hpi_control_union_res cu;
-                struct hpi_controlx_res cx;     /* extended mixer control; */
                 struct hpi_nvmemory_res n;
                 struct hpi_gpio_res l;  /* digital i/o */
                 struct hpi_watchdog_res w;
@@ -1213,7 +1129,7 @@ struct hpi_response {
         sizeof(struct hpi_response_header) + sizeof(struct hpi_watchdog_res),\
         sizeof(struct hpi_response_header) + sizeof(struct hpi_clock_res),\
         sizeof(struct hpi_response_header) + sizeof(struct hpi_profile_res),\
-        sizeof(struct hpi_response_header) + sizeof(struct hpi_controlx_res),\
+        sizeof(struct hpi_response_header), /* controlx obj removed */ \
         sizeof(struct hpi_response_header) + sizeof(struct hpi_async_res) \
 }
 
@@ -1308,6 +1224,30 @@ struct hpi_res_adapter_debug_read {
         u8 bytes[256];
 };
 
+struct hpi_msg_cobranet_hmi {
+        u16 attribute;
+        u16 padding;
+        u32 hmi_address;
+        u32 byte_count;
+};
+
+struct hpi_msg_cobranet_hmiwrite {
+        struct hpi_message_header h;
+        struct hpi_msg_cobranet_hmi p;
+        u8 bytes[256];
+};
+
+struct hpi_msg_cobranet_hmiread {
+        struct hpi_message_header h;
+        struct hpi_msg_cobranet_hmi p;
+};
+
+struct hpi_res_cobranet_hmiread {
+        struct hpi_response_header h;
+        u32 byte_count;
+        u8 bytes[256];
+};
+
 #if 1
 #define hpi_message_header_v1 hpi_message_header
 #define hpi_response_header_v1 hpi_response_header
@@ -1338,7 +1278,6 @@ struct hpi_msg_payload_v0 {
                 union hpi_mixerx_msg mx;
                 struct hpi_control_msg c;
                 struct hpi_control_union_msg cu;
-                struct hpi_controlx_msg cx;
                 struct hpi_nvmemory_msg n;
                 struct hpi_gpio_msg l;
                 struct hpi_watchdog_msg w;
@@ -1358,7 +1297,6 @@ struct hpi_res_payload_v0 {
                 union hpi_mixerx_res mx;
                 struct hpi_control_res c;
                 union hpi_control_union_res cu;
-                struct hpi_controlx_res cx;
                 struct hpi_nvmemory_res n;
                 struct hpi_gpio_res l;
                 struct hpi_watchdog_res w;
diff --git a/sound/pci/asihpi/hpifunc.c b/sound/pci/asihpi/hpifunc.c
index 7397b169b89f..ebb568d695f1 100644
--- a/sound/pci/asihpi/hpifunc.c
+++ b/sound/pci/asihpi/hpifunc.c
@@ -1663,68 +1663,64 @@ u16 hpi_channel_mode_get(u32 h_control, u16 *mode)
 u16 hpi_cobranet_hmi_write(u32 h_control, u32 hmi_address, u32 byte_count,
         u8 *pb_data)
 {
-        struct hpi_message hm;
-        struct hpi_response hr;
+        struct hpi_msg_cobranet_hmiwrite hm;
+        struct hpi_response_header hr;
 
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
-                HPI_CONTROL_SET_STATE);
-        if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
-                return HPI_ERROR_INVALID_HANDLE;
+        hpi_init_message_responseV1(&hm.h, sizeof(hm), &hr, sizeof(hr),
+                HPI_OBJ_CONTROL, HPI_CONTROL_SET_STATE);
 
-        hm.u.cx.u.cobranet_data.byte_count = byte_count;
-        hm.u.cx.u.cobranet_data.hmi_address = hmi_address;
+        if (hpi_handle_indexes(h_control, &hm.h.adapter_index,
+                        &hm.h.obj_index))
+                return HPI_ERROR_INVALID_HANDLE;
 
-        if (byte_count <= 8) {
-                memcpy(hm.u.cx.u.cobranet_data.data, pb_data, byte_count);
-                hm.u.cx.attribute = HPI_COBRANET_SET;
-        } else {
-                hm.u.cx.u.cobranet_bigdata.pb_data = pb_data;
-                hm.u.cx.attribute = HPI_COBRANET_SET_DATA;
-        }
+        if (byte_count > sizeof(hm.bytes))
+                return HPI_ERROR_MESSAGE_BUFFER_TOO_SMALL;
 
-        hpi_send_recv(&hm, &hr);
+        hm.p.attribute = HPI_COBRANET_SET;
+        hm.p.byte_count = byte_count;
+        hm.p.hmi_address = hmi_address;
+        memcpy(hm.bytes, pb_data, byte_count);
+        hm.h.size = (u16)(sizeof(hm.h) + sizeof(hm.p) + byte_count);
 
+        hpi_send_recvV1(&hm.h, &hr);
         return hr.error;
 }
 
 u16 hpi_cobranet_hmi_read(u32 h_control, u32 hmi_address, u32 max_byte_count,
         u32 *pbyte_count, u8 *pb_data)
 {
-        struct hpi_message hm;
-        struct hpi_response hr;
+        struct hpi_msg_cobranet_hmiread hm;
+        struct hpi_res_cobranet_hmiread hr;
 
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
-                HPI_CONTROL_GET_STATE);
-        if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
+        hpi_init_message_responseV1(&hm.h, sizeof(hm), &hr.h, sizeof(hr),
+                HPI_OBJ_CONTROL, HPI_CONTROL_GET_STATE);
+
+        if (hpi_handle_indexes(h_control, &hm.h.adapter_index,
+                        &hm.h.obj_index))
                 return HPI_ERROR_INVALID_HANDLE;
 
-        hm.u.cx.u.cobranet_data.byte_count = max_byte_count;
-        hm.u.cx.u.cobranet_data.hmi_address = hmi_address;
+        if (max_byte_count > sizeof(hr.bytes))
+                return HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL;
 
-        if (max_byte_count <= 8) {
-                hm.u.cx.attribute = HPI_COBRANET_GET;
-        } else {
-                hm.u.cx.u.cobranet_bigdata.pb_data = pb_data;
-                hm.u.cx.attribute = HPI_COBRANET_GET_DATA;
-        }
+        hm.p.attribute = HPI_COBRANET_GET;
+        hm.p.byte_count = max_byte_count;
+        hm.p.hmi_address = hmi_address;
 
-        hpi_send_recv(&hm, &hr);
-        if (!hr.error && pb_data) {
+        hpi_send_recvV1(&hm.h, &hr.h);
 
-                *pbyte_count = hr.u.cx.u.cobranet_data.byte_count;
+        if (!hr.h.error && pb_data) {
+                if (hr.byte_count > sizeof(hr.bytes))
 
-                if (*pbyte_count < max_byte_count)
-                        max_byte_count = *pbyte_count;
+                        return HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL;
 
-                if (hm.u.cx.attribute == HPI_COBRANET_GET) {
-                        memcpy(pb_data, hr.u.cx.u.cobranet_data.data,
-                                max_byte_count);
-                } else {
+                *pbyte_count = hr.byte_count;
 
-                }
+                if (hr.byte_count < max_byte_count)
+                        max_byte_count = *pbyte_count;
 
+                memcpy(pb_data, hr.bytes, max_byte_count);
         }
-        return hr.error;
+        return hr.h.error;
 }
 
 u16 hpi_cobranet_hmi_get_status(u32 h_control, u32 *pstatus,
@@ -1733,23 +1729,23 @@ u16 hpi_cobranet_hmi_get_status(u32 h_control, u32 *pstatus,
         struct hpi_message hm;
         struct hpi_response hr;
 
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
+        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
                 return HPI_ERROR_INVALID_HANDLE;
 
-        hm.u.cx.attribute = HPI_COBRANET_GET_STATUS;
+        hm.u.c.attribute = HPI_COBRANET_GET_STATUS;
 
         hpi_send_recv(&hm, &hr);
         if (!hr.error) {
                 if (pstatus)
-                        *pstatus = hr.u.cx.u.cobranet_status.status;
+                        *pstatus = hr.u.cu.cobranet.status.status;
                 if (preadable_size)
                         *preadable_size =
-                                hr.u.cx.u.cobranet_status.readable_size;
+                                hr.u.cu.cobranet.status.readable_size;
                 if (pwriteable_size)
                         *pwriteable_size =
-                                hr.u.cx.u.cobranet_status.writeable_size;
+                                hr.u.cu.cobranet.status.writeable_size;
         }
         return hr.error;
 }