Re: [PATCH/RFC] MTD: Striping layer core

Vitaly Wool
2006-03-30T09:06:57Z

Hi Alexander,

Belyakov, Alexander wrote:
> One may say that striping is quite similar to already existing in MTD
> concatenation layer. That is not true since these layers have some sharp
> distinctions. The first one is the purpose. Concatenation only purpose
> is to make larger device from several smaller devices. Striping purpose
> is to make devices operate faster. Next difference is provided access to
> sub-devices. Concatenation layer provides linear access to sub-devices.
> Striping provides interleaved access to sub-devices.
>
Still it's unclear why not to provide a configurable extension to
mtdconcat rather than create a new layer.
> Simultaneous operation means separate threads. Each independent chip
> which participates in creation of striped volume has its own worker
> thread. Worker threads are created at the stage of striped device
> initialization. Each worker thread has its own operation queue and
> interleaving algorithm feeds them. Worker threads interact with flash
> drivers (CFI, NAND subsystem).
>
Sooo many threads... :(
>
> 3. POSSIBLE CONFIGURATIONS AND LIMITATIONS
> It is possible to stripe devices of the same type. We can't stripe NOR
> and NAND, but only NOR and NOR or NAND and NAND. Flashes of the same
> type can differ in erase size and total size.
>
Why is that? Being able to deal only with flash chips of the same type,
your approach has very limited applicability (probably limited to almost
only Intel platforms ;))

