/* Copyright (C) 2005  Thomas Petazzoni
 
    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.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    USA.
 */
 
 #include <sos/kmalloc.h>
 #include <sos/blkdev.h>
 #include <drivers/bochs.h>
 
 /**
  * This structure defines the structure of a partition entry
  * (determined by the PC architecture)
  */
 typedef struct partition_entry
 {
   sos_ui8_t  active;
   sos_ui8_t  start_dl;
   sos_ui16_t start_cylinder;
   sos_ui8_t  type;
   sos_ui8_t  end_dl;
   sos_ui16_t end_cylinder;
   sos_ui32_t lba;
   sos_ui32_t size;
 } partition_entry_t;
 
 /**
  * Offset of the partition table inside the 512-byte sector.
  */
 #define PART_TABLE_OFFSET 446
 
 /**
  * The most common partition types. For a complete list, you can for
  * example refer to
  * http://www.win.tue.nl/~aeb/partitions/partition_types-1.html
  */
 #define PART_TYPE_EXTENDED   0x5
 #define PART_TYPE_FAT16_1    0xe
 #define PART_TYPE_FAT16_2    0x6
 #define PART_TYPE_FAT32_1    0xb
 #define PART_TYPE_FAT32_2    0xc
 #define PART_TYPE_LINUX_SWAP 0x82
 #define PART_TYPE_LINUX      0x83
 
 /**
  * Converts a partition type to a string
  */
 static const char *
 sos_part_type_str (unsigned int type)
 {
   switch (type)
     {
     case PART_TYPE_EXTENDED:
       return "Extended";
     case PART_TYPE_FAT16_1:
     case PART_TYPE_FAT16_2:
       return "FAT16";
     case PART_TYPE_FAT32_1:
     case PART_TYPE_FAT32_2:
       return "FAT32";
     case PART_TYPE_LINUX_SWAP:
       return "Linux Swap";
     case PART_TYPE_LINUX:
       return "Linux";
     default:
       return "Unknown";
     }
 }
 
 /**
  * Detect the partitions on the given device, and registers them to
  * the block device infrastructure.
  */
 sos_ret_t
 sos_part_detect (sos_ui32_t disk_class, sos_ui32_t disk_instance,
                  sos_size_t block_size, const char *name)
 {
   sos_vaddr_t buffer;
   struct sos_blockdev_instance *blkdev;
   struct partition_entry *part_entry;
   unsigned int extstart = 0, extsup = 0;
   sos_ret_t ret;
   sos_size_t size = block_size;
   unsigned int partnum;
 
   blkdev = sos_blockdev_ref_instance (disk_class, disk_instance);
   if (blkdev == NULL)
     return -SOS_ENOENT;
 
   buffer = (sos_vaddr_t) sos_kmalloc (block_size, 0);
   if (buffer == 0)
     {
       sos_blockdev_release_instance (blkdev);
       return -SOS_ENOMEM;
     }
 
   ret = sos_blockdev_kernel_read (blkdev, 0, buffer, & size);
   if (ret != SOS_OK)
     {
       sos_blockdev_release_instance (blkdev);
       sos_kfree (buffer);
       return ret;
     }
 
   if (size != block_size)
     {
       sos_blockdev_release_instance (blkdev);
       sos_kfree (buffer);
       return -SOS_EIO;
     }
 
   part_entry = (struct partition_entry *) (buffer + PART_TABLE_OFFSET);
 
   /* Handle primary partitions */
   for (partnum = 0; partnum < 4; partnum++)
     {
       if (part_entry [partnum].size == 0)
         continue;
 
       sos_bochs_printf ("%s%d (%lu Mb, %s) ", name, partnum+1,
                         (part_entry[partnum].size * block_size >> 20),
                         sos_part_type_str(part_entry[partnum].type));
       if (part_entry [partnum].type == PART_TYPE_EXTENDED)
         {
           if (extstart != 0)
             sos_bochs_printf ("Warning: two extended partitions detected\n");
           extstart = part_entry [partnum].lba;
           continue;
         }
 
       ret = sos_blockdev_register_partition (disk_class,
                                              disk_instance + partnum + 1,
                                              blkdev,
                                              part_entry[partnum].lba,
                                              part_entry[partnum].size, NULL);
       if (ret != SOS_OK)
         {
           sos_bochs_printf ("Could not register partition %d for disk %lu:%lu: error %d\n",
                             partnum, disk_class, disk_instance, ret);
           continue;
         }
     }
 
   while (extstart != 0 && partnum < 15)
     {
       ret = sos_blockdev_kernel_read (blkdev, (extstart + extsup) * block_size,
                                       (sos_luoffset_t) buffer, & size);
       if (ret != SOS_OK)
         {
           sos_blockdev_release_instance (blkdev);
           sos_kfree (buffer);
           return ret;
         }
 
       if (size != block_size)
         {
           sos_blockdev_release_instance (blkdev);
           sos_kfree (buffer);
           return -SOS_EIO;
         }
 
       sos_bochs_printf ("%s%d (%lu Mb, %s) ", name, partnum+1,
                         (part_entry[0].size * block_size >> 20),
                         sos_part_type_str(part_entry[0].type));
 
       ret = sos_blockdev_register_partition (disk_class,
                                              disk_instance + partnum + 1,
                                              blkdev,
                                              extstart + part_entry[0].lba,
                                              part_entry[0].size, NULL);
       if (ret != SOS_OK)
         sos_bochs_printf ("Could not register partition %d for disk %lu:%lu: error %d\n",
                           partnum, disk_class, disk_instance, ret);
 
       extsup = part_entry[1].lba;
       partnum ++;
       if (extsup == 0)
         break;
     }
 
   sos_blockdev_release_instance (blkdev);
   sos_kfree (buffer);
   return SOS_OK;
 }
 
 /**
  * Remove all detected partitions on given device
  */
 sos_ret_t
 sos_part_undetect (sos_ui32_t disk_class, sos_ui32_t disk_instance)
 {
   int partnum;
   sos_ret_t ret;
 
   for (partnum = 0; partnum < 15; partnum++)
     {
       ret = sos_blockdev_unregister_device (disk_class, disk_instance + partnum + 1);
       if (ret != SOS_OK)
         sos_bochs_printf ("Warning: could not unregister partition %d of device %lu:%lu\n",
                           partnum, disk_class, disk_instance);
     }
 
   return SOS_OK;
 }