Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wd.c
Go to the documentation of this file.
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 
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 
64 {
65  mei_cl_init(&dev->wd_cl, dev);
66 
67  /* look for WD client and connect to it */
68  dev->wd_cl.state = MEI_FILE_DISCONNECTED;
70  dev->wd_state = MEI_WD_IDLE;
71 
72  /* find ME WD client */
73  mei_me_cl_update_filext(dev, &dev->wd_cl,
74  &mei_wd_guid, MEI_WD_HOST_CLIENT_ID);
75 
76  dev_dbg(&dev->pdev->dev, "wd: check client\n");
77  if (MEI_FILE_CONNECTING != dev->wd_cl.state) {
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 = CONNECT_TIMEOUT;
89 
90  return 0;
91 }
92 
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 
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 
168  dev->wd_state == MEI_WD_IDLE,
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",
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 |
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 
359 {
360  if (watchdog_register_device(&amt_wd_dev)) {
361  dev_err(&dev->pdev->dev,
362  "wd: unable to register watchdog device.\n");
363  dev->wd_interface_reg = false;
364  return;
365  }
366 
367  dev_dbg(&dev->pdev->dev,
368  "wd: successfully register watchdog interface.\n");
369  dev->wd_interface_reg = true;
370  watchdog_set_drvdata(&amt_wd_dev, dev);
371 }
372 
374 {
375  if (!dev->wd_interface_reg)
376  return;
377 
378  watchdog_set_drvdata(&amt_wd_dev, NULL);
379  watchdog_unregister_device(&amt_wd_dev);
380  dev->wd_interface_reg = false;
381 }
382