/**

  * $Id$

  *

  * SCSI/MMC device interface (depends on lower-level SCSI transport)

  *

  * Copyright (c) 2009 Nathan Keynes.

  *

  * This program 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.

  *

  * This program 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.

  */

 #include <assert.h>

 #include <string.h>

 #include <glib/gstrfuncs.h>

 #include "lxdream.h"

 #include "gettext.h"

 #include "drivers/cdrom/cdimpl.h"

 #define MAXTOCENTRIES 600  /* This is a fairly generous overestimate really */

 #define MAXTOCSIZE 4 + (MAXTOCENTRIES*11)

 #define MAX_SECTORS_PER_CALL 1

 /**

  * Parse the TOC (format 2) into the cdrom_disc structure

  */

 void mmc_parse_toc2( cdrom_disc_t disc, unsigned char *buf )

 {

     int max_track = 0;

     int max_session = 0;

     int last_track = -1;

     int leadout = -1;

     int len = (buf[0] << 8) | buf[1];

     int session_type = -1;

     int i;

     for( i = 4; i<len; i+=11 ) {

         int session = buf[i];

         int adr = buf[i+1] >> 4;

         int point = buf[i+3];

         if( adr == 0x01 && point > 0 && point < 100 ) {

             /* Track info */

             int trackno = point-1;

             if( point > max_track ) {

                 max_track = point;

             }

             if( session > max_session ) {

                 max_session = session;

             }

             disc->track[trackno].trackno = point;

             disc->track[trackno].flags = (buf[i+1] & 0x0F) << 4;

             disc->track[trackno].sessionno = session;

             disc->track[trackno].lba = MSFTOLBA(buf[i+8],buf[i+9],buf[i+10]);

             last_track = trackno;

         } else switch( (adr << 8) | point ) {

         case 0x1A0: /* session info */

             if( buf[i+9] == 0x20 ) {

                 session_type = CDROM_DISC_XA;

             } else {

                 session_type = CDROM_DISC_NONXA;

             }

             disc->disc_type = session_type;

             break;

         case 0x1A2: /* leadout */

             disc->leadout = MSFTOLBA(buf[i+8], buf[i+9], buf[i+10]);

             break;

         }

     }

     disc->track_count = max_track;

     disc->session_count = max_session;

 }

 const char *mmc_parse_inquiry( unsigned char *buf )

 {

     char vendorid[9];

     char productid[17];

     char productrev[5];

     memcpy( vendorid, buf+8, 8 ); vendorid[8] = 0;

     memcpy( productid, buf+16, 16 ); productid[16] = 0;

     memcpy( productrev, buf+32, 4 ); productrev[4] = 0;

     return g_strdup_printf( "%.8s %.16s %.4s", g_strstrip(vendorid),

               g_strstrip(productid), g_strstrip(productrev) );

 }

 /**

  * Construct a drive indentification string based on the response to the

  * INQUIRY command. On success, returns the disc identification as a newly

  * allocated string, otherwise NULL.

  */

 const char *cdrom_disc_scsi_identify_drive( cdrom_disc_t disc )

 {

     unsigned char ident[256];

     uint32_t identlen = 256;

     char cmd[12] = {0x12,0,0,0, 0xFF,0,0,0, 0,0,0,0};

     cdrom_error_t status = SCSI_TRANSPORT(disc)->packet_read( disc, cmd, ident, &identlen );

     if( status == CDROM_ERROR_OK ) {

         return mmc_parse_inquiry(ident);

     }

     return NULL;

 }

 static cdrom_error_t cdrom_disc_scsi_read_sectors( sector_source_t source, cdrom_lba_t lba,

         cdrom_count_t count, cdrom_read_mode_t mode, unsigned char *buf, size_t *length )

 {

     assert( IS_SECTOR_SOURCE_TYPE(source,DISC_SECTOR_SOURCE) );

     cdrom_disc_t disc = (cdrom_disc_t)source;

     uint32_t sector_size = CDROM_MAX_SECTOR_SIZE;

     char cmd[12];

     cmd[0] = 0xBE;

     cmd[1] = CDROM_READ_TYPE(mode);

     cmd[2] = (lba >> 24) & 0xFF;

     cmd[3] = (lba >> 16) & 0xFF;

     cmd[4] = (lba >> 8) & 0xFF;

     cmd[5] = lba & 0xFF;

     cmd[6] = (count>>16) & 0xFF;

     cmd[7] = (count>>8) & 0xFF;

     cmd[8] = count & 0xFF;

     cmd[9] = CDROM_READ_FIELDS(mode)>>8;

     cmd[10]= 0;

     cmd[11]= 0;

     cdrom_error_t status = SCSI_TRANSPORT(disc)->packet_read( disc, cmd, buf, &sector_size );

     if( status != 0 ) {

         return status;

     }

     /* FIXME */

     *length = 2048;

     return 0;

 }

 /**

  * Read the full table of contents into the disc from the device.

  */

 gboolean cdrom_disc_scsi_read_toc( cdrom_disc_t disc, ERROR *err )

 {

     unsigned char buf[MAXTOCSIZE];

     uint32_t buflen = sizeof(buf);

     char cmd[12] = { 0x43, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

     cmd[7] = (sizeof(buf))>>8;

     cmd[8] = (sizeof(buf))&0xFF;

     memset( buf, 0, sizeof(buf) );

     cdrom_error_t status = SCSI_TRANSPORT(disc)->packet_read(disc, cmd, buf, &buflen );

     if( status == CDROM_ERROR_OK ) {

 	    mmc_parse_toc2( disc, buf );

 	    return TRUE;

     } else {

     	if( (status & 0xFF) != 0x02 ) {

     	    /* Sense key 2 == Not Ready (ie temporary failure). Just ignore and

     	     * consider the drive empty for now, but warn about any other errors

     	     * we get. */

     	    WARN( _("Unable to read disc table of contents (error %04x)"), status );

     	}

     	cdrom_disc_clear_toc(disc);

     	return FALSE;

     }

 }

 static gboolean cdrom_disc_scsi_check_media( cdrom_disc_t disc )

 {

 	if( SCSI_TRANSPORT(disc)->media_changed(disc) ) {

 		cdrom_disc_scsi_read_toc(disc, NULL);

 		return TRUE;

 	} else {

 		return FALSE;

 	}

 }

 static cdrom_error_t cdrom_disc_scsi_play_audio( cdrom_disc_t disc, cdrom_lba_t lba, cdrom_count_t length )

 {

     char cmd[12] = { 0xA5, 0,0,0, 0,0,0,0, 0,0,0,0 };

     cmd[2] = (lba >> 24) & 0xFF;

     cmd[3] = (lba >> 16) & 0xFF;

     cmd[4] = (lba >> 8) & 0xFF;

     cmd[5] = lba & 0xFF;

     cmd[6] = (length >> 24) & 0xFF;

     cmd[7] = (length >> 16) & 0xFF;

     cmd[8] = (length >> 8) & 0xFF;

     cmd[9] = length & 0xFF;

     return SCSI_TRANSPORT(disc)->packet_cmd( disc, cmd );

 }

 static cdrom_error_t cdrom_disc_scsi_stop_audio( cdrom_disc_t disc )

 {

     uint32_t buflen = 0;

     char cmd[12] = {0x4E,0,0,0, 0,0,0,0, 0,0,0,0};

     return SCSI_TRANSPORT(disc)->packet_cmd( disc, cmd );

 }

 void cdrom_disc_scsi_init( cdrom_disc_t disc, cdrom_scsi_transport_t scsi )

 {

     disc->impl_data = scsi;

     disc->source.read_sectors = cdrom_disc_scsi_read_sectors;

     disc->read_toc = cdrom_disc_scsi_read_toc;

     disc->check_media = cdrom_disc_scsi_check_media;

     disc->play_audio = cdrom_disc_scsi_play_audio;

     disc->stop_audio = cdrom_disc_scsi_stop_audio;

 }

 cdrom_disc_t cdrom_disc_scsi_new( const char *filename, cdrom_scsi_transport_t scsi, ERROR *err )

 {

     cdrom_disc_t disc = cdrom_disc_new(filename, err);

     if( disc != NULL ) {

         /* Initialize */

         cdrom_disc_scsi_init( disc, scsi );

         cdrom_disc_read_toc(disc, err);

     }

     return disc;

 } 

 cdrom_disc_t cdrom_disc_scsi_new_file( FILE *f, const char *filename, cdrom_scsi_transport_t scsi, ERROR *err )

 {

     cdrom_disc_t disc = cdrom_disc_new(filename, err);

     if( disc != NULL ) {

         /* Initialize */

         disc->base_source = file_sector_source_new( f, SECTOR_UNKNOWN, 0, 0, TRUE );

         if( disc->base_source != NULL ) {

             sector_source_ref( disc->base_source );

             cdrom_disc_scsi_init( disc, scsi );

             cdrom_disc_read_toc(disc, err);

         } else {

             cdrom_disc_unref(disc);

             disc = NULL;

         }

     }

     return disc;

 }