And, well, just having looked through the patch, I'd like to point out
multiple #ifdef's in C code and multiple whitespace problems.
> @@ -155,6 +158,15 @@
> };
> };
> up(&map_mutex);
> +
> +#ifdef CONFIG_MTD_CMDLINE_STRIPE
> +#ifndef MODULE
> + if(mtd_stripe_init()) {
> + printk(KERN_WARNING "MTD stripe initialization from cmdline
> has failed\n");
> + }
> +#endif
> +#endif
>
Bah, what's going on here?
> +/* Operation codes */
> +#define MTD_STRIPE_OPCODE_READ 0x1
> +#define MTD_STRIPE_OPCODE_WRITE 0x2
> +#define MTD_STRIPE_OPCODE_READ_ECC 0x3
> +#define MTD_STRIPE_OPCODE_WRITE_ECC 0x4
> +#define MTD_STRIPE_OPCODE_WRITE_OOB 0x5
> +#define MTD_STRIPE_OPCODE_ERASE 0x6
>
You don't need READ_OOB, eh?
> +/*
> + * Miscelaneus support routines
> + */
> +
> +/*
> + * searches for least common multiple of a and b
> + * returns: LCM or 0 in case of error
> + */
> +u_int32_t
> +lcm(u_int32_t a, u_int32_t b)
> +{
> + u_int32_t lcm;
> + u_int32_t t1 = a;
> + u_int32_t t2 = b;
> +
> + if(a <= 0 || b <= 0)
> + {
> + lcm = 0;
> + printk(KERN_ERR "lcm(): wrong arguments\n");
> + }
> + else if(a == b)
> + {
> + /* trivial case */
> + lcm = a;
> + }
> + else
> + {
> + do
> + {
> + lcm = a;
> + a = b;
> + b = lcm - a*(lcm/a);
> + }
> + while(b!=0);
> +
> + if(t1 % a)
> + lcm = (t2 / a) * t1;
> + else
> + lcm = (t1 / a) * t2;
> + }
> +
> + return lcm;
> +} /* int lcm(int a, int b) */
> +
> +u_int32_t last_offset(struct mtd_stripe *stripe, int subdev_num);
> +
> +/*
> + * Calculates last_offset for specific striped subdevice
> + * NOTE: subdev array MUST be sorted
> + * by subdevice size (from the smallest to the largest)
> + */
> +u_int32_t
> +last_offset(struct mtd_stripe *stripe, int subdev_num)
>
Aint this one and stuff alike gonna be static?
> +int stripe_merge_oobinfo(struct mtd_info *mtd, struct mtd_info
> *subdev[], int num_devs)
> +{
> + int ret = 0;
> + int i, j;
> + uint32_t eccpos_max_num = sizeof(mtd->oobinfo.eccpos) /
> sizeof(uint32_t);
> + uint32_t eccpos_counter = 0;
> + uint32_t oobfree_max_num = 8; /* array size defined in mtd-abi.h */
> + uint32_t oobfree_counter = 0;
> +
> + if(mtd->type != MTD_NANDFLASH)
> + return 0;
> +
> + mtd->oobinfo.useecc = subdev[0]->oobinfo.useecc;
> + mtd->oobinfo.eccbytes = subdev[0]->oobinfo.eccbytes;
> + for(i = 1; i < num_devs; i++)
> + {
> + if(mtd->oobinfo.useecc != subdev[i]->oobinfo.useecc ||
> + mtd->oobinfo.eccbytes != subdev[i]->oobinfo.eccbytes)
> + {
> + printk(KERN_ERR "stripe_merge_oobinfo(): oobinfo parameters
> is not compatible for all subdevices\n");
> + return -EINVAL;
> + }
> + }
>
I guess this is a limitation that is not mentioned anywhere.
> +
> + mtd->oobinfo.eccbytes *= num_devs;
> +
> + /* drop old oobavail value */
> + mtd->oobavail = 0;
> +
> + /* merge oobfree space positions */
> + for(i = 0; i < num_devs; i++)
> + {
> + for(j = 0; j < oobfree_max_num; j++)
> + {
> + if(subdev[i]->oobinfo.oobfree[j][1])
> + {
> + if(oobfree_counter >= oobfree_max_num)
> + break;
> +
> + mtd->oobinfo.oobfree[oobfree_counter][0] =
> subdev[i]->oobinfo.oobfree[j][0] +
> + i *
> subdev[i]->oobsize;
> + mtd->oobinfo.oobfree[oobfree_counter][1] =
> subdev[i]->oobinfo.oobfree[j][1];
> +
> + mtd->oobavail += subdev[i]->oobinfo.oobfree[j][1];
> + oobfree_counter++;
> + }
> + }
> + }
> +
> + /* merge ecc positions */
> + for(i = 0; i < num_devs; i++)
> + {
> + for(j = 0; j < eccpos_max_num; j++)
> + {
> + if(subdev[i]->oobinfo.eccpos[j])
> + {
> + if(eccpos_counter >= eccpos_max_num)
> + {
> + printk(KERN_ERR "stripe_merge_oobinfo(): eccpos
> merge error\n");
> + return -EINVAL;
> + }
> +
> mtd->oobinfo.eccpos[eccpos_counter]=subdev[i]->oobinfo.eccpos[j] + i *
> subdev[i]->oobsize;
> + eccpos_counter++;
> + }
> + }
> + }
> +
> + return ret;
> +}
> +
> +/* End of support routines */
> +
> +/* Multithreading support routines */
> +
> +/* Write to flash thread */
> +static void
> +stripe_write_thread(void *arg)
> +{
> + struct mtd_sw_thread_info* info = (struct mtd_sw_thread_info*)arg;
> + struct mtd_stripe_op* op;
> + struct subop_struct* subops;
> + u_int32_t retsize;
> + int err;
> +
> + int i;
> + struct list_head *pos;
> +
> + /* erase operation stuff */
> + struct erase_info erase; /* local copy */
> + struct erase_info *instr; /* pointer to original */
> +
> + info->thread = current;
> + up(&info->sw_thread_startstop);
> +
> + while(info->sw_thread)
> + {
> + /* wait for downcoming write/erase operation */
> + down(&info->sw_thread_wait);
> +
> + /* issue operation to the device and remove it from the list
> afterwards*/
> + spin_lock(&info->list_lock);
> + if(!list_empty(&info->list))
> + {
> + op = list_entry(info->list.next,struct mtd_stripe_op, list);
> + }
> + else
> + {
> + /* no operation in queue but sw_thread_wait has been rised.
> + * it means stripe_stop_write_thread() has been called
> + */
> + op = NULL;
> + }
> + spin_unlock(&info->list_lock);
> +
> + /* leave main thread loop if no ops */
> + if(!op)
> + break;
> +
> + err = 0;
> + op->status = 0;
> +
> + switch(op->opcode)
> + {
> + case MTD_STRIPE_OPCODE_WRITE:
> + case MTD_STRIPE_OPCODE_WRITE_OOB:
> + /* proceed with list head first */
> + subops = &op->subops;
> +
> + for(i = 0; i < subops->ops_num; i++)
> + {
> + if(op->opcode == MTD_STRIPE_OPCODE_WRITE)
> + err = info->subdev->write(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len, &retsize,
> subops->ops_array[i].buf);
> + else
> + err = info->subdev->write_oob(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len, &retsize,
> subops->ops_array[i].buf);
> +
> + if(err)
> + {
> + op->status = -EINVAL;
> + printk(KERN_ERR "mtd_stripe: write operation
> failed %d\n",err);
> + break;
> + }
> + }
> +
> + if(!op->status)
> + {
> + /* now proceed each list element except head */
> + list_for_each(pos, &op->subops.list)
> + {
> + subops = list_entry(pos, struct subop_struct,
> list);
> +
> + for(i = 0; i < subops->ops_num; i++)
> + {
> + if(op->opcode == MTD_STRIPE_OPCODE_WRITE)
> + err = info->subdev->write(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len, &retsize,
> subops->ops_array[i].buf);
> + else
> + err =
> info->subdev->write_oob(info->subdev, subops->ops_array[i].ofs,
> subops->ops_array[i].len, &retsize, subops->ops_array[i].buf);
> +
> + if(err)
> + {
> + op->status = -EINVAL;
> + printk(KERN_ERR "mtd_stripe: write
> operation failed %d\n",err);
> + break;
> + }
> + }
> +
> + if(op->status)
> + break;
> + }
> + }
> + break;
> +
> + case MTD_STRIPE_OPCODE_ERASE:
> + subops = &op->subops;
> + instr = (struct erase_info *)subops->ops_array[0].buf;
> +
> + /* make a local copy of original erase instruction to
> avoid modifying the caller's struct */
> + erase = *instr;
> + erase.addr = subops->ops_array[0].ofs;
> + erase.len = subops->ops_array[0].len;
> +
> + if ((err = stripe_dev_erase(info->subdev, &erase)))
> + {
> + /* sanity check: should never happen since
> + * block alignment has been checked early in
> stripe_erase() */
> +
> + if(erase.fail_addr != 0xffffffff)
> + /* For now this adddres shows address
> + * at failed subdevice,but not at "super" device
> */
> + op->fail_addr = erase.fail_addr;
> + }
> +
> + op->status = err;
> + op->state = erase.state;
> + break;
> +
> + case MTD_STRIPE_OPCODE_WRITE_ECC:
> + /* proceed with list head first */
> + subops = &op->subops;
> +
> + for(i = 0; i < subops->ops_num; i++)
> + {
> + err = info->subdev->write_ecc(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len,
> + &retsize,
> subops->ops_array[i].buf,
> +
> subops->ops_array[i].eccbuf, &info->subdev->oobinfo);
> + if(err)
> + {
> + op->status = -EINVAL;
> + printk(KERN_ERR "mtd_stripe: write operation
> failed %d\n",err);
> + break;
> + }
> + }
> +
> + if(!op->status)
> + {
> + /* now proceed each list element except head */
> + list_for_each(pos, &op->subops.list)
> + {
> + subops = list_entry(pos, struct subop_struct,
> list);
> +
> + for(i = 0; i < subops->ops_num; i++)
> + {
> + err = info->subdev->write_ecc(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len,
> + &retsize,
> subops->ops_array[i].buf,
> +
> subops->ops_array[i].eccbuf, &info->subdev->oobinfo);
> + if(err)
> + {
> + op->status = -EINVAL;
> + printk(KERN_ERR "mtd_stripe: write
> operation failed %d\n",err);
> + break;
> + }
> + }
> +
> + if(op->status)
> + break;
> + }
> + }
> + break;
> +
> + case MTD_STRIPE_OPCODE_READ_ECC:
> + case MTD_STRIPE_OPCODE_READ:
> + /* proceed with list head first */
> + subops = &op->subops;
> +
> + for(i = 0; i < subops->ops_num; i++)
> + {
> + if(op->opcode == MTD_STRIPE_OPCODE_READ_ECC)
> + {
> + err = info->subdev->read_ecc(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len,
> + &retsize,
> subops->ops_array[i].buf,
> +
> subops->ops_array[i].eccbuf, &info->subdev->oobinfo);
> + }
> + else
> + {
> + err = info->subdev->read(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len,
> + &retsize,
> subops->ops_array[i].buf);
> + }
> +
> + if(err)
> + {
> + op->status = -EINVAL;
> + printk(KERN_ERR "mtd_stripe: read operation
> failed %d\n",err);
> + break;
> + }
> + }
> +
> + if(!op->status)
> + {
> + /* now proceed each list element except head */
> + list_for_each(pos, &op->subops.list)
> + {
> + subops = list_entry(pos, struct subop_struct,
> list);
> +
> + for(i = 0; i < subops->ops_num; i++)
> + {
> + if(op->opcode == MTD_STRIPE_OPCODE_READ_ECC)
> + {
> + err =
> info->subdev->read_ecc(info->subdev, subops->ops_array[i].ofs,
> subops->ops_array[i].len,
> + &retsize,
> subops->ops_array[i].buf,
> +
> subops->ops_array[i].eccbuf, &info->subdev->oobinfo);
> + }
> + else
> + {
> + err = info->subdev->read(info->subdev,
> subops->ops_array[i].ofs, subops->ops_array[i].len,
> + &retsize,
> subops->ops_array[i].buf);
> + }
> +
> + if(err)
> + {
> + op->status = -EINVAL;
> + printk(KERN_ERR "mtd_stripe: read
> operation failed %d\n",err);
> + break;
> + }
> + }
> +
> + if(op->status)
> + break;
> + }
> + }
> +
> + break;
> +
> + default:
> + /* unknown operation code */
> + printk(KERN_ERR "mtd_stripe: invalid operation code %d",
> op->opcode);
> + op->status = -EINVAL;
> + break;
> + };
> +
> + /* remove issued operation from the list */
> + spin_lock(&info->list_lock);
> + list_del(&op->list);
> + spin_unlock(&info->list_lock);
> +
> + /* raise semaphore to let stripe_write() or stripe_erase()
> continue */
> + up(&op->sem);
> + }
> +
> + info->thread = NULL;
> + up(&info->sw_thread_startstop);
> +}
> +
> +/* Launches write to flash thread */
> +int
> +stripe_start_write_thread(struct mtd_sw_thread_info* info, struct
> mtd_info *device)
> +{
> + pid_t pid;
> + int ret = 0;
> +
> + if(info->thread)
> + BUG();
> +
> + info->subdev = device; /* set the
> pointer to corresponding device */
> +
> + init_MUTEX_LOCKED(&info->sw_thread_startstop); /* init
> start/stop semaphore */
> + info->sw_thread = 1; /* set continue
> thread flag */
> + init_MUTEX_LOCKED(&info->sw_thread_wait); /* init "wait for data"
> semaphore */
> +
> + INIT_LIST_HEAD(&info->list); /* initialize
> operation list head */
> +
> + spin_lock_init(&info->list_lock); /* init list lock */
> +
> + pid = kernel_thread((int (*)(void *))stripe_write_thread, info,
> CLONE_KERNEL); /* flags (3rd arg) TBD */
> + if (pid < 0)
> + {
> + printk(KERN_ERR "fork failed for MTD stripe thread: %d\n",
> -pid);
> + ret = pid;
> + }
> + else
> + {
> + /* wait thread started */
> + DEBUG(MTD_DEBUG_LEVEL1, "MTD stripe: write thread has pid %d\n",
> pid);
> + down(&info->sw_thread_startstop);
> + }
> +
> + return ret;
> +}
> +
> +/* Complete write to flash thread */
> +void
> +stripe_stop_write_thread(struct mtd_sw_thread_info* info)
> +{
> + if(info->thread)
> + {
> + info->sw_thread = 0; /* drop thread flag */
> + up(&info->sw_thread_wait); /* let the thread
> complete */
> + down(&info->sw_thread_startstop); /* wait for thread
> completion */
> + DEBUG(MTD_DEBUG_LEVEL1, "MTD stripe: writing thread has been
> stopped\n");
> + }
> +}
> +
> +/* Updates write/erase thread priority to max value
> + * based on operations in the queue
> + */
> +void
> +stripe_set_write_thread_prio(struct mtd_sw_thread_info* info)
> +{
> + struct mtd_stripe_op *op;
> + int oldnice, newnice;
> + struct list_head *pos;
> +
> + newnice = oldnice = info->thread->static_prio - MAX_RT_PRIO - 20;
> +
> + spin_lock(&info->list_lock);
> + list_for_each(pos, &info->list)
> + {
> + op = list_entry(pos, struct mtd_stripe_op, list);
> + newnice = (op->op_prio < newnice) ? op->op_prio : newnice;
> + }
> + spin_unlock(&info->list_lock);
> +
> + newnice = (newnice < -20) ? -20 : newnice;
> +
> + if(oldnice != newnice)
> + set_user_nice(info->thread, newnice);
> +}
> +
> +/* add sub operation into the array
> + op - pointer to the operation structure
> + ofs - operation offset within subdevice
> + len - data to be written/erased
> + buf - pointer to the buffer with data to be written (NULL is erase
> operation)
> +
> + returns: 0 - success
> +*/
> +static inline int
> +stripe_add_subop(struct mtd_stripe_op *op, u_int32_t ofs, u_int32_t
> len, const u_char *buf, const u_char *eccbuf)
> +{
> + u_int32_t size; /* number of items in
> the new array (if any) */
> + struct subop_struct *subop;
> +
> + if(!op)
> + BUG(); /* error */
> +
> + /* get tail list element or head */
> + subop = list_entry(op->subops.list.prev, struct subop_struct,
> list);
> +
> + /* check if current suboperation array is already filled or not */
> + if(subop->ops_num >= subop->ops_num_max)
> + {
> + /* array is full. allocate new one and add to list */
> + size = SIZEOF_STRUCT_MTD_STRIPE_SUBOP(op->subops.ops_num_max);
> + subop = kmalloc(size, GFP_KERNEL);
> + if(!subop)
> + {
> + printk(KERN_ERR "mtd_stripe: memory allocation error!\n");
> + return -ENOMEM;
> + }
> +
> + memset(subop, 0, size);
> + subop->ops_num = 0;
> + subop->ops_num_max = op->subops.ops_num_max;
> + subop->ops_array = (struct subop *)(subop + 1);
> +
> + list_add_tail(&subop->list, &op->subops.list);
> + }
> +
> + subop->ops_array[subop->ops_num].ofs = ofs;
> + subop->ops_array[subop->ops_num].len = len;
> + subop->ops_array[subop->ops_num].buf = (u_char *)buf;
> + subop->ops_array[subop->ops_num].eccbuf = (u_char *)eccbuf;
> +
> + subop->ops_num++; /* increase stored suboperations counter */
> +
> + return 0;
> +}
> +
> +/* deallocates memory allocated by stripe_add_subop routine */
> +static void
> +stripe_destroy_op(struct mtd_stripe_op *op)
> +{
> + struct subop_struct *subop;
> +
> + while(!list_empty(&op->subops.list))
> + {
> + subop = list_entry(op->subops.list.next,struct subop_struct,
> list);
> + list_del(&subop->list);
> + kfree(subop);
> + }
> +}
> +
> +/* adds new operation to the thread queue and unlock wait semaphore for
> specific thread */
> +static void
> +stripe_add_op(struct mtd_sw_thread_info* info, struct mtd_stripe_op*
> op)
> +{
> + if(!info || !op)
> + BUG();
> +
> + spin_lock(&info->list_lock);
> + list_add_tail(&op->list, &info->list);
> + spin_unlock(&info->list_lock);
> +}
> +
> +/* End of multithreading support routines */
> +
> +
> +/*
> + * MTD methods which look up the relevant subdevice, translate the
> + * effective address and pass through to the subdevice.
> + */
> +
> +
> +/* sychroneous read from striped volume */
> +static int
> +stripe_read_sync(struct mtd_info *mtd, loff_t from, size_t len,
> + size_t * retlen, u_char * buf)
> +{
> + u_int32_t from_loc = (u_int32_t)from; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> + size_t retsize; /* data read/written from/to
> subdev (bytes) */
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_sync(): offset = 0x%08x, size
> = %d\n", from_loc, len);
> +
> + /* Check whole striped device bounds here */
> + if(from_loc + len > mtd->size)
> + {
> + return err;
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from_loc -
> stripe->subdev_last_offset[i - 1]) / stripe->interleave_size) %
> dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from_loc / stripe->interleave_size) /
> dev_count;
> + subdev_number = (from_loc / stripe->interleave_size) %
> dev_count;
> + }
> +
> + subdev_offset_low = from_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Synch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_sync(): device = %d, offset =
> 0x%08x, len = %d\n", subdev_number, subdev_offset_low, subdev_len);
> + err =
> stripe->subdev[subdev_number]->read(stripe->subdev[subdev_number],
> subdev_offset_low, subdev_len, &retsize, buf);
> + if(!err)
> + {
> + *retlen += retsize;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + if(from_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Synch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_sync(): device = %d, offset
> = 0x%08x, len = %d\n", subdev_number, subdev_offset *
> stripe->interleave_size, subdev_len);
> + err =
> stripe->subdev[subdev_number]->read(stripe->subdev[subdev_number],
> subdev_offset * stripe->interleave_size, subdev_len, &retsize, buf);
> + if(err)
> + break;
> +
> + *retlen += retsize;
> + len_left -= subdev_len;
> + buf += subdev_len;
> +
> + if(from_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_sync(): read %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +
> +/* asychroneous read from striped volume */
> +static int
> +stripe_read_async(struct mtd_info *mtd, loff_t from, size_t len,
> + size_t * retlen, u_char * buf)
> +{
> + u_int32_t from_loc = (u_int32_t)from; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> +
> + struct mtd_stripe_op *ops; /* operations array (one per
> thread) */
> + u_int32_t size; /* amount of memory to be
> allocated for thread operations */
> + u_int32_t queue_size;
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_async(): offset = 0x%08x, size
> = %d\n", from_loc, len);
> +
> + /* Check whole striped device bounds here */
> + if(from_loc + len > mtd->size)
> + {
> + return err;
> + }
> +
> + /* allocate memory for multithread operations */
> + queue_size = len / stripe->interleave_size / stripe->num_subdev +
> 1; /* default queue size. could be set to predefined value */
> + size = stripe->num_subdev *
> SIZEOF_STRUCT_MTD_STRIPE_OP(queue_size);
> + ops = kmalloc(size, GFP_KERNEL);
> + if(!ops)
> + {
> + printk(KERN_ERR "mtd_stripe: memory allocation error!\n");
> + return -ENOMEM;
> + }
> +
> + memset(ops, 0, size);
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + ops[i].opcode = MTD_STRIPE_OPCODE_READ;
> + ops[i].caller_id = 0; /* TBD */
> + init_MUTEX_LOCKED(&ops[i].sem); /* mutex is locked here.
> to be unlocked by device thread */
> + //ops[i].status = 0; /* TBD */
> +
> + INIT_LIST_HEAD(&ops[i].subops.list); /* initialize
> suboperation list head */
> +
> + ops[i].subops.ops_num = 0; /* to be increased later
> here */
> + ops[i].subops.ops_num_max = queue_size; /* total number of
> suboperations can be stored in the array */
> + ops[i].subops.ops_array = (struct subop *)((char *)(ops +
> stripe->num_subdev) + i * queue_size * sizeof(struct subop));
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from_loc -
> stripe->subdev_last_offset[i - 1]) / stripe->interleave_size) %
> dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from_loc / stripe->interleave_size) /
> dev_count;
> + subdev_number = (from_loc / stripe->interleave_size) %
> dev_count;
> + }
> +
> + subdev_offset_low = from_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* asynch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_async(): device = %d, offset =
> 0x%08x, len = %d\n", subdev_number, subdev_offset_low, subdev_len);
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset_low,
> subdev_len, buf, NULL);
> + if(!err)
> + {
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + if(from_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Synch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_async(): device = %d,
> offset = 0x%08x, len = %d\n", subdev_number, subdev_offset *
> stripe->interleave_size, subdev_len);
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset *
> stripe->interleave_size, subdev_len, buf, NULL);
> + if(err)
> + break;
> +
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> +
> + if(from_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + /* Push operation into the corresponding threads queue and rise
> semaphores */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_add_op(&stripe->sw_threads[i], &ops[i]);
> +
> + /* set original operation priority */
> + ops[i].op_prio = current->static_prio - MAX_RT_PRIO - 20;
> + stripe_set_write_thread_prio(&stripe->sw_threads[i]);
> +
> + up(&stripe->sw_threads[i].sw_thread_wait);
> + }
> +
> + /* wait for all suboperations completed and check status */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + down(&ops[i].sem);
> +
> + /* set error if one of operations has failed */
> + if(ops[i].status)
> + err = ops[i].status;
> + }
> +
> + /* Deallocate all memory before exit */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_destroy_op(&ops[i]);
> + }
> + kfree(ops);
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_async(): read %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +
> +static int
> +stripe_read(struct mtd_info *mtd, loff_t from, size_t len,
> + size_t * retlen, u_char * buf)
> +{
> + int err;
> + if(mtd->type == MTD_NANDFLASH)
> + err = stripe_read_async(mtd, from, len, retlen, buf);
> + else
> + err = stripe_read_sync(mtd, from, len, retlen, buf);
> +
> + return err;
> +}
> +
> +
> +static int
> +stripe_write(struct mtd_info *mtd, loff_t to, size_t len,
> + size_t * retlen, const u_char * buf)
> +{
> + u_int32_t to_loc = (u_int32_t)to; /* we can do this since whole
> MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned block */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> +
> + struct mtd_stripe_op *ops; /* operations array (one per
> thread) */
> + u_int32_t size; /* amount of memory to be
> allocated for thread operations */
> + u_int32_t queue_size;
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_write(): offset = 0x%08x, size =
> %d\n", to_loc, len);
> +
> + /* check if no data is going to be written */
> + if(!len)
> + return 0;
> +
> + /* Check whole striped device bounds here */
> + if(to_loc + len > mtd->size)
> + return err;
> +
> + /* allocate memory for multithread operations */
> + queue_size = len / stripe->interleave_size / stripe->num_subdev +
> 1; /* default queue size. could be set to predefined value */
> + size = stripe->num_subdev *
> SIZEOF_STRUCT_MTD_STRIPE_OP(queue_size);
> + ops = kmalloc(size, GFP_KERNEL);
> + if(!ops)
> + {
> + printk(KERN_ERR "mtd_stripe: memory allocation error!\n");
> + return -ENOMEM;
> + }
> +
> + memset(ops, 0, size);
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + ops[i].opcode = MTD_STRIPE_OPCODE_WRITE;
> + ops[i].caller_id = 0; /* TBD */
> + init_MUTEX_LOCKED(&ops[i].sem); /* mutex is locked here.
> to be unlocked by device thread */
> + //ops[i].status = 0; /* TBD */
> +
> + INIT_LIST_HEAD(&ops[i].subops.list); /* initialize
> suboperation list head */
> +
> + ops[i].subops.ops_num = 0; /* to be increased later
> here */
> + ops[i].subops.ops_num_max = queue_size; /* total number of
> suboperations can be stored in the array */
> + ops[i].subops.ops_array = (struct subop *)((char *)(ops +
> stripe->num_subdev) + i * queue_size * sizeof(struct subop));
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(to_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((to_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((to_loc - stripe->subdev_last_offset[i
> - 1]) / stripe->interleave_size) % dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (to_loc / stripe->interleave_size) / dev_count;
> + subdev_number = (to_loc / stripe->interleave_size) % dev_count;
> + }
> +
> + subdev_offset_low = to_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Add suboperation to queue here */
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset_low,
> subdev_len, buf, NULL);
> + if(!err)
> + {
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + if(to_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Add suboperation to queue here */
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset *
> stripe->interleave_size, subdev_len, buf, NULL);
> + if(err)
> + break;
> +
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> +
> + if(to_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + /* Push operation into the corresponding threads queue and rise
> semaphores */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_add_op(&stripe->sw_threads[i], &ops[i]);
> +
> + /* set original operation priority */
> + ops[i].op_prio = current->static_prio - MAX_RT_PRIO - 20;
> + stripe_set_write_thread_prio(&stripe->sw_threads[i]);
> +
> + up(&stripe->sw_threads[i].sw_thread_wait);
> + }
> +
> + /* wait for all suboperations completed and check status */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + down(&ops[i].sem);
> +
> + /* set error if one of operations has failed */
> + if(ops[i].status)
> + err = ops[i].status;
> + }
> +
> + /* Deallocate all memory before exit */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_destroy_op(&ops[i]);
> + }
> + kfree(ops);
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_write(): written %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +
> +/* synchroneous ecc read from striped volume */
> +static int
> +stripe_read_ecc_sync(struct mtd_info *mtd, loff_t from, size_t len,
> + size_t * retlen, u_char * buf, u_char * eccbuf,
> + struct nand_oobinfo *oobsel)
> +{
> + u_int32_t from_loc = (u_int32_t)from; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> + size_t retsize; /* data read/written from/to
> subdev (bytes) */
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_ecc_sync(): offset = 0x%08x,
> size = %d\n", from_loc, len);
> +
> + if(oobsel != NULL)
> + {
> + /* check if oobinfo is has been chandes by FS */
> + if(memcmp(oobsel, &mtd->oobinfo, sizeof(struct nand_oobinfo)))
> + {
> + printk(KERN_ERR "stripe_read_ecc_sync(): oobinfo has been
> changed by FS (not supported yet)\n");
> + return err;
> + }
> + }
> +
> + /* Check whole striped device bounds here */
> + if(from_loc + len > mtd->size)
> + {
> + return err;
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from_loc -
> stripe->subdev_last_offset[i - 1]) / stripe->interleave_size) %
> dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from_loc / stripe->interleave_size) /
> dev_count;
> + subdev_number = (from_loc / stripe->interleave_size) %
> dev_count;
> + }
> +
> + subdev_offset_low = from_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Synch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_ecc_sync(): device = %d,
> offset = 0x%08x, len = %d\n", subdev_number, subdev_offset_low,
> subdev_len);
> + err =
> stripe->subdev[subdev_number]->read_ecc(stripe->subdev[subdev_number],
> subdev_offset_low, subdev_len, &retsize, buf, eccbuf,
> &stripe->subdev[subdev_number]->oobinfo);
> + if(!err)
> + {
> + *retlen += retsize;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + eccbuf += stripe->subdev[subdev_number]->oobavail;
> +
> + if(from_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Synch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_ecc_sync(): device = %d,
> offset = 0x%08x, len = %d\n", subdev_number, subdev_offset *
> stripe->interleave_size, subdev_len);
> + err =
> stripe->subdev[subdev_number]->read_ecc(stripe->subdev[subdev_number],
> subdev_offset * stripe->interleave_size, subdev_len, &retsize, buf,
> eccbuf, &stripe->subdev[subdev_number]->oobinfo);
> + if(err)
> + break;
> +
> + *retlen += retsize;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + eccbuf += stripe->subdev[subdev_number]->oobavail;
> +
> + if(from + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_ecc_sync(): read %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +
> +/* asynchroneous ecc read from striped volume */
> +static int
> +stripe_read_ecc_async(struct mtd_info *mtd, loff_t from, size_t len,
> + size_t * retlen, u_char * buf, u_char * eccbuf,
> + struct nand_oobinfo *oobsel)
> +{
> + u_int32_t from_loc = (u_int32_t)from; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> +
> + struct mtd_stripe_op *ops; /* operations array (one per
> thread) */
> + u_int32_t size; /* amount of memory to be
> allocated for thread operations */
> + u_int32_t queue_size;
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_ecc_async(): offset = 0x%08x,
> size = %d\n", from_loc, len);
> +
> + if(oobsel != NULL)
> + {
> + /* check if oobinfo is has been chandes by FS */
> + if(memcmp(oobsel, &mtd->oobinfo, sizeof(struct nand_oobinfo)))
> + {
> + printk(KERN_ERR "stripe_read_ecc_async(): oobinfo has been
> changed by FS (not supported yet)\n");
> + return err;
> + }
> + }
> +
> + /* Check whole striped device bounds here */
> + if(from_loc + len > mtd->size)
> + {
> + return err;
> + }
> +
> + /* allocate memory for multithread operations */
> + queue_size = len / stripe->interleave_size / stripe->num_subdev +
> 1; /* default queue size. could be set to predefined value */
> + size = stripe->num_subdev *
> SIZEOF_STRUCT_MTD_STRIPE_OP(queue_size);
> + ops = kmalloc(size, GFP_KERNEL);
> + if(!ops)
> + {
> + printk(KERN_ERR "mtd_stripe: memory allocation error!\n");
> + return -ENOMEM;
> + }
> +
> + memset(ops, 0, size);
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + ops[i].opcode = MTD_STRIPE_OPCODE_READ_ECC;
> + ops[i].caller_id = 0; /* TBD */
> + init_MUTEX_LOCKED(&ops[i].sem); /* mutex is locked here.
> to be unlocked by device thread */
> + //ops[i].status = 0; /* TBD */
> +
> + INIT_LIST_HEAD(&ops[i].subops.list); /* initialize
> suboperation list head */
> +
> + ops[i].subops.ops_num = 0; /* to be increased later
> here */
> + ops[i].subops.ops_num_max = queue_size; /* total number of
> suboperations can be stored in the array */
> + ops[i].subops.ops_array = (struct subop *)((char *)(ops +
> stripe->num_subdev) + i * queue_size * sizeof(struct subop));
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from_loc -
> stripe->subdev_last_offset[i - 1]) / stripe->interleave_size) %
> dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from_loc / stripe->interleave_size) /
> dev_count;
> + subdev_number = (from_loc / stripe->interleave_size) %
> dev_count;
> + }
> +
> + subdev_offset_low = from_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Issue read operation here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_ecc_async(): device = %d,
> offset = 0x%08x, len = %d\n", subdev_number, subdev_offset_low,
> subdev_len);
> +
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset_low,
> subdev_len, buf, eccbuf);
> + if(!err)
> + {
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + if(eccbuf)
> + eccbuf += stripe->subdev[subdev_number]->oobavail;
> +
> + if(from_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Issue read operation here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_ecc_async(): device = %d,
> offset = 0x%08x, len = %d\n", subdev_number, subdev_offset *
> stripe->interleave_size, subdev_len);
> +
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset *
> stripe->interleave_size, subdev_len, buf, eccbuf);
> + if(err)
> + break;
> +
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + if(eccbuf)
> + eccbuf += stripe->subdev[subdev_number]->oobavail;
> +
> + if(from + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + /* Push operation into the corresponding threads queue and rise
> semaphores */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_add_op(&stripe->sw_threads[i], &ops[i]);
> +
> + /* set original operation priority */
> + ops[i].op_prio = current->static_prio - MAX_RT_PRIO - 20;
> + stripe_set_write_thread_prio(&stripe->sw_threads[i]);
> +
> + up(&stripe->sw_threads[i].sw_thread_wait);
> + }
> +
> + /* wait for all suboperations completed and check status */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + down(&ops[i].sem);
> +
> + /* set error if one of operations has failed */
> + if(ops[i].status)
> + err = ops[i].status;
> + }
> +
> + /* Deallocate all memory before exit */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_destroy_op(&ops[i]);
> + }
> + kfree(ops);
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_ecc_async(): read %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +
> +static int
> +stripe_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
> + size_t * retlen, u_char * buf, u_char * eccbuf,
> + struct nand_oobinfo *oobsel)
> +{
> + int err;
> + if(mtd->type == MTD_NANDFLASH)
> + err = stripe_read_ecc_async(mtd, from, len, retlen, buf, eccbuf,
> oobsel);
> + else
> + err = stripe_read_ecc_sync(mtd, from, len, retlen, buf, eccbuf,
> oobsel);
> +
> + return err;
> +}
> +
> +
> +static int
> +stripe_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
> + size_t * retlen, const u_char * buf, u_char * eccbuf,
> + struct nand_oobinfo *oobsel)
> +{
> + u_int32_t to_loc = (u_int32_t)to; /* we can do this since whole
> MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned block */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> +
> + struct mtd_stripe_op *ops; /* operations array (one per
> thread) */
> + u_int32_t size; /* amount of memory to be
> allocated for thread operations */
> + u_int32_t queue_size;
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_write_ecc(): offset = 0x%08x, size
> = %d\n", to_loc, len);
> +
> + if(oobsel != NULL)
> + {
> + /* check if oobinfo is has been chandes by FS */
> + if(memcmp(oobsel, &mtd->oobinfo, sizeof(struct nand_oobinfo)))
> + {
> + printk(KERN_ERR "stripe_write_ecc(): oobinfo has been
> changed by FS (not supported yet)\n");
> + return err;
> + }
> + }
> +
> + /* check if no data is going to be written */
> + if(!len)
> + return 0;
> +
> + /* Check whole striped device bounds here */
> + if(to_loc + len > mtd->size)
> + return err;
> +
> + /* allocate memory for multithread operations */
> + queue_size = len / stripe->interleave_size / stripe->num_subdev +
> 1; /* default queue size */
> + size = stripe->num_subdev *
> SIZEOF_STRUCT_MTD_STRIPE_OP(queue_size);
> + ops = kmalloc(size, GFP_KERNEL);
> + if(!ops)
> + {
> + printk(KERN_ERR "mtd_stripe: memory allocation error!\n");
> + return -ENOMEM;
> + }
> +
> + memset(ops, 0, size);
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + ops[i].opcode = MTD_STRIPE_OPCODE_WRITE_ECC;
> + ops[i].caller_id = 0; /* TBD */
> + init_MUTEX_LOCKED(&ops[i].sem); /* mutex is locked here.
> to be unlocked by device thread */
> + //ops[i].status = 0; /* TBD */
> +
> + INIT_LIST_HEAD(&ops[i].subops.list); /* initialize
> suboperation list head */
> +
> + ops[i].subops.ops_num = 0; /* to be increased later
> here */
> + ops[i].subops.ops_num_max = queue_size; /* total number of
> suboperations can be stored in the array */
> + ops[i].subops.ops_array = (struct subop *)((char *)(ops +
> stripe->num_subdev) + i * queue_size * sizeof(struct subop));
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(to_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((to_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((to_loc - stripe->subdev_last_offset[i
> - 1]) / stripe->interleave_size) % dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (to_loc / stripe->interleave_size) / dev_count;
> + subdev_number = (to_loc / stripe->interleave_size) % dev_count;
> + }
> +
> + subdev_offset_low = to_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Add suboperation to queue here */
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset_low,
> subdev_len, buf, eccbuf);
> + if(!err)
> + {
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + if(eccbuf)
> + eccbuf += stripe->subdev[subdev_number]->oobavail;
> +
> + if(to_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Add suboperation to queue here */
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset *
> stripe->interleave_size, subdev_len, buf, eccbuf);
> + if(err)
> + break;
> +
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> + if(eccbuf)
> + eccbuf += stripe->subdev[subdev_number]->oobavail;
> +
> + if(to_loc + *retlen >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + /* Push operation into the corresponding threads queue and rise
> semaphores */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_add_op(&stripe->sw_threads[i], &ops[i]);
> +
> + /* set original operation priority */
> + ops[i].op_prio = current->static_prio - MAX_RT_PRIO - 20;
> + stripe_set_write_thread_prio(&stripe->sw_threads[i]);
> +
> + up(&stripe->sw_threads[i].sw_thread_wait);
> + }
> +
> + /* wait for all suboperations completed and check status */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + down(&ops[i].sem);
> +
> + /* set error if one of operations has failed */
> + if(ops[i].status)
> + err = ops[i].status;
> + }
> +
> + /* Deallocate all memory before exit */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_destroy_op(&ops[i]);
> + }
> + kfree(ops);
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_write_ecc(): written %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +
> +static int
> +stripe_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
> + size_t * retlen, u_char * buf)
> +{
> + u_int32_t from_loc = (u_int32_t)from; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> + size_t retsize; /* data read/written from/to
> subdev (bytes) */
> +
> + u_int32_t subdev_oobavail = stripe->subdev[0]->oobsize;
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_oob(): offset = 0x%08x, size =
> %d\n", from_loc, len);
> +
> + /* Check whole striped device bounds here */
> + if(from_loc + len > mtd->size)
> + {
> + return err;
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from_loc -
> stripe->subdev_last_offset[i - 1]) / stripe->interleave_size) %
> dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from_loc / stripe->interleave_size) /
> dev_count;
> + subdev_number = (from_loc / stripe->interleave_size) %
> dev_count;
> + }
> +
> + subdev_offset_low = from_loc % subdev_oobavail;
> + subdev_len = (len_left < (subdev_oobavail - subdev_offset_low)) ?
> len_left : (subdev_oobavail - subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Synch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_oob(): device = %d, offset =
> 0x%08x, len = %d\n", subdev_number, subdev_offset_low, subdev_len);
> + err =
> stripe->subdev[subdev_number]->read_oob(stripe->subdev[subdev_number],
> subdev_offset_low, subdev_len, &retsize, buf);
> + if(!err)
> + {
> + *retlen += retsize;
> + len_left -= subdev_len;
> + buf += subdev_len;
> +
> + /* increase flash offset by interleave size since oob blocks
> + * aligned with page size (i.e. interleave size) */
> + from_loc += stripe->interleave_size;
> +
> + if(from_loc >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < subdev_oobavail) ? len_left :
> subdev_oobavail;
> +
> + /* Synch read here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_read_oob(): device = %d, offset
> = 0x%08x, len = %d\n", subdev_number, subdev_offset *
> stripe->interleave_size, subdev_len);
> + err =
> stripe->subdev[subdev_number]->read_oob(stripe->subdev[subdev_number],
> subdev_offset * stripe->interleave_size, subdev_len, &retsize, buf);
> + if(err)
> + break;
> +
> + *retlen += retsize;
> + len_left -= subdev_len;
> + buf += subdev_len;
> +
> + /* increase flash offset by interleave size since oob blocks
> + * aligned with page size (i.e. interleave size) */
> + from_loc += stripe->interleave_size;
> +
> + if(from_loc >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> + }
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_read_oob(): read %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +static int
> +stripe_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
> + size_t *retlen, const u_char * buf)
> +{
> + u_int32_t to_loc = (u_int32_t)to; /* we can do this since whole
> MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned block */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to read/write
> left (bytes) */
> +
> + struct mtd_stripe_op *ops; /* operations array (one per
> thread) */
> + u_int32_t size; /* amount of memory to be
> allocated for thread operations */
> + u_int32_t queue_size;
> +
> + //u_int32_t subdev_oobavail = stripe->subdev[0]->oobavail;
> + u_int32_t subdev_oobavail = stripe->subdev[0]->oobsize;
> +
> + *retlen = 0;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_write_oob(): offset = 0x%08x, size
> = %d\n", to_loc, len);
> +
> + /* check if no data is going to be written */
> + if(!len)
> + return 0;
> +
> + /* Check whole striped device bounds here */
> + if(to_loc + len > mtd->size)
> + return err;
> +
> + /* allocate memory for multithread operations */
> + queue_size = len / subdev_oobavail / stripe->num_subdev + 1;
> /* default queue size. could be set to predefined value */
> + size = stripe->num_subdev *
> SIZEOF_STRUCT_MTD_STRIPE_OP(queue_size);
> + ops = kmalloc(size, GFP_KERNEL);
> + if(!ops)
> + {
> + printk(KERN_ERR "stripe_write_oob(): memory allocation
> error!\n");
> + return -ENOMEM;
> + }
> +
> + memset(ops, 0, size);
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + ops[i].opcode = MTD_STRIPE_OPCODE_WRITE_OOB;
> + ops[i].caller_id = 0; /* TBD */
> + init_MUTEX_LOCKED(&ops[i].sem); /* mutex is locked here.
> to be unlocked by device thread */
> + //ops[i].status = 0; /* TBD */
> +
> + INIT_LIST_HEAD(&ops[i].subops.list); /* initialize
> suboperation list head */
> +
> + ops[i].subops.ops_num = 0; /* to be increased later
> here */
> + ops[i].subops.ops_num_max = queue_size; /* total number of
> suboperations can be stored in the array */
> + ops[i].subops.ops_array = (struct subop *)((char *)(ops +
> stripe->num_subdev) + i * queue_size * sizeof(struct subop));
> + }
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(to_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((to_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((to_loc - stripe->subdev_last_offset[i
> - 1]) / stripe->interleave_size) % dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (to_loc / stripe->interleave_size) / dev_count;
> + subdev_number = (to_loc / stripe->interleave_size) % dev_count;
> + }
> +
> + subdev_offset_low = to_loc % subdev_oobavail;
> + subdev_len = (len_left < (subdev_oobavail - subdev_offset_low)) ?
> len_left : (subdev_oobavail - subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Add suboperation to queue here */
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset_low,
> subdev_len, buf, NULL);
> +
>
> + if(!err)
> + {
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> +
> + /* increase flash offset by interleave size since oob blocks
> + * aligned with page size (i.e. interleave size) */
> + to_loc += stripe->interleave_size;
> +
> + if(to_loc >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < subdev_oobavail) ? len_left :
> subdev_oobavail;
> +
> + /* Add suboperation to queue here */
> + err = stripe_add_subop(&ops[subdev_number], subdev_offset *
> stripe->interleave_size, subdev_len, buf, NULL);
> + if(err)
> + break;
> +
> + *retlen += subdev_len;
> + len_left -= subdev_len;
> + buf += subdev_len;
> +
> + /* increase flash offset by interleave size since oob blocks
> + * aligned with page size (i.e. interleave size) */
> + to_loc += stripe->interleave_size;
> +
> + if(to_loc >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> + }
> +
> + /* Push operation into the corresponding threads queue and rise
> semaphores */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_add_op(&stripe->sw_threads[i], &ops[i]);
> +
> + /* set original operation priority */
> + ops[i].op_prio = current->static_prio - MAX_RT_PRIO - 20;
> + stripe_set_write_thread_prio(&stripe->sw_threads[i]);
> +
> + up(&stripe->sw_threads[i].sw_thread_wait);
> + }
> +
> + /* wait for all suboperations completed and check status */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + down(&ops[i].sem);
> +
> + /* set error if one of operations has failed */
> + if(ops[i].status)
> + err = ops[i].status;
> + }
> +
> + /* Deallocate all memory before exit */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_destroy_op(&ops[i]);
> + }
> + kfree(ops);
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_write_oob(): written %d bytes\n",
> *retlen);
> + return err;
> +}
> +
> +/* this routine aimed to support striping on NOR_ECC
> + * it has been taken from cfi_cmdset_0001.c
> + */
> +static int
> +stripe_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned
> long count,
> + loff_t to, size_t * retlen)
> +{
> + int i, page, len, total_len, ret = 0, written = 0, cnt = 0,
> towrite;
> + u_char *bufstart;
> + char* data_poi;
> + char* data_buf;
> + loff_t write_offset;
> + int rl_wr;
> +
> + u_int32_t pagesize;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "==> stripe_writev()\n");
> +
> +#ifdef MTD_PROGRAM_REGIONS
> + /* Montavista patch for Sibley support detected */
> + if(mtd->flags & MTD_PROGRAM_REGIONS)
> + {
> + pagesize = MTD_PROGREGION_SIZE(mtd);
> + }
> + else if(mtd->flags & MTD_ECC)
> + {
> + pagesize = mtd->eccsize;
> + }
> + else
> + {
> + printk(KERN_ERR "stripe_writev() has been called for device
> without MTD_PROGRAM_REGIONS or MTD_ECC set\n");
> + return -EINVAL;
> + }
> +#else
> + if(mtd->flags & MTD_ECC)
> + {
> + pagesize = mtd->eccsize;
> + }
> + else
> + {
> + printk(KERN_ERR "stripe_writev() has been called for device
> without MTD_ECC set\n");
> + return -EINVAL;
> + }
> +#endif
> +
> + data_buf = kmalloc(pagesize, GFP_KERNEL);
> +
> + /* Preset written len for early exit */
> + *retlen = 0;
> +
> + /* Calculate total length of data */
> + total_len = 0;
> + for (i = 0; i < count; i++)
> + total_len += (int) vecs[i].iov_len;
> +
> + /* check if no data is going to be written */
> + if(!total_len)
> + {
> + kfree(data_buf);
> + return 0;
> + }
> +
> + /* Do not allow write past end of page */
> + if ((to + total_len) > mtd->size) {
> + DEBUG (MTD_DEBUG_LEVEL0, "stripe_writev(): Attempted write past
> end of device\n");
> + kfree(data_buf);
> + return -EINVAL;
> + }
> +
> + /* Setup start page */
> + page = ((int) to) / pagesize;
> + towrite = (page + 1) * pagesize - to; /* rest of the page */
> + write_offset = to;
> + written = 0;
> + /* Loop until all iovecs' data has been written */
> + len = 0;
> + while (len < total_len) {
> + bufstart = (u_char *)vecs->iov_base;
> + bufstart += written;
> + data_poi = bufstart;
> +
> + /* If the given tuple is >= reet of page then
> + * write it out from the iov
> + */
> + if ( (vecs->iov_len-written) >= towrite) { /* The fastest
> case is to write data by int * blocksize */
> + ret = mtd->write(mtd, write_offset, towrite, &rl_wr,
> data_poi);
> + if(ret)
> + break;
> + len += towrite;
> + page ++;
> + write_offset = page * pagesize;
> + towrite = pagesize;
> + written += towrite;
> + if(vecs->iov_len == written) {
> + vecs ++;
> + written = 0;
> + }
> + }
> + else
> + {
> + cnt = 0;
> + while(cnt < towrite ) {
> + data_buf[cnt++] = ((u_char *)
> vecs->iov_base)[written++];
> + if(vecs->iov_len == written )
> + {
> + if((cnt+len) == total_len )
> + break;
> + vecs ++;
> + written = 0;
> + }
> + }
> + data_poi = data_buf;
> + ret = mtd->write(mtd, write_offset, cnt, &rl_wr, data_poi);
> + if (ret)
> + break;
> + len += cnt;
> + page ++;
> + write_offset = page * pagesize;
> + towrite = pagesize;
> + }
> + }
> +
> + if(retlen)
> + *retlen = len;
> + kfree(data_buf);
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "<== stripe_writev()\n");
> +
> + return ret;
> +}
> +
> +
> +static int
> +stripe_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs,
> unsigned long count,
> + loff_t to, size_t * retlen, u_char *eccbuf, struct
> nand_oobinfo *oobsel)
> +{
> + int i, page, len, total_len, ret = 0, written = 0, cnt = 0,
> towrite;
> + u_char *bufstart;
> + char* data_poi;
> + char* data_buf;
> + loff_t write_offset;
> + data_buf = kmalloc(mtd->oobblock, GFP_KERNEL);
> + int rl_wr;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "==> stripe_writev_ecc()\n");
> +
> + if(oobsel != NULL)
> + {
> + /* check if oobinfo is has been chandes by FS */
> + if(memcmp(oobsel, &mtd->oobinfo, sizeof(struct nand_oobinfo)))
> + {
> + printk(KERN_ERR "stripe_writev_ecc(): oobinfo has been
> changed by FS (not supported yet)\n");
> + kfree(data_buf);
> + return -EINVAL;
> + }
> + }
> +
> + if(!(mtd->flags & MTD_ECC))
> + {
> + printk(KERN_ERR "stripe_writev_ecc() has been called for device
> without MTD_ECC set\n");
> + kfree(data_buf);
> + return -EINVAL;
> + }
> +
> + /* Preset written len for early exit */
> + *retlen = 0;
> +
> + /* Calculate total length of data */
> + total_len = 0;
> + for (i = 0; i < count; i++)
> + total_len += (int) vecs[i].iov_len;
> +
> + /* check if no data is going to be written */
> + if(!total_len)
> + {
> + kfree(data_buf);
> + return 0;
> + }
> +
> + /* Do not allow write past end of page */
> + if ((to + total_len) > mtd->size) {
> + DEBUG (MTD_DEBUG_LEVEL0, "stripe_writev_ecc(): Attempted write
> past end of device\n");
> + kfree(data_buf);
> + return -EINVAL;
> + }
> +
> + /* Check "to" and "len" alignment here */
> + /* NOTE: can't use if(to & (mtd->ooblock - 1)) alignment check here
> since
> + * mtd->oobblock can be not-power-of-two number */
> + if((((int) to) % mtd->oobblock) || (total_len % mtd->oobblock))
> + {
> + printk(KERN_ERR "stripe_writev_ecc(): Attempted write not
> aligned data!\n");
> + kfree(data_buf);
> + return -EINVAL;
> + }
> +
> + /* Setup start page. Notaligned data is not allowed for write_ecc.
> */
> + page = ((int) to) / mtd->oobblock;
> + towrite = (page + 1) * mtd->oobblock - to; /* aligned with
> oobblock */
> + write_offset = to;
> + written = 0;
> + /* Loop until all iovecs' data has been written */
> + len = 0;
> + while (len < total_len) {
> + bufstart = (u_char *)vecs->iov_base;
> + bufstart += written;
> + data_poi = bufstart;
> +
> + /* If the given tuple is >= reet of page then
> + * write it out from the iov
> + */
> + if ( (vecs->iov_len-written) >= towrite) { /* The fastest
> case is to write data by int * blocksize */
> + ret = mtd->write_ecc(mtd, write_offset, towrite, &rl_wr,
> data_poi, eccbuf, oobsel);
> + if(ret)
> + break;
> + len += rl_wr;
> + page ++;
> + write_offset = page * mtd->oobblock;
> + towrite = mtd->oobblock;
> + written += towrite;
> + if(vecs->iov_len == written) {
> + vecs ++;
> + written = 0;
> + }
> +
> + if(eccbuf)
> + eccbuf += mtd->oobavail;
> + }
> + else
> + {
> + cnt = 0;
> + while(cnt < towrite ) {
> + data_buf[cnt++] = ((u_char *)
> vecs->iov_base)[written++];
> + if(vecs->iov_len == written )
> + {
> + if((cnt+len) == total_len )
> + break;
> + vecs ++;
> + written = 0;
> + }
> + }
> + data_poi = data_buf;
> + ret = mtd->write_ecc(mtd, write_offset, cnt, &rl_wr,
> data_poi, eccbuf, oobsel);
> + if (ret)
> + break;
> + len += rl_wr;
> + page ++;
> + write_offset = page * mtd->oobblock;
> + towrite = mtd->oobblock;
> +
> + if(eccbuf)
> + eccbuf += mtd->oobavail;
> + }
> + }
> +
> + if(retlen)
> + *retlen = len;
> + kfree(data_buf);
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "<== stripe_writev_ecc()\n");
> +
> + return ret;
> +}
> +
> +
> +static void
> +stripe_erase_callback(struct erase_info *instr)
> +{
> + wake_up((wait_queue_head_t *) instr->priv);
> +}
> +
> +static int
> +stripe_dev_erase(struct mtd_info *mtd, struct erase_info *erase)
> +{
> + int err;
> + wait_queue_head_t waitq;
> + DECLARE_WAITQUEUE(wait, current);
> +
> + init_waitqueue_head(&waitq);
> +
> + erase->mtd = mtd;
> + erase->callback = stripe_erase_callback;
> + erase->priv = (unsigned long) &waitq;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_dev_erase(): addr=0x%08x,
> len=%d\n", erase->addr, erase->len);
> +
> + /*
> + * FIXME: Allow INTERRUPTIBLE. Which means
> + * not having the wait_queue head on the stack.
> + */
> + err = mtd->erase(mtd, erase);
> + if (!err)
> + {
> + set_current_state(TASK_UNINTERRUPTIBLE);
> + add_wait_queue(&waitq, &wait);
> + if (erase->state != MTD_ERASE_DONE
> + && erase->state != MTD_ERASE_FAILED)
> + schedule();
> + remove_wait_queue(&waitq, &wait);
> + set_current_state(TASK_RUNNING);
> +
> + err = (erase->state == MTD_ERASE_FAILED) ? -EIO : 0;
> + }
> + return err;
> +}
> +
> +static int
> +stripe_erase(struct mtd_info *mtd, struct erase_info *instr)
> +{
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int i, err;
> + struct mtd_stripe_erase_bounds *erase_bounds;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to erase
> (bytes) */
> + size_t subdev_len; /* data size to be erased at
> this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left; /* total data size left to be
> erased (bytes) */
> + size_t len_done; /* total data size erased */
> + u_int32_t from;
> +
> + struct mtd_stripe_op *ops; /* operations array (one per
> thread) */
> + u_int32_t size; /* amount of memory to be
> allocated for thread operations */
> + u_int32_t queue_size;
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_earse(): addr=0x%08x, len=%d\n",
> instr->addr, instr->len);
> +
> + if(!(mtd->flags & MTD_WRITEABLE))
> + return -EROFS;
> +
> + if(instr->addr > stripe->mtd.size)
> + return -EINVAL;
> +
> + if(instr->len + instr->addr > stripe->mtd.size)
> + return -EINVAL;
> +
> + /*
> + * Check for proper erase block alignment of the to-be-erased area.
> + */
> + if(!stripe->mtd.numeraseregions)
> + {
> + /* striped device has uniform erase block size */
> + /* NOTE: can't use if(instr->addr & (stripe->mtd.erasesize - 1))
> alignment check here
> + * since stripe->mtd.erasesize can be not-power-of-two number */
> + if(instr->addr % stripe->mtd.erasesize || instr->len %
> stripe->mtd.erasesize)
> + return -EINVAL;
> + }
> + else
> + {
> + /* we should not get here */
> + return -EINVAL;
> + }
> +
> + instr->fail_addr = 0xffffffff;
> +
> + /* allocate memory for multithread operations */
> + queue_size = 1; /* queue size for erase opration is 1 */
> + size = stripe->num_subdev *
> SIZEOF_STRUCT_MTD_STRIPE_OP(queue_size);
> + ops = kmalloc(size, GFP_KERNEL);
> + if(!ops)
> + {
> + printk(KERN_ERR "mtd_stripe: memory allocation error!\n");
> + return -ENOMEM;
> + }
> +
> + memset(ops, 0, size);
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + ops[i].opcode = MTD_STRIPE_OPCODE_ERASE;
> + ops[i].caller_id = 0; /* TBD */
> + init_MUTEX_LOCKED(&ops[i].sem); /* mutex is locked here.
> to be unlocked by device thread */
> + //ops[i].status = 0; /* TBD */
> + ops[i].fail_addr = 0xffffffff;
> +
> + INIT_LIST_HEAD(&ops[i].subops.list); /* initialize
> suboperation list head */
> +
> + ops[i].subops.ops_num = 0; /* to be increased later
> here */
> + ops[i].subops.ops_num_max = queue_size; /* total number of
> suboperations can be stored in the array */
> + ops[i].subops.ops_array = (struct subop *)((char *)(ops +
> stripe->num_subdev) + i * queue_size * sizeof(struct subop));
> + }
> +
> + len_left = instr->len;
> + len_done = 0;
> + from = instr->addr;
> +
> + /* allocate memory for erase boundaries for all subdevices */
> + erase_bounds = kmalloc(stripe->num_subdev * sizeof(struct
> mtd_stripe_erase_bounds), GFP_KERNEL);
> + if(!erase_bounds)
> + {
> + kfree(ops);
> + return -ENOMEM;
> + }
> + memset(erase_bounds, 0, sizeof(struct mtd_stripe_erase_bounds) *
> stripe->num_subdev);
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from - stripe->subdev_last_offset[i - 1])
> / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) % dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from / stripe->interleave_size) / dev_count;
> + subdev_number = (from / stripe->interleave_size) % dev_count;
> + }
> +
> + /* Should by optimized for erase op */
> + subdev_offset_low = from % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Add/extend block-to-be erased */
> + if(!erase_bounds[subdev_number].need_erase)
> + {
> + erase_bounds[subdev_number].need_erase = 1;
> + erase_bounds[subdev_number].addr = subdev_offset_low;
> + }
> + erase_bounds[subdev_number].len += subdev_len;
> + len_left -= subdev_len;
> + len_done += subdev_len;
> +
> + if(from + len_done >= stripe->subdev_last_offset[stripe->num_subdev
> - dev_count])
> + dev_count--;
> +
> + while(len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size; /* can by optimized for erase op*/
> +
> + /* Add/extend block-to-be erased */
> + if(!erase_bounds[subdev_number].need_erase)
> + {
> + erase_bounds[subdev_number].need_erase = 1;
> + erase_bounds[subdev_number].addr = subdev_offset *
> stripe->interleave_size;
> + }
> + erase_bounds[subdev_number].len += subdev_len;
> + len_left -= subdev_len;
> + len_done += subdev_len;
> +
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_erase(): device = %d, addr =
> 0x%08x, len = %d\n", subdev_number, erase_bounds[subdev_number].addr,
> erase_bounds[subdev_number].len);
> +
> + if(from + len_done >=
> stripe->subdev_last_offset[stripe->num_subdev - dev_count])
> + dev_count--;
> + }
> +
> + /* now do the erase: */
> + err = 0;
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + if(erase_bounds[i].need_erase)
> + {
> + if (!(stripe->subdev[i]->flags & MTD_WRITEABLE))
> + {
> + err = -EROFS;
> + break;
> + }
> +
> + stripe_add_subop(&ops[i], erase_bounds[i].addr,
> erase_bounds[i].len, (u_char *)instr, NULL);
> + }
> + }
> +
> + /* Push operation queues into the corresponding threads */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + if(erase_bounds[i].need_erase)
> + {
> + stripe_add_op(&stripe->sw_threads[i], &ops[i]);
> +
> + /* set original operation priority */
> + ops[i].op_prio = current->static_prio - MAX_RT_PRIO - 20;
> + stripe_set_write_thread_prio(&stripe->sw_threads[i]);
> +
> + up(&stripe->sw_threads[i].sw_thread_wait);
> + }
> + }
> +
> + /* wait for all suboperations completed and check status */
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + if(erase_bounds[i].need_erase)
> + {
> + down(&ops[i].sem);
> +
> + /* set error if one of operations has failed */
> + if(ops[i].status)
> + {
> + err = ops[i].status;
> +
> + /* FIX ME: For now this adddres shows address
> + * at the last failed subdevice,
> + * but not at the "super" device */
> + if(ops[i].fail_addr != 0xffffffff)
> + instr->fail_addr = ops[i].fail_addr;
> + }
> +
> + instr->state = ops[i].state;
> + }
> + }
> +
> + /* Deallocate all memory before exit */
> + kfree(erase_bounds);
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + stripe_destroy_op(&ops[i]);
> + }
> + kfree(ops);
> +
> + if(err)
> + return err;
> +
> + if(instr->callback)
> + instr->callback(instr);
> + return 0;
> +}
> +
> +static int
> +stripe_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
> +{
> + u_int32_t ofs_loc = (u_int32_t)ofs; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to lock
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be locked @
> subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to lock left
> (bytes) */
> +
> + size_t retlen = 0;
> + struct mtd_stripe_erase_bounds *erase_bounds;
> +
> + /* Check whole striped device bounds here */
> + if(ofs_loc + len > mtd->size)
> + return err;
> +
> + /* allocate memory for lock boundaries for all subdevices */
> + erase_bounds = kmalloc(stripe->num_subdev * sizeof(struct
> mtd_stripe_erase_bounds), GFP_KERNEL);
> + if(!erase_bounds)
> + return -ENOMEM;
> + memset(erase_bounds, 0, sizeof(struct mtd_stripe_erase_bounds) *
> stripe->num_subdev);
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(ofs_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((ofs_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((ofs_loc - stripe->subdev_last_offset[i
> - 1]) / stripe->interleave_size) % dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (ofs_loc / stripe->interleave_size) / dev_count;
> + subdev_number = (ofs_loc / stripe->interleave_size) % dev_count;
> + }
> +
> + subdev_offset_low = ofs_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Add/extend block-to-be locked */
> + if(!erase_bounds[subdev_number].need_erase)
> + {
> + erase_bounds[subdev_number].need_erase = 1;
> + erase_bounds[subdev_number].addr = subdev_offset_low;
> + }
> + erase_bounds[subdev_number].len += subdev_len;
> +
> + retlen += subdev_len;
> + len_left -= subdev_len;
> + if(ofs + retlen >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> +
> + while(len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Add/extend block-to-be locked */
> + if(!erase_bounds[subdev_number].need_erase)
> + {
> + erase_bounds[subdev_number].need_erase = 1;
> + erase_bounds[subdev_number].addr = subdev_offset *
> stripe->interleave_size;
> + }
> + erase_bounds[subdev_number].len += subdev_len;
> +
> + retlen += subdev_len;
> + len_left -= subdev_len;
> +
> + if(ofs + retlen >= stripe->subdev_last_offset[stripe->num_subdev
> - dev_count])
> + dev_count--;
> + }
> +
> + /* now do lock */
> + err = 0;
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + if(erase_bounds[i].need_erase)
> + {
> + if (stripe->subdev[i]->lock)
> + {
> + err = stripe->subdev[i]->lock(stripe->subdev[i],
> erase_bounds[i].addr, erase_bounds[i].len);
> + if(err)
> + break;
> + };
> + }
> + }
> +
> + /* Free allocated memory here */
> + kfree(erase_bounds);
> +
> + return err;
> +}
> +
> +static int
> +stripe_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
> +{
> + u_int32_t ofs_loc = (u_int32_t)ofs; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to unlock
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be unlocked @
> subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = len; /* total data size to unlock
> left (bytes) */
> +
> + size_t retlen = 0;
> + struct mtd_stripe_erase_bounds *erase_bounds;
> +
> + /* Check whole striped device bounds here */
> + if(ofs_loc + len > mtd->size)
> + return err;
> +
> + /* allocate memory for unlock boundaries for all subdevices */
> + erase_bounds = kmalloc(stripe->num_subdev * sizeof(struct
> mtd_stripe_erase_bounds), GFP_KERNEL);
> + if(!erase_bounds)
> + return -ENOMEM;
> + memset(erase_bounds, 0, sizeof(struct mtd_stripe_erase_bounds) *
> stripe->num_subdev);
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(ofs_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((ofs_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((ofs_loc - stripe->subdev_last_offset[i
> - 1]) / stripe->interleave_size) % dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (ofs_loc / stripe->interleave_size) / dev_count;
> + subdev_number = (ofs_loc / stripe->interleave_size) % dev_count;
> + }
> +
> + subdev_offset_low = ofs_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* Add/extend block-to-be unlocked */
> + if(!erase_bounds[subdev_number].need_erase)
> + {
> + erase_bounds[subdev_number].need_erase = 1;
> + erase_bounds[subdev_number].addr = subdev_offset_low;
> + }
> + erase_bounds[subdev_number].len += subdev_len;
> +
> + retlen += subdev_len;
> + len_left -= subdev_len;
> + if(ofs + retlen >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> +
> + while(len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* Add/extend block-to-be unlocked */
> + if(!erase_bounds[subdev_number].need_erase)
> + {
> + erase_bounds[subdev_number].need_erase = 1;
> + erase_bounds[subdev_number].addr = subdev_offset *
> stripe->interleave_size;
> + }
> + erase_bounds[subdev_number].len += subdev_len;
> +
> + retlen += subdev_len;
> + len_left -= subdev_len;
> +
> + if(ofs + retlen >= stripe->subdev_last_offset[stripe->num_subdev
> - dev_count])
> + dev_count--;
> + }
> +
> + /* now do unlock */
> + err = 0;
> + for(i = 0; i < stripe->num_subdev; i++)
> + {
> + if(erase_bounds[i].need_erase)
> + {
> + if (stripe->subdev[i]->unlock)
> + {
> + err = stripe->subdev[i]->unlock(stripe->subdev[i],
> erase_bounds[i].addr, erase_bounds[i].len);
> + if(err)
> + break;
> + };
> + }
> + }
> +
> + /* Free allocated memory here */
> + kfree(erase_bounds);
> +
> + return err;
> +}
> +
> +static void
> +stripe_sync(struct mtd_info *mtd)
> +{
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int i;
> +
> + for (i = 0; i < stripe->num_subdev; i++)
> + {
> + struct mtd_info *subdev = stripe->subdev[i];
> + if (subdev->sync)
> + subdev->sync(subdev);
> + }
> +}
> +
> +static int
> +stripe_suspend(struct mtd_info *mtd)
> +{
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int i, rc = 0;
> +
> + for (i = 0; i < stripe->num_subdev; i++)
> + {
> + struct mtd_info *subdev = stripe->subdev[i];
> + if (subdev->suspend)
> + {
> + if ((rc = subdev->suspend(subdev)) < 0)
> + return rc;
> + };
> + }
> + return rc;
> +}
> +
> +static void
> +stripe_resume(struct mtd_info *mtd)
> +{
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int i;
> +
> + for (i = 0; i < stripe->num_subdev; i++)
> + {
> + struct mtd_info *subdev = stripe->subdev[i];
> + if (subdev->resume)
> + subdev->resume(subdev);
> + }
> +}
> +
> +static int
> +stripe_block_isbad(struct mtd_info *mtd, loff_t ofs)
> +{
> + u_int32_t from_loc = (u_int32_t)ofs; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int res = 0;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = mtd->oobblock; /* total data size to read/write
> left (bytes) */
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_block_isbad(): offset = 0x%08x\n",
> from_loc);
> +
> + from_loc = (from_loc / mtd->oobblock) * mtd->oobblock; /* align
> offset here */
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from_loc -
> stripe->subdev_last_offset[i - 1]) / stripe->interleave_size) %
> dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from_loc / stripe->interleave_size) /
> dev_count;
> + subdev_number = (from_loc / stripe->interleave_size) %
> dev_count;
> + }
> +
> + subdev_offset_low = from_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* check block on subdevice is bad here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_block_isbad(): device = %d, offset
> = 0x%08x\n", subdev_number, subdev_offset_low);
> + res =
> stripe->subdev[subdev_number]->block_isbad(stripe->subdev[subdev_number]
> , subdev_offset_low);
> + if(!res)
> + {
> + len_left -= subdev_len;
> + from_loc += subdev_len;
> + if(from_loc >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> + }
> +
> + while(!res && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* check block on subdevice is bad here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_block_isbad(): device = %d,
> offset = 0x%08x\n", subdev_number, subdev_offset *
> stripe->interleave_size);
> + res =
> stripe->subdev[subdev_number]->block_isbad(stripe->subdev[subdev_number]
> , subdev_offset * stripe->interleave_size);
> + if(res)
> + {
> + break;
> + }
> + else
> + {
> + len_left -= subdev_len;
> + from_loc += subdev_len;
> + if(from_loc >= stripe->subdev_last_offset[stripe->num_subdev
> - dev_count])
> + dev_count--;
> + }
> + }
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "<== stripe_block_isbad()\n");
> + return res;
> +}
> +
> +/* returns 0 - success */
> +static int
> +stripe_block_markbad(struct mtd_info *mtd, loff_t ofs)
> +{
> + u_int32_t from_loc = (u_int32_t)ofs; /* we can do this since
> whole MTD size in current implementation has u_int32_t type */
> +
> + struct mtd_stripe *stripe = STRIPE(mtd);
> + int err = -EINVAL;
> + int i;
> +
> + u_int32_t subdev_offset; /* equal size subdevs offset
> (interleaved block size count)*/
> + u_int32_t subdev_number; /* number of current subdev */
> + u_int32_t subdev_offset_low; /* subdev offset to read/write
> (bytes). used for "first" probably unaligned with erasesize data block
> */
> + size_t subdev_len; /* data size to be read/written
> from/to subdev at this turn (bytes) */
> + int dev_count; /* equal size subdev count */
> + size_t len_left = mtd->oobblock; /* total data size to read/write
> left (bytes) */
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "stripe_block_markbad(): offset =
> 0x%08x\n", from_loc);
> +
> + from_loc = (from_loc / mtd->oobblock) * mtd->oobblock; /* align
> offset here */
> +
> + /* Locate start position and corresponding subdevice number */
> + subdev_offset = 0;
> + subdev_number = 0;
> + dev_count = stripe->num_subdev;
> + for(i = (stripe->num_subdev - 1); i > 0; i--)
> + {
> + if(from_loc >= stripe->subdev_last_offset[i-1])
> + {
> + dev_count = stripe->num_subdev - i; /* get "equal size"
> devices count */
> + subdev_offset = stripe->subdev[i - 1]->size /
> stripe->interleave_size - 1;
> + subdev_offset += ((from_loc - stripe->subdev_last_offset[i -
> 1]) / stripe->interleave_size) / dev_count;
> + subdev_number = i + ((from_loc -
> stripe->subdev_last_offset[i - 1]) / stripe->interleave_size) %
> dev_count;
> + break;
> + }
> + }
> +
> + if(subdev_offset == 0)
> + {
> + subdev_offset = (from_loc / stripe->interleave_size) /
> dev_count;
> + subdev_number = (from_loc / stripe->interleave_size) %
> dev_count;
> + }
> +
> + subdev_offset_low = from_loc % stripe->interleave_size;
> + subdev_len = (len_left < (stripe->interleave_size -
> subdev_offset_low)) ? len_left : (stripe->interleave_size -
> subdev_offset_low);
> + subdev_offset_low += subdev_offset * stripe->interleave_size;
> +
> + /* check block on subdevice is bad here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_block_markbad(): device = %d,
> offset = 0x%08x\n", subdev_number, subdev_offset_low);
> + err =
> stripe->subdev[subdev_number]->block_markbad(stripe->subdev[subdev_numbe
> r], subdev_offset_low);
> + if(!err)
> + {
> + len_left -= subdev_len;
> + from_loc += subdev_len;
> + if(from_loc >= stripe->subdev_last_offset[stripe->num_subdev -
> dev_count])
> + dev_count--;
> + }
> +
> + while(!err && len_left > 0 && dev_count > 0)
> + {
> + subdev_number++;
> + if(subdev_number >= stripe->num_subdev)
> + {
> + subdev_number = stripe->num_subdev - dev_count;
> + subdev_offset++;
> + }
> + subdev_len = (len_left < stripe->interleave_size) ? len_left :
> stripe->interleave_size;
> +
> + /* check block on subdevice is bad here */
> + DEBUG(MTD_DEBUG_LEVEL3, "stripe_block_markbad(): device = %d,
> offset = 0x%08x\n", subdev_number, subdev_offset *
> stripe->interleave_size);
> + err =
> stripe->subdev[subdev_number]->block_markbad(stripe->subdev[subdev_numbe
> r], subdev_offset * stripe->interleave_size);
> + if(err)
> + {
> + break;
> + }
> + else
> + {
> + len_left -= subdev_len;
> + from_loc += subdev_len;
> + if(from_loc >= stripe->subdev_last_offset[stripe->num_subdev
> - dev_count])
> + dev_count--;
> + }
> + }
> +
> + DEBUG(MTD_DEBUG_LEVEL2, "<== stripe_block_markbad()\n");
> + return err;
> +}
> +
> +/*
> + * This function constructs a virtual MTD device by interleaving
> (striping)
> + * num_devs MTD devices. A pointer to the new device object is
> + * stored to *new_dev upon success. This function does _not_
> + * register any devices: this is the caller's responsibility.
> + */
> +struct mtd_info *mtd_stripe_create(struct mtd_info *subdev[], /*
> subdevices to stripe */
> + int num_devs, /*
> number of subdevices */
> + char *name, /* name
> for the new device */
> + int interleave_size) /*
> interleaving size (sanity check is required) */
> +{
> + int i,j;
> + size_t size;
> + struct mtd_stripe *stripe;
> + u_int32_t curr_erasesize;
> + int sort_done = 0;
> +
> + printk(KERN_NOTICE "Striping MTD devices:\n");
> + for (i = 0; i < num_devs; i++)
> + printk(KERN_NOTICE "(%d): \"%s\"\n", i, subdev[i]->name);
> + printk(KERN_NOTICE "into device \"%s\"\n", name);
> +
> + /* check if trying to stripe same device */
> + for(i = 0; i < num_devs; i++)
> + {
> + for(j = i; j < num_devs; j++)
> + {
> + if(i != j && !(strcmp(subdev[i]->name,subdev[j]->name)))
> + {
> + printk(KERN_ERR "MTD Stripe failed. The same subdevice
> names were found.\n");
> + return NULL;
> + }
> + }
> + }
> +
> + /* allocate the device structure */
> + size = SIZEOF_STRUCT_MTD_STRIPE(num_devs);
> + stripe = kmalloc(size, GFP_KERNEL);
> + if (!stripe)
> + {
> + printk(KERN_ERR "mtd_stripe_create(): memory allocation
> error\n");
> + return NULL;
> + }
> + memset(stripe, 0, size);
> + stripe->subdev = (struct mtd_info **) (stripe + 1);
> + stripe->subdev_last_offset = (u_int32_t *) ((char *)(stripe + 1) +
> num_devs * sizeof(struct mtd_info *));
> + stripe->sw_threads = (struct mtd_sw_thread_info *)((char *)(stripe
> + 1) + num_devs * sizeof(struct mtd_info *) + num_devs *
> sizeof(u_int32_t));
> +
> + /*
> + * Set up the new "super" device's MTD object structure, check for
> + * incompatibilites between the subdevices.
> + */
> + stripe->mtd.type = subdev[0]->type;
> + stripe->mtd.flags = subdev[0]->flags;
> + stripe->mtd.size = subdev[0]->size;
> + stripe->mtd.erasesize = subdev[0]->erasesize;
> + stripe->mtd.oobblock = subdev[0]->oobblock;
> + stripe->mtd.oobsize = subdev[0]->oobsize;
> + stripe->mtd.oobavail = subdev[0]->oobavail;
> + stripe->mtd.ecctype = subdev[0]->ecctype;
> + stripe->mtd.eccsize = subdev[0]->eccsize;
> + if (subdev[0]->read_ecc)
> + stripe->mtd.read_ecc = stripe_read_ecc;
> + if (subdev[0]->write_ecc)
> + stripe->mtd.write_ecc = stripe_write_ecc;
> + if (subdev[0]->read_oob)
> + stripe->mtd.read_oob = stripe_read_oob;
> + if (subdev[0]->write_oob)
> + stripe->mtd.write_oob = stripe_write_oob;
> +
> + stripe->subdev[0] = subdev[0];
> +
> + for(i = 1; i < num_devs; i++)
> + {
> + /*
> + * Check device compatibility,
> + */
> + if(stripe->mtd.type != subdev[i]->type)
> + {
> + kfree(stripe);
> + printk(KERN_ERR "mtd_stripe_create(): incompatible device
> type on \"%s\"\n",
> + subdev[i]->name);
> + return NULL;
> + }
> +
> + /*
> + * Check MTD flags
> + */
> + if(stripe->mtd.flags != subdev[i]->flags)
> + {
> + /*
> + * Expect all flags to be
> + * equal on all subdevices.
> + */
> + kfree(stripe);
> + printk(KERN_ERR "mtd_stripe_create(): incompatible device
> flags on \"%s\"\n",
> + subdev[i]->name);
> + return NULL;
> + }
> +
> + stripe->mtd.size += subdev[i]->size;
> +
> + /*
> + * Check OOB and ECC data
> + */
> + if (stripe->mtd.oobblock != subdev[i]->oobblock ||
> + stripe->mtd.oobsize != subdev[i]->oobsize ||
> + stripe->mtd.oobavail != subdev[i]->oobavail ||
> + stripe->mtd.ecctype != subdev[i]->ecctype ||
> + stripe->mtd.eccsize != subdev[i]->eccsize ||
> + !stripe->mtd.read_ecc != !subdev[i]->read_ecc ||
> + !stripe->mtd.write_ecc != !subdev[i]->write_ecc ||
> + !stripe->mtd.read_oob != !subdev[i]->read_oob ||
> + !stripe->mtd.write_oob != !subdev[i]->write_oob)
> + {
> + kfree(stripe);
> + printk(KERN_ERR "mtd_stripe_create(): incompatible OOB or
> ECC data on \"%s\"\n",
> + subdev[i]->name);
> + return NULL;
> + }
> + stripe->subdev[i] = subdev[i];
> + }
> +
> + stripe->num_subdev = num_devs;
> + stripe->mtd.name = name;
> +
> + /*
> + * Main MTD routines
> + */
> + stripe->mtd.erase = stripe_erase;
> + stripe->mtd.read = stripe_read;
> + stripe->mtd.write = stripe_write;
> + stripe->mtd.sync = stripe_sync;
> + stripe->mtd.lock = stripe_lock;
> + stripe->mtd.unlock = stripe_unlock;
> + stripe->mtd.suspend = stripe_suspend;
> + stripe->mtd.resume = stripe_resume;
> +
> +#ifdef MTD_PROGRAM_REGIONS
> + /* Montavista patch for Sibley support detected */
> + if((stripe->mtd.flags & MTD_PROGRAM_REGIONS) ||
> (stripe->mtd.flags & MTD_ECC))
> + stripe->mtd.writev = stripe_writev;
> +#else
> + if(stripe->mtd.flags & MTD_ECC)
> + stripe->mtd.writev = stripe_writev;
> +#endif
> +
> + /* not sure about that case. probably should be used not only for
> NAND */
> + if(stripe->mtd.type == MTD_NANDFLASH)
> + stripe->mtd.writev_ecc = stripe_writev_ecc;
> +
> + if(subdev[0]->block_isbad)
> + stripe->mtd.block_isbad = stripe_block_isbad;
> +
> + if(subdev[0]->block_markbad)
> + stripe->mtd.block_markbad = stripe_block_markbad;
> +
> + /* NAND specific */
> + if(stripe->mtd.type == MTD_NANDFLASH)
> + {
> + stripe->mtd.oobblock *= num_devs;
> + stripe->mtd.oobsize *= num_devs;
> + stripe->mtd.oobavail *= num_devs; /* oobavail is to be changed
> later in stripe_merge_oobinfo() */
> + stripe->mtd.eccsize *= num_devs;
> + }
> +
> +#ifdef MTD_PROGRAM_REGIONS
> + /* Montavista patch for Sibley support detected */
> + if(stripe->mtd.flags & MTD_PROGRAM_REGIONS)
> + stripe->mtd.oobblock *= num_devs;
> + else if(stripe->mtd.flags & MTD_ECC)
> + stripe->mtd.eccsize *= num_devs;
> +#else
> + if(stripe->mtd.flags & MTD_ECC)
> + stripe->mtd.eccsize *= num_devs;
> +#endif
> +
> + /* Sort all subdevices by their size (from largest to smallest)*/
> + while(!sort_done)
> + {
> + sort_done = 1;
> + for(i=0; i < num_devs - 1; i++)
> + {
> + struct mtd_info *subdev = stripe->subdev[i];
> + if(subdev->size > stripe->subdev[i+1]->size)
> + {
> + stripe->subdev[i] = stripe->subdev[i+1];
> + stripe->subdev[i+1] = subdev;
> + sort_done = 0;
> + }
> + }
> + }
> +
> + /* Create new device with uniform erase size */
> + curr_erasesize = subdev[0]->erasesize;
> + for (i = 1; i < num_devs; i++)
> + {
> + curr_erasesize = lcm(curr_erasesize, subdev[i]->erasesize);
> + }
> + curr_erasesize *= num_devs;
> +
> + /* Check if there are different size devices in the array*/
> + for (i = 1; i < num_devs; i++)
> + {
> + /* note: subdevices must be already sorted by their size here */
> + if(subdev[i - 1]->size > subdev[i]->size)
> + {
> + u_int32_t tmp_erasesize = subdev[i]->erasesize;
> + for(j = 0; j < i; j++)
> + {
> + tmp_erasesize = lcm(tmp_erasesize,
> subdev[j]->erasesize);
> + }
> + tmp_erasesize *= i;
> + curr_erasesize = lcm(curr_erasesize, tmp_erasesize);
> + }
> + }
> +
> + /* Check if erase size found is valid */
> + if(curr_erasesize <= 0)
> + {
> + kfree(stripe);
> + printk(KERN_ERR "mtd_stripe_create(): Can't find lcm of
> subdevice erase sizes\n");
> + return NULL;
> + }
> +
> + /* Check interleave size validity here */
> + if(curr_erasesize % interleave_size)
> + {
> + kfree(stripe);
> + printk(KERN_ERR "mtd_stripe_create(): Wrong interleave size\n");
> + return NULL;
> + }
> + stripe->interleave_size = interleave_size;
> +
> + stripe->mtd.erasesize = curr_erasesize;
> + stripe->mtd.numeraseregions = 0;
> +
> + /* update (truncate) super device size in accordance with new
> erasesize */
> + stripe->mtd.size = (stripe->mtd.size / stripe->mtd.erasesize) *
> stripe->mtd.erasesize;
> +
> + /* Calculate last data offset for each striped device */
> + for (i = 0; i < num_devs; i++)
> + stripe->subdev_last_offset[i] = last_offset(stripe, i);
> +
> + /* NAND specific */
> + if(stripe->mtd.type == MTD_NANDFLASH)
> + {
> + /* Fill oobavail with correct values here */
> + for (i = 0; i < num_devs; i++)
> + stripe->subdev[i]->oobavail =
> stripe_get_oobavail(stripe->subdev[i]);
> +
> + /* Sets new device oobinfo
> + * NAND flash check is performed inside stripe_merge_oobinfo()
> + * - this should be made after subdevices sorting done for
> proper eccpos and oobfree positioning
> + * NOTE: there are some limitations with different size NAND
> devices striping. all devices must have
> + * the same oobfree and eccpos maps */
> + if(stripe_merge_oobinfo(&stripe->mtd, subdev, num_devs))
> + {
> + kfree(stripe);
> + printk(KERN_ERR "mtd_stripe_create(): oobinfo merge has
> failed\n");
> + return NULL;
> + }
> + }
> +
> + /* Create worker threads */
> + for (i = 0; i < num_devs; i++)
> + {
> + if(stripe_start_write_thread(&stripe->sw_threads[i],
> stripe->subdev[i]) < 0)
> + {
> + kfree(stripe);
> + return NULL;
> + }
> + }
> +
> + return &stripe->mtd;
> +}
> +
>

> +EXPORT_SYMBOL(mtd_stripe_init);
> +EXPORT_SYMBOL(mtd_stripe_exit);
>
Why do you need these functions exported?
> +/*
> + * This is the handler for our kernel parameter, called from
> + * main.c::checksetup(). Note that we can not yet kmalloc() anything,
> + * so we only save the commandline for later processing.
> + *
> + * This function needs to be visible for bootloaders.
>
Can you please elaborate on this?
> +struct mtd_info *mtd_stripe_create(
> + struct mtd_info *subdev[], /* subdevices to stripe */
> + int num_devs, /* number of subdevices */
> + char *name, /* name for the new device */
> + int inteleave_size); /* interleaving size */
> +
> +
> +struct mtd_info *mtd_stripe_create(struct mtd_info *subdev[], /*
> subdevices to stripe */
> + int num_devs, /*
> number of subdevices */
> + char *name, /* name
> for the new device */
> + int interleave_size); /*
> interleaving size (sanity check is required) */
>
Cool, it's an important func, why not declare it twice? ;)

Vitaly