1/*
2 * Copyright 2009 VMware, Inc.
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 "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * on the rights to use, copy, modify, merge, publish, distribute, sub
9 * license, and/or sell copies of the Software, and to permit persons to whom
10 * the Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
19 * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
22 * USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25/*
26 * This file holds the function implementation for one of the rbug extensions.
27 * Prototypes and declerations of functions and structs is in the same folder
28 * in the header file matching this file's name.
29 *
30 * The functions starting rbug_send_* encodes a call to the write format and
31 * sends that to the supplied connection, while functions starting with
32 * rbug_demarshal_* demarshal data in the wire protocol.
33 *
34 * Functions ending with _reply are replies to requests.
35 */
36
37#include "rbug_internal.h"
38#include "rbug_shader.h"
39
40int rbug_send_shader_list(struct rbug_connection *__con,
41                          rbug_context_t context,
42                          uint32_t *__serial)
43{
44	uint32_t __len = 0;
45	uint32_t __pos = 0;
46	uint8_t *__data = NULL;
47	int __ret = 0;
48
49	LEN(8); /* header */
50	LEN(8); /* context */
51
52	/* align */
53	PAD(__len, 8);
54
55	__data = (uint8_t*)MALLOC(__len);
56	if (!__data)
57		return -ENOMEM;
58
59	WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST));
60	WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
61	WRITE(8, rbug_context_t, context); /* context */
62
63	/* final pad */
64	PAD(__pos, 8);
65
66	if (__pos != __len) {
67		__ret = -EINVAL;
68	} else {
69		rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST, __len);
70		rbug_connection_write(__con, __data, __len);
71		__ret = rbug_connection_send_finish(__con, __serial);
72	}
73
74	FREE(__data);
75	return __ret;
76}
77
78int rbug_send_shader_info(struct rbug_connection *__con,
79                          rbug_context_t context,
80                          rbug_shader_t shader,
81                          uint32_t *__serial)
82{
83	uint32_t __len = 0;
84	uint32_t __pos = 0;
85	uint8_t *__data = NULL;
86	int __ret = 0;
87
88	LEN(8); /* header */
89	LEN(8); /* context */
90	LEN(8); /* shader */
91
92	/* align */
93	PAD(__len, 8);
94
95	__data = (uint8_t*)MALLOC(__len);
96	if (!__data)
97		return -ENOMEM;
98
99	WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO));
100	WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
101	WRITE(8, rbug_context_t, context); /* context */
102	WRITE(8, rbug_shader_t, shader); /* shader */
103
104	/* final pad */
105	PAD(__pos, 8);
106
107	if (__pos != __len) {
108		__ret = -EINVAL;
109	} else {
110		rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO, __len);
111		rbug_connection_write(__con, __data, __len);
112		__ret = rbug_connection_send_finish(__con, __serial);
113	}
114
115	FREE(__data);
116	return __ret;
117}
118
119int rbug_send_shader_disable(struct rbug_connection *__con,
120                             rbug_context_t context,
121                             rbug_shader_t shader,
122                             uint8_t disable,
123                             uint32_t *__serial)
124{
125	uint32_t __len = 0;
126	uint32_t __pos = 0;
127	uint8_t *__data = NULL;
128	int __ret = 0;
129
130	LEN(8); /* header */
131	LEN(8); /* context */
132	LEN(8); /* shader */
133	LEN(1); /* disable */
134
135	/* align */
136	PAD(__len, 8);
137
138	__data = (uint8_t*)MALLOC(__len);
139	if (!__data)
140		return -ENOMEM;
141
142	WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_DISABLE));
143	WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
144	WRITE(8, rbug_context_t, context); /* context */
145	WRITE(8, rbug_shader_t, shader); /* shader */
146	WRITE(1, uint8_t, disable); /* disable */
147
148	/* final pad */
149	PAD(__pos, 8);
150
151	if (__pos != __len) {
152		__ret = -EINVAL;
153	} else {
154		rbug_connection_send_start(__con, RBUG_OP_SHADER_DISABLE, __len);
155		rbug_connection_write(__con, __data, __len);
156		__ret = rbug_connection_send_finish(__con, __serial);
157	}
158
159	FREE(__data);
160	return __ret;
161}
162
163int rbug_send_shader_replace(struct rbug_connection *__con,
164                             rbug_context_t context,
165                             rbug_shader_t shader,
166                             uint32_t *tokens,
167                             uint32_t tokens_len,
168                             uint32_t *__serial)
169{
170	uint32_t __len = 0;
171	uint32_t __pos = 0;
172	uint8_t *__data = NULL;
173	int __ret = 0;
174
175	LEN(8); /* header */
176	LEN(8); /* context */
177	LEN(8); /* shader */
178	LEN_ARRAY(4, tokens); /* tokens */
179
180	/* align */
181	PAD(__len, 8);
182
183	__data = (uint8_t*)MALLOC(__len);
184	if (!__data)
185		return -ENOMEM;
186
187	WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_REPLACE));
188	WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
189	WRITE(8, rbug_context_t, context); /* context */
190	WRITE(8, rbug_shader_t, shader); /* shader */
191	WRITE_ARRAY(4, uint32_t, tokens); /* tokens */
192
193	/* final pad */
194	PAD(__pos, 8);
195
196	if (__pos != __len) {
197		__ret = -EINVAL;
198	} else {
199		rbug_connection_send_start(__con, RBUG_OP_SHADER_REPLACE, __len);
200		rbug_connection_write(__con, __data, __len);
201		__ret = rbug_connection_send_finish(__con, __serial);
202	}
203
204	FREE(__data);
205	return __ret;
206}
207
208int rbug_send_shader_list_reply(struct rbug_connection *__con,
209                                uint32_t serial,
210                                rbug_shader_t *shaders,
211                                uint32_t shaders_len,
212                                uint32_t *__serial)
213{
214	uint32_t __len = 0;
215	uint32_t __pos = 0;
216	uint8_t *__data = NULL;
217	int __ret = 0;
218
219	LEN(8); /* header */
220	LEN(4); /* serial */
221	LEN_ARRAY(8, shaders); /* shaders */
222
223	/* align */
224	PAD(__len, 8);
225
226	__data = (uint8_t*)MALLOC(__len);
227	if (!__data)
228		return -ENOMEM;
229
230	WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_LIST_REPLY));
231	WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
232	WRITE(4, uint32_t, serial); /* serial */
233	WRITE_ARRAY(8, rbug_shader_t, shaders); /* shaders */
234
235	/* final pad */
236	PAD(__pos, 8);
237
238	if (__pos != __len) {
239		__ret = -EINVAL;
240	} else {
241		rbug_connection_send_start(__con, RBUG_OP_SHADER_LIST_REPLY, __len);
242		rbug_connection_write(__con, __data, __len);
243		__ret = rbug_connection_send_finish(__con, __serial);
244	}
245
246	FREE(__data);
247	return __ret;
248}
249
250int rbug_send_shader_info_reply(struct rbug_connection *__con,
251                                uint32_t serial,
252                                uint32_t *original,
253                                uint32_t original_len,
254                                uint32_t *replaced,
255                                uint32_t replaced_len,
256                                uint8_t disabled,
257                                uint32_t *__serial)
258{
259	uint32_t __len = 0;
260	uint32_t __pos = 0;
261	uint8_t *__data = NULL;
262	int __ret = 0;
263
264	LEN(8); /* header */
265	LEN(4); /* serial */
266	LEN_ARRAY(4, original); /* original */
267	LEN_ARRAY(4, replaced); /* replaced */
268	LEN(1); /* disabled */
269
270	/* align */
271	PAD(__len, 8);
272
273	__data = (uint8_t*)MALLOC(__len);
274	if (!__data)
275		return -ENOMEM;
276
277	WRITE(4, int32_t, ((int32_t)RBUG_OP_SHADER_INFO_REPLY));
278	WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
279	WRITE(4, uint32_t, serial); /* serial */
280	WRITE_ARRAY(4, uint32_t, original); /* original */
281	WRITE_ARRAY(4, uint32_t, replaced); /* replaced */
282	WRITE(1, uint8_t, disabled); /* disabled */
283
284	/* final pad */
285	PAD(__pos, 8);
286
287	if (__pos != __len) {
288		__ret = -EINVAL;
289	} else {
290		rbug_connection_send_start(__con, RBUG_OP_SHADER_INFO_REPLY, __len);
291		rbug_connection_write(__con, __data, __len);
292		__ret = rbug_connection_send_finish(__con, __serial);
293	}
294
295	FREE(__data);
296	return __ret;
297}
298
299struct rbug_proto_shader_list * rbug_demarshal_shader_list(struct rbug_proto_header *header)
300{
301	uint32_t len = 0;
302	uint32_t pos = 0;
303	uint8_t *data =  NULL;
304	struct rbug_proto_shader_list *ret;
305
306	if (!header)
307		return NULL;
308	if (header->opcode != (int32_t)RBUG_OP_SHADER_LIST)
309		return NULL;
310
311	pos = 0;
312	len = header->length * 4;
313	data = (uint8_t*)&header[1];
314	ret = MALLOC(sizeof(*ret));
315	if (!ret)
316		return NULL;
317
318	ret->header.__message = header;
319	ret->header.opcode = header->opcode;
320
321	READ(8, rbug_context_t, context); /* context */
322
323	return ret;
324}
325
326struct rbug_proto_shader_info * rbug_demarshal_shader_info(struct rbug_proto_header *header)
327{
328	uint32_t len = 0;
329	uint32_t pos = 0;
330	uint8_t *data =  NULL;
331	struct rbug_proto_shader_info *ret;
332
333	if (!header)
334		return NULL;
335	if (header->opcode != (int32_t)RBUG_OP_SHADER_INFO)
336		return NULL;
337
338	pos = 0;
339	len = header->length * 4;
340	data = (uint8_t*)&header[1];
341	ret = MALLOC(sizeof(*ret));
342	if (!ret)
343		return NULL;
344
345	ret->header.__message = header;
346	ret->header.opcode = header->opcode;
347
348	READ(8, rbug_context_t, context); /* context */
349	READ(8, rbug_shader_t, shader); /* shader */
350
351	return ret;
352}
353
354struct rbug_proto_shader_disable * rbug_demarshal_shader_disable(struct rbug_proto_header *header)
355{
356	uint32_t len = 0;
357	uint32_t pos = 0;
358	uint8_t *data =  NULL;
359	struct rbug_proto_shader_disable *ret;
360
361	if (!header)
362		return NULL;
363	if (header->opcode != (int32_t)RBUG_OP_SHADER_DISABLE)
364		return NULL;
365
366	pos = 0;
367	len = header->length * 4;
368	data = (uint8_t*)&header[1];
369	ret = MALLOC(sizeof(*ret));
370	if (!ret)
371		return NULL;
372
373	ret->header.__message = header;
374	ret->header.opcode = header->opcode;
375
376	READ(8, rbug_context_t, context); /* context */
377	READ(8, rbug_shader_t, shader); /* shader */
378	READ(1, uint8_t, disable); /* disable */
379
380	return ret;
381}
382
383struct rbug_proto_shader_replace * rbug_demarshal_shader_replace(struct rbug_proto_header *header)
384{
385	uint32_t len = 0;
386	uint32_t pos = 0;
387	uint8_t *data =  NULL;
388	struct rbug_proto_shader_replace *ret;
389
390	if (!header)
391		return NULL;
392	if (header->opcode != (int32_t)RBUG_OP_SHADER_REPLACE)
393		return NULL;
394
395	pos = 0;
396	len = header->length * 4;
397	data = (uint8_t*)&header[1];
398	ret = MALLOC(sizeof(*ret));
399	if (!ret)
400		return NULL;
401
402	ret->header.__message = header;
403	ret->header.opcode = header->opcode;
404
405	READ(8, rbug_context_t, context); /* context */
406	READ(8, rbug_shader_t, shader); /* shader */
407	READ_ARRAY(4, uint32_t, tokens); /* tokens */
408
409	return ret;
410}
411
412struct rbug_proto_shader_list_reply * rbug_demarshal_shader_list_reply(struct rbug_proto_header *header)
413{
414	uint32_t len = 0;
415	uint32_t pos = 0;
416	uint8_t *data =  NULL;
417	struct rbug_proto_shader_list_reply *ret;
418
419	if (!header)
420		return NULL;
421	if (header->opcode != (int32_t)RBUG_OP_SHADER_LIST_REPLY)
422		return NULL;
423
424	pos = 0;
425	len = header->length * 4;
426	data = (uint8_t*)&header[1];
427	ret = MALLOC(sizeof(*ret));
428	if (!ret)
429		return NULL;
430
431	ret->header.__message = header;
432	ret->header.opcode = header->opcode;
433
434	READ(4, uint32_t, serial); /* serial */
435	READ_ARRAY(8, rbug_shader_t, shaders); /* shaders */
436
437	return ret;
438}
439
440struct rbug_proto_shader_info_reply * rbug_demarshal_shader_info_reply(struct rbug_proto_header *header)
441{
442	uint32_t len = 0;
443	uint32_t pos = 0;
444	uint8_t *data =  NULL;
445	struct rbug_proto_shader_info_reply *ret;
446
447	if (!header)
448		return NULL;
449	if (header->opcode != (int32_t)RBUG_OP_SHADER_INFO_REPLY)
450		return NULL;
451
452	pos = 0;
453	len = header->length * 4;
454	data = (uint8_t*)&header[1];
455	ret = MALLOC(sizeof(*ret));
456	if (!ret)
457		return NULL;
458
459	ret->header.__message = header;
460	ret->header.opcode = header->opcode;
461
462	READ(4, uint32_t, serial); /* serial */
463	READ_ARRAY(4, uint32_t, original); /* original */
464	READ_ARRAY(4, uint32_t, replaced); /* replaced */
465	READ(1, uint8_t, disabled); /* disabled */
466
467	return ret;
468}
469