acorn.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  *  linux/fs/partitions/acorn.c
    3  *
    4  *  Copyright (c) 1996-2000 Russell King.
    5  *
    6  * This program is free software; you can redistribute it and/or modify
    7  * it under the terms of the GNU General Public License version 2 as
    8  * published by the Free Software Foundation.
    9  *
   10  *  Scan ADFS partitions on hard disk drives.
   11  */
   12 #include <linux/config.h>
   13 #include <linux/kernel.h>
   14 #include <linux/types.h>
   15 #include <linux/kdev_t.h>
   16 #include <linux/major.h>
   17 #include <linux/string.h>
   18 #include <linux/genhd.h>
   19 #include <linux/fs.h>
   20 #include <linux/pagemap.h>
   21 
   22 #include "check.h"
   23 #include "acorn.h"
   24 
   25 static void
   26 adfspart_setgeometry(kdev_t dev, unsigned int secspertrack, unsigned int heads)
   27 {
   28 #ifdef CONFIG_BLK_DEV_MFM
   29         extern void xd_set_geometry(kdev_t dev, unsigned char, unsigned char,
   30                                     unsigned long, unsigned int);
   31 
   32         if (MAJOR(dev) == MFM_ACORN_MAJOR) {
   33                 unsigned long totalblocks = hd->part[MINOR(dev)].nr_sects;
   34                 xd_set_geometry(dev, secspertrack, heads, totalblocks, 1);
   35         }
   36 #endif
   37 }
   38 
   39 static struct adfs_discrecord *
   40 adfs_partition(struct gendisk *hd, char *name, char *data,
   41                unsigned long first_sector, int minor)
   42 {
   43         struct adfs_discrecord *dr;
   44         unsigned int nr_sects;
   45 
   46         if (adfs_checkbblk(data))
   47                 return NULL;
   48 
   49         dr = (struct adfs_discrecord *)(data + 0x1c0);
   50 
   51         if (dr->disc_size == 0 && dr->disc_size_high == 0)
   52                 return NULL;
   53 
   54         nr_sects = (le32_to_cpu(dr->disc_size_high) << 23) |
   55                    (le32_to_cpu(dr->disc_size) >> 9);
   56 
   57         if (name)
   58                 printk(" [%s]", name);
   59         add_gd_partition(hd, minor, first_sector, nr_sects);
   60         return dr;
   61 }
   62 
   63 #ifdef CONFIG_ACORN_PARTITION_RISCIX
   64 static int
   65 riscix_partition(struct gendisk *hd, struct block_device *bdev,
   66                 unsigned long first_sect, int minor, unsigned long nr_sects)
   67 {
   68         Sector sect;
   69         struct riscix_record *rr;
   70         
   71         rr = (struct riscix_record *)read_dev_sector(bdev, first_sect, &sect);
   72         if (!rr)
   73                 return -1;
   74 
   75         printk(" [RISCiX]");
   76 
   77 
   78         if (rr->magic == RISCIX_MAGIC) {
   79                 unsigned long size = nr_sects > 2 ? 2 : nr_sects;
   80                 int part;
   81 
   82                 printk(" <");
   83 
   84                 add_gd_partition(hd, minor++, first_sect, size);
   85                 for (part = 0; part < 8; part++) {
   86                         if (rr->part[part].one &&
   87                             memcmp(rr->part[part].name, "All\0", 4)) {
   88                                 add_gd_partition(hd, minor++,
   89                                                 le32_to_cpu(rr->part[part].start),
   90                                                 le32_to_cpu(rr->part[part].length));
   91                                 printk("(%s)", rr->part[part].name);
   92                         }
   93                 }
   94 
   95                 printk(" >\n");
   96         } else {
   97                 add_gd_partition(hd, minor++, first_sect, nr_sects);
   98         }
   99 
  100         put_dev_sector(sect);
  101         return minor;
  102 }
  103 #endif
  104 
  105 static int
  106 linux_partition(struct gendisk *hd, struct block_device *bdev,
  107                 unsigned long first_sect, int minor, unsigned long nr_sects)
  108 {
  109         Sector sect;
  110         struct linux_part *linuxp;
  111         unsigned int mask = (1 << hd->minor_shift) - 1;
  112         unsigned long size = nr_sects > 2 ? 2 : nr_sects;
  113 
  114         printk(" [Linux]");
  115 
  116         add_gd_partition(hd, minor++, first_sect, size);
  117 
  118         linuxp = (struct linux_part *)read_dev_sector(bdev, first_sect, &sect);
  119         if (!linuxp)
  120                 return -1;
  121 
  122         printk(" <");
  123         while (linuxp->magic == cpu_to_le32(LINUX_NATIVE_MAGIC) ||
  124                linuxp->magic == cpu_to_le32(LINUX_SWAP_MAGIC)) {
  125                 if (!(minor & mask))
  126                         break;
  127                 add_gd_partition(hd, minor++, first_sect +
  128                                  le32_to_cpu(linuxp->start_sect),
  129                                  le32_to_cpu(linuxp->nr_sects));
  130                 linuxp ++;
  131         }
  132         printk(" >");
  133 
  134         put_dev_sector(sect);
  135         return minor;
  136 }
  137 
  138 #ifdef CONFIG_ACORN_PARTITION_CUMANA
  139 static int
  140 adfspart_check_CUMANA(struct gendisk *hd, struct block_device *bdev,
  141                       unsigned long first_sector, int minor)
  142 {
  143         unsigned int start_blk = 0, mask = (1 << hd->minor_shift) - 1;
  144         Sector sect;
  145         unsigned char *data;
  146         char *name = "CUMANA/ADFS";
  147         int first = 1;
  148 
  149         /*
  150          * Try Cumana style partitions - sector 3 contains ADFS boot block
  151          * with pointer to next 'drive'.
  152          *
  153          * There are unknowns in this code - is the 'cylinder number' of the
  154          * next partition relative to the start of this one - I'm assuming
  155          * it is.
  156          *
  157          * Also, which ID did Cumana use?
  158          *
  159          * This is totally unfinished, and will require more work to get it
  160          * going. Hence it is totally untested.
  161          */
  162         do {
  163                 struct adfs_discrecord *dr;
  164                 unsigned int nr_sects;
  165 
  166                 if (!(minor & mask))
  167                         break;
  168 
  169                 data = read_dev_sector(bdev, start_blk * 2 + 6, &sect);
  170                 if (!data)
  171                         return -1;
  172 
  173                 dr = adfs_partition(hd, name, data, first_sector, minor++);
  174                 if (!dr)
  175                         break;
  176 
  177                 name = NULL;
  178 
  179                 nr_sects = (data[0x1fd] + (data[0x1fe] << 8)) *
  180                            (dr->heads + (dr->lowsector & 0x40 ? 1 : 0)) *
  181                            dr->secspertrack;
  182 
  183                 if (!nr_sects)
  184                         break;
  185 
  186                 first = 0;
  187                 first_sector += nr_sects;
  188                 start_blk += nr_sects >> (BLOCK_SIZE_BITS - 9);
  189                 nr_sects = 0; /* hmm - should be partition size */
  190 
  191                 switch (data[0x1fc] & 15) {
  192                 case 0: /* No partition / ADFS? */
  193                         break;
  194 
  195 #ifdef CONFIG_ACORN_PARTITION_RISCIX
  196                 case PARTITION_RISCIX_SCSI:
  197                         /* RISCiX - we don't know how to find the next one. */
  198                         minor = riscix_partition(hd, bdev, first_sector,
  199                                                  minor, nr_sects);
  200                         break;
  201 #endif
  202 
  203                 case PARTITION_LINUX:
  204                         minor = linux_partition(hd, bdev, first_sector,
  205                                                 minor, nr_sects);
  206                         break;
  207                 }
  208                 put_dev_sector(sect);
  209                 if (minor == -1)
  210                         return minor;
  211         } while (1);
  212         put_dev_sector(sect);
  213         return first ? 0 : 1;
  214 }
  215 #endif
  216 
  217 #ifdef CONFIG_ACORN_PARTITION_ADFS
  218 /*
  219  * Purpose: allocate ADFS partitions.
  220  *
  221  * Params : hd          - pointer to gendisk structure to store partition info.
  222  *          dev         - device number to access.
  223  *          first_sector- first readable sector on the device.
  224  *          minor       - first available minor on device.
  225  *
  226  * Returns: -1 on error, 0 for no ADFS boot sector, 1 for ok.
  227  *
  228  * Alloc  : hda  = whole drive
  229  *          hda1 = ADFS partition on first drive.
  230  *          hda2 = non-ADFS partition.
  231  */
  232 static int
  233 adfspart_check_ADFS(struct gendisk *hd, struct block_device *bdev,
  234                    unsigned long first_sector, int minor)
  235 {
  236         unsigned long start_sect, nr_sects, sectscyl, heads;
  237         Sector sect;
  238         unsigned char *data;
  239         struct adfs_discrecord *dr;
  240         unsigned char id;
  241 
  242         data = read_dev_sector(bdev, 6, &sect);
  243         if (!data)
  244                 return -1;
  245 
  246         dr = adfs_partition(hd, "ADFS", data, first_sector, minor++);
  247         if (!dr) {
  248                 put_dev_sector(sect);
  249                 return 0;
  250         }
  251 
  252         heads = dr->heads + ((dr->lowsector >> 6) & 1);
  253         sectscyl = dr->secspertrack * heads;
  254         start_sect = ((data[0x1fe] << 8) + data[0x1fd]) * sectscyl;
  255         id = data[0x1fc] & 15;
  256         put_dev_sector(sect);
  257 
  258         adfspart_setgeometry(to_kdev_t(bdev->bd_dev), dr->secspertrack, heads);
  259         invalidate_bdev(bdev, 1);
  260         truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
  261 
  262         /*
  263          * Work out start of non-adfs partition.
  264          */
  265         nr_sects = hd->part[MINOR(to_kdev_t(bdev->bd_dev))].nr_sects - start_sect;
  266 
  267         if (start_sect) {
  268                 first_sector += start_sect;
  269 
  270                 switch (id) {
  271 #ifdef CONFIG_ACORN_PARTITION_RISCIX
  272                 case PARTITION_RISCIX_SCSI:
  273                 case PARTITION_RISCIX_MFM:
  274                         minor = riscix_partition(hd, bdev, first_sector,
  275                                                  minor, nr_sects);
  276                         break;
  277 #endif
  278 
  279                 case PARTITION_LINUX:
  280                         minor = linux_partition(hd, bdev, first_sector,
  281                                                 minor, nr_sects);
  282                         break;
  283                 }
  284         }
  285         return 1;
  286 }
  287 #endif
  288 
  289 #ifdef CONFIG_ACORN_PARTITION_ICS
  290 static int adfspart_check_ICSLinux(struct block_device *bdev, unsigned long block)
  291 {
  292         Sector sect;
  293         unsigned char *data = read_dev_sector(bdev, block, &sect);
  294         int result = 0;
  295 
  296         if (data) {
  297                 if (memcmp(data, "LinuxPart", 9) == 0)
  298                         result = 1;
  299                 put_dev_sector(sect);
  300         }
  301 
  302         return result;
  303 }
  304 
  305 /*
  306  * Purpose: allocate ICS partitions.
  307  * Params : hd          - pointer to gendisk structure to store partition info.
  308  *          dev         - device number to access.
  309  *          first_sector- first readable sector on the device.
  310  *          minor       - first available minor on device.
  311  * Returns: -1 on error, 0 for no ICS table, 1 for partitions ok.
  312  * Alloc  : hda  = whole drive
  313  *          hda1 = ADFS partition 0 on first drive.
  314  *          hda2 = ADFS partition 1 on first drive.
  315  *              ..etc..
  316  */
  317 static int
  318 adfspart_check_ICS(struct gendisk *hd, struct block_device *bdev,
  319                    unsigned long first_sector, int minor)
  320 {
  321         Sector sect;
  322         unsigned char *data;
  323         unsigned long sum;
  324         unsigned int i, mask = (1 << hd->minor_shift) - 1;
  325         struct ics_part *p;
  326 
  327         /*
  328          * Try ICS style partitions - sector 0 contains partition info.
  329          */
  330         data = read_dev_sector(bdev, 0, &sect);
  331         if (!data)
  332                 return -1;
  333 
  334         /*
  335          * check for a valid checksum
  336          */
  337         for (i = 0, sum = 0x50617274; i < 508; i++)
  338                 sum += data[i];
  339 
  340         sum -= le32_to_cpu(*(__u32 *)(&data[508]));
  341         if (sum) {
  342                 put_dev_sector(sect);
  343                 return 0; /* not ICS partition table */
  344         }
  345 
  346         printk(" [ICS]");
  347 
  348         for (p = (struct ics_part *)data; p->size; p++) {
  349                 unsigned long start;
  350                 long size;
  351 
  352                 if ((minor & mask) == 0)
  353                         break;
  354 
  355                 start = le32_to_cpu(p->start);
  356                 size  = le32_to_cpu(p->size);
  357 
  358                 if (size < 0) {
  359                         size = -size;
  360 
  361                         /*
  362                          * We use the first sector to identify what type
  363                          * this partition is...
  364                          */
  365                         if (size > 1 && adfspart_check_ICSLinux(bdev, start)) {
  366                                 start += 1;
  367                                 size -= 1;
  368                         }
  369                 }
  370 
  371                 if (size) {
  372                         add_gd_partition(hd, minor, first_sector + start, size);
  373                         minor++;
  374                 }
  375         }
  376 
  377         put_dev_sector(sect);
  378         return 1;
  379 }
  380 #endif
  381 
  382 /*
  383  * Purpose: allocate ICS partitions.
  384  * Params : hd          - pointer to gendisk structure to store partition info.
  385  *          dev         - device number to access.
  386  *          first_sector- first readable sector on the device.
  387  *          minor       - first available minor on device.
  388  * Returns: -1 on error, 0 for no ICS table, 1 for partitions ok.
  389  * Alloc  : hda  = whole drive
  390  *          hda1 = ADFS partition 0 on first drive.
  391  *          hda2 = ADFS partition 1 on first drive.
  392  *              ..etc..
  393  */
  394 #ifdef CONFIG_ACORN_PARTITION_POWERTEC
  395 static int
  396 adfspart_check_POWERTEC(struct gendisk *hd, struct block_device *bdev,
  397                         unsigned long first_sector, int minor)
  398 {
  399         Sector sect;
  400         unsigned char *data;
  401         struct ptec_partition *p;
  402         unsigned char checksum;
  403         int i;
  404 
  405         data = read_dev_sector(bdev, 0, &sect);
  406         if (!data)
  407                 return -1;
  408 
  409         for (checksum = 0x2a, i = 0; i < 511; i++)
  410                 checksum += data[i];
  411 
  412         if (checksum != data[511]) {
  413                 put_dev_sector(sect);
  414                 return 0;
  415         }
  416 
  417         printk(" [POWERTEC]");
  418 
  419         for (i = 0, p = (struct ptec_partition *)data; i < 12; i++, p++) {
  420                 unsigned long start;
  421                 unsigned long size;
  422 
  423                 start = le32_to_cpu(p->start);
  424                 size  = le32_to_cpu(p->size);
  425 
  426                 if (size)
  427                         add_gd_partition(hd, minor, first_sector + start,
  428                                          size);
  429                 minor++;
  430         }
  431 
  432         put_dev_sector(sect);
  433         return 1;
  434 }
  435 #endif
  436 
  437 static int (*partfn[])(struct gendisk *, struct block_device *, unsigned long, int) = {
  438 #ifdef CONFIG_ACORN_PARTITION_ICS
  439         adfspart_check_ICS,
  440 #endif
  441 #ifdef CONFIG_ACORN_PARTITION_POWERTEC
  442         adfspart_check_POWERTEC,
  443 #endif
  444 #ifdef CONFIG_ACORN_PARTITION_CUMANA
  445         adfspart_check_CUMANA,
  446 #endif
  447 #ifdef CONFIG_ACORN_PARTITION_ADFS
  448         adfspart_check_ADFS,
  449 #endif
  450         NULL
  451 };
  452 /*
  453  * Purpose: initialise all the partitions on an ADFS drive.
  454  *          These may be other ADFS partitions or a Linux/RiscBSD/RISCiX
  455  *          partition.
  456  *
  457  * Params : hd          - pointer to gendisk structure
  458  *          dev         - device number to access
  459  *          first_sect  - first available sector on the disk.
  460  *          first_minor - first available minor on this device.
  461  *
  462  * Returns: -1 on error, 0 if not ADFS format, 1 if ok.
  463  */
  464 int acorn_partition(struct gendisk *hd, struct block_device *bdev,
  465                     unsigned long first_sect, int first_minor)
  466 {
  467         int i;
  468 
  469         for (i = 0; partfn[i]; i++) {
  470                 int r = partfn[i](hd, bdev, first_sect, first_minor);
  471                 if (r) {
  472                         if (r > 0)
  473                                 printk("\n");
  474                         return r;
  475                 }
  476         }
  477         return 0;
  478 }
Cache object: f16399642cdc77a6e1facc1b44b09e66
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/partitions/acorn.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/partitions/acorn.c
