blob: 428d21e364160f0002a1ccb5e07c01fb42c94c41 [file] [log] [blame]
Oren Weil3ce72722011-05-15 13:43:43 +03001/*
2 *
3 * Intel Management Engine Interface (Intel MEI) Linux driver
Tomas Winkler733ba912012-02-09 19:25:53 +02004 * Copyright (c) 2003-2012, Intel Corporation.
Oren Weil3ce72722011-05-15 13:43:43 +03005 *
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
17#include <linux/pci.h>
18#include "mei_dev.h"
Tomas Winkler4f3afe12012-05-09 16:38:59 +030019#include <linux/mei.h>
Oren Weil3ce72722011-05-15 13:43:43 +030020#include "interface.h"
21
22
23
24/**
25 * mei_set_csr_register - writes H_CSR register to the mei device,
26 * and ignores the H_IS bit for it is write-one-to-zero.
27 *
28 * @dev: the device structure
29 */
30void mei_hcsr_set(struct mei_device *dev)
31{
32 if ((dev->host_hw_state & H_IS) == H_IS)
33 dev->host_hw_state &= ~H_IS;
34 mei_reg_write(dev, H_CSR, dev->host_hw_state);
35 dev->host_hw_state = mei_hcsr_read(dev);
36}
37
38/**
39 * mei_csr_enable_interrupts - enables mei device interrupts
40 *
41 * @dev: the device structure
42 */
43void mei_enable_interrupts(struct mei_device *dev)
44{
45 dev->host_hw_state |= H_IE;
46 mei_hcsr_set(dev);
47}
48
49/**
50 * mei_csr_disable_interrupts - disables mei device interrupts
51 *
52 * @dev: the device structure
53 */
54void mei_disable_interrupts(struct mei_device *dev)
55{
56 dev->host_hw_state &= ~H_IE;
57 mei_hcsr_set(dev);
58}
59
60/**
61 * _host_get_filled_slots - gets number of device filled buffer slots
62 *
63 * @device: the device structure
64 *
65 * returns number of filled slots
66 */
67static unsigned char _host_get_filled_slots(const struct mei_device *dev)
68{
69 char read_ptr, write_ptr;
70
71 read_ptr = (char) ((dev->host_hw_state & H_CBRP) >> 8);
72 write_ptr = (char) ((dev->host_hw_state & H_CBWP) >> 16);
73
74 return (unsigned char) (write_ptr - read_ptr);
75}
76
77/**
78 * mei_host_buffer_is_empty - checks if host buffer is empty.
79 *
80 * @dev: the device structure
81 *
82 * returns 1 if empty, 0 - otherwise.
83 */
84int mei_host_buffer_is_empty(struct mei_device *dev)
85{
86 unsigned char filled_slots;
87
88 dev->host_hw_state = mei_hcsr_read(dev);
89 filled_slots = _host_get_filled_slots(dev);
90
91 if (filled_slots == 0)
92 return 1;
93
94 return 0;
95}
96
97/**
98 * mei_count_empty_write_slots - counts write empty slots.
99 *
100 * @dev: the device structure
101 *
102 * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
103 */
104int mei_count_empty_write_slots(struct mei_device *dev)
105{
106 unsigned char buffer_depth, filled_slots, empty_slots;
107
108 dev->host_hw_state = mei_hcsr_read(dev);
109 buffer_depth = (unsigned char) ((dev->host_hw_state & H_CBD) >> 24);
110 filled_slots = _host_get_filled_slots(dev);
111 empty_slots = buffer_depth - filled_slots;
112
113 /* check for overflow */
114 if (filled_slots > buffer_depth)
115 return -EOVERFLOW;
116
117 return empty_slots;
118}
119
120/**
121 * mei_write_message - writes a message to mei device.
122 *
123 * @dev: the device structure
124 * @header: header of message
125 * @write_buffer: message buffer will be written
126 * @write_length: message size will be written
127 *
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200128 * This function returns -EIO if write has failed
Oren Weil3ce72722011-05-15 13:43:43 +0300129 */
130int mei_write_message(struct mei_device *dev,
Tomas Winkler441ab502011-12-13 23:39:34 +0200131 struct mei_msg_hdr *header,
132 unsigned char *write_buffer,
133 unsigned long write_length)
Oren Weil3ce72722011-05-15 13:43:43 +0300134{
135 u32 temp_msg = 0;
136 unsigned long bytes_written = 0;
137 unsigned char buffer_depth, filled_slots, empty_slots;
138 unsigned long dw_to_write;
139
140 dev->host_hw_state = mei_hcsr_read(dev);
141
142 dev_dbg(&dev->pdev->dev,
143 "host_hw_state = 0x%08x.\n",
144 dev->host_hw_state);
145
146 dev_dbg(&dev->pdev->dev,
147 "mei_write_message header=%08x.\n",
148 *((u32 *) header));
149
150 buffer_depth = (unsigned char) ((dev->host_hw_state & H_CBD) >> 24);
151 filled_slots = _host_get_filled_slots(dev);
152 empty_slots = buffer_depth - filled_slots;
153 dev_dbg(&dev->pdev->dev,
154 "filled = %hu, empty = %hu.\n",
155 filled_slots, empty_slots);
156
157 dw_to_write = ((write_length + 3) / 4);
158
159 if (dw_to_write > empty_slots)
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200160 return -EIO;
Oren Weil3ce72722011-05-15 13:43:43 +0300161
162 mei_reg_write(dev, H_CB_WW, *((u32 *) header));
163
164 while (write_length >= 4) {
165 mei_reg_write(dev, H_CB_WW,
166 *(u32 *) (write_buffer + bytes_written));
167 bytes_written += 4;
168 write_length -= 4;
169 }
170
171 if (write_length > 0) {
172 memcpy(&temp_msg, &write_buffer[bytes_written], write_length);
173 mei_reg_write(dev, H_CB_WW, temp_msg);
174 }
175
176 dev->host_hw_state |= H_IG;
177 mei_hcsr_set(dev);
178 dev->me_hw_state = mei_mecsr_read(dev);
179 if ((dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200180 return -EIO;
Oren Weil3ce72722011-05-15 13:43:43 +0300181
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200182 return 0;
Oren Weil3ce72722011-05-15 13:43:43 +0300183}
184
185/**
186 * mei_count_full_read_slots - counts read full slots.
187 *
188 * @dev: the device structure
189 *
190 * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
191 */
192int mei_count_full_read_slots(struct mei_device *dev)
193{
194 char read_ptr, write_ptr;
195 unsigned char buffer_depth, filled_slots;
196
197 dev->me_hw_state = mei_mecsr_read(dev);
198 buffer_depth = (unsigned char)((dev->me_hw_state & ME_CBD_HRA) >> 24);
199 read_ptr = (char) ((dev->me_hw_state & ME_CBRP_HRA) >> 8);
200 write_ptr = (char) ((dev->me_hw_state & ME_CBWP_HRA) >> 16);
201 filled_slots = (unsigned char) (write_ptr - read_ptr);
202
203 /* check for overflow */
204 if (filled_slots > buffer_depth)
205 return -EOVERFLOW;
206
207 dev_dbg(&dev->pdev->dev, "filled_slots =%08x\n", filled_slots);
208 return (int)filled_slots;
209}
210
211/**
212 * mei_read_slots - reads a message from mei device.
213 *
214 * @dev: the device structure
215 * @buffer: message buffer will be written
216 * @buffer_length: message size will be read
217 */
Tomas Winkleredf1eed2012-02-09 19:25:54 +0200218void mei_read_slots(struct mei_device *dev, unsigned char *buffer,
219 unsigned long buffer_length)
Oren Weil3ce72722011-05-15 13:43:43 +0300220{
Tomas Winkleredf1eed2012-02-09 19:25:54 +0200221 u32 *reg_buf = (u32 *)buffer;
Oren Weil3ce72722011-05-15 13:43:43 +0300222
Tomas Winkleredf1eed2012-02-09 19:25:54 +0200223 for (; buffer_length >= sizeof(u32); buffer_length -= sizeof(u32))
224 *reg_buf++ = mei_mecbrw_read(dev);
Oren Weil3ce72722011-05-15 13:43:43 +0300225
226 if (buffer_length > 0) {
Tomas Winkleredf1eed2012-02-09 19:25:54 +0200227 u32 reg = mei_mecbrw_read(dev);
228 memcpy(reg_buf, &reg, buffer_length);
Oren Weil3ce72722011-05-15 13:43:43 +0300229 }
230
231 dev->host_hw_state |= H_IG;
232 mei_hcsr_set(dev);
233}
234
235/**
236 * mei_flow_ctrl_creds - checks flow_control credentials.
237 *
238 * @dev: the device structure
239 * @cl: private data of the file object
240 *
241 * returns 1 if mei_flow_ctrl_creds >0, 0 - otherwise.
242 * -ENOENT if mei_cl is not present
243 * -EINVAL if single_recv_buf == 0
244 */
245int mei_flow_ctrl_creds(struct mei_device *dev, struct mei_cl *cl)
246{
247 int i;
248
Tomas Winklercf9673d2011-06-06 10:44:33 +0300249 if (!dev->me_clients_num)
Oren Weil3ce72722011-05-15 13:43:43 +0300250 return 0;
251
252 if (cl->mei_flow_ctrl_creds > 0)
253 return 1;
254
Tomas Winklercf9673d2011-06-06 10:44:33 +0300255 for (i = 0; i < dev->me_clients_num; i++) {
Oren Weil3ce72722011-05-15 13:43:43 +0300256 struct mei_me_client *me_cl = &dev->me_clients[i];
257 if (me_cl->client_id == cl->me_client_id) {
258 if (me_cl->mei_flow_ctrl_creds) {
259 if (WARN_ON(me_cl->props.single_recv_buf == 0))
260 return -EINVAL;
261 return 1;
262 } else {
263 return 0;
264 }
265 }
266 }
267 return -ENOENT;
268}
269
270/**
271 * mei_flow_ctrl_reduce - reduces flow_control.
272 *
273 * @dev: the device structure
274 * @cl: private data of the file object
275 * @returns
276 * 0 on success
277 * -ENOENT when me client is not found
Justin P. Mattock5f9092f32012-03-12 07:18:09 -0700278 * -EINVAL when ctrl credits are <= 0
Oren Weil3ce72722011-05-15 13:43:43 +0300279 */
280int mei_flow_ctrl_reduce(struct mei_device *dev, struct mei_cl *cl)
281{
282 int i;
283
Tomas Winklercf9673d2011-06-06 10:44:33 +0300284 if (!dev->me_clients_num)
Oren Weil3ce72722011-05-15 13:43:43 +0300285 return -ENOENT;
286
Tomas Winklercf9673d2011-06-06 10:44:33 +0300287 for (i = 0; i < dev->me_clients_num; i++) {
Oren Weil3ce72722011-05-15 13:43:43 +0300288 struct mei_me_client *me_cl = &dev->me_clients[i];
289 if (me_cl->client_id == cl->me_client_id) {
290 if (me_cl->props.single_recv_buf != 0) {
291 if (WARN_ON(me_cl->mei_flow_ctrl_creds <= 0))
292 return -EINVAL;
293 dev->me_clients[i].mei_flow_ctrl_creds--;
294 } else {
295 if (WARN_ON(cl->mei_flow_ctrl_creds <= 0))
296 return -EINVAL;
297 cl->mei_flow_ctrl_creds--;
298 }
299 return 0;
300 }
301 }
302 return -ENOENT;
303}
304
305/**
306 * mei_send_flow_control - sends flow control to fw.
307 *
308 * @dev: the device structure
309 * @cl: private data of the file object
310 *
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200311 * This function returns -EIO on write failure
Oren Weil3ce72722011-05-15 13:43:43 +0300312 */
313int mei_send_flow_control(struct mei_device *dev, struct mei_cl *cl)
314{
315 struct mei_msg_hdr *mei_hdr;
316 struct hbm_flow_control *mei_flow_control;
317
318 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
319 mei_hdr->host_addr = 0;
320 mei_hdr->me_addr = 0;
321 mei_hdr->length = sizeof(struct hbm_flow_control);
322 mei_hdr->msg_complete = 1;
323 mei_hdr->reserved = 0;
324
325 mei_flow_control = (struct hbm_flow_control *) &dev->wr_msg_buf[1];
Julia Lawallc0569982011-09-16 08:57:33 +0200326 memset(mei_flow_control, 0, sizeof(*mei_flow_control));
Oren Weil3ce72722011-05-15 13:43:43 +0300327 mei_flow_control->host_addr = cl->host_client_id;
328 mei_flow_control->me_addr = cl->me_client_id;
Tomas Winkler1ca7e782012-02-26 23:18:57 +0200329 mei_flow_control->hbm_cmd = MEI_FLOW_CONTROL_CMD;
Oren Weil3ce72722011-05-15 13:43:43 +0300330 memset(mei_flow_control->reserved, 0,
331 sizeof(mei_flow_control->reserved));
332 dev_dbg(&dev->pdev->dev, "sending flow control host client = %d, ME client = %d\n",
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200333 cl->host_client_id, cl->me_client_id);
334
335 return mei_write_message(dev, mei_hdr,
Oren Weil3ce72722011-05-15 13:43:43 +0300336 (unsigned char *) mei_flow_control,
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200337 sizeof(struct hbm_flow_control));
Oren Weil3ce72722011-05-15 13:43:43 +0300338}
339
340/**
341 * mei_other_client_is_connecting - checks if other
342 * client with the same client id is connected.
343 *
344 * @dev: the device structure
345 * @cl: private data of the file object
346 *
347 * returns 1 if other client is connected, 0 - otherwise.
348 */
349int mei_other_client_is_connecting(struct mei_device *dev,
350 struct mei_cl *cl)
351{
352 struct mei_cl *cl_pos = NULL;
353 struct mei_cl *cl_next = NULL;
354
355 list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
356 if ((cl_pos->state == MEI_FILE_CONNECTING) &&
357 (cl_pos != cl) &&
358 cl->me_client_id == cl_pos->me_client_id)
359 return 1;
360
361 }
362 return 0;
363}
364
365/**
366 * mei_disconnect - sends disconnect message to fw.
367 *
368 * @dev: the device structure
369 * @cl: private data of the file object
370 *
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200371 * This function returns -EIO on write failure
Oren Weil3ce72722011-05-15 13:43:43 +0300372 */
373int mei_disconnect(struct mei_device *dev, struct mei_cl *cl)
374{
375 struct mei_msg_hdr *mei_hdr;
376 struct hbm_client_disconnect_request *mei_cli_disconnect;
377
378 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
379 mei_hdr->host_addr = 0;
380 mei_hdr->me_addr = 0;
381 mei_hdr->length = sizeof(struct hbm_client_disconnect_request);
382 mei_hdr->msg_complete = 1;
383 mei_hdr->reserved = 0;
384
385 mei_cli_disconnect =
386 (struct hbm_client_disconnect_request *) &dev->wr_msg_buf[1];
Julia Lawallc0569982011-09-16 08:57:33 +0200387 memset(mei_cli_disconnect, 0, sizeof(*mei_cli_disconnect));
Oren Weil3ce72722011-05-15 13:43:43 +0300388 mei_cli_disconnect->host_addr = cl->host_client_id;
389 mei_cli_disconnect->me_addr = cl->me_client_id;
Tomas Winkler1ca7e782012-02-26 23:18:57 +0200390 mei_cli_disconnect->hbm_cmd = CLIENT_DISCONNECT_REQ_CMD;
Oren Weil3ce72722011-05-15 13:43:43 +0300391 mei_cli_disconnect->reserved[0] = 0;
392
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200393 return mei_write_message(dev, mei_hdr,
Oren Weil3ce72722011-05-15 13:43:43 +0300394 (unsigned char *) mei_cli_disconnect,
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200395 sizeof(struct hbm_client_disconnect_request));
Oren Weil3ce72722011-05-15 13:43:43 +0300396}
397
398/**
399 * mei_connect - sends connect message to fw.
400 *
401 * @dev: the device structure
402 * @cl: private data of the file object
403 *
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200404 * This function returns -EIO on write failure
Oren Weil3ce72722011-05-15 13:43:43 +0300405 */
406int mei_connect(struct mei_device *dev, struct mei_cl *cl)
407{
408 struct mei_msg_hdr *mei_hdr;
409 struct hbm_client_connect_request *mei_cli_connect;
410
411 mei_hdr = (struct mei_msg_hdr *) &dev->wr_msg_buf[0];
412 mei_hdr->host_addr = 0;
413 mei_hdr->me_addr = 0;
414 mei_hdr->length = sizeof(struct hbm_client_connect_request);
415 mei_hdr->msg_complete = 1;
416 mei_hdr->reserved = 0;
417
418 mei_cli_connect =
419 (struct hbm_client_connect_request *) &dev->wr_msg_buf[1];
420 mei_cli_connect->host_addr = cl->host_client_id;
421 mei_cli_connect->me_addr = cl->me_client_id;
Tomas Winkler1ca7e782012-02-26 23:18:57 +0200422 mei_cli_connect->hbm_cmd = CLIENT_CONNECT_REQ_CMD;
Oren Weil3ce72722011-05-15 13:43:43 +0300423 mei_cli_connect->reserved = 0;
424
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200425 return mei_write_message(dev, mei_hdr,
Oren Weil3ce72722011-05-15 13:43:43 +0300426 (unsigned char *) mei_cli_connect,
Tomas Winkler1ccb7b62012-03-14 14:39:42 +0200427 sizeof(struct hbm_client_connect_request));
Oren Weil3ce72722011-05-15 13:43:43 +0300428}