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