HID: intel-ish-hid: ishtp-hid-client: use helper functions for connection

[linux-2.6-microblaze.git] / drivers / hid / intel-ish-hid / ishtp-hid-client.c

diff --git a/drivers/hid/intel-ish-hid/ishtp-hid-client.c b/drivers/hid/intel-ish-hid/ishtp-hid-client.c
index e3d70c5..fbd4f8e 100644 (file)
--- a/drivers/hid/intel-ish-hid/ishtp-hid-client.c
+++ b/drivers/hid/intel-ish-hid/ishtp-hid-client.c
@@ -639,47 +639,26 @@ static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
  *
  * Return: 0 on success, non zero on error
  */
-static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
+static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, bool reset)
 {
-       struct ishtp_device *dev;
        struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
-       struct ishtp_fw_client *fw_client;
        int i;
        int rv;
 
        dev_dbg(cl_data_to_dev(client_data), "%s\n", __func__);
        hid_ishtp_trace(client_data,  "%s reset flag: %d\n", __func__, reset);
 
-       rv = ishtp_cl_link(hid_ishtp_cl);
-       if (rv) {
-               dev_err(cl_data_to_dev(client_data),
-                       "ishtp_cl_link failed\n");
-               return  -ENOMEM;
-       }
-
        client_data->init_done = 0;
 
-       dev = ishtp_get_ishtp_device(hid_ishtp_cl);
-
-       /* Connect to FW client */
-       ishtp_set_tx_ring_size(hid_ishtp_cl, HID_CL_TX_RING_SIZE);
-       ishtp_set_rx_ring_size(hid_ishtp_cl, HID_CL_RX_RING_SIZE);
-
-       fw_client = ishtp_fw_cl_get_client(dev, &hid_ishtp_id_table[0].guid);
-       if (!fw_client) {
-               dev_err(cl_data_to_dev(client_data),
-                       "ish client uuid not found\n");
-               return -ENOENT;
-       }
-       ishtp_cl_set_fw_client_id(hid_ishtp_cl,
-                                 ishtp_get_fw_client_id(fw_client));
-       ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_CONNECTING);
-
-       rv = ishtp_cl_connect(hid_ishtp_cl);
+       rv = ishtp_cl_establish_connection(hid_ishtp_cl,
+                                          &hid_ishtp_id_table[0].guid,
+                                          HID_CL_TX_RING_SIZE,
+                                          HID_CL_RX_RING_SIZE,
+                                          reset);
        if (rv) {
                dev_err(cl_data_to_dev(client_data),
                        "client connect fail\n");
-               goto err_cl_unlink;
+               goto err_cl_disconnect;
        }
 
        hid_ishtp_trace(client_data,  "%s client connected\n", __func__);
@@ -723,10 +702,7 @@ static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
        return 0;
 
 err_cl_disconnect:
-       ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
-       ishtp_cl_disconnect(hid_ishtp_cl);
-err_cl_unlink:
-       ishtp_cl_unlink(hid_ishtp_cl);
+       ishtp_cl_destroy_connection(hid_ishtp_cl, reset);
        return rv;
 }
 
@@ -738,8 +714,7 @@ err_cl_unlink:
  */
 static void hid_ishtp_cl_deinit(struct ishtp_cl *hid_ishtp_cl)
 {
-       ishtp_cl_unlink(hid_ishtp_cl);
-       ishtp_cl_flush_queues(hid_ishtp_cl);
+       ishtp_cl_destroy_connection(hid_ishtp_cl, false);
 
        /* disband and free all Tx and Rx client-level rings */
        ishtp_cl_free(hid_ishtp_cl);
@@ -749,33 +724,23 @@ static void hid_ishtp_cl_reset_handler(struct work_struct *work)
 {
        struct ishtp_cl_data *client_data;
        struct ishtp_cl *hid_ishtp_cl;
-       struct ishtp_cl_device *cl_device;
        int retry;
        int rv;
 
        client_data = container_of(work, struct ishtp_cl_data, work);
 
        hid_ishtp_cl = client_data->hid_ishtp_cl;
-       cl_device = client_data->cl_device;
 
        hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
                        hid_ishtp_cl);
        dev_dbg(ishtp_device(client_data->cl_device), "%s\n", __func__);
 
-       hid_ishtp_cl_deinit(hid_ishtp_cl);
-
-       hid_ishtp_cl = ishtp_cl_allocate(cl_device);
-       if (!hid_ishtp_cl)
-               return;
-
-       ishtp_set_drvdata(cl_device, hid_ishtp_cl);
-       ishtp_set_client_data(hid_ishtp_cl, client_data);
-       client_data->hid_ishtp_cl = hid_ishtp_cl;
+       ishtp_cl_destroy_connection(hid_ishtp_cl, true);
 
        client_data->num_hid_devices = 0;
 
        for (retry = 0; retry < 3; ++retry) {
-               rv = hid_ishtp_cl_init(hid_ishtp_cl, 1);
+               rv = hid_ishtp_cl_init(hid_ishtp_cl, true);
                if (!rv)
                        break;
                dev_err(cl_data_to_dev(client_data), "Retry reset init\n");
@@ -841,7 +806,7 @@ static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
 
        ishtp_hid_print_trace = ishtp_trace_callback(cl_device);
 
-       rv = hid_ishtp_cl_init(hid_ishtp_cl, 0);
+       rv = hid_ishtp_cl_init(hid_ishtp_cl, false);
        if (rv) {
                ishtp_cl_free(hid_ishtp_cl);
                return rv;
@@ -868,11 +833,9 @@ static void hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
                        hid_ishtp_cl);
 
        dev_dbg(ishtp_device(cl_device), "%s\n", __func__);
-       ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
-       ishtp_cl_disconnect(hid_ishtp_cl);
+       hid_ishtp_cl_deinit(hid_ishtp_cl);
        ishtp_put_device(cl_device);
        ishtp_hid_remove(client_data);
-       hid_ishtp_cl_deinit(hid_ishtp_cl);
 
        hid_ishtp_cl = NULL;