Merge branch 'perfcounters-fixes-for-linus' of git://git.kernel.org/pub/scm/linux...
[linux-2.6] / drivers / ide / ide-gd.c
1 #include <linux/module.h>
2 #include <linux/types.h>
3 #include <linux/string.h>
4 #include <linux/kernel.h>
5 #include <linux/errno.h>
6 #include <linux/genhd.h>
7 #include <linux/mutex.h>
8 #include <linux/ide.h>
9 #include <linux/hdreg.h>
10 #include <linux/dmi.h>
11
12 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
13 #define IDE_DISK_MINORS         (1 << PARTN_BITS)
14 #else
15 #define IDE_DISK_MINORS         0
16 #endif
17
18 #include "ide-disk.h"
19 #include "ide-floppy.h"
20
21 #define IDE_GD_VERSION  "1.18"
22
23 /* module parameters */
24 static unsigned long debug_mask;
25 module_param(debug_mask, ulong, 0644);
26
27 static DEFINE_MUTEX(ide_disk_ref_mutex);
28
29 static void ide_disk_release(struct device *);
30
31 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
32 {
33         struct ide_disk_obj *idkp = NULL;
34
35         mutex_lock(&ide_disk_ref_mutex);
36         idkp = ide_drv_g(disk, ide_disk_obj);
37         if (idkp) {
38                 if (ide_device_get(idkp->drive))
39                         idkp = NULL;
40                 else
41                         get_device(&idkp->dev);
42         }
43         mutex_unlock(&ide_disk_ref_mutex);
44         return idkp;
45 }
46
47 static void ide_disk_put(struct ide_disk_obj *idkp)
48 {
49         ide_drive_t *drive = idkp->drive;
50
51         mutex_lock(&ide_disk_ref_mutex);
52         put_device(&idkp->dev);
53         ide_device_put(drive);
54         mutex_unlock(&ide_disk_ref_mutex);
55 }
56
57 sector_t ide_gd_capacity(ide_drive_t *drive)
58 {
59         return drive->capacity64;
60 }
61
62 static int ide_gd_probe(ide_drive_t *);
63
64 static void ide_gd_remove(ide_drive_t *drive)
65 {
66         struct ide_disk_obj *idkp = drive->driver_data;
67         struct gendisk *g = idkp->disk;
68
69         ide_proc_unregister_driver(drive, idkp->driver);
70         device_del(&idkp->dev);
71         del_gendisk(g);
72         drive->disk_ops->flush(drive);
73
74         mutex_lock(&ide_disk_ref_mutex);
75         put_device(&idkp->dev);
76         mutex_unlock(&ide_disk_ref_mutex);
77 }
78
79 static void ide_disk_release(struct device *dev)
80 {
81         struct ide_disk_obj *idkp = to_ide_drv(dev, ide_disk_obj);
82         ide_drive_t *drive = idkp->drive;
83         struct gendisk *g = idkp->disk;
84
85         drive->disk_ops = NULL;
86         drive->driver_data = NULL;
87         g->private_data = NULL;
88         put_disk(g);
89         kfree(idkp);
90 }
91
92 /*
93  * On HPA drives the capacity needs to be
94  * reinitilized on resume otherwise the disk
95  * can not be used and a hard reset is required
96  */
97 static void ide_gd_resume(ide_drive_t *drive)
98 {
99         if (ata_id_hpa_enabled(drive->id))
100                 (void)drive->disk_ops->get_capacity(drive);
101 }
102
103 static const struct dmi_system_id ide_coldreboot_table[] = {
104         {
105                 /* Acer TravelMate 66x cuts power during reboot */
106                 .ident   = "Acer TravelMate 660",
107                 .matches = {
108                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
109                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 660"),
110                 },
111         },
112
113         { }     /* terminate list */
114 };
115
116 static void ide_gd_shutdown(ide_drive_t *drive)
117 {
118 #ifdef  CONFIG_ALPHA
119         /* On Alpha, halt(8) doesn't actually turn the machine off,
120            it puts you into the sort of firmware monitor. Typically,
121            it's used to boot another kernel image, so it's not much
122            different from reboot(8). Therefore, we don't need to
123            spin down the disk in this case, especially since Alpha
124            firmware doesn't handle disks in standby mode properly.
125            On the other hand, it's reasonably safe to turn the power
126            off when the shutdown process reaches the firmware prompt,
127            as the firmware initialization takes rather long time -
128            at least 10 seconds, which should be sufficient for
129            the disk to expire its write cache. */
130         if (system_state != SYSTEM_POWER_OFF) {
131 #else
132         if (system_state == SYSTEM_RESTART &&
133                 !dmi_check_system(ide_coldreboot_table)) {
134 #endif
135                 drive->disk_ops->flush(drive);
136                 return;
137         }
138
139         printk(KERN_INFO "Shutdown: %s\n", drive->name);
140
141         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
142 }
143
144 #ifdef CONFIG_IDE_PROC_FS
145 static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
146 {
147         return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
148 }
149
150 static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive)
151 {
152         return (drive->media == ide_disk) ? ide_disk_settings
153                                           : ide_floppy_settings;
154 }
155 #endif
156
157 static ide_startstop_t ide_gd_do_request(ide_drive_t *drive,
158                                          struct request *rq, sector_t sector)
159 {
160         return drive->disk_ops->do_request(drive, rq, sector);
161 }
162
163 static struct ide_driver ide_gd_driver = {
164         .gen_driver = {
165                 .owner          = THIS_MODULE,
166                 .name           = "ide-gd",
167                 .bus            = &ide_bus_type,
168         },
169         .probe                  = ide_gd_probe,
170         .remove                 = ide_gd_remove,
171         .resume                 = ide_gd_resume,
172         .shutdown               = ide_gd_shutdown,
173         .version                = IDE_GD_VERSION,
174         .do_request             = ide_gd_do_request,
175 #ifdef CONFIG_IDE_PROC_FS
176         .proc_entries           = ide_disk_proc_entries,
177         .proc_devsets           = ide_disk_proc_devsets,
178 #endif
179 };
180
181 static int ide_gd_open(struct block_device *bdev, fmode_t mode)
182 {
183         struct gendisk *disk = bdev->bd_disk;
184         struct ide_disk_obj *idkp;
185         ide_drive_t *drive;
186         int ret = 0;
187
188         idkp = ide_disk_get(disk);
189         if (idkp == NULL)
190                 return -ENXIO;
191
192         drive = idkp->drive;
193
194         ide_debug_log(IDE_DBG_FUNC, "enter");
195
196         idkp->openers++;
197
198         if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
199                 drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
200                 /* Just in case */
201
202                 ret = drive->disk_ops->init_media(drive, disk);
203
204                 /*
205                  * Allow O_NDELAY to open a drive without a disk, or with an
206                  * unreadable disk, so that we can get the format capacity
207                  * of the drive or begin the format - Sam
208                  */
209                 if (ret && (mode & FMODE_NDELAY) == 0) {
210                         ret = -EIO;
211                         goto out_put_idkp;
212                 }
213
214                 if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) {
215                         ret = -EROFS;
216                         goto out_put_idkp;
217                 }
218
219                 /*
220                  * Ignore the return code from door_lock,
221                  * since the open() has already succeeded,
222                  * and the door_lock is irrelevant at this point.
223                  */
224                 drive->disk_ops->set_doorlock(drive, disk, 1);
225                 drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
226                 check_disk_change(bdev);
227         } else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
228                 ret = -EBUSY;
229                 goto out_put_idkp;
230         }
231         return 0;
232
233 out_put_idkp:
234         idkp->openers--;
235         ide_disk_put(idkp);
236         return ret;
237 }
238
239 static int ide_gd_release(struct gendisk *disk, fmode_t mode)
240 {
241         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
242         ide_drive_t *drive = idkp->drive;
243
244         ide_debug_log(IDE_DBG_FUNC, "enter");
245
246         if (idkp->openers == 1)
247                 drive->disk_ops->flush(drive);
248
249         if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
250                 drive->disk_ops->set_doorlock(drive, disk, 0);
251                 drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
252         }
253
254         idkp->openers--;
255
256         ide_disk_put(idkp);
257
258         return 0;
259 }
260
261 static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
262 {
263         struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
264         ide_drive_t *drive = idkp->drive;
265
266         geo->heads = drive->bios_head;
267         geo->sectors = drive->bios_sect;
268         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
269         return 0;
270 }
271
272 static int ide_gd_media_changed(struct gendisk *disk)
273 {
274         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
275         ide_drive_t *drive = idkp->drive;
276         int ret;
277
278         /* do not scan partitions twice if this is a removable device */
279         if (drive->dev_flags & IDE_DFLAG_ATTACH) {
280                 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
281                 return 0;
282         }
283
284         ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
285         drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
286
287         return ret;
288 }
289
290 static unsigned long long ide_gd_set_capacity(struct gendisk *disk,
291                                               unsigned long long capacity)
292 {
293         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
294         ide_drive_t *drive = idkp->drive;
295         const struct ide_disk_ops *disk_ops = drive->disk_ops;
296
297         if (disk_ops->set_capacity)
298                 return disk_ops->set_capacity(drive, capacity);
299
300         return drive->capacity64;
301 }
302
303 static int ide_gd_revalidate_disk(struct gendisk *disk)
304 {
305         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
306         ide_drive_t *drive = idkp->drive;
307
308         if (ide_gd_media_changed(disk))
309                 drive->disk_ops->get_capacity(drive);
310
311         set_capacity(disk, ide_gd_capacity(drive));
312         return 0;
313 }
314
315 static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
316                              unsigned int cmd, unsigned long arg)
317 {
318         struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
319         ide_drive_t *drive = idkp->drive;
320
321         return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
322 }
323
324 static struct block_device_operations ide_gd_ops = {
325         .owner                  = THIS_MODULE,
326         .open                   = ide_gd_open,
327         .release                = ide_gd_release,
328         .locked_ioctl           = ide_gd_ioctl,
329         .getgeo                 = ide_gd_getgeo,
330         .media_changed          = ide_gd_media_changed,
331         .set_capacity           = ide_gd_set_capacity,
332         .revalidate_disk        = ide_gd_revalidate_disk
333 };
334
335 static int ide_gd_probe(ide_drive_t *drive)
336 {
337         const struct ide_disk_ops *disk_ops = NULL;
338         struct ide_disk_obj *idkp;
339         struct gendisk *g;
340
341         /* strstr("foo", "") is non-NULL */
342         if (!strstr("ide-gd", drive->driver_req))
343                 goto failed;
344
345 #ifdef CONFIG_IDE_GD_ATA
346         if (drive->media == ide_disk)
347                 disk_ops = &ide_ata_disk_ops;
348 #endif
349 #ifdef CONFIG_IDE_GD_ATAPI
350         if (drive->media == ide_floppy)
351                 disk_ops = &ide_atapi_disk_ops;
352 #endif
353         if (disk_ops == NULL)
354                 goto failed;
355
356         if (disk_ops->check(drive, DRV_NAME) == 0) {
357                 printk(KERN_ERR PFX "%s: not supported by this driver\n",
358                         drive->name);
359                 goto failed;
360         }
361
362         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
363         if (!idkp) {
364                 printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
365                         drive->name);
366                 goto failed;
367         }
368
369         g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
370         if (!g)
371                 goto out_free_idkp;
372
373         ide_init_disk(g, drive);
374
375         idkp->dev.parent = &drive->gendev;
376         idkp->dev.release = ide_disk_release;
377         dev_set_name(&idkp->dev, dev_name(&drive->gendev));
378
379         if (device_register(&idkp->dev))
380                 goto out_free_disk;
381
382         idkp->drive = drive;
383         idkp->driver = &ide_gd_driver;
384         idkp->disk = g;
385
386         g->private_data = &idkp->driver;
387
388         drive->driver_data = idkp;
389         drive->debug_mask = debug_mask;
390         drive->disk_ops = disk_ops;
391
392         disk_ops->setup(drive);
393
394         set_capacity(g, ide_gd_capacity(drive));
395
396         g->minors = IDE_DISK_MINORS;
397         g->driverfs_dev = &drive->gendev;
398         g->flags |= GENHD_FL_EXT_DEVT;
399         if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
400                 g->flags = GENHD_FL_REMOVABLE;
401         g->fops = &ide_gd_ops;
402         add_disk(g);
403         return 0;
404
405 out_free_disk:
406         put_disk(g);
407 out_free_idkp:
408         kfree(idkp);
409 failed:
410         return -ENODEV;
411 }
412
413 static int __init ide_gd_init(void)
414 {
415         printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
416         return driver_register(&ide_gd_driver.gen_driver);
417 }
418
419 static void __exit ide_gd_exit(void)
420 {
421         driver_unregister(&ide_gd_driver.gen_driver);
422 }
423
424 MODULE_ALIAS("ide:*m-disk*");
425 MODULE_ALIAS("ide-disk");
426 MODULE_ALIAS("ide:*m-floppy*");
427 MODULE_ALIAS("ide-floppy");
428 module_init(ide_gd_init);
429 module_exit(ide_gd_exit);
430 MODULE_LICENSE("GPL");
431 MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");