/**

  * $Id$

  *

  * OSX native cd-rom driver.

  *

  * Copyright (c) 2005 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 <IOKit/IOKitLib.h>

 #include <IOKit/IOBSD.h>

 #include <IOKit/storage/IOStorageDeviceCharacteristics.h>

 #include <IOKit/storage/IOCDMediaBSDClient.h>

 #include <IOKit/storage/IOCDTypes.h>

 #include <sys/param.h>

 #include <errno.h>

 #include <stdio.h>

 #include <string.h>

 #include <paths.h>

 #include "gdrom/gddriver.h"

 #include "gdrom/packet.h"

 #include "drivers/osx_iokit.h"

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

 #define MAXTOCSIZE 4 + (MAXTOCENTRIES*11)

 static gboolean cdrom_osx_image_is_valid( FILE *f );

 static gdrom_disc_t cdrom_osx_open_device( const gchar *filename, FILE *f );

 static gdrom_error_t cdrom_osx_read_toc( gdrom_image_t disc );

 static gdrom_error_t cdrom_osx_read_sector( gdrom_disc_t disc, uint32_t sector,

                                             int mode, unsigned char *buf, uint32_t *length );

 struct gdrom_image_class cdrom_device_class = { "osx", NULL,

         cdrom_osx_image_is_valid, cdrom_osx_open_device };

 #define OSX_DRIVE(disc) ( (osx_cdrom_drive_t)(((gdrom_image_t)disc)->private) )

 static void cdrom_osx_destroy( gdrom_disc_t disc )

 {

     osx_cdrom_close_drive( OSX_DRIVE(disc) );

     gdrom_image_destroy_no_close( disc );

 }

 static void cdrom_osx_media_changed( osx_cdrom_drive_t drive, gboolean present,

                                      void *user_data )

 {

     gdrom_image_t image = (gdrom_image_t)user_data;

     if( present ) {

         cdrom_osx_read_toc( image );

     } else {

         image->disc_type = IDE_DISC_NONE;

         image->track_count = 0;        

     }

 }

 static gdrom_disc_t cdrom_osx_new( const char *name, osx_cdrom_drive_t drive )

 {

     char tmp[strlen(name)+7];

     sprintf( tmp, "dvd://%s", name );

     gdrom_image_t image = (gdrom_image_t)gdrom_image_new(tmp, NULL);

     image->private = drive;

     image->disc.read_sector = cdrom_osx_read_sector;

     image->disc.close = cdrom_osx_destroy;

     cdrom_osx_read_toc(image);

     osx_cdrom_set_media_changed_callback( drive, cdrom_osx_media_changed, image );

     return (gdrom_disc_t)image;

 }

 gdrom_disc_t cdrom_open_device( const gchar *method, const gchar *path )

 {

     gdrom_disc_t result = NULL;

     osx_cdrom_drive_t drive = osx_cdrom_open_drive(path);

     if( drive == NULL ) {

         return NULL;

     } else {

         return cdrom_osx_new( path, drive );

     }

 }

 static gboolean cdrom_enum_callback( io_object_t object, char *vendor, char *product, char *iopath, void *ptr )

 {

     GList **list = (GList **)ptr;

     char tmp1[sizeof(io_string_t) + 6];

     char tmp2[512];

     snprintf( tmp1, sizeof(tmp1), "dvd://%s", iopath );

     snprintf( tmp2, sizeof(tmp2), "%s %s", vendor, product );

     *list = g_list_append( *list, gdrom_device_new( tmp1, tmp2 ) );

     return FALSE;

 }

 GList *cdrom_get_native_devices(void)

 {

     GList *list = NULL;

     find_cdrom_drive(cdrom_enum_callback, &list);

     osx_register_iokit_notifications();

     return list;

 }

 static gboolean cdrom_osx_image_is_valid( FILE *f )

 {

     return FALSE;

 }

 static gdrom_disc_t cdrom_osx_open_device( const gchar *filename, FILE *f )

 {

     return NULL;

 }

 static gdrom_error_t cdrom_osx_read_toc( gdrom_image_t image )

 {

     osx_cdrom_drive_t drive = OSX_DRIVE(image);

     int fh = osx_cdrom_get_media_handle(drive);

     if( fh == -1 ) {

         image->disc_type = IDE_DISC_NONE;

         image->track_count = 0;

         return -1;

     } else {

         unsigned char buf[MAXTOCSIZE];

         dk_cd_read_toc_t readtoc;

         memset( &readtoc, 0, sizeof(readtoc) );

         readtoc.format = 2;

         readtoc.formatAsTime = 0;

         readtoc.address.session = 0;

         readtoc.bufferLength = sizeof(buf);

         readtoc.buffer = buf;

         if( ioctl(fh, DKIOCCDREADTOC, &readtoc ) == -1 ) {

             image->disc_type = IDE_DISC_NONE;

             image->track_count = 0;

             return -1;

         } else {

             mmc_parse_toc2( image, buf );

         }

     }

     return 0;

 }

 static gdrom_error_t cdrom_osx_read_sector( gdrom_disc_t disc, uint32_t lba,

                                             int mode, unsigned char *buf, uint32_t *length ) 

 {

     gdrom_image_t image = (gdrom_image_t)disc;

     int real_lba = lba - 150;

     int sector_size = 2352;

     int direct_read = 1;

     char data[MAX_SECTOR_SIZE];

     osx_cdrom_drive_t drive = OSX_DRIVE(disc);

     int fh = osx_cdrom_get_media_handle(drive);

     if( fh == -1 ) {

         return PKT_ERR_NODISC;

     } else {

         dk_cd_read_t readcd;

         memset( &readcd, 0, sizeof(readcd) );

         readcd.buffer = buf;

         // This is complicated by needing to know the exact read size. Gah.

         if( READ_CD_RAW(mode) ) {

             sector_size = 2352;

             readcd.sectorArea = 0xF8; 

         } else if ( READ_CD_MODE(mode) == READ_CD_MODE_ANY ) {

             /* Sector could be anything - need to do a raw read and then parse

              * the requested data out ourselves

              */

             int track_no = gdrom_image_get_track_by_lba( image, lba );

             struct gdrom_track *track = &image->track[track_no-1];

             sector_size = 2352;

             if( track->mode == GDROM_CDDA ) {

                 readcd.sectorArea = kCDSectorAreaUser;

             } else {

                 readcd.sectorArea = 0xF8;

                 readcd.buffer = data;

                 direct_read = 0;

             }

         } else {

             // This is incomplete...

             if( READ_CD_DATA(mode) ) {

                 readcd.sectorArea = kCDSectorAreaUser;

                 switch( READ_CD_MODE(mode) ) {

                 case READ_CD_MODE_CDDA:

                     sector_size = 2352;

                     break;

                 case READ_CD_MODE_1:

                 case READ_CD_MODE_2_FORM_1:

                     sector_size = 2048;

                     break;

                 case READ_CD_MODE_2:

                     sector_size = 2336;

                     break;

                 case READ_CD_MODE_2_FORM_2:

                     sector_size = 2324;

                     break;

                 }

             }

         }

         readcd.offset = sector_size * real_lba;

         readcd.sectorType = READ_CD_MODE(mode)>>1;

         readcd.bufferLength = sector_size;

         if( ioctl( fh, DKIOCCDREAD, &readcd ) == -1 ) {

             return -1;

         }

         if( direct_read ) {

             *length = sector_size;

         } else {

             gdrom_extract_raw_data_sector( data, mode, buf, length );

         }

         return 0;

     }

 }