[PATCH] 2.5.17 IDE 70
[opensuse:kernel.git] / drivers / ide / hptraid.c
1 /*
2    hptraid.c  Copyright (C) 2001 Red Hat, Inc. All rights reserved.
3
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation; either version 2, or (at your option)
7    any later version.
8    
9    You should have received a copy of the GNU General Public License
10    (for example /usr/src/linux/COPYING); if not, write to the Free
11    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
12    
13    Authors:     Arjan van de Ven <arjanv@redhat.com>
14
15    Based on work
16         Copyleft  (C) 2001 by Wilfried Weissmann <wweissmann@gmx.at>
17         Copyright (C) 1994-96 Marc ZYNGIER <zyngier@ufr-info-p7.ibp.fr>
18    Based on work done by Søren Schmidt for FreeBSD
19
20    
21 */
22
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/sched.h>
26 #include <linux/smp_lock.h>
27 #include <linux/kernel.h>
28 #include <linux/blkdev.h>
29 #include <linux/blkpg.h>
30 #include <linux/genhd.h>
31 #include <linux/ioctl.h>
32
33 #include <linux/ide.h>
34 #include <asm/uaccess.h>
35
36 #include "ataraid.h"
37
38 static int hptraid_open(struct inode * inode, struct file * filp);
39 static int hptraid_release(struct inode * inode, struct file * filp);
40 static int hptraid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
41 static int hptraid_make_request (request_queue_t *q, int rw, struct buffer_head * bh);
42
43
44
45 struct hptdisk {
46         kdev_t  device;
47         unsigned long sectors;
48         struct block_device *bdev;
49 };
50
51 struct hptraid {
52         unsigned int stride;
53         unsigned int disks;
54         unsigned long sectors;
55         struct geom geom;
56         
57         struct hptdisk disk[8];
58         
59         unsigned long cutoff[8];
60         unsigned int cutoff_disks[8];   
61 };
62
63 static struct raid_device_operations hptraid_ops = {
64         open:                   hptraid_open,
65         release:                hptraid_release,
66         ioctl:                  hptraid_ioctl,
67         make_request:           hptraid_make_request
68 };
69
70 static struct hptraid raid[16];
71
72 static int hptraid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
73 {
74         unsigned int minor;
75         unsigned char val;
76         unsigned long sectors;
77         
78         if (!inode || kdev_none(inode->i_rdev))
79                 return -EINVAL;
80
81         minor = minor(inode->i_rdev)>>SHIFT;
82         
83         switch (cmd) {
84                 case BLKGETSIZE:   /* Return device size */
85                         if (!arg)  return -EINVAL;
86                         sectors = ataraid_gendisk.part[minor(inode->i_rdev)].nr_sects;
87                         if (minor(inode->i_rdev)&15)
88                                 return put_user(sectors, (unsigned long *) arg);
89                         return put_user(raid[minor].sectors , (unsigned long *) arg);
90                         break;
91                         
92
93                 case HDIO_GETGEO:
94                 {
95                         struct hd_geometry *loc = (struct hd_geometry *) arg;
96                         unsigned short bios_cyl;
97                         
98                         if (!loc) return -EINVAL;
99                         val = 255;
100                         if (put_user(val, (byte *) &loc->heads)) return -EFAULT;
101                         val=63;
102                         if (put_user(val, (byte *) &loc->sectors)) return -EFAULT;
103                         bios_cyl = raid[minor].sectors/63/255;
104                         if (put_user(bios_cyl, (unsigned short *) &loc->cylinders)) return -EFAULT;
105                         if (put_user((unsigned)ataraid_gendisk.part[minor(inode->i_rdev)].start_sect,
106                                 (unsigned long *) &loc->start)) return -EFAULT;
107                         return 0;
108                 }
109
110                 case BLKROSET:
111                 case BLKROGET:
112                 case BLKSSZGET:
113                         return blk_ioctl(inode->i_bdev, cmd, arg);
114
115                 default:
116                         return -EINVAL;
117         };
118
119         return 0;
120 }
121
122
123 static int hptraid_make_request (request_queue_t *q, int rw, struct buffer_head * bh)
124 {
125         unsigned long rsect;
126         unsigned long rsect_left,rsect_accum = 0;
127         unsigned long block;
128         unsigned int disk=0,real_disk=0;
129         int i;
130         int device;
131         struct hptraid *thisraid;
132
133         rsect = bh->b_rsector;
134
135         /* Ok. We need to modify this sector number to a new disk + new sector number. 
136          * If there are disks of different sizes, this gets tricky. 
137          * Example with 3 disks (1Gb, 4Gb and 5 GB):
138          * The first 3 Gb of the "RAID" are evenly spread over the 3 disks.
139          * Then things get interesting. The next 2Gb (RAID view) are spread across disk 2 and 3
140          * and the last 1Gb is disk 3 only.
141          *
142          * the way this is solved is like this: We have a list of "cutoff" points where everytime
143          * a disk falls out of the "higher" count, we mark the max sector. So once we pass a cutoff
144          * point, we have to divide by one less.
145          */
146         
147         device = (bh->b_rdev >> SHIFT)&MAJOR_MASK;
148         thisraid = &raid[device];
149         if (thisraid->stride==0)
150                 thisraid->stride=1;
151
152         /* Partitions need adding of the start sector of the partition to the requested sector */
153         
154         rsect += ataraid_gendisk.part[minor(bh->b_rdev)].start_sect;
155
156         /* Woops we need to split the request to avoid crossing a stride barrier */
157         if ((rsect/thisraid->stride) != ((rsect+(bh->b_size/512)-1)/thisraid->stride)) {
158                 return -1;
159         }
160                         
161         rsect_left = rsect;
162         
163         for (i=0;i<8;i++) {
164                 if (thisraid->cutoff_disks[i]==0)
165                         break;
166                 if (rsect > thisraid->cutoff[i]) {
167                         /* we're in the wrong area so far */
168                         rsect_left -= thisraid->cutoff[i];
169                         rsect_accum += thisraid->cutoff[i]/thisraid->cutoff_disks[i];
170                 } else {
171                         block = rsect_left / thisraid->stride;
172                         disk = block % thisraid->cutoff_disks[i];
173                         block = (block / thisraid->cutoff_disks[i]) * thisraid->stride;
174                         rsect = rsect_accum + (rsect_left % thisraid->stride) + block;
175                         break;
176                 }
177         }
178         
179         for (i=0;i<8;i++) {
180                 if ((disk==0) && (thisraid->disk[i].sectors > rsect_accum)) {
181                         real_disk = i;
182                         break;
183                 }
184                 if ((disk>0) && (thisraid->disk[i].sectors >= rsect_accum)) {
185                         disk--;
186                 }
187                 
188         }
189         disk = real_disk;
190         
191         /* All but the first disk have a 10 sector offset */
192         if (i>0)
193                 rsect+=10;
194                 
195         
196         /*
197          * The new BH_Lock semantics in ll_rw_blk.c guarantee that this
198          * is the only IO operation happening on this bh.
199          */
200          
201         bh->b_rdev = thisraid->disk[disk].device;
202         bh->b_rsector = rsect;
203
204         /*
205          * Let the main block layer submit the IO and resolve recursion:
206          */
207         return 1;
208 }
209
210
211 #include "hptraid.h"
212
213 static int __init read_disk_sb(struct block_device *bdev,
214                                 struct highpoint_raid_conf *buf)
215 {
216         /* Superblock is at 9*512 bytes */
217         Sector sect;
218         unsigned char *p = read_dev_sector(bdev, 9, &sect);
219
220         if (p) {
221                 memcpy(buf, p, 512);
222                 put_dev_sector(&sect);
223                 return 0;
224         }
225         printk(KERN_ERR "hptraid: Error reading superblock.\n");
226         return -1;
227 }
228
229 static unsigned long maxsectors (int major,int minor)
230 {
231         unsigned long lba = 0;
232         kdev_t dev;
233         struct ata_device *ideinfo;
234
235         dev = mk_kdev(major,minor);
236         ideinfo = get_info_ptr (dev);
237         if (ideinfo==NULL)
238                 return 0;
239
240
241         /* first sector of the last cluster */
242         if (ideinfo->head==0) 
243                 return 0;
244         if (ideinfo->sect==0)
245                 return 0;
246         lba = (ideinfo->capacity);
247
248         return lba;
249 }
250
251 static struct highpoint_raid_conf __initdata prom;
252 static void __init probedisk(int major, int minor,int device)
253 {
254         int i;
255         struct block_device *bdev = bdget(mk_kdev(major,minor));
256         struct gendisk *gd;
257
258         if (!bdev)
259                 return;
260
261         if (blkdev_get(bdev,FMODE_READ|FMODE_WRITE,0,BDEV_RAW) < 0)
262                 return;
263
264         if (maxsectors(major,minor)==0)
265                 goto out;
266
267         if (read_disk_sb(bdev, &prom))
268                 goto out;
269
270         if (prom.magic!=  0x5a7816f0)
271                 goto out;
272         if (prom.type) {
273                 printk(KERN_INFO "hptraid: only RAID0 is supported currently\n");
274                 goto out;
275         }
276
277         i = prom.disk_number;
278         if (i<0)
279                 goto out;
280         if (i>8) 
281                 goto out;
282
283         raid[device].disk[i].bdev = bdev;
284         /* This is supposed to prevent others from stealing our underlying disks */
285         /* now blank the /proc/partitions table for the wrong partition table,
286            so that scripts don't accidentally mount it and crash the kernel */
287          /* XXX: the 0 is an utter hack  --hch */
288         gd=get_gendisk(mk_kdev(major, 0));
289         if (gd!=NULL) {
290                 int j;
291                 for (j=1+(minor<<gd->minor_shift);j<((minor+1)<<gd->minor_shift);j++) 
292                         gd->part[j].nr_sects=0;                                 
293         }
294
295         raid[device].disk[i].device = mk_kdev(major,minor);
296         raid[device].disk[i].sectors = maxsectors(major,minor);
297         raid[device].stride = (1<<prom.raid0_shift);
298         raid[device].disks = prom.raid_disks;
299         raid[device].sectors = prom.total_secs;
300         return;
301 out:
302         blkdev_put(bdev);
303 }
304
305 static void __init fill_cutoff(int device)
306 {
307         int i,j;
308         unsigned long smallest;
309         unsigned long bar;
310         int count;
311         
312         bar = 0;
313         for (i=0;i<8;i++) {
314                 smallest = ~0;
315                 for (j=0;j<8;j++) 
316                         if ((raid[device].disk[j].sectors < smallest) && (raid[device].disk[j].sectors>bar))
317                                 smallest = raid[device].disk[j].sectors;
318                 count = 0;
319                 for (j=0;j<8;j++) 
320                         if (raid[device].disk[j].sectors >= smallest)
321                                 count++;
322                 
323                 smallest = smallest * count;            
324                 bar = smallest;
325                 raid[device].cutoff[i] = smallest;
326                 raid[device].cutoff_disks[i] = count;
327                 
328         }
329 }
330
331
332 static __init int hptraid_init_one(int device)
333 {
334         int i,count;
335
336         probedisk(IDE0_MAJOR,  0, device);
337         probedisk(IDE0_MAJOR, 64, device);
338         probedisk(IDE1_MAJOR,  0, device);
339         probedisk(IDE1_MAJOR, 64, device);
340         probedisk(IDE2_MAJOR,  0, device);
341         probedisk(IDE2_MAJOR, 64, device);
342         probedisk(IDE3_MAJOR,  0, device);
343         probedisk(IDE3_MAJOR, 64, device);
344                                                                         
345         fill_cutoff(device);
346         
347         /* Initialize the gendisk structure */
348         
349         ataraid_register_disk(device,raid[device].sectors);
350
351         count=0;
352         printk(KERN_INFO "Highpoint HPT370 Softwareraid driver for linux version 0.01\n");
353                 
354         for (i=0;i<8;i++) {
355                 if (raid[device].disk[i].device!=0) {
356                         printk(KERN_INFO "Drive %i is %li Mb \n",
357                                 i,raid[device].disk[i].sectors/2048);
358                         count++;
359                 }
360         }
361         if (count) {
362                 printk(KERN_INFO "Raid array consists of %i drives. \n",count);
363                 return 0;
364         } else {
365                 printk(KERN_INFO "No raid array found\n");
366                 return -ENODEV;
367         }
368         
369 }
370
371 static __init int hptraid_init(void)
372 {
373         int retval,device;
374         
375         device=ataraid_get_device(&hptraid_ops);
376         if (device<0)
377                 return -ENODEV;
378         retval = hptraid_init_one(device);
379         if (retval)
380                 ataraid_release_device(device);
381         return retval;
382 }
383
384 static void __exit hptraid_exit (void)
385 {
386         int i,device;
387         for (device = 0; device<16; device++) {
388                 for (i=0;i<8;i++)  {
389                         struct block_device *bdev = raid[device].disk[i].bdev;
390                         raid[device].disk[i].bdev = NULL;
391                         if (bdev)
392                                 blkdev_put(bdev, BDEV_RAW);
393                 }       
394                 if (raid[device].sectors)
395                         ataraid_release_device(device);
396         }
397 }
398
399 static int hptraid_open(struct inode * inode, struct file * filp) 
400 {
401         MOD_INC_USE_COUNT;
402         return 0;
403 }
404 static int hptraid_release(struct inode * inode, struct file * filp)
405 {       
406         MOD_DEC_USE_COUNT;
407         return 0;
408 }
409
410 module_init(hptraid_init);
411 module_exit(hptraid_exit);
412 MODULE_LICENSE("GPL");