Subversion Repositories freemyipod

//
//
//    Copyright 2011 TheSeven
//    Copyright 2012 njsg
//
//
//    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/>.
//
//

// This is a linux-based implementation of ipodscsi, originally
// implemented by TheSeven for Microsoft Windows.
//
// Currently, this only works for iPod 6g/Classic, but it should also
// work with minor modifications for, e.g., Nano 4g, which uses a
// similar firmware update mechanism.

#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <scsi/sg.h>
#include <stdlib.h>

#include "build/version.h"

#define APPLE_PREFIX 0xc6
#define CMD_INIT_FIRMWARE 0x90
#define CMD_SEND_FIRMWARE 0x91
#define CMD_PARTITION 0x94

// Return a file descriptor for the SCSI device, after checking if it
// is really a SCSI-generic device.
int open_scsi(const char * scsi_device) {
  int version;
  int sg_fd;
  
  // Open SCSI device 
  if ((sg_fd = open(scsi_device, O_RDWR)) < 0) 
  {
    perror("error opening given file name");
    exit(EXIT_FAILURE);
  }

  // Request a very simple scsi-generic ioctl(). If this fails, this
  // is not a scsi-generic device.
  if (ioctl(sg_fd, SG_GET_VERSION_NUM, &version) < 0) 
  {
    printf("%s is not a SCSI-generic device.\n", scsi_device);
    exit(EXIT_FAILURE);
  }

  return sg_fd;
}

int usage(char const* msg, char const* msgarg, int argc, char const* const* argv)
{
    printf(msg, msgarg);
    printf("\n"
           "\n"
           "Usage: %s <scsi_device> <command> [options...]\n"
           "\n"
           "  scsi_device is the path to a device managed by the\n"
           "  'scsi-generic' driver. Those are usually /dev/sgN,\n"
           "  where N is the device number.\n"
           "\n"
           "Commands:\n"
           "  writefirmware [-p] [-r] <firmware.mse>\n"
           "    -r: Reboot device\n"
           "    -p: Repartition device\n", argv[0]);
    exit(EXIT_SUCCESS);
}

