examples: make picoproj usage look more like am7xxx-play one
[libam7xxx.git] / src / am7xxx.c
1 /* am7xxx - communication with AM7xxx based USB Pico Projectors and DPFs
2  *
3  * Copyright (C) 2012  Antonio Ospite <ospite@studenti.unina.it>
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <stdarg.h>
23 #include <errno.h>
24 #include <libusb.h>
25 #include <math.h>
26
27 #include "am7xxx.h"
28 #include "serialize.h"
29
30 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
31
32 /* If we're not using GNU C, elide __attribute__
33  * taken from: http://unixwiz.net/techtips/gnu-c-attributes.html)
34  */
35 #ifndef __GNUC__
36 #  define  __attribute__(x)  /*NOTHING*/
37 #endif
38
39 static void log_message(am7xxx_context *ctx,
40                         int level,
41                         const char *function,
42                         int line,
43                         const char *fmt,
44                         ...) __attribute__ ((format (printf, 5, 6)));
45
46 #define fatal(...)        log_message(NULL, AM7XXX_LOG_FATAL,   __func__, __LINE__, __VA_ARGS__)
47 #define error(ctx, ...)   log_message(ctx,  AM7XXX_LOG_ERROR,   __func__, __LINE__, __VA_ARGS__)
48 #define warning(ctx, ...) log_message(ctx,  AM7XXX_LOG_WARNING, __func__, 0,        __VA_ARGS__)
49 #define info(ctx, ...)    log_message(ctx,  AM7XXX_LOG_INFO,    __func__, 0,        __VA_ARGS__)
50 #define debug(ctx, ...)   log_message(ctx,  AM7XXX_LOG_DEBUG,   __func__, 0,        __VA_ARGS__)
51 #define trace(ctx, ...)   log_message(ctx,  AM7XXX_LOG_TRACE,   NULL,     0,        __VA_ARGS__)
52
53 struct am7xxx_usb_device_descriptor {
54         const char *name;
55         uint16_t vendor_id;
56         uint16_t product_id;
57 };
58
59 static struct am7xxx_usb_device_descriptor supported_devices[] = {
60         {
61                 .name       = "Acer C110",
62                 .vendor_id  = 0x1de1,
63                 .product_id = 0xc101,
64         },
65         {
66                 .name       = "Philips/Sagemcom PicoPix 1020",
67                 .vendor_id  = 0x21e7,
68                 .product_id = 0x000e,
69         },
70 };
71
72 /* The header size on the wire is known to be always 24 bytes, regardless of
73  * the memory configuration enforced by different architectures or compilers
74  * for struct am7xxx_header
75  */
76 #define AM7XXX_HEADER_WIRE_SIZE 24
77
78 struct _am7xxx_device {
79         libusb_device_handle *usb_device;
80         uint8_t buffer[AM7XXX_HEADER_WIRE_SIZE];
81         am7xxx_context *ctx;
82         am7xxx_device *next;
83 };
84
85 struct _am7xxx_context {
86         libusb_context *usb_context;
87         int log_level;
88         am7xxx_device *devices_list;
89 };
90
91 typedef enum {
92         AM7XXX_PACKET_TYPE_DEVINFO = 0x01,
93         AM7XXX_PACKET_TYPE_IMAGE   = 0x02,
94         AM7XXX_PACKET_TYPE_POWER   = 0x04,
95         AM7XXX_PACKET_TYPE_UNKNOWN = 0x05,
96 } am7xxx_packet_type;
97
98 struct am7xxx_generic_header {
99         uint32_t field0;
100         uint32_t field1;
101         uint32_t field2;
102         uint32_t field3;
103 };
104
105 struct am7xxx_devinfo_header {
106         uint32_t native_width;
107         uint32_t native_height;
108         uint32_t unknown0;
109         uint32_t unknown1;
110 };
111
112 struct am7xxx_image_header {
113         uint32_t format;
114         uint32_t width;
115         uint32_t height;
116         uint32_t image_size;
117 };
118
119 struct am7xxx_power_header {
120         uint32_t bit2;
121         uint32_t bit1;
122         uint32_t bit0;
123 };
124
125 /*
126  * Examples of packet headers:
127  *
128  * Image header:
129  * 02 00 00 00 00 10 3e 10 01 00 00 00 20 03 00 00 e0 01 00 00 53 E8 00 00
130  *
131  * Power header:
132  * 04 00 00 00 00 0c ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
133  */
134
135 struct am7xxx_header {
136         uint32_t packet_type;
137         uint8_t unknown0;
138         uint8_t header_data_len;
139         uint8_t unknown2;
140         uint8_t unknown3;
141         union {
142                 struct am7xxx_generic_header data;
143                 struct am7xxx_devinfo_header devinfo;
144                 struct am7xxx_image_header image;
145                 struct am7xxx_power_header power;
146         } header_data;
147 };
148
149
150 #ifdef DEBUG
151 static void debug_dump_devinfo_header(am7xxx_context *ctx, struct am7xxx_devinfo_header *d)
152 {
153         if (ctx == NULL || d == NULL)
154                 return;
155
156         debug(ctx, "Info header:\n");
157         debug(ctx, "\tnative_width:  0x%08x (%u)\n", d->native_width, d->native_width);
158         debug(ctx, "\tnative_height: 0x%08x (%u)\n", d->native_height, d->native_height);
159         debug(ctx, "\tunknown0:      0x%08x (%u)\n", d->unknown0, d->unknown0);
160         debug(ctx, "\tunknown1:      0x%08x (%u)\n", d->unknown1, d->unknown1);
161 }
162
163 static void debug_dump_image_header(am7xxx_context *ctx, struct am7xxx_image_header *i)
164 {
165         if (ctx == NULL || i == NULL)
166                 return;
167
168         debug(ctx, "Image header:\n");
169         debug(ctx, "\tformat:     0x%08x (%u)\n", i->format, i->format);
170         debug(ctx, "\twidth:      0x%08x (%u)\n", i->width, i->width);
171         debug(ctx, "\theight:     0x%08x (%u)\n", i->height, i->height);
172         debug(ctx, "\timage size: 0x%08x (%u)\n", i->image_size, i->image_size);
173 }
174
175 static void debug_dump_power_header(am7xxx_context *ctx, struct am7xxx_power_header *p)
176 {
177         if (ctx == NULL || p == NULL)
178                 return;
179
180         debug(ctx, "Power header:\n");
181         debug(ctx, "\tbit2: 0x%08x (%u)\n", p->bit2, p->bit2);
182         debug(ctx, "\tbit1: 0x%08x (%u)\n", p->bit1, p->bit1);
183         debug(ctx, "\tbit0: 0x%08x (%u)\n", p->bit0, p->bit0);
184 }
185
186 static void debug_dump_header(am7xxx_context *ctx, struct am7xxx_header *h)
187 {
188         if (ctx == NULL || h == NULL)
189                 return;
190
191         debug(ctx, "BEGIN\n");
192         debug(ctx, "packet_type:     0x%08x (%u)\n", h->packet_type, h->packet_type);
193         debug(ctx, "unknown0:        0x%02hhx (%hhu)\n", h->unknown0, h->unknown0);
194         debug(ctx, "header_data_len: 0x%02hhx (%hhu)\n", h->header_data_len, h->header_data_len);
195         debug(ctx, "unknown2:        0x%02hhx (%hhu)\n", h->unknown2, h->unknown2);
196         debug(ctx, "unknown3:        0x%02hhx (%hhu)\n", h->unknown3, h->unknown3);
197
198         switch(h->packet_type) {
199         case AM7XXX_PACKET_TYPE_DEVINFO:
200                 debug_dump_devinfo_header(ctx, &(h->header_data.devinfo));
201                 break;
202
203         case AM7XXX_PACKET_TYPE_IMAGE:
204                 debug_dump_image_header(ctx, &(h->header_data.image));
205                 break;
206
207         case AM7XXX_PACKET_TYPE_POWER:
208                 debug_dump_power_header(ctx, &(h->header_data.power));
209                 break;
210
211         default:
212                 debug(ctx, "Packet type not supported!\n");
213                 break;
214         }
215         debug(ctx, "END\n\n");
216 }
217
218 static inline unsigned int in_80chars(unsigned int i)
219 {
220         /* The 3 below is the length of "xx " where xx is the hex string
221          * representation of a byte */
222         return ((i+1) % (80/3));
223 }
224
225 static void trace_dump_buffer(am7xxx_context *ctx, const char *message,
226                               uint8_t *buffer, unsigned int len)
227 {
228         unsigned int i;
229
230         if (ctx == NULL || buffer == NULL || len == 0)
231                 return;
232
233         trace(ctx, "\n");
234         if (message)
235                 trace(ctx, "%s\n", message);
236
237         for (i = 0; i < len; i++) {
238                 trace(ctx, "%02hhX%c", buffer[i], (in_80chars(i) && (i < len - 1)) ? ' ' : '\n');
239         }
240         trace(ctx, "\n");
241 }
242 #else
243 static void debug_dump_header(am7xxx_context *ctx, struct am7xxx_header *h)
244 {
245         (void)ctx;
246         (void)h;
247 }
248
249 static void trace_dump_buffer(am7xxx_context *ctx, const char *message,
250                               uint8_t *buffer, unsigned int len)
251 {
252         (void)ctx;
253         (void)message;
254         (void)buffer;
255         (void)len;
256 }
257 #endif /* DEBUG */
258
259 static int read_data(am7xxx_device *dev, uint8_t *buffer, unsigned int len)
260 {
261         int ret;
262         int transferred = 0;
263
264         ret = libusb_bulk_transfer(dev->usb_device, 0x81, buffer, len, &transferred, 0);
265         if (ret != 0 || (unsigned int)transferred != len) {
266                 error(dev->ctx, "ret: %d\ttransferred: %d (expected %u)\n",
267                       ret, transferred, len);
268                 return ret;
269         }
270
271         trace_dump_buffer(dev->ctx, "<-- received", buffer, len);
272
273         return 0;
274 }
275
276 static int send_data(am7xxx_device *dev, uint8_t *buffer, unsigned int len)
277 {
278         int ret;
279         int transferred = 0;
280
281         trace_dump_buffer(dev->ctx, "sending -->", buffer, len);
282
283         ret = libusb_bulk_transfer(dev->usb_device, 1, buffer, len, &transferred, 0);
284         if (ret != 0 || (unsigned int)transferred != len) {
285                 error(dev->ctx, "ret: %d\ttransferred: %d (expected %u)\n",
286                       ret, transferred, len);
287                 return ret;
288         }
289
290         return 0;
291 }
292
293 static void serialize_header(struct am7xxx_header *h, uint8_t *buffer)
294 {
295         uint8_t **buffer_iterator = &buffer;
296
297         put_le32(h->packet_type, buffer_iterator);
298         put_8(h->unknown0, buffer_iterator);
299         put_8(h->header_data_len, buffer_iterator);
300         put_8(h->unknown2, buffer_iterator);
301         put_8(h->unknown3, buffer_iterator);
302         put_le32(h->header_data.data.field0, buffer_iterator);
303         put_le32(h->header_data.data.field1, buffer_iterator);
304         put_le32(h->header_data.data.field2, buffer_iterator);
305         put_le32(h->header_data.data.field3, buffer_iterator);
306 }
307
308 static void unserialize_header(uint8_t *buffer, struct am7xxx_header *h)
309 {
310         uint8_t **buffer_iterator = &buffer;
311
312         h->packet_type = get_le32(buffer_iterator);
313         h->unknown0 = get_8(buffer_iterator);
314         h->header_data_len = get_8(buffer_iterator);
315         h->unknown2 = get_8(buffer_iterator);
316         h->unknown3 = get_8(buffer_iterator);
317         h->header_data.data.field0 = get_le32(buffer_iterator);
318         h->header_data.data.field1 = get_le32(buffer_iterator);
319         h->header_data.data.field2 = get_le32(buffer_iterator);
320         h->header_data.data.field3 = get_le32(buffer_iterator);
321 }
322
323 static int read_header(am7xxx_device *dev, struct am7xxx_header *h)
324 {
325         int ret;
326
327         ret = read_data(dev, dev->buffer, AM7XXX_HEADER_WIRE_SIZE);
328         if (ret < 0)
329                 goto out;
330
331         unserialize_header(dev->buffer, h);
332
333         debug_dump_header(dev->ctx, h);
334
335         ret = 0;
336
337 out:
338         return ret;
339 }
340
341 static int send_header(am7xxx_device *dev, struct am7xxx_header *h)
342 {
343         int ret;
344
345         debug_dump_header(dev->ctx, h);
346
347         serialize_header(h, dev->buffer);
348         ret = send_data(dev, dev->buffer, AM7XXX_HEADER_WIRE_SIZE);
349         if (ret < 0)
350                 error(dev->ctx, "failed to send data\n");
351
352         return ret;
353 }
354
355 /* When level == AM7XXX_LOG_FATAL do not check the log_level from the context
356  * and print the message unconditionally, this makes it possible to print
357  * fatal messages even early on initialization, before the context has been
358  * set up */
359 static void log_message(am7xxx_context *ctx,
360                         int level,
361                         const char *function,
362                         int line,
363                         const char *fmt,
364                         ...)
365 {
366         va_list ap;
367
368         if (level == AM7XXX_LOG_FATAL || (ctx && level <= ctx->log_level)) {
369                 if (function) {
370                         fprintf(stderr, "%s", function);
371                         if (line)
372                                 fprintf(stderr, "[%d]", line);
373                         fprintf(stderr, ": ");
374                 }
375
376                 va_start(ap, fmt);
377                 vfprintf(stderr, fmt, ap);
378                 va_end(ap);
379         }
380
381         return;
382 }
383
384 static am7xxx_device *add_new_device(am7xxx_context *ctx)
385 {
386         am7xxx_device **devices_list;
387         am7xxx_device *new_device;
388
389         if (ctx == NULL) {
390                 fatal("context must not be NULL!\n");
391                 return NULL;
392         }
393
394         devices_list = &(ctx->devices_list);
395
396         new_device = malloc(sizeof(*new_device));
397         if (new_device == NULL) {
398                 fatal("cannot allocate a new device (%s)\n", strerror(errno));
399                 return NULL;
400         }
401         memset(new_device, 0, sizeof(*new_device));
402
403         new_device->ctx = ctx;
404
405         if (*devices_list == NULL) {
406                 *devices_list = new_device;
407         } else {
408                 am7xxx_device *prev = *devices_list;
409                 while (prev->next)
410                         prev = prev->next;
411                 prev->next = new_device;
412         }
413         return new_device;
414 }
415
416 static am7xxx_device *find_device(am7xxx_context *ctx,
417                                   unsigned int device_index)
418 {
419         unsigned int i = 0;
420         am7xxx_device *current;
421
422         if (ctx == NULL) {
423                 fatal("context must not be NULL!\n");
424                 return NULL;
425         }
426
427         current = ctx->devices_list;
428         while (current && i++ < device_index)
429                 current = current->next;
430
431         return current;
432 }
433
434 typedef enum {
435         SCAN_OP_BUILD_DEVLIST,
436         SCAN_OP_OPEN_DEVICE,
437 } scan_op;
438
439 /**
440  * This is where the central logic of multi-device support is.
441  *
442  * When 'op' == SCAN_OP_BUILD_DEVLIST the parameters 'open_device_index' and
443  * 'dev' are ignored; the function returns 0 on success and a negative value
444  * on error.
445  *
446  * When 'op' == SCAN_OP_OPEN_DEVICE the function opens the supported USB
447  * device with index 'open_device_index' and returns the correspondent
448  * am7xxx_device in the 'dev' parameter; the function returns 0 on success,
449  * 1 if the device was already open and a negative value on error.
450  *
451  * NOTES:
452  * if scan_devices() fails when called with 'op' == SCAN_OP_BUILD_DEVLIST,
453  * the caller might want to call am7xxx_shutdown() in order to remove
454  * devices possibly added before the failure.
455  */
456 static int scan_devices(am7xxx_context *ctx, scan_op op,
457                         unsigned int open_device_index, am7xxx_device **dev)
458 {
459         int num_devices;
460         libusb_device** list;
461         unsigned int current_index;
462         int i;
463         int ret;
464
465         if (ctx == NULL) {
466                 fatal("context must not be NULL!\n");
467                 return -EINVAL;
468         }
469         if (op == SCAN_OP_BUILD_DEVLIST && ctx->devices_list != NULL) {
470                 error(ctx, "device scan done already? Abort!\n");
471                 return -EINVAL;
472         }
473
474         num_devices = libusb_get_device_list(ctx->usb_context, &list);
475         if (num_devices < 0) {
476                 ret = -ENODEV;
477                 goto out;
478         }
479
480         current_index = 0;
481         for (i = 0; i < num_devices; i++) {
482                 struct libusb_device_descriptor desc;
483                 unsigned int j;
484
485                 ret = libusb_get_device_descriptor(list[i], &desc);
486                 if (ret < 0)
487                         continue;
488
489                 for (j = 0; j < ARRAY_SIZE(supported_devices); j++) {
490                         if (desc.idVendor == supported_devices[j].vendor_id
491                             && desc.idProduct == supported_devices[j].product_id) {
492
493                                 if (op == SCAN_OP_BUILD_DEVLIST) {
494                                         am7xxx_device *new_device;
495                                         info(ctx, "am7xxx device found, index: %d, name: %s\n",
496                                              current_index,
497                                              supported_devices[j].name);
498                                         new_device = add_new_device(ctx);
499                                         if (new_device == NULL) {
500                                                 /* XXX, the caller may want
501                                                  * to call am7xxx_shutdown() if
502                                                  * we fail here, as we may have
503                                                  * added some devices already
504                                                  */
505                                                 debug(ctx, "Cannot create a new device\n");
506                                                 ret = -ENODEV;
507                                                 goto out;
508                                         }
509                                 } else if (op == SCAN_OP_OPEN_DEVICE &&
510                                            current_index == open_device_index) {
511
512                                         *dev = find_device(ctx, open_device_index);
513                                         if (*dev == NULL) {
514                                                 ret = -ENODEV;
515                                                 goto out;
516                                         }
517
518                                         /* the usb device has already been opened */
519                                         if ((*dev)->usb_device) {
520                                                 debug(ctx, "(*dev)->usb_device already set\n");
521                                                 ret = 1;
522                                                 goto out;
523                                         }
524
525                                         ret = libusb_open(list[i], &((*dev)->usb_device));
526                                         if (ret < 0) {
527                                                 debug(ctx, "libusb_open failed\n");
528                                                 goto out;
529                                         }
530
531                                         libusb_set_configuration((*dev)->usb_device, 1);
532                                         libusb_claim_interface((*dev)->usb_device, 0);
533                                         goto out;
534                                 }
535                                 current_index++;
536                         }
537                 }
538         }
539
540         /* if we made it up to here we didn't find any device to open */
541         if (op == SCAN_OP_OPEN_DEVICE) {
542                 error(ctx, "Cannot find any device to open\n");
543                 ret = -ENODEV;
544                 goto out;
545         }
546
547         /* everything went fine when building the device list */
548         ret = 0;
549 out:
550         libusb_free_device_list(list, 1);
551         return ret;
552 }
553
554 int am7xxx_init(am7xxx_context **ctx)
555 {
556         int ret = 0;
557
558         *ctx = malloc(sizeof(**ctx));
559         if (*ctx == NULL) {
560                 fatal("cannot allocate the context (%s)\n", strerror(errno));
561                 ret = -ENOMEM;
562                 goto out;
563         }
564         memset(*ctx, 0, sizeof(**ctx));
565
566         /* Set the highest log level during initialization */
567         (*ctx)->log_level = AM7XXX_LOG_TRACE;
568
569         ret = libusb_init(&((*ctx)->usb_context));
570         if (ret < 0)
571                 goto out_free_context;
572
573         libusb_set_debug((*ctx)->usb_context, 3);
574
575         ret = scan_devices(*ctx, SCAN_OP_BUILD_DEVLIST , 0, NULL);
576         if (ret < 0) {
577                 error(*ctx, "scan_devices() failed\n");
578                 am7xxx_shutdown(*ctx);
579                 goto out;
580         }
581
582         /* Set a quieter log level as default for normal operation */
583         (*ctx)->log_level = AM7XXX_LOG_ERROR;
584         return 0;
585
586 out_free_context:
587         free(*ctx);
588         *ctx = NULL;
589 out:
590         return ret;
591 }
592
593 void am7xxx_shutdown(am7xxx_context *ctx)
594 {
595         am7xxx_device *current;
596
597         if (ctx == NULL) {
598                 fatal("context must not be NULL!\n");
599                 return;
600         }
601
602         current = ctx->devices_list;
603         while (current) {
604                 am7xxx_device *next = current->next;
605                 am7xxx_close_device(current);
606                 free(current);
607                 current = next;
608         }
609
610         libusb_exit(ctx->usb_context);
611         free(ctx);
612         ctx = NULL;
613 }
614
615 void am7xxx_set_log_level(am7xxx_context *ctx, am7xxx_log_level log_level)
616 {
617         ctx->log_level = log_level;
618 }
619
620 int am7xxx_open_device(am7xxx_context *ctx, am7xxx_device **dev,
621                        unsigned int device_index)
622 {
623         int ret;
624
625         if (ctx == NULL) {
626                 fatal("context must not be NULL!\n");
627                 return -EINVAL;
628         }
629
630         ret = scan_devices(ctx, SCAN_OP_OPEN_DEVICE, device_index, dev);
631         if (ret < 0) {
632                 errno = ENODEV;
633         } else if (ret > 0) {
634                 warning(ctx, "device %d already open\n", device_index);
635                 errno = EBUSY;
636                 ret = -EBUSY;
637         }
638
639         return ret;
640 }
641
642 int am7xxx_close_device(am7xxx_device *dev)
643 {
644         if (dev == NULL) {
645                 fatal("dev must not be NULL!\n");
646                 return -EINVAL;
647         }
648         if (dev->usb_device) {
649                 libusb_release_interface(dev->usb_device, 0);
650                 libusb_close(dev->usb_device);
651                 dev->usb_device = NULL;
652         }
653         return 0;
654 }
655
656 int am7xxx_get_device_info(am7xxx_device *dev,
657                            am7xxx_device_info *device_info)
658 {
659         int ret;
660         struct am7xxx_header h = {
661                 .packet_type     = AM7XXX_PACKET_TYPE_DEVINFO,
662                 .unknown0        = 0x00,
663                 .header_data_len = 0x00,
664                 .unknown2        = 0x3e,
665                 .unknown3        = 0x10,
666                 .header_data = {
667                         .devinfo = {
668                                 .native_width  = 0,
669                                 .native_height = 0,
670                                 .unknown0      = 0,
671                                 .unknown1      = 0,
672                         },
673                 },
674         };
675
676         ret = send_header(dev, &h);
677         if (ret < 0)
678                 return ret;
679
680         ret = read_header(dev, &h);
681         if (ret < 0)
682                 return ret;
683
684         device_info->native_width = h.header_data.devinfo.native_width;
685         device_info->native_height = h.header_data.devinfo.native_height;
686 #if 0
687         /* No reason to expose these in the public API until we know what they mean */
688         device_info->unknown0 = h.header_data.devinfo.unknown0;
689         device_info->unknown1 = h.header_data.devinfo.unknown1;
690 #endif
691
692         return 0;
693 }
694
695 int am7xxx_calc_scaled_image_dimensions(am7xxx_device *dev,
696                                         unsigned int upscale,
697                                         unsigned int original_width,
698                                         unsigned int original_height,
699                                         unsigned int *scaled_width,
700                                         unsigned int *scaled_height)
701 {
702
703         am7xxx_device_info device_info;
704         float width_ratio;
705         float height_ratio;
706         int ret;
707
708         ret = am7xxx_get_device_info(dev, &device_info);
709         if (ret < 0) {
710                 error(dev->ctx, "cannot get device info\n");
711                 return ret;
712         }
713
714         /*
715          * Check if we need to rescale; if the input image fits the native
716          * dimensions there is no need to, unless we want to upscale.
717          */
718         if (!upscale &&
719             original_width <= device_info.native_width &&
720             original_height <= device_info.native_height ) {
721                 debug(dev->ctx, "CASE 0, no rescaling, the original image fits already\n");
722                 *scaled_width = original_width;
723                 *scaled_height = original_height;
724                 return 0;
725         }
726
727         /* Input dimensions relative to the device native dimensions */
728         width_ratio =  (float)original_width / device_info.native_width;
729         height_ratio = (float)original_height / device_info.native_height;
730
731         if (width_ratio > height_ratio) {
732                 /*
733                  * The input is proportionally "wider" than the device viewport
734                  * so its height needs to be adjusted
735                  */
736                 debug(dev->ctx, "CASE 1, original image wider, adjust the scaled height\n");
737                 *scaled_width = device_info.native_width;
738                 *scaled_height = (unsigned int)lroundf(original_height / width_ratio);
739         } else if (width_ratio < height_ratio) {
740                 /*
741                  * The input is proportionally "taller" than the device viewport
742                  * so its width needs to be adjusted
743                  */
744                 debug(dev->ctx, "CASE 2 original image taller, adjust the scaled width\n");
745                 *scaled_width = (unsigned int)lroundf(original_width / height_ratio);
746                 *scaled_height = device_info.native_height;
747         } else {
748                 debug(dev->ctx, "CASE 3, just rescale, same aspect ratio already\n");
749                 *scaled_width = device_info.native_width;
750                 *scaled_height = device_info.native_height;
751         }
752         debug(dev->ctx, "scaled dimensions: %dx%d\n", *scaled_width, *scaled_height);
753
754         return 0;
755 }
756
757 int am7xxx_send_image(am7xxx_device *dev,
758                       am7xxx_image_format format,
759                       unsigned int width,
760                       unsigned int height,
761                       uint8_t *image,
762                       unsigned int image_size)
763 {
764         int ret;
765         struct am7xxx_header h = {
766                 .packet_type     = AM7XXX_PACKET_TYPE_IMAGE,
767                 .unknown0        = 0x00,
768                 .header_data_len = sizeof(struct am7xxx_image_header),
769                 .unknown2        = 0x3e,
770                 .unknown3        = 0x10,
771                 .header_data = {
772                         .image = {
773                                 .format     = format,
774                                 .width      = width,
775                                 .height     = height,
776                                 .image_size = image_size,
777                         },
778                 },
779         };
780
781         ret = send_header(dev, &h);
782         if (ret < 0)
783                 return ret;
784
785         if (image == NULL || image_size == 0) {
786                 warning(dev->ctx, "Not sending any data, check the 'image' or 'image_size' parameters\n");
787                 return 0;
788         }
789
790         return send_data(dev, image, image_size);
791 }
792
793 int am7xxx_set_power_mode(am7xxx_device *dev, am7xxx_power_mode mode)
794 {
795         int ret;
796         struct am7xxx_header h = {
797                 .packet_type     = AM7XXX_PACKET_TYPE_POWER,
798                 .unknown0        = 0x00,
799                 .header_data_len = sizeof(struct am7xxx_power_header),
800                 .unknown2        = 0x3e,
801                 .unknown3        = 0x10,
802         };
803
804         switch(mode) {
805         case AM7XXX_POWER_OFF:
806                 h.header_data.power.bit2 = 0;
807                 h.header_data.power.bit1 = 0;
808                 h.header_data.power.bit0 = 0;
809                 break;
810
811         case AM7XXX_POWER_LOW:
812                 h.header_data.power.bit2 = 0;
813                 h.header_data.power.bit1 = 0;
814                 h.header_data.power.bit0 = 1;
815
816         case AM7XXX_POWER_MIDDLE:
817                 h.header_data.power.bit2 = 0;
818                 h.header_data.power.bit1 = 1;
819                 h.header_data.power.bit0 = 0;
820                 break;
821
822         case AM7XXX_POWER_HIGH:
823                 h.header_data.power.bit2 = 0;
824                 h.header_data.power.bit1 = 1;
825                 h.header_data.power.bit0 = 1;
826                 break;
827
828         case AM7XXX_POWER_TURBO:
829                 h.header_data.power.bit2 = 1;
830                 h.header_data.power.bit1 = 0;
831                 h.header_data.power.bit0 = 0;
832                 break;
833
834         default:
835                 error(dev->ctx, "Power mode not supported!\n");
836                 return -EINVAL;
837         };
838
839         ret = send_header(dev, &h);
840         if (ret < 0)
841                 return ret;
842
843         return 0;
844 }