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