int main(int argc, char const* const* argv)
{
    int arg = 3;
    char const* mse_filename = NULL;
    char const* scsi_device = NULL;
    int repartition = 0;
    int reboot = 0;

    int f; // Firmware file descriptor
    unsigned long bytes;

    printf("iPodSCSI for linux v. " VERSION " r" VERSION_SVN " - Copyright 2012 by Nuno J. Silva (njsg)\n"
           "Based on the original iPodSCSI Windows code by Michael Sparmann (TheSeven)\n"
           "This is free software; see the source for copying conditions.  There is NO\n"
           "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
           "\n");

    if (argc < 3) return usage("Not enough arguments specified", NULL, argc, argv);

    if (strcmp(argv[2], "writefirmware") != 0)
    {
      usage("Unknown command: %s", argv[2], argc, argv);
    }

    scsi_device = argv[1];
    

    while (arg < argc)
    {
        if (argv[arg][0] == '-')
        {
            if (!strcmp(argv[arg], "-p")) repartition = 1;
            else if (!strcmp(argv[arg], "-r")) reboot = 1;
            else return usage("Unknown option: %s", argv[arg], argc, argv);
        }
        else if (mse_filename) return usage("Excessive argument: %s", argv[arg], argc, argv);
        else mse_filename = argv[arg];
        arg++;
    }

    int sg_fd = open_scsi (scsi_device);

    if (!mse_filename) return usage("No MSE file name specified", NULL, argc, argv);


    f = open(mse_filename, O_RDONLY);
  
    if (f == -1)
    {
      perror("Error while opening MSE file");
      exit(EXIT_FAILURE);
    }


    {
      // Get MSE file size 
      struct stat *f_stat = malloc (sizeof (struct stat));
      unsigned long size;

      if (fstat (f, f_stat) == -1) 
      {
        perror("Error while getting MSE file size");
        exit(EXIT_FAILURE);
      }

      bytes = f_stat->st_size;

      if (bytes & 0xfff) 
      {
        fprintf(stderr, "MSE file size must be a multiple of 4096\n");
        exit (EXIT_FAILURE);
      }
    }

    int sectors = bytes >> 12;

    // Most commands will have the same prefix.
    unsigned char cmdBlk[] = {APPLE_PREFIX, 0, 0, 0, 0, 0};


    // Prepare a SCSI command structure, which will be changed as
    // needed later.
    sg_io_hdr_t io_hdr;
    memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
    io_hdr.interface_id = 'S';
    io_hdr.dxfer_direction = SG_DXFER_NONE;
    io_hdr.dxfer_len = 0;
    io_hdr.dxferp = NULL;
    io_hdr.cmdp = cmdBlk;
    io_hdr.cmd_len = sizeof(cmdBlk);
    io_hdr.mx_sb_len = 0;
    io_hdr.sbp = NULL;

    if (repartition)
    {
      printf("Repartitioning...");
      int partsize = sectors << 2;
      cmdBlk[1] = CMD_PARTITION;
      cmdBlk[2] = (partsize >> 24) & 0xff;
      cmdBlk[3] = (partsize >> 16) & 0xff;
      cmdBlk[4] = (partsize >> 8) & 0xff;
      cmdBlk[5] = (partsize) & 0xff;

      io_hdr.timeout = 60000;     
      
      if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) 
      {
        perror("iPod repartitioning SG_IO ioctl error");
        exit(EXIT_FAILURE);
      }
      printf(" done\n");
    }
    

    printf("Initiating firmware transfer...");

    cmdBlk[1] = CMD_INIT_FIRMWARE;
    cmdBlk[2] = 0;
    cmdBlk[3] = 0;
    cmdBlk[4] = 0;
    cmdBlk[5] = 0;

    io_hdr.timeout = 1000;     
        


    if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) 
    {
      perror("iPod firmware transfer init SG_IO ioctl error");
      exit(EXIT_FAILURE);
    }
    printf(" done\n");



    printf("Writing firmware...");

    cmdBlk[1] = CMD_SEND_FIRMWARE;

    while (sectors)
    {
      int tsize = sectors > 0x10 ? 0x10 : sectors;
      int got = 0;
        
      char * buf = malloc((tsize << 12) * sizeof(char));

      while (got < (tsize << 12))
      {
        int b = read(f, buf + got, (tsize << 12) - got);
        if (b == -1) 
        {
          perror("Error reading from MSE file");
          exit(EXIT_FAILURE);
        }
        got += b;
      }
                
      cmdBlk[3] = tsize;
        
      io_hdr.dxfer_direction = SG_DXFER_TO_DEV;
      io_hdr.dxfer_len = tsize << 12;
      io_hdr.dxferp = buf;
      io_hdr.timeout = 5000; 

      if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) 
      {
        perror("iPod firmware transfer SG_IO ioctl error");
        exit(EXIT_FAILURE);
      }

      sectors -= tsize;
      printf(".");
      fflush(stdout);
    }
    printf(" done\n");


    if (reboot)
    {
        printf("Rebooting device...");

        cmdBlk[0] = 0x1b;
        cmdBlk[1] = 0;
        cmdBlk[2] = 0;
        cmdBlk[3] = 0;
        cmdBlk[4] = 0x02;
        cmdBlk[5] = 0;

        io_hdr.dxfer_direction = SG_DXFER_NONE;
        io_hdr.dxfer_len = 0;
        io_hdr.dxferp = NULL;
        io_hdr.timeout = 10000;     

        if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) 
        {
          perror("iPod reboot SG_IO ioctl error");
          exit(EXIT_FAILURE);
        }

        printf(" done\n");
    }
      
    close(sg_fd);
    exit(EXIT_SUCCESS);
}