S3C: Backported openmoko's touchscreen filters
[linux-2.6/mini2440.git] / drivers / ide / ide-gd.c
blob753241429c26b4e9b370c72e388a79990a780028
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>
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
18 #include "ide-disk.h"
19 #include "ide-floppy.h"
21 #define IDE_GD_VERSION "1.18"
23 /* module parameters */
24 static unsigned long debug_mask;
25 module_param(debug_mask, ulong, 0644);
27 static DEFINE_MUTEX(ide_disk_ref_mutex);
29 static void ide_disk_release(struct device *);
31 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
33 struct ide_disk_obj *idkp = NULL;
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);
43 mutex_unlock(&ide_disk_ref_mutex);
44 return idkp;
47 static void ide_disk_put(struct ide_disk_obj *idkp)
49 ide_drive_t *drive = idkp->drive;
51 mutex_lock(&ide_disk_ref_mutex);
52 put_device(&idkp->dev);
53 ide_device_put(drive);
54 mutex_unlock(&ide_disk_ref_mutex);
57 sector_t ide_gd_capacity(ide_drive_t *drive)
59 return drive->capacity64;
62 static int ide_gd_probe(ide_drive_t *);
64 static void ide_gd_remove(ide_drive_t *drive)
66 struct ide_disk_obj *idkp = drive->driver_data;
67 struct gendisk *g = idkp->disk;
69 ide_proc_unregister_driver(drive, idkp->driver);
70 device_del(&idkp->dev);
71 del_gendisk(g);
72 drive->disk_ops->flush(drive);
74 mutex_lock(&ide_disk_ref_mutex);
75 put_device(&idkp->dev);
76 mutex_unlock(&ide_disk_ref_mutex);
79 static void ide_disk_release(struct device *dev)
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;
85 drive->disk_ops = NULL;
86 drive->driver_data = NULL;
87 g->private_data = NULL;
88 put_disk(g);
89 kfree(idkp);
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
97 static void ide_gd_resume(ide_drive_t *drive)
99 if (ata_id_hpa_enabled(drive->id))
100 (void)drive->disk_ops->get_capacity(drive);
103 static const struct dmi_system_id ide_coldreboot_table[] = {
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"),
113 { } /* terminate list */
116 static void ide_gd_shutdown(ide_drive_t *drive)
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;
139 printk(KERN_INFO "Shutdown: %s\n", drive->name);
141 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
144 #ifdef CONFIG_IDE_PROC_FS
145 static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
147 return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
150 static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive)
152 return (drive->media == ide_disk) ? ide_disk_settings
153 : ide_floppy_settings;
155 #endif
157 static ide_startstop_t ide_gd_do_request(ide_drive_t *drive,
158 struct request *rq, sector_t sector)
160 return drive->disk_ops->do_request(drive, rq, sector);
163 static struct ide_driver ide_gd_driver = {
164 .gen_driver = {
165 .owner = THIS_MODULE,
166 .name = "ide-gd",
167 .bus = &ide_bus_type,
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
181 static int ide_gd_open(struct block_device *bdev, fmode_t mode)
183 struct gendisk *disk = bdev->bd_disk;
184 struct ide_disk_obj *idkp;
185 ide_drive_t *drive;
186 int ret = 0;
188 idkp = ide_disk_get(disk);
189 if (idkp == NULL)
190 return -ENXIO;
192 drive = idkp->drive;
194 ide_debug_log(IDE_DBG_FUNC, "enter");
196 idkp->openers++;
198 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
199 drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
200 /* Just in case */
202 ret = drive->disk_ops->init_media(drive, disk);
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
209 if (ret && (mode & FMODE_NDELAY) == 0) {
210 ret = -EIO;
211 goto out_put_idkp;
214 if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) {
215 ret = -EROFS;
216 goto out_put_idkp;
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.
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;
231 return 0;
233 out_put_idkp:
234 idkp->openers--;
235 ide_disk_put(idkp);
236 return ret;
239 static int ide_gd_release(struct gendisk *disk, fmode_t mode)
241 struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
242 ide_drive_t *drive = idkp->drive;
244 ide_debug_log(IDE_DBG_FUNC, "enter");
246 if (idkp->openers == 1)
247 drive->disk_ops->flush(drive);
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;
254 idkp->openers--;
256 ide_disk_put(idkp);
258 return 0;
261 static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
263 struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
264 ide_drive_t *drive = idkp->drive;
266 geo->heads = drive->bios_head;
267 geo->sectors = drive->bios_sect;
268 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
269 return 0;
272 static int ide_gd_media_changed(struct gendisk *disk)
274 struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
275 ide_drive_t *drive = idkp->drive;
276 int ret;
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;
284 ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
285 drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
287 return ret;
290 static unsigned long long ide_gd_set_capacity(struct gendisk *disk,
291 unsigned long long capacity)
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;
297 if (disk_ops->set_capacity)
298 return disk_ops->set_capacity(drive, capacity);
300 return drive->capacity64;
303 static int ide_gd_revalidate_disk(struct gendisk *disk)
305 struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
306 ide_drive_t *drive = idkp->drive;
308 if (ide_gd_media_changed(disk))
309 drive->disk_ops->get_capacity(drive);
311 set_capacity(disk, ide_gd_capacity(drive));
312 return 0;
315 static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
316 unsigned int cmd, unsigned long arg)
318 struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
319 ide_drive_t *drive = idkp->drive;
321 return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
324 static const 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
335 static int ide_gd_probe(ide_drive_t *drive)
337 const struct ide_disk_ops *disk_ops = NULL;
338 struct ide_disk_obj *idkp;
339 struct gendisk *g;
341 /* strstr("foo", "") is non-NULL */
342 if (!strstr("ide-gd", drive->driver_req))
343 goto failed;
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;
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;
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;
369 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
370 if (!g)
371 goto out_free_idkp;
373 ide_init_disk(g, drive);
375 idkp->dev.parent = &drive->gendev;
376 idkp->dev.release = ide_disk_release;
377 dev_set_name(&idkp->dev, dev_name(&drive->gendev));
379 if (device_register(&idkp->dev))
380 goto out_free_disk;
382 idkp->drive = drive;
383 idkp->driver = &ide_gd_driver;
384 idkp->disk = g;
386 g->private_data = &idkp->driver;
388 drive->driver_data = idkp;
389 drive->debug_mask = debug_mask;
390 drive->disk_ops = disk_ops;
392 disk_ops->setup(drive);
394 set_capacity(g, ide_gd_capacity(drive));
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;
405 out_free_disk:
406 put_disk(g);
407 out_free_idkp:
408 kfree(idkp);
409 failed:
410 return -ENODEV;
413 static int __init ide_gd_init(void)
415 printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
416 return driver_register(&ide_gd_driver.gen_driver);
419 static void __exit ide_gd_exit(void)
421 driver_unregister(&ide_gd_driver.gen_driver);
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");