diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig index c41d64d..1a7bd5d 100644 --- a/drivers/usb/storage/Kconfig +++ b/drivers/usb/storage/Kconfig @@ -124,3 +124,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 index 44ab8f9..5f90c2b 100644 --- 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 index 0000000..ea1be9a --- /dev/null +++ b/drivers/usb/storage/rio_karma.c @@ -0,0 +1,104 @@ +/* USB driver for DNNA Rio Karma + * + * (C) 2005 Bob Copeland (me@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 RIO_MSC 0x08 +#define RIOP_INIT "RIOP\x00\x01\x08\x00" +#define CMD_LEN 40 +#define RECV_LEN 0x200 + +/* Initialize the Karma and get it into mass storage mode. + * + * The initialization begins by sending 40 bytes starting + * 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; + char *recv; + static char init_cmd[] = RIOP_INIT; + unsigned long timeout; + + // us->iobuf is big enough to hold cmd but not receive + if (!(recv = kmalloc(RECV_LEN, GFP_KERNEL | __GFP_DMA))) + goto die_nomem; + + US_DEBUGP("Initializing Karma...\n"); + + memcpy(us->iobuf, init_cmd, sizeof(init_cmd)); + memset(&us->iobuf[sizeof(init_cmd)], 0, CMD_LEN - sizeof(init_cmd)); + + result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, + us->iobuf, 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; + + us->iobuf[4] = 0x80; + us->iobuf[5] = 0; + timeout = jiffies + msecs_to_jiffies(3000); + for (;;) { + US_DEBUGP("Sending init command\n"); + result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, + us->iobuf, 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] == RIO_MSC) + break; + if (time_after(jiffies, timeout)) + goto die; + msleep(10); + } + US_DEBUGP("Karma initialized.\n"); + kfree(recv); + return 0; + +die: + kfree(recv); +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 index 0000000..99b44fd --- /dev/null +++ b/drivers/usb/storage/rio_karma.h @@ -0,0 +1,9 @@ +#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 index 0a9858f..a223519 100644 --- a/drivers/usb/storage/unusual_devs.h +++ b/drivers/usb/storage/unusual_devs.h @@ -145,6 +145,13 @@ 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, 0x0101, 0x0101, + "Rio", + "Rio Karma", + US_SC_SCSI, US_PR_BULK, rio_karma_init, US_FL_FIX_INQUIRY), +#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 index 3847ebe..caeaa5e 100644 --- a/drivers/usb/storage/usb.c +++ b/drivers/usb/storage/usb.c @@ -94,6 +94,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 index d5255e6..87ac8fd 100644 --- a/fs/Kconfig +++ b/fs/Kconfig @@ -1248,6 +1248,10 @@ config SYSV_FS If you haven't heard about all of this before, it's safe to say N. +config OMFS_FS + tristate "OMFS (Rio Karma)" + help + Say 'Y' to get support for the RIO Karma fs. config UFS_FS tristate "UFS file system support (read only)" diff --git a/fs/Makefile b/fs/Makefile index 4c26557..9efa233 100644 --- 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 index 0000000..fb91d37 --- /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 bitmap.o diff --git a/fs/omfs/bitmap.c b/fs/omfs/bitmap.c new file mode 100644 index 0000000..cb8e5ad --- /dev/null +++ b/fs/omfs/bitmap.c @@ -0,0 +1,22 @@ +#include "omfs.h" + +static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0}; + +unsigned long omfs_count_free(struct super_block *sb) +{ + unsigned int i, j, count = 0; + long *map; + unsigned long sum = 0; + struct omfs_sb_info *sbi = OMFS_SB(sb); + + for (i = 0; i < sbi->imap_size; i++) + { + map = sbi->imap[i]; + for (j=0; j < sb->s_blocksize && + count + j < sbi->num_blocks; j++) + sum += nibblemap[map[j] & 0xf] + + nibblemap[(map[j] >> 4) & 0xf]; + count += sb->s_blocksize; + } + return (sum); +} diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c new file mode 100644 index 0000000..2061729 --- /dev/null +++ b/fs/omfs/dir.c @@ -0,0 +1,290 @@ +/* + * 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); + + return sb_bread(dir->i_sb, block); +} + +static struct buffer_head *omfs_find_entry(struct inode *dir, + const char *name, int namelen) +{ + struct buffer_head *bh; + struct omfs_inode *oi; + int ofs; + u64 cluster; + bh = omfs_get_bucket(dir, name, namelen, &ofs); + if (!bh) + goto out; + + 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 NULL; +} + +#ifdef OMFS_WRITE +int omfs_make_empty(struct inode *inode, struct super_block *sb) +{ + int i; + int block = clus_to_blk(inode->i_ino); + int ofs = OMFS_DIR_START; + struct buffer_head *bh; + + for (i=0; i < OMFS_SB(sb)->sys_blocksize; i += sb->s_blocksize) + { + bh = sb_bread(sb, block++); + if (!bh) + return -ENOMEM; + + memset(&bh->b_data[ofs], 0xff, sb->s_blocksize - ofs); + brelse(bh); + ofs = 0; + } + return 0; +} + +int omfs_add_link(struct dentry *dentry, struct inode *inode) +{ + struct inode *dir = dentry->d_parent->d_inode; + const char *name = dentry->d_name.name; + int namelen = dentry->d_name.len; + struct omfs_inode *oi; + struct buffer_head *bh; + u64 cluster; + u64 *entry; + int ofs; + + // just prepend to head of queue in proper bucket and we are done. + bh = omfs_get_bucket(dir, name, namelen, &ofs); + if (!bh) + goto out; + + entry = (u64 *) &bh->b_data[ofs]; + cluster = be64_to_cpu(*entry); + *entry = cpu_to_be64(inode->i_ino); + mark_buffer_dirty(bh); + brelse(bh); + + // now set the sibling and parent pointers on the new inode + + bh = sb_bread(dir->i_sb, clus_to_blk(inode->i_ino)); + if (!bh) + goto out; + + oi = (struct omfs_inode *) bh->b_data; + memcpy (oi->name, name, namelen); + memset (oi->name + namelen, 0, OMFS_NAMELEN - namelen); + oi->sibling = cpu_to_be64(cluster); + oi->parent = cpu_to_be64(dir->i_ino); + mark_buffer_dirty(bh); + brelse(bh); + + dir->i_ctime = CURRENT_TIME_SEC; + mark_inode_dirty(dir); + return 0; +out: + return -ENOMEM; +} + +static int omfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) +{ + int err = 0; + struct inode *inode; + + mode |= S_IFDIR; + + inode = omfs_new_inode(dir, mode); + if (!inode) + return -ENOSPC; + + if (dir->i_mode & S_ISGID) { + inode->i_gid = dir->i_gid; + if (S_ISDIR(mode)) + inode->i_mode |= S_ISGID; + } + + printk(KERN_DEBUG "I just made an inode at block %lx\n", inode->i_ino); + + err = omfs_make_empty(inode, dir->i_sb); + if (err) + goto out; + + err = omfs_add_link(dentry, inode); + if (err) + goto out; + + d_instantiate(dentry, inode); +out: + return err; +} +#endif + +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; + + printk(KERN_DEBUG "Reading inode %lx\n", dir->i_ino); + + 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, +#ifdef OMFS_WRITE + .mkdir = omfs_mkdir, + .rename = simple_rename, +#endif +}; + +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 index 0000000..24e82c6 --- /dev/null +++ b/fs/omfs/file.c @@ -0,0 +1,130 @@ +/* + * 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) + { + printk(KERN_DEBUG "omfs: wanted to write block %ld", block); + return -EIO; + } + + if (block > clus_to_blk(OMFS_SB(inode->i_sb)->num_blocks)) + 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); +} + +#ifdef OMFS_WRITE +static int omfs_writepage(struct page *page, struct writeback_control *wbc) +{ + return block_write_full_page(page, omfs_get_block, wbc); +} +#endif + +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, +#ifdef OMFS_WRITE + .writepage = omfs_writepage, +#endif +}; + diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c new file mode 100644 index 0000000..14e4284 --- /dev/null +++ b/fs/omfs/inode.c @@ -0,0 +1,432 @@ +/* + * Optimized MPEG FS - inode and super operations. + * Copyright (C) 2005 Bob Copeland + */ +#include +#include +#include +#include +#include +#include +#include "omfs.h" + +MODULE_AUTHOR("Bob Copeland "); +MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux"); +MODULE_LICENSE("GPL"); + +int find_empty_block(struct super_block *sb, int mode, ino_t *ino) +{ + int bit=0, i; + struct omfs_sb_info *sbi = OMFS_SB(sb); + int block_request = 1; + int bits_per_entry = 8 * sb->s_blocksize; + + if (S_ISREG(mode)) + block_request = sbi->clustersize; + + for (i=0; i < sbi->imap_size; i++) + { + bit = find_first_zero_bit(sbi->imap[i], bits_per_entry); + if (bit < bits_per_entry) + break; + } + bit = i * bits_per_entry + bit; + if (bit >= sbi->num_blocks) + return -ENOSPC; + *ino = bit; + return 0; +} + +int claim_block(struct super_block *sb, ino_t ino) +{ +#if 0 + struct omfs_sb_info *sbi = OMFS_SB(sb); + set_bit(ino, sbi->imap); +#endif + return 1; +} + +static kmem_cache_t *omfs_inode_cachep; + +static struct inode *omfs_alloc_inode(struct super_block *sb) +{ + struct omfs_inode_info *oinf; + oinf = (struct omfs_inode_info *) kmem_cache_alloc(omfs_inode_cachep, + SLAB_KERNEL); + if (!oinf) + return NULL; + return &oinf->vfs_inode; +} + +static void omfs_destroy_inode(struct inode *inode) +{ + kmem_cache_free(omfs_inode_cachep, OMFS_I(inode)); +} + +static void init_once(void *p, kmem_cache_t *cachep, unsigned long flags) +{ + struct omfs_inode_info *oinf = (struct omfs_inode_info *) p; + + if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == + SLAB_CTOR_CONSTRUCTOR) + inode_init_once(&oinf->vfs_inode); +} + +static int init_inodecache(void) +{ + omfs_inode_cachep = kmem_cache_create("omfs_inode_cache", + sizeof(struct omfs_inode_info), + 0, SLAB_RECLAIM_ACCOUNT, + init_once, NULL); + if (!omfs_inode_cachep) + return -ENOMEM; + return 0; +} + +static void destroy_inodecache(void) +{ + if (kmem_cache_destroy(omfs_inode_cachep)) + printk(KERN_INFO "omfs_inode_cache: not all structures were freed\n"); +} + +#ifdef OMFS_WRITE +struct inode *omfs_new_inode(struct inode *dir, int mode) +{ + struct inode *inode; + ino_t ino; + int res; + + inode = new_inode(dir->i_sb); + if (!inode) + return ERR_PTR(-ENOMEM); + + do { + res = find_empty_block(dir->i_sb, mode, &ino); + if (res) + return ERR_PTR(res); + } + while (!claim_block(dir->i_sb, ino)); + + inode->i_ino = ino; + inode->i_mode = mode; + inode->i_uid = current->fsuid; + inode->i_gid = current->fsgid; + inode->i_blksize = PAGE_SIZE; + inode->i_blocks = 0; + inode->i_mapping->a_ops = &omfs_aops; + + OMFS_I(inode)->state = OMFS_STATE_NEW; + + inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; + switch (mode & S_IFMT) { + case S_IFDIR: + inode->i_op = &omfs_dir_inops; + inode->i_fop = &omfs_dir_operations; + inode->i_nlink++; /* "." entry */ + break; + case S_IFREG: + inode->i_fop = &omfs_file_operations; + break; + } + mark_inode_dirty(inode); + return inode; +} + +static int omfs_write_inode(struct inode *inode, int wait) +{ + struct omfs_inode *oi; + struct buffer_head *bh; + unsigned int block; + u64 ctime; + ino_t ino = inode->i_ino; + + /* get current inode since we may have written sibling ptrs etc. */ + block = clus_to_blk(ino); + bh = sb_bread(inode->i_sb, block); + if (!bh) + return -EIO; + + oi = (struct omfs_inode *) bh->b_data; + if (OMFS_I(inode)->state & OMFS_STATE_NEW) + { + memset(oi, 0, sizeof (struct omfs_header)); + OMFS_I(inode)->state &= ~OMFS_STATE_NEW; + } + + oi->head.self = cpu_to_be64(ino); + + if (S_ISDIR(inode->i_mode)) { + oi->type = OMFS_DIR; + } else if (S_ISREG(inode->i_mode)) { + oi->type = OMFS_FILE; + } else + BUG(); + + ctime = inode->i_ctime.tv_sec * 1000LL + + ((inode->i_ctime.tv_nsec + 999)/1000); + oi->ctime = cpu_to_be64(ctime); + + mark_buffer_dirty(bh); + // do_sync? + brelse(bh); + return 0; +} +#endif + +void omfs_read_inode(struct inode *inode) +{ + struct omfs_inode *oi; + struct omfs_inode_info *oinf = OMFS_I(inode); + 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) * 1000L; + + 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; + + oinf->state = 0; + + if (oi->type == OMFS_DIR) { + inode->i_mode = S_IFDIR | S_IRUGO | S_IWUGO | S_IXUGO; + 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); +} + + +static void omfs_put_super(struct super_block *sb) +{ + struct omfs_sb_info *sbi = OMFS_SB(sb); + if (sbi) + { + kfree(sbi->imap); + kfree(sbi); + } + sb->s_fs_info = NULL; +} + +static int omfs_statfs(struct super_block *s, struct kstatfs *buf) +{ + struct omfs_sb_info *sbi = OMFS_SB(s); + buf->f_type = OMFS_MAGIC; + buf->f_bsize = sbi->blocksize; + buf->f_blocks = sbi->num_blocks; + buf->f_files = sbi->num_blocks; + buf->f_namelen = OMFS_NAMELEN; + + buf->f_bfree = buf->f_bavail = buf->f_ffree = + omfs_count_free(s); + return 0; +} + +struct super_operations omfs_sops = { + .alloc_inode = omfs_alloc_inode, + .destroy_inode = omfs_destroy_inode, +#ifdef OMFS_WRITE + .write_inode = omfs_write_inode, +#endif + .read_inode = omfs_read_inode, + .put_super = omfs_put_super, + .statfs = omfs_statfs, +}; + +/* + * For Rio Karma, there is an on-disk free bitmap whose location is + * stored in the root block. For ReplayTV, there is no such free bitmap + * so we have to walk the tree. Both inodes and file data are allocated + * from the same map. This array can be big (300k) so we allocate + * in units of the blocksize. + */ +static int omfs_get_imap(struct super_block *sb) +{ + int bitmap_size; + int array_size; + int count; + struct omfs_sb_info *sbi = OMFS_SB(sb); + struct buffer_head *bh; + unsigned long **ptr; + sector_t block; + + bitmap_size = (sbi->num_blocks + 7) / 8; + array_size = (bitmap_size + sb->s_blocksize - 1) / sb->s_blocksize; + + printk(KERN_DEBUG "omfs: trying to alloc %d bytes\n", array_size); + sbi->imap_size = array_size; + sbi->imap = kzalloc(array_size, GFP_KERNEL); + if (!sbi->imap) + return -ENOMEM; + + block = clus_to_blk(sbi->bitmap_ino); + ptr = sbi->imap; + for (count = bitmap_size; count > 0; count -= sb->s_blocksize) { + bh = sb_bread(sb, block++); + if (!bh) + goto nomem; + *ptr = kmalloc(sb->s_blocksize, GFP_KERNEL); + memcpy(*ptr, bh->b_data, sb->s_blocksize); + brelse(bh); + ptr ++; + } + return 0; +nomem: + printk(KERN_DEBUG "died at %ld\n", block); + for (count=0; countimap[count]); + } + printk(KERN_DEBUG "Freeing imap\n"); + kfree(sbi->imap); + sbi->imap = NULL; + return -ENOMEM; +} + +static int omfs_fill_super(struct super_block *sb, void *data, int silent) +{ + struct buffer_head *bh=NULL, *bh2=NULL; + struct omfs_super_block *omfs_sb; + struct omfs_root_block *omfs_rb; + struct omfs_sb_info *sbi; + struct inode *root; + sector_t start; + int ret = 0; + + sbi = kzalloc(sizeof(struct omfs_sb_info), GFP_KERNEL); + if (!sbi) + return -ENOMEM; + sb->s_fs_info = sbi; + +#ifndef OMFS_WRITE + sb->s_flags |= MS_RDONLY; +#endif + sb->s_maxbytes = 0xffffffff; + + // We always operate on single sectors since OMFS partitions + // regularly use blocks larger than PAGE_SIZE + 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))) + goto out; + + omfs_rb = (struct omfs_root_block *)bh2->b_data; + printk(KERN_DEBUG "omfs: volume: %s\n", omfs_rb->name); + + sbi->num_blocks = be64_to_cpu(omfs_sb->num_blocks); + sbi->blocksize = be32_to_cpu(omfs_sb->blocksize); + sbi->mirrors = be32_to_cpu(omfs_sb->mirrors); + sbi->root_ino = be64_to_cpu(omfs_sb->root_block); + sbi->sys_blocksize = be32_to_cpu(omfs_sb->sys_blocksize); + sbi->bitmap_ino = be64_to_cpu(omfs_rb->bitmap); + sbi->clustersize = be32_to_cpu(omfs_rb->clustersize); + + ret = omfs_get_imap(sb); + if (ret) + goto end; + + sb->s_op = &omfs_sops; + root = iget(sb, be64_to_cpu(omfs_rb->root_dir)); + + sb->s_root = d_alloc_root(root); + if (!sb->s_root) { + iput(root); + goto out; + } + goto end; + +out: + ret = -EINVAL; + +end: + if (bh2) + brelse(bh2); + if (bh) + brelse(bh); + return ret; +} + +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) +{ + int err = init_inodecache(); + if (err) + goto out; + + err = register_filesystem(&omfs_fs_type); + if (err) + destroy_inodecache(); +out: + return err; +} + +static void __exit exit_omfs_fs(void) +{ + unregister_filesystem(&omfs_fs_type); + destroy_inodecache(); +} + +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 index 0000000..b88fcec --- /dev/null +++ b/fs/omfs/omfs.h @@ -0,0 +1,125 @@ +#ifndef _OMFS_H +#define _OMFS_H + +#include +#include +#include + +#define OMFS_MAGIC 0xC2993D87 +#define OMFS_DIR 'D' +#define OMFS_FILE 'F' +#define OMFS_NAMELEN 256 +#define OMFS_DIR_START 0x1b8 + +#undef OMFS_WRITE + +#define OMFS_STATE_NEW 1 + +/* In-memory structures */ +struct omfs_sb_info { + u64 num_blocks; + u64 bitmap_ino; + u64 root_ino; + u32 blocksize; + u32 mirrors; + u32 sys_blocksize; + u32 clustersize; + unsigned long **imap; + int imap_size; +}; + +struct omfs_inode_info { + u8 state; + struct inode vfs_inode; +}; + +/* On-disk structures */ +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; +}; + +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; +} + +static inline struct omfs_sb_info *OMFS_SB(struct super_block *sb) +{ + return sb->s_fs_info; +} + +static inline struct omfs_inode_info *OMFS_I(struct inode *inode) +{ + return list_entry(inode, struct omfs_inode_info, vfs_inode); +} + +/* bitmap.c */ +unsigned long omfs_count_free(struct super_block *sb); + +/* 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); +extern struct inode *omfs_new_inode(struct inode *dir, int mode); + +#endif diff --git a/fs/partitions/Kconfig b/fs/partitions/Kconfig index deb25b6..f916ef1 100644 --- 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 index 66d5cc2..42c7d38 100644 --- 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 index 8dc1822..ac10938 100644 --- 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 index 0000000..b4f5fed --- /dev/null +++ b/fs/partitions/karma.c @@ -0,0 +1,57 @@ +/* + * fs/partitions/karma.c + * Rio Karma partition info. + * + * Copyright (C) 2005 Bob Copeland (me@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 index 0000000..ecf7d3f --- /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); +