Subversion Repositories freemyipod

//

//

//    Copyright 2011 user890104

//

//

//    This file is part of emCORE.

//

//    emCORE is free software: you can redistribute it and/or

//    modify it under the terms of the GNU General Public License as

//    published by the Free Software Foundation, either version 2 of the

//    License, or (at your option) any later version.

//

//    emCORE is distributed in the hope that it will be useful,

//    but WITHOUT ANY WARRANTY; without even the implied warranty of

//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

//    See the GNU General Public License for more details.

//

//    You should have received a copy of the GNU General Public License along

//    with emCORE.  If not, see <http://www.gnu.org/licenses/>.

//

//

#include "global.h"

#include "util.h"

const char* libusb_error_messages[13] =

{

    "No error",                /* LIBUSB_SUCCESS = 0               */

    "Input/output error",      /* LIBUSB_ERROR_IO = -1             */

    "Invalid parameter",       /* LIBUSB_ERROR_INVALID_PARAM = -2  */

    "Access denied",           /* LIBUSB_ERROR_ACCESS = -3         */

    "No such device",          /* LIBUSB_ERROR_NO_DEVICE = -4      */

    "Entity not found",        /* LIBUSB_ERROR_NOT_FOUND = -5      */

    "Resource busy",           /* LIBUSB_ERROR_BUSY = -6           */

    "Operation timed out",     /* LIBUSB_ERROR_TIMEOUT = -7        */

    "Overflow",                /* LIBUSB_ERROR_OVERFLOW = -8       */

    "Pipe error",              /* LIBUSB_ERROR_PIPE = -9           */

    "System call interrupted", /* LIBUSB_ERROR_INTERRUPTED = -10   */

    "Insufficient memory",     /* LIBUSB_ERROR_NO_MEM = -11        */

    "Operation not supported", /* LIBUSB_ERROR_NOT_SUPPORTED = -12 */

};

const char* emcore_error_messages[10] =

{

    "No error",               /* EMCORE_SUCCESS = 0               */

    "Invalid command",        /* EMCORE_ERROR_INVALID = 1         */

    "Command not supported",  /* EMCORE_ERROR_NOT_SUPPORTED = 2   */

    "Device is busy",         /* EMCORE_ERROR_BUSY = 3            */

    "No such device",         /* EMCORE_ERROR_NO_DEVICE = 4       */

    "Incomplete transfer",    /* EMCORE_ERROR_INCOMPLETE = 5      */

    "Overflow",               /* EMCORE_ERROR_OVERFLOW = 6        */

    "Not implemented",        /* EMCORE_ERROR_NOT_IMPLEMENTED = 7 */

    "No more entries in dir", /* EMCORE_ERROR_NO_MORE_ENTRIES = 8 */

    "I/O error",              /* EMCORE_ERROR_IO = 9              */

};

void dump_packet(const void* data, const size_t length)

{

    static size_t i;

    for (i = 0; i < length; ++i)

    {

        fprintf(stderr, "%02x ", *((uint8_t*)(data + i)));

        if (i % 4 == 3)

        {

            fprintf(stderr, " ");

        }

        if (i % 16 == 15 && i + 1 < length)

        {

            fprintf(stderr, "\n");

        }

    }

    fprintf(stderr, "\n");

}

void alignsplit(struct alignsizes* sizeptr, const uint32_t addr,

    const uint32_t size, const uint32_t blksize, const uint32_t align)

{

    uint32_t end, bodyaddr, tailaddr;

    if (size <= blksize)

    {

        sizeptr->head = size;

        sizeptr->body = 0;

        sizeptr->tail = 0;

        return;

    }

    end = addr + size;

    if (addr & (align -1))

    {

        bodyaddr = (addr + MIN(size, blksize)) & ~(align - 1);

    }

    else

    {

        bodyaddr = addr;

    }

    sizeptr->head = bodyaddr - addr;

    if ((size - sizeptr->head) & (align - 1))

    {

        tailaddr = ((end - MIN(end - bodyaddr, blksize) + align - 1) & ~(align - 1));

    }

    else

    {

        tailaddr = end;

    }

    sizeptr->tail = end - tailaddr;

    sizeptr->body = tailaddr - bodyaddr;

    return;

}

time_t fat_time_to_unix_ts(const short wrttime, const short wrtdate)

{

    struct tm result;

    /*

        Example time: 0x9365

        in memory:

        M M M S S S S S   H H H H H M M M

        as a number:

        H H H H H M M M   M M M S S S S S

        Example date: 0x3d37

        in memory:

        M M M D D D D D   Y Y Y Y Y Y Y M

        as a number:

        Y Y Y Y Y Y Y M   M M M D D D D D

    */

    result.tm_sec = ((wrttime & 0x1f) << 1);

    result.tm_min = (wrttime >> 5) & 0x3f;

    result.tm_hour = (wrttime >> 11) & 0x1f;

    result.tm_mday = wrtdate & 0x1f;

    result.tm_mon = ((wrtdate >> 5) & 0xf) - 1;

    result.tm_year = ((wrtdate >> 9) & 0x7f) + 80;

    return mktime(&result);

}

int32_t unix_ts_to_fat_time(const time_t datetime)

{

    struct tm* tm_ptr;

    tm_ptr = localtime(&datetime);

    return (tm_ptr->tm_sec >> 1) |

           (tm_ptr->tm_min << 5) |

           (tm_ptr->tm_hour << 0xb) |

           (tm_ptr->tm_mday << 0x10) |

           ((tm_ptr->tm_mon + 1) << 0x15) |

           ((tm_ptr->tm_year - 80) << 0x19);

}

void print_error(const int code)

{

    if (code > 0)

    {

        fprintf(stderr, "emcore error: %s\n", emcore_error_messages[code]);

    }

    else

    {

        fprintf(stderr, "libusb error: %s\n", (

            LIBUSB_ERROR_OTHER == code ?

                "Other error" :

                libusb_error_messages[-code]

        ));

    }

}