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 unsigned long long ide_gd_set_capacity(struct gendisk *disk,
 292                                               unsigned long long capacity)
 293 {
 294         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
 295         ide_drive_t *drive = idkp->drive;
 296         const struct ide_disk_ops *disk_ops = drive->disk_ops;
 297
 298         if (disk_ops->set_capacity)
 299                 return disk_ops->set_capacity(drive, capacity);
 300
 301         return drive->capacity64;
 302 }
 303
 304 static int ide_gd_revalidate_disk(struct gendisk *disk)
 305 {
 306         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
 307         ide_drive_t *drive = idkp->drive;
 308
 309         if (ide_gd_media_changed(disk))
 310                 drive->disk_ops->get_capacity(drive);
 311
 312         set_capacity(disk, ide_gd_capacity(drive));
 313         return 0;
 314 }
 315
 316 static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
 317                              unsigned int cmd, unsigned long arg)
 318 {
 319         struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
 320         ide_drive_t *drive = idkp->drive;
 321
 322         return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
 323 }
 324
 325 static const struct block_device_operations ide_gd_ops = {
 326         .owner                  = THIS_MODULE,
 327         .open                   = ide_gd_open,
 328         .release                = ide_gd_release,
 329         .locked_ioctl           = ide_gd_ioctl,
 330         .getgeo                 = ide_gd_getgeo,
 331         .media_changed          = ide_gd_media_changed,
 332         .set_capacity           = ide_gd_set_capacity,
 333         .revalidate_disk        = ide_gd_revalidate_disk
 334 };
 335
 336 static int ide_gd_probe(ide_drive_t *drive)
 337 {
 338         const struct ide_disk_ops *disk_ops = NULL;
 339         struct ide_disk_obj *idkp;
 340         struct gendisk *g;
 341
 342         /* strstr("foo", "") is non-NULL */
 343         if (!strstr("ide-gd", drive->driver_req))
 344                 goto failed;
 345
 346 #ifdef CONFIG_IDE_GD_ATA
 347         if (drive->media == ide_disk)
 348                 disk_ops = &ide_ata_disk_ops;
 349 #endif
 350 #ifdef CONFIG_IDE_GD_ATAPI
 351         if (drive->media == ide_floppy)
 352                 disk_ops = &ide_atapi_disk_ops;
 353 #endif
 354         if (disk_ops == NULL)
 355                 goto failed;
 356
 357         if (disk_ops->check(drive, DRV_NAME) == 0) {
 358                 printk(KERN_ERR PFX "%s: not supported by this driver\n",
 359                         drive->name);
 360                 goto failed;
 361         }
 362
 363         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
 364         if (!idkp) {
 365                 printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
 366                         drive->name);
 367                 goto failed;
 368         }
 369
 370         g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
 371         if (!g)
 372                 goto out_free_idkp;
 373
 374         ide_init_disk(g, drive);
 375
 376         idkp->dev.parent = &drive->gendev;
 377         idkp->dev.release = ide_disk_release;
 378         dev_set_name(&idkp->dev, dev_name(&drive->gendev));
 379
 380         if (device_register(&idkp->dev))
 381                 goto out_free_disk;
 382
 383         idkp->drive = drive;
 384         idkp->driver = &ide_gd_driver;
 385         idkp->disk = g;
 386
 387         g->private_data = &idkp->driver;
 388
 389         drive->driver_data = idkp;
 390         drive->debug_mask = debug_mask;
 391         drive->disk_ops = disk_ops;
 392
 393         disk_ops->setup(drive);
 394
 395         set_capacity(g, ide_gd_capacity(drive));
 396
 397         g->minors = IDE_DISK_MINORS;
 398         g->driverfs_dev = &drive->gendev;
 399         g->flags |= GENHD_FL_EXT_DEVT;
 400         if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
 401                 g->flags = GENHD_FL_REMOVABLE;
 402         g->fops = &ide_gd_ops;
 403         add_disk(g);
 404         return 0;
 405
 406 out_free_disk:
 407         put_disk(g);
 408 out_free_idkp:
 409         kfree(idkp);
 410 failed:
 411         return -ENODEV;
 412 }
 413
 414 static int __init ide_gd_init(void)
 415 {
 416         printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
 417         return driver_register(&ide_gd_driver.gen_driver);
 418 }
 419
 420 static void __exit ide_gd_exit(void)
 421 {
 422         driver_unregister(&ide_gd_driver.gen_driver);
 423 }
 424
 425 MODULE_ALIAS("ide:*m-disk*");
 426 MODULE_ALIAS("ide-disk");
 427 MODULE_ALIAS("ide:*m-floppy*");
 428 MODULE_ALIAS("ide-floppy");
 429 module_init(ide_gd_init);
 430 module_exit(ide_gd_exit);
 431 MODULE_LICENSE("GPL");
 432 MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");