]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/misc/mei/wd.c
636409f9667f397c7ea3ea972fda636cf171e81d
[~shefty/rdma-dev.git] / drivers / misc / mei / wd.c
1 /*
2  *
3  * Intel Management Engine Interface (Intel MEI) Linux driver
4  * Copyright (c) 2003-2012, Intel Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  */
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/device.h>
20 #include <linux/pci.h>
21 #include <linux/sched.h>
22 #include <linux/watchdog.h>
23
24 #include "mei_dev.h"
25 #include "hw.h"
26 #include "interface.h"
27 #include <linux/mei.h>
28
29 static const u8 mei_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10 };
30 static const u8 mei_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10 };
31
32 const u8 mei_wd_state_independence_msg[3][4] = {
33         {0x05, 0x02, 0x51, 0x10},
34         {0x05, 0x02, 0x52, 0x10},
35         {0x07, 0x02, 0x01, 0x10}
36 };
37
38 /*
39  * AMT Watchdog Device
40  */
41 #define INTEL_AMT_WATCHDOG_ID "INTCAMT"
42
43 /* UUIDs for AMT F/W clients */
44 const uuid_le mei_wd_guid = UUID_LE(0x05B79A6F, 0x4628, 0x4D7F, 0x89,
45                                                 0x9D, 0xA9, 0x15, 0x14, 0xCB,
46                                                 0x32, 0xAB);
47
48 static void mei_wd_set_start_timeout(struct mei_device *dev, u16 timeout)
49 {
50         dev_dbg(&dev->pdev->dev, "wd: set timeout=%d.\n", timeout);
51         memcpy(dev->wd_data, mei_start_wd_params, MEI_WD_HDR_SIZE);
52         memcpy(dev->wd_data + MEI_WD_HDR_SIZE, &timeout, sizeof(u16));
53 }
54
55 /**
56  * mei_wd_host_init - connect to the watchdog client
57  *
58  * @dev: the device structure
59  * returns -ENENT if wd client cannot be found
60  *         -EIO if write has failed
61  *         0 on success
62  */
63 int mei_wd_host_init(struct mei_device *dev)
64 {
65         int id;
66         mei_cl_init(&dev->wd_cl, dev);
67
68         /* look for WD client and connect to it */
69         dev->wd_cl.state = MEI_FILE_DISCONNECTED;
70         dev->wd_timeout = MEI_WD_DEFAULT_TIMEOUT;
71         dev->wd_state = MEI_WD_IDLE;
72
73         /* Connect WD ME client to the host client */
74         id = mei_me_cl_link(dev, &dev->wd_cl,
75                                 &mei_wd_guid, MEI_WD_HOST_CLIENT_ID);
76
77         if (id < 0) {
78                 dev_info(&dev->pdev->dev, "wd: failed to find the client\n");
79                 return -ENOENT;
80         }
81
82         if (mei_connect(dev, &dev->wd_cl)) {
83                 dev_err(&dev->pdev->dev, "wd: failed to connect to the client\n");
84                 dev->wd_cl.state = MEI_FILE_DISCONNECTED;
85                 dev->wd_cl.host_client_id = 0;
86                 return -EIO;
87         }
88         dev->wd_cl.timer_count = MEI_CONNECT_TIMEOUT;
89
90         return 0;
91 }
92
93 /**
94  * mei_wd_send - sends watch dog message to fw.
95  *
96  * @dev: the device structure
97  *
98  * returns 0 if success,
99  *      -EIO when message send fails
100  *      -EINVAL when invalid message is to be sent
101  */
102 int mei_wd_send(struct mei_device *dev)
103 {
104         struct mei_msg_hdr *mei_hdr;
105
106         mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
107         mei_hdr->host_addr = dev->wd_cl.host_client_id;
108         mei_hdr->me_addr = dev->wd_cl.me_client_id;
109         mei_hdr->msg_complete = 1;
110         mei_hdr->reserved = 0;
111
112         if (!memcmp(dev->wd_data, mei_start_wd_params, MEI_WD_HDR_SIZE))
113                 mei_hdr->length = MEI_WD_START_MSG_SIZE;
114         else if (!memcmp(dev->wd_data, mei_stop_wd_params, MEI_WD_HDR_SIZE))
115                 mei_hdr->length = MEI_WD_STOP_MSG_SIZE;
116         else
117                 return -EINVAL;
118
119         return mei_write_message(dev, mei_hdr, dev->wd_data, mei_hdr->length);
120 }
121
122 /**
123  * mei_wd_stop - sends watchdog stop message to fw.
124  *
125  * @dev: the device structure
126  * @preserve: indicate if to keep the timeout value
127  *
128  * returns 0 if success,
129  *      -EIO when message send fails
130  *      -EINVAL when invalid message is to be sent
131  */
132 int mei_wd_stop(struct mei_device *dev)
133 {
134         int ret;
135
136         if (dev->wd_cl.state != MEI_FILE_CONNECTED ||
137             dev->wd_state != MEI_WD_RUNNING)
138                 return 0;
139
140         memcpy(dev->wd_data, mei_stop_wd_params, MEI_WD_STOP_MSG_SIZE);
141
142         dev->wd_state = MEI_WD_STOPPING;
143
144         ret = mei_flow_ctrl_creds(dev, &dev->wd_cl);
145         if (ret < 0)
146                 goto out;
147
148         if (ret && dev->mei_host_buffer_is_empty) {
149                 ret = 0;
150                 dev->mei_host_buffer_is_empty = false;
151
152                 if (!mei_wd_send(dev)) {
153                         ret = mei_flow_ctrl_reduce(dev, &dev->wd_cl);
154                         if (ret)
155                                 goto out;
156                 } else {
157                         dev_err(&dev->pdev->dev, "wd: send stop failed\n");
158                 }
159
160                 dev->wd_pending = false;
161         } else {
162                 dev->wd_pending = true;
163         }
164
165         mutex_unlock(&dev->device_lock);
166
167         ret = wait_event_interruptible_timeout(dev->wait_stop_wd,
168                                         dev->wd_state == MEI_WD_IDLE,
169                                         msecs_to_jiffies(MEI_WD_STOP_TIMEOUT));
170         mutex_lock(&dev->device_lock);
171         if (dev->wd_state == MEI_WD_IDLE) {
172                 dev_dbg(&dev->pdev->dev, "wd: stop completed ret=%d.\n", ret);
173                 ret = 0;
174         } else {
175                 if (!ret)
176                         ret = -ETIMEDOUT;
177                 dev_warn(&dev->pdev->dev,
178                         "wd: stop failed to complete ret=%d.\n", ret);
179         }
180
181 out:
182         return ret;
183 }
184
185 /*
186  * mei_wd_ops_start - wd start command from the watchdog core.
187  *
188  * @wd_dev - watchdog device struct
189  *
190  * returns 0 if success, negative errno code for failure
191  */
192 static int mei_wd_ops_start(struct watchdog_device *wd_dev)
193 {
194         int err = -ENODEV;
195         struct mei_device *dev;
196
197         dev = watchdog_get_drvdata(wd_dev);
198         if (!dev)
199                 return -ENODEV;
200
201         mutex_lock(&dev->device_lock);
202
203         if (dev->dev_state != MEI_DEV_ENABLED) {
204                 dev_dbg(&dev->pdev->dev,
205                         "wd: dev_state != MEI_DEV_ENABLED  dev_state = %s\n",
206                         mei_dev_state_str(dev->dev_state));
207                 goto end_unlock;
208         }
209
210         if (dev->wd_cl.state != MEI_FILE_CONNECTED)     {
211                 dev_dbg(&dev->pdev->dev,
212                         "MEI Driver is not connected to Watchdog Client\n");
213                 goto end_unlock;
214         }
215
216         mei_wd_set_start_timeout(dev, dev->wd_timeout);
217
218         err = 0;
219 end_unlock:
220         mutex_unlock(&dev->device_lock);
221         return err;
222 }
223
224 /*
225  * mei_wd_ops_stop -  wd stop command from the watchdog core.
226  *
227  * @wd_dev - watchdog device struct
228  *
229  * returns 0 if success, negative errno code for failure
230  */
231 static int mei_wd_ops_stop(struct watchdog_device *wd_dev)
232 {
233         struct mei_device *dev;
234
235         dev = watchdog_get_drvdata(wd_dev);
236         if (!dev)
237                 return -ENODEV;
238
239         mutex_lock(&dev->device_lock);
240         mei_wd_stop(dev);
241         mutex_unlock(&dev->device_lock);
242
243         return 0;
244 }
245
246 /*
247  * mei_wd_ops_ping - wd ping command from the watchdog core.
248  *
249  * @wd_dev - watchdog device struct
250  *
251  * returns 0 if success, negative errno code for failure
252  */
253 static int mei_wd_ops_ping(struct watchdog_device *wd_dev)
254 {
255         int ret = 0;
256         struct mei_device *dev;
257
258         dev = watchdog_get_drvdata(wd_dev);
259         if (!dev)
260                 return -ENODEV;
261
262         mutex_lock(&dev->device_lock);
263
264         if (dev->wd_cl.state != MEI_FILE_CONNECTED) {
265                 dev_err(&dev->pdev->dev, "wd: not connected.\n");
266                 ret = -ENODEV;
267                 goto end;
268         }
269
270         dev->wd_state = MEI_WD_RUNNING;
271
272         /* Check if we can send the ping to HW*/
273         if (dev->mei_host_buffer_is_empty &&
274                 mei_flow_ctrl_creds(dev, &dev->wd_cl) > 0) {
275
276                 dev->mei_host_buffer_is_empty = false;
277                 dev_dbg(&dev->pdev->dev, "wd: sending ping\n");
278
279                 if (mei_wd_send(dev)) {
280                         dev_err(&dev->pdev->dev, "wd: send failed.\n");
281                         ret = -EIO;
282                         goto end;
283                 }
284
285                 if (mei_flow_ctrl_reduce(dev, &dev->wd_cl)) {
286                         dev_err(&dev->pdev->dev,
287                                 "wd: mei_flow_ctrl_reduce() failed.\n");
288                         ret = -EIO;
289                         goto end;
290                 }
291
292         } else {
293                 dev->wd_pending = true;
294         }
295
296 end:
297         mutex_unlock(&dev->device_lock);
298         return ret;
299 }
300
301 /*
302  * mei_wd_ops_set_timeout - wd set timeout command from the watchdog core.
303  *
304  * @wd_dev - watchdog device struct
305  * @timeout - timeout value to set
306  *
307  * returns 0 if success, negative errno code for failure
308  */
309 static int mei_wd_ops_set_timeout(struct watchdog_device *wd_dev, unsigned int timeout)
310 {
311         struct mei_device *dev;
312
313         dev = watchdog_get_drvdata(wd_dev);
314         if (!dev)
315                 return -ENODEV;
316
317         /* Check Timeout value */
318         if (timeout < MEI_WD_MIN_TIMEOUT || timeout > MEI_WD_MAX_TIMEOUT)
319                 return -EINVAL;
320
321         mutex_lock(&dev->device_lock);
322
323         dev->wd_timeout = timeout;
324         wd_dev->timeout = timeout;
325         mei_wd_set_start_timeout(dev, dev->wd_timeout);
326
327         mutex_unlock(&dev->device_lock);
328
329         return 0;
330 }
331
332 /*
333  * Watchdog Device structs
334  */
335 static const struct watchdog_ops wd_ops = {
336                 .owner = THIS_MODULE,
337                 .start = mei_wd_ops_start,
338                 .stop = mei_wd_ops_stop,
339                 .ping = mei_wd_ops_ping,
340                 .set_timeout = mei_wd_ops_set_timeout,
341 };
342 static const struct watchdog_info wd_info = {
343                 .identity = INTEL_AMT_WATCHDOG_ID,
344                 .options = WDIOF_KEEPALIVEPING |
345                            WDIOF_SETTIMEOUT |
346                            WDIOF_ALARMONLY,
347 };
348
349 static struct watchdog_device amt_wd_dev = {
350                 .info = &wd_info,
351                 .ops = &wd_ops,
352                 .timeout = MEI_WD_DEFAULT_TIMEOUT,
353                 .min_timeout = MEI_WD_MIN_TIMEOUT,
354                 .max_timeout = MEI_WD_MAX_TIMEOUT,
355 };
356
357
358 void mei_watchdog_register(struct mei_device *dev)
359 {
360         if (watchdog_register_device(&amt_wd_dev)) {
361                 dev_err(&dev->pdev->dev,
362                         "wd: unable to register watchdog device.\n");
363                 return;
364         }
365
366         dev_dbg(&dev->pdev->dev,
367                 "wd: successfully register watchdog interface.\n");
368         watchdog_set_drvdata(&amt_wd_dev, dev);
369 }
370
371 void mei_watchdog_unregister(struct mei_device *dev)
372 {
373         if (test_bit(WDOG_UNREGISTERED, &amt_wd_dev.status))
374                 return;
375
376         watchdog_set_drvdata(&amt_wd_dev, NULL);
377         watchdog_unregister_device(&amt_wd_dev);
378 }
379