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