Commit | Line | Data |
---|---|---|
89da76fd SY |
1 | /* |
2 | * Copyright © 2016 VMware, Inc., Palo Alto, CA., USA | |
3 | * All Rights Reserved. | |
4 | * | |
5 | * Permission is hereby granted, free of charge, to any person obtaining a | |
6 | * copy of this software and associated documentation files (the | |
7 | * "Software"), to deal in the Software without restriction, including | |
8 | * without limitation the rights to use, copy, modify, merge, publish, | |
9 | * distribute, sub license, and/or sell copies of the Software, and to | |
10 | * permit persons to whom the Software is furnished to do so, subject to | |
11 | * the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice (including the | |
14 | * next paragraph) shall be included in all copies or substantial portions | |
15 | * of the Software. | |
16 | * | |
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL | |
20 | * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, | |
21 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
22 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
23 | * USE OR OTHER DEALINGS IN THE SOFTWARE. | |
24 | * | |
25 | */ | |
26 | ||
27 | ||
28 | #include <linux/slab.h> | |
29 | #include <linux/module.h> | |
30 | #include <linux/kernel.h> | |
0b0d81e3 | 31 | #include <linux/frame.h> |
89da76fd SY |
32 | #include <asm/hypervisor.h> |
33 | #include "drmP.h" | |
34 | #include "vmwgfx_msg.h" | |
35 | ||
36 | ||
37 | #define MESSAGE_STATUS_SUCCESS 0x0001 | |
38 | #define MESSAGE_STATUS_DORECV 0x0002 | |
39 | #define MESSAGE_STATUS_CPT 0x0010 | |
40 | #define MESSAGE_STATUS_HB 0x0080 | |
41 | ||
42 | #define RPCI_PROTOCOL_NUM 0x49435052 | |
43 | #define GUESTMSG_FLAG_COOKIE 0x80000000 | |
44 | ||
45 | #define RETRIES 3 | |
46 | ||
47 | #define VMW_HYPERVISOR_MAGIC 0x564D5868 | |
48 | #define VMW_HYPERVISOR_PORT 0x5658 | |
49 | #define VMW_HYPERVISOR_HB_PORT 0x5659 | |
50 | ||
51 | #define VMW_PORT_CMD_MSG 30 | |
52 | #define VMW_PORT_CMD_HB_MSG 0 | |
53 | #define VMW_PORT_CMD_OPEN_CHANNEL (MSG_TYPE_OPEN << 16 | VMW_PORT_CMD_MSG) | |
54 | #define VMW_PORT_CMD_CLOSE_CHANNEL (MSG_TYPE_CLOSE << 16 | VMW_PORT_CMD_MSG) | |
55 | #define VMW_PORT_CMD_SENDSIZE (MSG_TYPE_SENDSIZE << 16 | VMW_PORT_CMD_MSG) | |
56 | #define VMW_PORT_CMD_RECVSIZE (MSG_TYPE_RECVSIZE << 16 | VMW_PORT_CMD_MSG) | |
57 | #define VMW_PORT_CMD_RECVSTATUS (MSG_TYPE_RECVSTATUS << 16 | VMW_PORT_CMD_MSG) | |
58 | ||
59 | #define HIGH_WORD(X) ((X & 0xFFFF0000) >> 16) | |
60 | ||
61 | static u32 vmw_msg_enabled = 1; | |
62 | ||
63 | enum rpc_msg_type { | |
64 | MSG_TYPE_OPEN, | |
65 | MSG_TYPE_SENDSIZE, | |
66 | MSG_TYPE_SENDPAYLOAD, | |
67 | MSG_TYPE_RECVSIZE, | |
68 | MSG_TYPE_RECVPAYLOAD, | |
69 | MSG_TYPE_RECVSTATUS, | |
70 | MSG_TYPE_CLOSE, | |
71 | }; | |
72 | ||
73 | struct rpc_channel { | |
74 | u16 channel_id; | |
75 | u32 cookie_high; | |
76 | u32 cookie_low; | |
77 | }; | |
78 | ||
79 | ||
80 | ||
81 | /** | |
82 | * vmw_open_channel | |
83 | * | |
84 | * @channel: RPC channel | |
85 | * @protocol: | |
86 | * | |
87 | * Returns: 0 on success | |
88 | */ | |
89 | static int vmw_open_channel(struct rpc_channel *channel, unsigned int protocol) | |
90 | { | |
91 | unsigned long eax, ebx, ecx, edx, si = 0, di = 0; | |
92 | ||
93 | VMW_PORT(VMW_PORT_CMD_OPEN_CHANNEL, | |
94 | (protocol | GUESTMSG_FLAG_COOKIE), si, di, | |
95 | VMW_HYPERVISOR_PORT, | |
96 | VMW_HYPERVISOR_MAGIC, | |
97 | eax, ebx, ecx, edx, si, di); | |
98 | ||
99 | if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0) | |
100 | return -EINVAL; | |
101 | ||
102 | channel->channel_id = HIGH_WORD(edx); | |
103 | channel->cookie_high = si; | |
104 | channel->cookie_low = di; | |
105 | ||
106 | return 0; | |
107 | } | |
108 | ||
109 | ||
110 | ||
111 | /** | |
112 | * vmw_close_channel | |
113 | * | |
114 | * @channel: RPC channel | |
115 | * | |
116 | * Returns: 0 on success | |
117 | */ | |
118 | static int vmw_close_channel(struct rpc_channel *channel) | |
119 | { | |
120 | unsigned long eax, ebx, ecx, edx, si, di; | |
121 | ||
122 | /* Set up additional parameters */ | |
123 | si = channel->cookie_high; | |
124 | di = channel->cookie_low; | |
125 | ||
126 | VMW_PORT(VMW_PORT_CMD_CLOSE_CHANNEL, | |
127 | 0, si, di, | |
128 | (VMW_HYPERVISOR_PORT | (channel->channel_id << 16)), | |
129 | VMW_HYPERVISOR_MAGIC, | |
130 | eax, ebx, ecx, edx, si, di); | |
131 | ||
132 | if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0) | |
133 | return -EINVAL; | |
134 | ||
135 | return 0; | |
136 | } | |
137 | ||
138 | ||
139 | ||
140 | /** | |
141 | * vmw_send_msg: Sends a message to the host | |
142 | * | |
143 | * @channel: RPC channel | |
144 | * @logmsg: NULL terminated string | |
145 | * | |
146 | * Returns: 0 on success | |
147 | */ | |
148 | static int vmw_send_msg(struct rpc_channel *channel, const char *msg) | |
149 | { | |
150 | unsigned long eax, ebx, ecx, edx, si, di, bp; | |
151 | size_t msg_len = strlen(msg); | |
152 | int retries = 0; | |
153 | ||
154 | ||
155 | while (retries < RETRIES) { | |
156 | retries++; | |
157 | ||
158 | /* Set up additional parameters */ | |
159 | si = channel->cookie_high; | |
160 | di = channel->cookie_low; | |
161 | ||
162 | VMW_PORT(VMW_PORT_CMD_SENDSIZE, | |
163 | msg_len, si, di, | |
164 | VMW_HYPERVISOR_PORT | (channel->channel_id << 16), | |
165 | VMW_HYPERVISOR_MAGIC, | |
166 | eax, ebx, ecx, edx, si, di); | |
167 | ||
168 | if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0 || | |
169 | (HIGH_WORD(ecx) & MESSAGE_STATUS_HB) == 0) { | |
170 | /* Expected success + high-bandwidth. Give up. */ | |
171 | return -EINVAL; | |
172 | } | |
173 | ||
174 | /* Send msg */ | |
175 | si = (uintptr_t) msg; | |
176 | di = channel->cookie_low; | |
177 | bp = channel->cookie_high; | |
178 | ||
179 | VMW_PORT_HB_OUT( | |
180 | (MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG, | |
181 | msg_len, si, di, | |
182 | VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16), | |
183 | VMW_HYPERVISOR_MAGIC, bp, | |
184 | eax, ebx, ecx, edx, si, di); | |
185 | ||
186 | if ((HIGH_WORD(ebx) & MESSAGE_STATUS_SUCCESS) != 0) { | |
187 | return 0; | |
188 | } else if ((HIGH_WORD(ebx) & MESSAGE_STATUS_CPT) != 0) { | |
189 | /* A checkpoint occurred. Retry. */ | |
190 | continue; | |
191 | } else { | |
192 | break; | |
193 | } | |
194 | } | |
195 | ||
196 | return -EINVAL; | |
197 | } | |
0b0d81e3 | 198 | STACK_FRAME_NON_STANDARD(vmw_send_msg); |
89da76fd SY |
199 | |
200 | ||
201 | /** | |
202 | * vmw_recv_msg: Receives a message from the host | |
203 | * | |
204 | * Note: It is the caller's responsibility to call kfree() on msg. | |
205 | * | |
206 | * @channel: channel opened by vmw_open_channel | |
207 | * @msg: [OUT] message received from the host | |
208 | * @msg_len: message length | |
209 | */ | |
210 | static int vmw_recv_msg(struct rpc_channel *channel, void **msg, | |
211 | size_t *msg_len) | |
212 | { | |
213 | unsigned long eax, ebx, ecx, edx, si, di, bp; | |
214 | char *reply; | |
215 | size_t reply_len; | |
216 | int retries = 0; | |
217 | ||
218 | ||
219 | *msg_len = 0; | |
220 | *msg = NULL; | |
221 | ||
222 | while (retries < RETRIES) { | |
223 | retries++; | |
224 | ||
225 | /* Set up additional parameters */ | |
226 | si = channel->cookie_high; | |
227 | di = channel->cookie_low; | |
228 | ||
229 | VMW_PORT(VMW_PORT_CMD_RECVSIZE, | |
230 | 0, si, di, | |
231 | (VMW_HYPERVISOR_PORT | (channel->channel_id << 16)), | |
232 | VMW_HYPERVISOR_MAGIC, | |
233 | eax, ebx, ecx, edx, si, di); | |
234 | ||
235 | if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0 || | |
236 | (HIGH_WORD(ecx) & MESSAGE_STATUS_HB) == 0) { | |
237 | DRM_ERROR("Failed to get reply size\n"); | |
238 | return -EINVAL; | |
239 | } | |
240 | ||
241 | /* No reply available. This is okay. */ | |
242 | if ((HIGH_WORD(ecx) & MESSAGE_STATUS_DORECV) == 0) | |
243 | return 0; | |
244 | ||
245 | reply_len = ebx; | |
246 | reply = kzalloc(reply_len + 1, GFP_KERNEL); | |
247 | if (reply == NULL) { | |
248 | DRM_ERROR("Cannot allocate memory for reply\n"); | |
249 | return -ENOMEM; | |
250 | } | |
251 | ||
252 | ||
253 | /* Receive buffer */ | |
254 | si = channel->cookie_high; | |
255 | di = (uintptr_t) reply; | |
256 | bp = channel->cookie_low; | |
257 | ||
258 | VMW_PORT_HB_IN( | |
259 | (MESSAGE_STATUS_SUCCESS << 16) | VMW_PORT_CMD_HB_MSG, | |
260 | reply_len, si, di, | |
261 | VMW_HYPERVISOR_HB_PORT | (channel->channel_id << 16), | |
262 | VMW_HYPERVISOR_MAGIC, bp, | |
263 | eax, ebx, ecx, edx, si, di); | |
264 | ||
265 | if ((HIGH_WORD(ebx) & MESSAGE_STATUS_SUCCESS) == 0) { | |
266 | kfree(reply); | |
267 | ||
268 | if ((HIGH_WORD(ebx) & MESSAGE_STATUS_CPT) != 0) { | |
269 | /* A checkpoint occurred. Retry. */ | |
270 | continue; | |
271 | } | |
272 | ||
273 | return -EINVAL; | |
274 | } | |
275 | ||
276 | reply[reply_len] = '\0'; | |
277 | ||
278 | ||
279 | /* Ack buffer */ | |
280 | si = channel->cookie_high; | |
281 | di = channel->cookie_low; | |
282 | ||
283 | VMW_PORT(VMW_PORT_CMD_RECVSTATUS, | |
284 | MESSAGE_STATUS_SUCCESS, si, di, | |
285 | (VMW_HYPERVISOR_PORT | (channel->channel_id << 16)), | |
286 | VMW_HYPERVISOR_MAGIC, | |
287 | eax, ebx, ecx, edx, si, di); | |
288 | ||
289 | if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0) { | |
290 | kfree(reply); | |
291 | ||
292 | if ((HIGH_WORD(ecx) & MESSAGE_STATUS_CPT) != 0) { | |
293 | /* A checkpoint occurred. Retry. */ | |
294 | continue; | |
295 | } | |
296 | ||
297 | return -EINVAL; | |
298 | } | |
299 | ||
300 | break; | |
301 | } | |
302 | ||
303 | *msg_len = reply_len; | |
304 | *msg = reply; | |
305 | ||
306 | return 0; | |
307 | } | |
0b0d81e3 | 308 | STACK_FRAME_NON_STANDARD(vmw_recv_msg); |
89da76fd SY |
309 | |
310 | ||
311 | /** | |
312 | * vmw_host_get_guestinfo: Gets a GuestInfo parameter | |
313 | * | |
314 | * Gets the value of a GuestInfo.* parameter. The value returned will be in | |
315 | * a string, and it is up to the caller to post-process. | |
316 | * | |
317 | * @guest_info_param: Parameter to get, e.g. GuestInfo.svga.gl3 | |
318 | * @buffer: if NULL, *reply_len will contain reply size. | |
319 | * @length: size of the reply_buf. Set to size of reply upon return | |
320 | * | |
321 | * Returns: 0 on success | |
322 | */ | |
323 | int vmw_host_get_guestinfo(const char *guest_info_param, | |
324 | char *buffer, size_t *length) | |
325 | { | |
326 | struct rpc_channel channel; | |
327 | char *msg, *reply = NULL; | |
328 | size_t msg_len, reply_len = 0; | |
329 | int ret = 0; | |
330 | ||
331 | ||
332 | if (!vmw_msg_enabled) | |
333 | return -ENODEV; | |
334 | ||
335 | if (!guest_info_param || !length) | |
336 | return -EINVAL; | |
337 | ||
338 | msg_len = strlen(guest_info_param) + strlen("info-get ") + 1; | |
339 | msg = kzalloc(msg_len, GFP_KERNEL); | |
340 | if (msg == NULL) { | |
341 | DRM_ERROR("Cannot allocate memory to get %s", guest_info_param); | |
342 | return -ENOMEM; | |
343 | } | |
344 | ||
345 | sprintf(msg, "info-get %s", guest_info_param); | |
346 | ||
347 | if (vmw_open_channel(&channel, RPCI_PROTOCOL_NUM) || | |
348 | vmw_send_msg(&channel, msg) || | |
349 | vmw_recv_msg(&channel, (void *) &reply, &reply_len) || | |
350 | vmw_close_channel(&channel)) { | |
351 | DRM_ERROR("Failed to get %s", guest_info_param); | |
352 | ||
353 | ret = -EINVAL; | |
354 | } | |
355 | ||
356 | if (buffer && reply && reply_len > 0) { | |
357 | /* Remove reply code, which are the first 2 characters of | |
358 | * the reply | |
359 | */ | |
360 | reply_len = max(reply_len - 2, (size_t) 0); | |
361 | reply_len = min(reply_len, *length); | |
362 | ||
363 | if (reply_len > 0) | |
364 | memcpy(buffer, reply + 2, reply_len); | |
365 | } | |
366 | ||
367 | *length = reply_len; | |
368 | ||
369 | kfree(reply); | |
370 | kfree(msg); | |
371 | ||
372 | return ret; | |
373 | } | |
374 | ||
375 | ||
376 | ||
377 | /** | |
378 | * vmw_host_log: Sends a log message to the host | |
379 | * | |
380 | * @log: NULL terminated string | |
381 | * | |
382 | * Returns: 0 on success | |
383 | */ | |
384 | int vmw_host_log(const char *log) | |
385 | { | |
386 | struct rpc_channel channel; | |
387 | char *msg; | |
388 | int msg_len; | |
389 | int ret = 0; | |
390 | ||
391 | ||
392 | if (!vmw_msg_enabled) | |
393 | return -ENODEV; | |
394 | ||
395 | if (!log) | |
396 | return ret; | |
397 | ||
398 | msg_len = strlen(log) + strlen("log ") + 1; | |
399 | msg = kzalloc(msg_len, GFP_KERNEL); | |
400 | if (msg == NULL) { | |
401 | DRM_ERROR("Cannot allocate memory for log message\n"); | |
402 | return -ENOMEM; | |
403 | } | |
404 | ||
405 | sprintf(msg, "log %s", log); | |
406 | ||
407 | if (vmw_open_channel(&channel, RPCI_PROTOCOL_NUM) || | |
408 | vmw_send_msg(&channel, msg) || | |
409 | vmw_close_channel(&channel)) { | |
410 | DRM_ERROR("Failed to send log\n"); | |
411 | ||
412 | ret = -EINVAL; | |
413 | } | |
414 | ||
415 | kfree(msg); | |
416 | ||
417 | return ret; | |
418 | } |