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_texture.h" 39 40 int rbug_send_texture_list(struct rbug_connection *__con, 41 uint32_t *__serial) 42 { 43 uint32_t __len = 0; 44 uint32_t __pos = 0; 45 uint8_t *__data = NULL; 46 int __ret = 0; 47 48 LEN(8); /* header */ 49 50 /* align */ 51 PAD(__len, 8); 52 53 __data = (uint8_t*)MALLOC(__len); 54 if (!__data) 55 return -ENOMEM; 56 57 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST)); 58 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 59 60 /* final pad */ 61 PAD(__pos, 8); 62 63 if (__pos != __len) { 64 __ret = -EINVAL; 65 } else { 66 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST, __len); 67 rbug_connection_write(__con, __data, __len); 68 __ret = rbug_connection_send_finish(__con, __serial); 69 } 70 71 FREE(__data); 72 return __ret; 73 } 74 75 int rbug_send_texture_info(struct rbug_connection *__con, 76 rbug_texture_t texture, 77 uint32_t *__serial) 78 { 79 uint32_t __len = 0; 80 uint32_t __pos = 0; 81 uint8_t *__data = NULL; 82 int __ret = 0; 83 84 LEN(8); /* header */ 85 LEN(8); /* texture */ 86 87 /* align */ 88 PAD(__len, 8); 89 90 __data = (uint8_t*)MALLOC(__len); 91 if (!__data) 92 return -ENOMEM; 93 94 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO)); 95 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 96 WRITE(8, rbug_texture_t, texture); /* texture */ 97 98 /* final pad */ 99 PAD(__pos, 8); 100 101 if (__pos != __len) { 102 __ret = -EINVAL; 103 } else { 104 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO, __len); 105 rbug_connection_write(__con, __data, __len); 106 __ret = rbug_connection_send_finish(__con, __serial); 107 } 108 109 FREE(__data); 110 return __ret; 111 } 112 113 int rbug_send_texture_write(struct rbug_connection *__con, 114 rbug_texture_t texture, 115 uint32_t face, 116 uint32_t level, 117 uint32_t zslice, 118 uint32_t x, 119 uint32_t y, 120 uint32_t w, 121 uint32_t h, 122 uint8_t *data, 123 uint32_t data_len, 124 uint32_t stride, 125 uint32_t *__serial) 126 { 127 uint32_t __len = 0; 128 uint32_t __pos = 0; 129 uint8_t *__data = NULL; 130 int __ret = 0; 131 132 LEN(8); /* header */ 133 LEN(8); /* texture */ 134 LEN(4); /* face */ 135 LEN(4); /* level */ 136 LEN(4); /* zslice */ 137 LEN(4); /* x */ 138 LEN(4); /* y */ 139 LEN(4); /* w */ 140 LEN(4); /* h */ 141 LEN_ARRAY(1, data); /* data */ 142 LEN(4); /* stride */ 143 144 /* align */ 145 PAD(__len, 8); 146 147 __data = (uint8_t*)MALLOC(__len); 148 if (!__data) 149 return -ENOMEM; 150 151 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_WRITE)); 152 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 153 WRITE(8, rbug_texture_t, texture); /* texture */ 154 WRITE(4, uint32_t, face); /* face */ 155 WRITE(4, uint32_t, level); /* level */ 156 WRITE(4, uint32_t, zslice); /* zslice */ 157 WRITE(4, uint32_t, x); /* x */ 158 WRITE(4, uint32_t, y); /* y */ 159 WRITE(4, uint32_t, w); /* w */ 160 WRITE(4, uint32_t, h); /* h */ 161 WRITE_ARRAY(1, uint8_t, data); /* data */ 162 WRITE(4, uint32_t, stride); /* stride */ 163 164 /* final pad */ 165 PAD(__pos, 8); 166 167 if (__pos != __len) { 168 __ret = -EINVAL; 169 } else { 170 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_WRITE, __len); 171 rbug_connection_write(__con, __data, __len); 172 __ret = rbug_connection_send_finish(__con, __serial); 173 } 174 175 FREE(__data); 176 return __ret; 177 } 178 179 int rbug_send_texture_read(struct rbug_connection *__con, 180 rbug_texture_t texture, 181 uint32_t face, 182 uint32_t level, 183 uint32_t zslice, 184 uint32_t x, 185 uint32_t y, 186 uint32_t w, 187 uint32_t h, 188 uint32_t *__serial) 189 { 190 uint32_t __len = 0; 191 uint32_t __pos = 0; 192 uint8_t *__data = NULL; 193 int __ret = 0; 194 195 LEN(8); /* header */ 196 LEN(8); /* texture */ 197 LEN(4); /* face */ 198 LEN(4); /* level */ 199 LEN(4); /* zslice */ 200 LEN(4); /* x */ 201 LEN(4); /* y */ 202 LEN(4); /* w */ 203 LEN(4); /* h */ 204 205 /* align */ 206 PAD(__len, 8); 207 208 __data = (uint8_t*)MALLOC(__len); 209 if (!__data) 210 return -ENOMEM; 211 212 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ)); 213 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 214 WRITE(8, rbug_texture_t, texture); /* texture */ 215 WRITE(4, uint32_t, face); /* face */ 216 WRITE(4, uint32_t, level); /* level */ 217 WRITE(4, uint32_t, zslice); /* zslice */ 218 WRITE(4, uint32_t, x); /* x */ 219 WRITE(4, uint32_t, y); /* y */ 220 WRITE(4, uint32_t, w); /* w */ 221 WRITE(4, uint32_t, h); /* h */ 222 223 /* final pad */ 224 PAD(__pos, 8); 225 226 if (__pos != __len) { 227 __ret = -EINVAL; 228 } else { 229 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ, __len); 230 rbug_connection_write(__con, __data, __len); 231 __ret = rbug_connection_send_finish(__con, __serial); 232 } 233 234 FREE(__data); 235 return __ret; 236 } 237 238 int rbug_send_texture_list_reply(struct rbug_connection *__con, 239 uint32_t serial, 240 rbug_texture_t *textures, 241 uint32_t textures_len, 242 uint32_t *__serial) 243 { 244 uint32_t __len = 0; 245 uint32_t __pos = 0; 246 uint8_t *__data = NULL; 247 int __ret = 0; 248 249 LEN(8); /* header */ 250 LEN(4); /* serial */ 251 LEN_ARRAY(8, textures); /* textures */ 252 253 /* align */ 254 PAD(__len, 8); 255 256 __data = (uint8_t*)MALLOC(__len); 257 if (!__data) 258 return -ENOMEM; 259 260 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_LIST_REPLY)); 261 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 262 WRITE(4, uint32_t, serial); /* serial */ 263 WRITE_ARRAY(8, rbug_texture_t, textures); /* textures */ 264 265 /* final pad */ 266 PAD(__pos, 8); 267 268 if (__pos != __len) { 269 __ret = -EINVAL; 270 } else { 271 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_LIST_REPLY, __len); 272 rbug_connection_write(__con, __data, __len); 273 __ret = rbug_connection_send_finish(__con, __serial); 274 } 275 276 FREE(__data); 277 return __ret; 278 } 279 280 int rbug_send_texture_info_reply(struct rbug_connection *__con, 281 uint32_t serial, 282 uint32_t target, 283 uint32_t format, 284 uint32_t *width, 285 uint32_t width_len, 286 uint32_t *height, 287 uint32_t height_len, 288 uint32_t *depth, 289 uint32_t depth_len, 290 uint32_t blockw, 291 uint32_t blockh, 292 uint32_t blocksize, 293 uint32_t last_level, 294 uint32_t nr_samples, 295 uint32_t tex_usage, 296 uint32_t *__serial) 297 { 298 uint32_t __len = 0; 299 uint32_t __pos = 0; 300 uint8_t *__data = NULL; 301 int __ret = 0; 302 303 LEN(8); /* header */ 304 LEN(4); /* serial */ 305 LEN(4); /* target */ 306 LEN(4); /* format */ 307 LEN_ARRAY(4, width); /* width */ 308 LEN_ARRAY(4, height); /* height */ 309 LEN_ARRAY(4, depth); /* depth */ 310 LEN(4); /* blockw */ 311 LEN(4); /* blockh */ 312 LEN(4); /* blocksize */ 313 LEN(4); /* last_level */ 314 LEN(4); /* nr_samples */ 315 LEN(4); /* tex_usage */ 316 317 /* align */ 318 PAD(__len, 8); 319 320 __data = (uint8_t*)MALLOC(__len); 321 if (!__data) 322 return -ENOMEM; 323 324 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_INFO_REPLY)); 325 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 326 WRITE(4, uint32_t, serial); /* serial */ 327 WRITE(4, uint32_t, target); /* target */ 328 WRITE(4, uint32_t, format); /* format */ 329 WRITE_ARRAY(4, uint32_t, width); /* width */ 330 WRITE_ARRAY(4, uint32_t, height); /* height */ 331 WRITE_ARRAY(4, uint32_t, depth); /* depth */ 332 WRITE(4, uint32_t, blockw); /* blockw */ 333 WRITE(4, uint32_t, blockh); /* blockh */ 334 WRITE(4, uint32_t, blocksize); /* blocksize */ 335 WRITE(4, uint32_t, last_level); /* last_level */ 336 WRITE(4, uint32_t, nr_samples); /* nr_samples */ 337 WRITE(4, uint32_t, tex_usage); /* tex_usage */ 338 339 /* final pad */ 340 PAD(__pos, 8); 341 342 if (__pos != __len) { 343 __ret = -EINVAL; 344 } else { 345 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_INFO_REPLY, __len); 346 rbug_connection_write(__con, __data, __len); 347 __ret = rbug_connection_send_finish(__con, __serial); 348 } 349 350 FREE(__data); 351 return __ret; 352 } 353 354 int rbug_send_texture_read_reply(struct rbug_connection *__con, 355 uint32_t serial, 356 uint32_t format, 357 uint32_t blockw, 358 uint32_t blockh, 359 uint32_t blocksize, 360 uint8_t *data, 361 uint32_t data_len, 362 uint32_t stride, 363 uint32_t *__serial) 364 { 365 uint32_t __len = 0; 366 uint32_t __pos = 0; 367 uint8_t *__data = NULL; 368 int __ret = 0; 369 370 LEN(8); /* header */ 371 LEN(4); /* serial */ 372 LEN(4); /* format */ 373 LEN(4); /* blockw */ 374 LEN(4); /* blockh */ 375 LEN(4); /* blocksize */ 376 LEN_ARRAY(1, data); /* data */ 377 LEN(4); /* stride */ 378 379 /* align */ 380 PAD(__len, 8); 381 382 __data = (uint8_t*)MALLOC(__len); 383 if (!__data) 384 return -ENOMEM; 385 386 WRITE(4, int32_t, ((int32_t)RBUG_OP_TEXTURE_READ_REPLY)); 387 WRITE(4, uint32_t, ((uint32_t)(__len / 4))); 388 WRITE(4, uint32_t, serial); /* serial */ 389 WRITE(4, uint32_t, format); /* format */ 390 WRITE(4, uint32_t, blockw); /* blockw */ 391 WRITE(4, uint32_t, blockh); /* blockh */ 392 WRITE(4, uint32_t, blocksize); /* blocksize */ 393 WRITE_ARRAY(1, uint8_t, data); /* data */ 394 WRITE(4, uint32_t, stride); /* stride */ 395 396 /* final pad */ 397 PAD(__pos, 8); 398 399 if (__pos != __len) { 400 __ret = -EINVAL; 401 } else { 402 rbug_connection_send_start(__con, RBUG_OP_TEXTURE_READ_REPLY, __len); 403 rbug_connection_write(__con, __data, __len); 404 __ret = rbug_connection_send_finish(__con, __serial); 405 } 406 407 FREE(__data); 408 return __ret; 409 } 410 411 struct rbug_proto_texture_list * rbug_demarshal_texture_list(struct rbug_proto_header *header) 412 { 413 struct rbug_proto_texture_list *ret; 414 415 if (!header) 416 return NULL; 417 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST) 418 return NULL; 419 420 ret = MALLOC(sizeof(*ret)); 421 if (!ret) 422 return NULL; 423 424 ret->header.__message = header; 425 ret->header.opcode = header->opcode; 426 427 return ret; 428 } 429 430 struct rbug_proto_texture_info * rbug_demarshal_texture_info(struct rbug_proto_header *header) 431 { 432 uint32_t len = 0; 433 uint32_t pos = 0; 434 uint8_t *data = NULL; 435 struct rbug_proto_texture_info *ret; 436 437 if (!header) 438 return NULL; 439 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO) 440 return NULL; 441 442 pos = 0; 443 len = header->length * 4; 444 data = (uint8_t*)&header[1]; 445 ret = MALLOC(sizeof(*ret)); 446 if (!ret) 447 return NULL; 448 449 ret->header.__message = header; 450 ret->header.opcode = header->opcode; 451 452 READ(8, rbug_texture_t, texture); /* texture */ 453 454 return ret; 455 } 456 457 struct rbug_proto_texture_write * rbug_demarshal_texture_write(struct rbug_proto_header *header) 458 { 459 uint32_t len = 0; 460 uint32_t pos = 0; 461 uint8_t *data = NULL; 462 struct rbug_proto_texture_write *ret; 463 464 if (!header) 465 return NULL; 466 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_WRITE) 467 return NULL; 468 469 pos = 0; 470 len = header->length * 4; 471 data = (uint8_t*)&header[1]; 472 ret = MALLOC(sizeof(*ret)); 473 if (!ret) 474 return NULL; 475 476 ret->header.__message = header; 477 ret->header.opcode = header->opcode; 478 479 READ(8, rbug_texture_t, texture); /* texture */ 480 READ(4, uint32_t, face); /* face */ 481 READ(4, uint32_t, level); /* level */ 482 READ(4, uint32_t, zslice); /* zslice */ 483 READ(4, uint32_t, x); /* x */ 484 READ(4, uint32_t, y); /* y */ 485 READ(4, uint32_t, w); /* w */ 486 READ(4, uint32_t, h); /* h */ 487 READ_ARRAY(1, uint8_t, data); /* data */ 488 READ(4, uint32_t, stride); /* stride */ 489 490 return ret; 491 } 492 493 struct rbug_proto_texture_read * rbug_demarshal_texture_read(struct rbug_proto_header *header) 494 { 495 uint32_t len = 0; 496 uint32_t pos = 0; 497 uint8_t *data = NULL; 498 struct rbug_proto_texture_read *ret; 499 500 if (!header) 501 return NULL; 502 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ) 503 return NULL; 504 505 pos = 0; 506 len = header->length * 4; 507 data = (uint8_t*)&header[1]; 508 ret = MALLOC(sizeof(*ret)); 509 if (!ret) 510 return NULL; 511 512 ret->header.__message = header; 513 ret->header.opcode = header->opcode; 514 515 READ(8, rbug_texture_t, texture); /* texture */ 516 READ(4, uint32_t, face); /* face */ 517 READ(4, uint32_t, level); /* level */ 518 READ(4, uint32_t, zslice); /* zslice */ 519 READ(4, uint32_t, x); /* x */ 520 READ(4, uint32_t, y); /* y */ 521 READ(4, uint32_t, w); /* w */ 522 READ(4, uint32_t, h); /* h */ 523 524 return ret; 525 } 526 527 struct rbug_proto_texture_list_reply * rbug_demarshal_texture_list_reply(struct rbug_proto_header *header) 528 { 529 uint32_t len = 0; 530 uint32_t pos = 0; 531 uint8_t *data = NULL; 532 struct rbug_proto_texture_list_reply *ret; 533 534 if (!header) 535 return NULL; 536 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_LIST_REPLY) 537 return NULL; 538 539 pos = 0; 540 len = header->length * 4; 541 data = (uint8_t*)&header[1]; 542 ret = MALLOC(sizeof(*ret)); 543 if (!ret) 544 return NULL; 545 546 ret->header.__message = header; 547 ret->header.opcode = header->opcode; 548 549 READ(4, uint32_t, serial); /* serial */ 550 READ_ARRAY(8, rbug_texture_t, textures); /* textures */ 551 552 return ret; 553 } 554 555 struct rbug_proto_texture_info_reply * rbug_demarshal_texture_info_reply(struct rbug_proto_header *header) 556 { 557 uint32_t len = 0; 558 uint32_t pos = 0; 559 uint8_t *data = NULL; 560 struct rbug_proto_texture_info_reply *ret; 561 562 if (!header) 563 return NULL; 564 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_INFO_REPLY) 565 return NULL; 566 567 pos = 0; 568 len = header->length * 4; 569 data = (uint8_t*)&header[1]; 570 ret = MALLOC(sizeof(*ret)); 571 if (!ret) 572 return NULL; 573 574 ret->header.__message = header; 575 ret->header.opcode = header->opcode; 576 577 READ(4, uint32_t, serial); /* serial */ 578 READ(4, uint32_t, target); /* target */ 579 READ(4, uint32_t, format); /* format */ 580 READ_ARRAY(4, uint32_t, width); /* width */ 581 READ_ARRAY(4, uint32_t, height); /* height */ 582 READ_ARRAY(4, uint32_t, depth); /* depth */ 583 READ(4, uint32_t, blockw); /* blockw */ 584 READ(4, uint32_t, blockh); /* blockh */ 585 READ(4, uint32_t, blocksize); /* blocksize */ 586 READ(4, uint32_t, last_level); /* last_level */ 587 READ(4, uint32_t, nr_samples); /* nr_samples */ 588 READ(4, uint32_t, tex_usage); /* tex_usage */ 589 590 return ret; 591 } 592 593 struct rbug_proto_texture_read_reply * rbug_demarshal_texture_read_reply(struct rbug_proto_header *header) 594 { 595 uint32_t len = 0; 596 uint32_t pos = 0; 597 uint8_t *data = NULL; 598 struct rbug_proto_texture_read_reply *ret; 599 600 if (!header) 601 return NULL; 602 if (header->opcode != (int32_t)RBUG_OP_TEXTURE_READ_REPLY) 603 return NULL; 604 605 pos = 0; 606 len = header->length * 4; 607 data = (uint8_t*)&header[1]; 608 ret = MALLOC(sizeof(*ret)); 609 if (!ret) 610 return NULL; 611 612 ret->header.__message = header; 613 ret->header.opcode = header->opcode; 614 615 READ(4, uint32_t, serial); /* serial */ 616 READ(4, uint32_t, format); /* format */ 617 READ(4, uint32_t, blockw); /* blockw */ 618 READ(4, uint32_t, blockh); /* blockh */ 619 READ(4, uint32_t, blocksize); /* blocksize */ 620 READ_ARRAY(1, uint8_t, data); /* data */ 621 READ(4, uint32_t, stride); /* stride */ 622 623 return ret; 624 } 625
