diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig --- a/drivers/usb/storage/Kconfig +++ b/drivers/usb/storage/Kconfig @@ -123,3 +123,10 @@ config USB_STORAGE_ONETOUCH hard drive's as an input device. An action can be associated with this input in any keybinding software. (e.g. gnome's keyboard short- cuts) + +config USB_STORAGE_KARMA + bool "Rio Karma MP3 player (EXPERIMENTAL)" + depends on USB_STORAGE && EXPERIMENTAL + help + Say Y here to include additional code to support the Rio Karma + digital music player as a mass storage device. diff --git a/drivers/usb/storage/Makefile b/drivers/usb/storage/Makefile --- a/drivers/usb/storage/Makefile +++ b/drivers/usb/storage/Makefile @@ -19,6 +19,7 @@ usb-storage-obj-$(CONFIG_USB_STORAGE_ISD usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB) += datafab.o usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT) += jumpshot.o usb-storage-obj-$(CONFIG_USB_STORAGE_ONETOUCH) += onetouch.o +usb-storage-obj-$(CONFIG_USB_STORAGE_KARMA) += rio_karma.o usb-storage-objs := scsiglue.o protocol.o transport.o usb.o \ initializers.o $(usb-storage-obj-y) diff --git a/drivers/usb/storage/rio_karma.c b/drivers/usb/storage/rio_karma.c new file mode 100644 --- /dev/null +++ b/drivers/usb/storage/rio_karma.c @@ -0,0 +1,105 @@ +/* USB driver for DNNA Rio Karma + * + * (C) 2005 Bob Copeland (email@bobcopeland.com) + * + * The Karma is a mass storage device, although it requires some + * initialization code to get in that mode. + * + * 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, 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., + * 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include +#include +#include +#include "rio_karma.h" +#include "usb.h" +#include "transport.h" +#include "debug.h" + +#define RIOP_INIT "RIOP\x00\x01\x08" +#define CMD_LEN 40 +#define RECV_LEN 0x200 + +/* Initialize the karma and get it into mass storage mode. + * + * The initialization begins by sending RIOP\x00\x01\x08\x00... which + * the device will ack with a 512 byte packet with the high four bits + * set and everything else null. + * + * Next, we send RIOP\x80\x00\x08\x00. Each time, a 512 byte response + * must be read, but we must loop until byte 5 in the response is 0x08, + * indicating success. */ +int rio_karma_init(struct us_data *us) +{ + int result, partial; + static char init_cmd[] = RIOP_INIT; + char *cmd, *recv, *buf; + unsigned long timeout = msecs_to_jiffies(2000); + + if (!(buf = kmalloc(CMD_LEN + RECV_LEN, GFP_KERNEL | __GFP_DMA))) + goto die_nomem; + + cmd = buf; + recv = buf + CMD_LEN; + + us->max_lun = 0; + + US_DEBUGP("Initializing Karma...\n"); + + memcpy(cmd, init_cmd, sizeof(init_cmd)); + memset(&cmd[sizeof(init_cmd)], 0, CMD_LEN - sizeof(init_cmd)); + + result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, cmd, + CMD_LEN, &partial); + if (result != USB_STOR_XFER_GOOD) + goto die; + + result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, + recv, RECV_LEN, &partial); + if (result != USB_STOR_XFER_GOOD) + goto die; + + cmd[4] = 0x80; + cmd[5] = 0; + for (;;) { + US_DEBUGP("Sending init command\n"); + result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, + cmd, CMD_LEN, &partial); + if (result != USB_STOR_XFER_GOOD) + goto die; + + result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, + recv, RECV_LEN, &partial); + if (result != USB_STOR_XFER_GOOD) + goto die; + + if (recv[5] == 0x08) + break; + if (time_after(jiffies, timeout)) + goto die; + msleep(10); + } + US_DEBUGP("Karma initialized.\n"); + kfree(buf); + return 0; + +die: + kfree(buf); +die_nomem: + US_DEBUGP("Could not initialize karma.\n"); + return USB_STOR_TRANSPORT_FAILED; +} + diff --git a/drivers/usb/storage/rio_karma.h b/drivers/usb/storage/rio_karma.h new file mode 100644 --- /dev/null +++ b/drivers/usb/storage/rio_karma.h @@ -0,0 +1,31 @@ +/* Header file for USB driver for DNNA Rio Karma + * + * Rio Karma driver v0.1.1 + * + * (C) 2005 Bob Copeland (email@bobcopeland.com) + * + * 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, 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., + * 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#ifndef _RIO_KARMA_H +#define _RIO_KARMA_H + +#include +#include "usb.h" + +int rio_karma_init(struct us_data *); + +#endif diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h --- a/drivers/usb/storage/unusual_devs.h +++ b/drivers/usb/storage/unusual_devs.h @@ -138,6 +138,14 @@ UNUSUAL_DEV( 0x0451, 0x5416, 0x0100, 0x US_SC_DEVICE, US_PR_BULK, NULL, US_FL_NEED_OVERRIDE ), +#ifdef CONFIG_USB_STORAGE_KARMA +UNUSUAL_DEV( 0x045a, 0x5210, 0x0000, 0x9999, + "Rio", + "Rio Karma", + US_SC_SCSI, US_PR_BULK, rio_karma_init, + US_FL_FIX_INQUIRY | US_FL_SINGLE_LUN ), +#endif + /* Patch submitted by Philipp Friedrich */ UNUSUAL_DEV( 0x0482, 0x0100, 0x0100, 0x0100, "Kyocera", diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c --- a/drivers/usb/storage/usb.c +++ b/drivers/usb/storage/usb.c @@ -93,6 +93,9 @@ #ifdef CONFIG_USB_STORAGE_ONETOUCH #include "onetouch.h" #endif +#ifdef CONFIG_USB_STORAGE_KARMA +#include "rio_karma.h" +#endif /* Some informational data */ MODULE_AUTHOR("Matthew Dharm "); diff --git a/fs/Kconfig b/fs/Kconfig --- a/fs/Kconfig +++ b/fs/Kconfig @@ -1700,6 +1700,11 @@ config CODA_FS_OLD_API For most cases you probably want to say N. +config OMFS_FS + tristate "OMFS (Rio Karma)" + help + Say 'Y' to get support for the RIO Karma fs. + config AFS_FS # for fs/nls/Config.in tristate "Andrew File System support (AFS) (Experimental)" diff --git a/fs/Makefile b/fs/Makefile --- a/fs/Makefile +++ b/fs/Makefile @@ -100,4 +100,5 @@ obj-$(CONFIG_AFS_FS) += afs/ obj-$(CONFIG_BEFS_FS) += befs/ obj-$(CONFIG_HOSTFS) += hostfs/ obj-$(CONFIG_HPPFS) += hppfs/ +obj-$(CONFIG_OMFS_FS) += omfs/ obj-$(CONFIG_DEBUG_FS) += debugfs/ diff --git a/fs/omfs/Makefile b/fs/omfs/Makefile new file mode 100644 --- /dev/null +++ b/fs/omfs/Makefile @@ -0,0 +1,8 @@ +# +# Makefile for OMFS filesystem. +# + + +obj-$(CONFIG_OMFS_FS) += omfs.o + +omfs-objs := inode.o dir.o file.o diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c new file mode 100644 --- /dev/null +++ b/fs/omfs/dir.c @@ -0,0 +1,175 @@ +/* + * fs/omfs/dir.c + * OMFS (as used by RIO Karma) directory operations. + * Copyright (C) 2005 Bob Copeland + */ + +#include +#include +#include +#include +#include "omfs.h" + +static int omfs_hash(const char *name, int namelen, int mod) +{ + int i, hash=0; + for (i=0; ii_size - OMFS_DIR_START)/8; + + int block = clus_to_blk(dir->i_ino); + int bucket = omfs_hash(name, namelen, nbuckets); + + ptr = OMFS_DIR_START + bucket * 8; + block += ptr >> dir->i_sb->s_blocksize_bits; + ofs = ptr & (dir->i_sb->s_blocksize - 1); + + bh = sb_bread(dir->i_sb, block); + cluster = be64_to_cpu(*((u64 *) & bh->b_data[ofs])); + brelse(bh); + while (cluster != ~0) { + bh = sb_bread(dir->i_sb, clus_to_blk(cluster)); + if (!bh) + goto out; + + oi = (struct omfs_inode *)bh->b_data; + if (strncmp(oi->name, name, namelen) == 0) { + return bh; + } + cluster = be64_to_cpu(oi->sibling); + brelse(bh); + } +out: + return 0; +} + +static struct dentry *omfs_lookup(struct inode *dir, struct dentry *dentry, + struct nameidata *nd) +{ + struct buffer_head *bh; + struct inode *inode = NULL; + + if (dentry->d_name.len > OMFS_NAMELEN) + return ERR_PTR(-ENAMETOOLONG); + + bh = omfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len); + if (bh) { + struct omfs_inode *oi = (struct omfs_inode *)bh->b_data; + ino_t ino = be64_to_cpu(oi->head.self); + brelse(bh); + inode = iget(dir->i_sb, ino); + if (!inode) { + return ERR_PTR(-EINVAL); + } + } + d_add(dentry, inode); + return NULL; +} + +static int omfs_readdir(struct file *filp, void *dirent, filldir_t filldir) +{ + struct inode *dir = filp->f_dentry->d_inode; + struct buffer_head *bh = NULL, *bh2; + struct omfs_inode *oi; + loff_t bl_ofs; + loff_t offset, res; + u64 cluster; + unsigned char d_type; + ino_t self; + unsigned int hchain, hindex; + sector_t block; + int nbuckets; + + switch (filp->f_pos) { + case 0: + if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0) + goto success; + filp->f_pos++; + /* fall through */ + case 1: + if (filldir(dirent, "..", 2, 1, parent_ino(filp->f_dentry), DT_DIR) < 0) + goto success; + filp->f_pos = 0x01000000; + /* fall through */ + } + + nbuckets = (dir->i_size - OMFS_DIR_START) / 8; + + /* high byte stores bucket + 1 and low 24 bits store hash index */ + hchain = (filp->f_pos >> 24) -1; + hindex = filp->f_pos & 0xffffff; + + for (; hchain < nbuckets; hchain++) { + offset = OMFS_DIR_START + hchain * 8; + + bl_ofs = offset & (dir->i_sb->s_blocksize - 1); + if (!bl_ofs || !bh) { // wrapped a block + brelse(bh); + block = offset >> dir->i_sb->s_blocksize_bits; + bh = sb_bread(dir->i_sb, block + + clus_to_blk(dir->i_ino)); + if (!bh) + goto no_bh; + } + cluster = be64_to_cpu(*((u64 *) & bh->b_data[bl_ofs])); + while (cluster != ~0) { + bh2 = sb_bread(dir->i_sb, clus_to_blk(cluster)); + if (!bh2) + goto no_bh2; + + oi = (struct omfs_inode *)bh2->b_data; + self = cluster; + cluster = be64_to_cpu(oi->sibling); + + if (hindex) { + hindex--; + brelse(bh2); + continue; + } + + if (oi->type == OMFS_DIR) + d_type = DT_DIR; + else + d_type = DT_REG; + + res = filldir(dirent, oi->name, strnlen(oi->name, + OMFS_NAMELEN), filp->f_pos, self, d_type); + brelse(bh2); + if (res < 0) + { + brelse(bh); + goto success; + } + filp->f_pos++; + } + filp->f_pos = (hchain+2) << 24; + } + brelse(bh); + +success: + return 0; +no_bh2: + brelse(bh); +no_bh: + return -EINVAL; +} + +struct inode_operations omfs_dir_inops = { + .lookup = omfs_lookup, +}; + +struct file_operations omfs_dir_operations = { + .read = generic_read_dir, + .readdir = omfs_readdir, +}; diff --git a/fs/omfs/file.c b/fs/omfs/file.c new file mode 100644 --- /dev/null +++ b/fs/omfs/file.c @@ -0,0 +1,116 @@ +/* + * fs/omfs/file.c + * OMFS (as used by RIO Karma) file operations. + * Copyright (C) 2005 Bob Copeland + */ + +#include +#include +#include +#include "omfs.h" + +/* + * Scans across the directory table for a given block number. There are + * several possible exit conditions: + * 1) we find the cluster and return it + * 2) count is zero (for this table); we return 0 and *count is zero. + * 3) no more pointers on this page (but more in table); return 0 and + * *count is non-zero. caller must repeat with ent on next block. + */ +static sector_t find_block(struct inode *inode, struct omfs_extent_entry *ent, + sector_t block, sector_t *searched, + int block_ofs, int *count) +{ + for (; *count > 0 && block_ofs < inode->i_sb->s_blocksize; + *count--, block_ofs += sizeof(struct omfs_extent_entry)) + { + int numblocks = clus_to_blk(be64_to_cpu(ent->blocks)); + if (block >= *searched && + block < (*searched + numblocks)) + { + // found it at cluster + (block - searched) + return clus_to_blk(be64_to_cpu(ent->cluster)) + + block - *searched; + } + *searched += numblocks; + ent++; + } + return 0; +} + +static int omfs_get_block(struct inode *inode, sector_t block, + struct buffer_head *bh_result, int create) +{ + struct buffer_head *bh; + sector_t next, block_start, offset, searched=0; + int block_ofs; + struct omfs_extent *oe; + struct omfs_extent_entry *entry; + if (create) + goto err; + + if (block < 0) // || > stuff + goto err; + + block_start = clus_to_blk(inode->i_ino); + bh = sb_bread(inode->i_sb, block_start); + if (!bh) + goto err; + + oe = (struct omfs_extent *)(&bh->b_data[0x1d0]); + + for(;;) { + int count = be32_to_cpu(oe->extent_count); + next = be64_to_cpu(oe->next); + entry = &oe->entry; + block_ofs = (long) entry - (long)bh->b_data; + + while (count > 0) { + offset = find_block(inode, entry, block, &searched, + block_ofs, &count); + if (offset > 0) { + brelse(bh); + map_bh(bh_result, inode->i_sb, offset); + return 0; + } + if (count) { + // spilled over a buffer + brelse(bh); + bh = sb_bread(inode->i_sb, ++block_start); + if (!bh) goto err; + entry = (struct omfs_extent_entry *) bh->b_data; + block_ofs = 0; + } + } + brelse(bh); + + if (next == ~0) + break; + + bh = sb_bread(inode->i_sb, next); + if (!bh) goto err; + oe = (struct omfs_extent *) (&bh->b_data[0x40]); + } + + return 0; +err: + return -EIO; +} + +static int omfs_readpage(struct file *file, struct page *page) +{ + return block_read_full_page(page, omfs_get_block); +} + +struct file_operations omfs_file_operations = { + .llseek = generic_file_llseek, + .read = generic_file_read, + .write = generic_file_write, + .mmap = generic_file_mmap, + .sendfile = generic_file_sendfile, +}; + +struct address_space_operations omfs_aops = { + .readpage = omfs_readpage, +}; + diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c new file mode 100644 --- /dev/null +++ b/fs/omfs/inode.c @@ -0,0 +1,157 @@ +/* + * fs/omfs/inode.c + * OMFS (as used by RIO Karma) inode and super operations. + * Copyright (C) 2005 Bob Copeland + */ + +#include +#include +#include +#include +#include +#include "omfs.h" + +MODULE_AUTHOR("Bob Copeland "); +MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux"); +MODULE_LICENSE("GPL"); + +void omfs_read_inode(struct inode *inode) +{ + struct omfs_inode *oi; + struct buffer_head *bh; + unsigned int block; + u64 ctime; + unsigned long nsecs; + ino_t ino = inode->i_ino; + + // check against num_blocks + block = clus_to_blk(ino); + bh = sb_bread(inode->i_sb, block); + if (!bh) { + make_bad_inode(inode); + return; + } + + oi = (struct omfs_inode *)bh->b_data; + + // check self + if (ino != be64_to_cpu(oi->head.self)) { + make_bad_inode(inode); + return; + } + + inode->i_uid = 0; + inode->i_gid = 0; + + ctime = be64_to_cpu(oi->ctime); + nsecs = do_div(ctime, 1000); + + inode->i_atime.tv_sec = ctime; + inode->i_mtime.tv_sec = ctime; + inode->i_ctime.tv_sec = ctime; + inode->i_atime.tv_nsec = nsecs; + inode->i_mtime.tv_nsec = nsecs; + inode->i_ctime.tv_nsec = nsecs; + + if (oi->type == OMFS_DIR) { + inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; + inode->i_mode |= S_IFDIR; + inode->i_op = &omfs_dir_inops; + inode->i_fop = &omfs_dir_operations; + inode->i_size = be32_to_cpu(oi->head.body_size) + + sizeof(struct omfs_header); + } else if (oi->type == OMFS_FILE) { + inode->i_mode = S_IFREG | S_IRUGO; + inode->i_mapping->a_ops = &omfs_aops; + inode->i_fop = &omfs_file_operations; + inode->i_size = be64_to_cpu(oi->size); + } + brelse(bh); +} + +struct super_operations omfs_sops = { + .read_inode = omfs_read_inode, +}; + +static int omfs_fill_super(struct super_block *sb, void *data, int silent) +{ + struct buffer_head *bh, *bh2; + struct omfs_super_block *omfs_sb; + struct omfs_root_block *omfs_rb; + struct inode *root; + sector_t start; + + sb->s_flags |= MS_RDONLY; + sb->s_maxbytes = 0xffffffff; + + sb_set_blocksize(sb, 0x200); + + if (!(bh = sb_bread(sb, 0))) + goto out; + + omfs_sb = (struct omfs_super_block *)bh->b_data; + + if (be32_to_cpu(omfs_sb->magic) != OMFS_MAGIC) { + if (!silent) + printk(KERN_ERR "omfs: Invalid superblock (%x)\n", + omfs_sb->magic); + goto out; + } + sb->s_magic = OMFS_MAGIC; + + start = clus_to_blk(be64_to_cpu(omfs_sb->root_block)); + if (!(bh2 = sb_bread(sb, start))) + { + brelse(bh); + goto out; + } + + omfs_rb = (struct omfs_root_block *)bh2->b_data; + printk(KERN_DEBUG "omfs: volume: %s\n", omfs_rb->name); + + sb->s_op = &omfs_sops; + root = iget(sb, be64_to_cpu(omfs_rb->root_dir)); + + brelse(bh); + brelse(bh2); + + sb->s_root = d_alloc_root(root); + if (!sb->s_root) { + iput(root); + goto out; + } + + return 0; + +out: + return -EINVAL; +} + +static struct super_block *omfs_get_sb(struct file_system_type *fs_type, + int flags, const char *dev_name, + void *data) +{ + return get_sb_bdev(fs_type, flags, dev_name, data, omfs_fill_super); +} + +static struct file_system_type omfs_fs_type = { + .owner = THIS_MODULE, + .name = "omfs", + .get_sb = omfs_get_sb, + .kill_sb = kill_block_super, + .fs_flags = FS_REQUIRES_DEV, +}; + +static int __init init_omfs_fs(void) +{ + register_filesystem(&omfs_fs_type); + return 0; +} + +static void __exit exit_omfs_fs(void) +{ + unregister_filesystem(&omfs_fs_type); +} + +module_init(init_omfs_fs); +module_exit(exit_omfs_fs); diff --git a/fs/omfs/omfs.h b/fs/omfs/omfs.h new file mode 100644 --- /dev/null +++ b/fs/omfs/omfs.h @@ -0,0 +1,86 @@ +#ifndef _OMFS_H +#define _OMFS_H + +#include + +#define OMFS_MAGIC 0xC2993D87 +#define OMFS_DIR 'D' +#define OMFS_FILE 'F' +#define OMFS_NAMELEN 256 +#define OMFS_DIR_START 0x1b8 + +struct omfs_super_block { + char fill1[256]; + u64 root_block; + u64 num_blocks; + u32 magic; + u32 blocksize; + u32 mirrors; + u32 sys_blocksize; +}; + +struct omfs_header { + u64 self; + u32 body_size; + u16 crc; + char fill1[5]; + u8 check_xor; + u32 fill2; +}; + +struct omfs_root_block { + struct omfs_header head; + u64 fill1; + u64 num_blocks; + u64 root_dir; + u64 bitmap; + u32 blocksize; + u32 clustersize; + u64 mirrors; + char name[OMFS_NAMELEN]; +}; + +struct omfs_inode { + struct omfs_header head; + u64 parent; + u64 sibling; + u64 ctime; + char fill1[35]; + char type; + u32 fill2; + char fill3[64]; + char name[OMFS_NAMELEN]; + u64 size; + // 198 bytes of nonsense. +}; + +struct omfs_extent_entry { + u64 cluster; + u64 blocks; +}; + +struct omfs_extent { + u64 next; + u32 extent_count; + u32 fill; + struct omfs_extent_entry entry; +}; + +/* convert a cluster number to a 512-byte block number */ +static inline sector_t clus_to_blk(sector_t in) +{ + return in << 4; +} + +/* dir.c */ +extern struct file_operations omfs_dir_operations; +extern struct inode_operations omfs_dir_inops; + +/* file.c */ +extern struct file_operations omfs_file_operations; +extern struct address_space_operations omfs_aops; + +/* inode.c */ +extern void omfs_read_inode(struct inode *inode); + +#endif diff --git a/fs/partitions/Kconfig b/fs/partitions/Kconfig --- a/fs/partitions/Kconfig +++ b/fs/partitions/Kconfig @@ -225,4 +225,11 @@ config EFI_PARTITION were partitioned using EFI GPT. Presently only useful on the IA-64 platform. +config KARMA_PARTITION + bool "Karma Partition support" + depends on PARTITION_ADVANCED + help + Say Y here if you would like to mount the Rio Karma MP3 player, + as it uses a proprietary partition table. + # define_bool CONFIG_ACORN_PARTITION_CUMANA y diff --git a/fs/partitions/Makefile b/fs/partitions/Makefile --- a/fs/partitions/Makefile +++ b/fs/partitions/Makefile @@ -17,3 +17,4 @@ obj-$(CONFIG_SUN_PARTITION) += sun.o obj-$(CONFIG_ULTRIX_PARTITION) += ultrix.o obj-$(CONFIG_IBM_PARTITION) += ibm.o obj-$(CONFIG_EFI_PARTITION) += efi.o +obj-$(CONFIG_KARMA_PARTITION) += karma.o diff --git a/fs/partitions/check.c b/fs/partitions/check.c --- a/fs/partitions/check.c +++ b/fs/partitions/check.c @@ -35,6 +35,7 @@ #include "ibm.h" #include "ultrix.h" #include "efi.h" +#include "karma.h" #ifdef CONFIG_BLK_DEV_MD extern void md_autodetect_dev(dev_t dev); @@ -103,6 +104,9 @@ static int (*check_part[])(struct parsed #ifdef CONFIG_IBM_PARTITION ibm_partition, #endif +#ifdef CONFIG_KARMA_PARTITION + karma_partition, +#endif NULL }; diff --git a/fs/partitions/karma.c b/fs/partitions/karma.c new file mode 100644 --- /dev/null +++ b/fs/partitions/karma.c @@ -0,0 +1,57 @@ +/* + * fs/partitions/karma.c + * Rio Karma partition info. + * + * Copyright (C) 2005 Bob Copeland (email@bobcopeland.com) + * based on ofs.c + */ + +#include "check.h" +#include "karma.h" + +int karma_partition(struct parsed_partitions *state, struct block_device *bdev) +{ + int i; + int slot = 1; + Sector sect; + unsigned char *data; + struct disklabel { + u8 reserved[270]; + struct d_partition { + __le32 res; + u8 fstype; + u8 res2[3]; + __le32 offset; + __le32 size; + } partitions[2]; + u8 blank[208]; + __le16 magic; + } __attribute__((packed)) *label; + struct d_partition *p; + + data = read_dev_sector(bdev, 0, §); + if (!data) + return -1; + + label = (struct disklabel *) data; + if (le16_to_cpu(label->magic) != KARMA_LABEL_MAGIC) { + put_dev_sector(sect); + return 0; + } + + p = label->partitions; + for (i = 0 ; i < 2; i++, p++) { + if (slot == state->limit) + break; + + if (p->fstype == 0x4d && le32_to_cpu(p->size)) { + put_partition(state, slot, le32_to_cpu(p->offset), + le32_to_cpu(p->size)); + } + slot++; + } + printk("\n"); + put_dev_sector(sect); + return 1; +} + diff --git a/fs/partitions/karma.h b/fs/partitions/karma.h new file mode 100644 --- /dev/null +++ b/fs/partitions/karma.h @@ -0,0 +1,8 @@ +/* + * fs/partitions/karma.h + */ + +#define KARMA_LABEL_MAGIC 0xAB56 + +int karma_partition(struct parsed_partitions *state, struct block_device *bdev); +