drivers/ide/ide-gd.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/module.h>
   3 #include <linux/types.h>
   4 #include <linux/string.h>
   5 #include <linux/kernel.h>
   6 #include <linux/errno.h>
   7 #include <linux/genhd.h>
   8 #include <linux/mutex.h>
   9 #include <linux/ide.h>
  10 #include <linux/hdreg.h>
  11 #include <linux/dmi.h>
  12 #include <linux/slab.h>
  13
  14 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
  15 #define IDE_DISK_MINORS         (1 << PARTN_BITS)
  16 #else
  17 #define IDE_DISK_MINORS         0
  18 #endif
  19
  20 #include "ide-disk.h"
  21 #include "ide-floppy.h"
  22
  23 #define IDE_GD_VERSION  "1.18"
  24
  25 /* module parameters */
  26 static DEFINE_MUTEX(ide_gd_mutex);
  27 static unsigned long debug_mask;
  28 module_param(debug_mask, ulong, 0644);
  29
  30 static DEFINE_MUTEX(ide_disk_ref_mutex);
  31
  32 static void ide_disk_release(struct device *);
  33
  34 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
  35 {
  36         struct ide_disk_obj *idkp = NULL;
  37
  38         mutex_lock(&ide_disk_ref_mutex);
  39         idkp = ide_drv_g(disk, ide_disk_obj);
  40         if (idkp) {
  41                 if (ide_device_get(idkp->drive))
  42                         idkp = NULL;
  43                 else
  44                         get_device(&idkp->dev);
  45         }
  46         mutex_unlock(&ide_disk_ref_mutex);
  47         return idkp;
  48 }
  49
  50 static void ide_disk_put(struct ide_disk_obj *idkp)
  51 {
  52         ide_drive_t *drive = idkp->drive;
  53
  54         mutex_lock(&ide_disk_ref_mutex);
  55         put_device(&idkp->dev);
  56         ide_device_put(drive);
  57         mutex_unlock(&ide_disk_ref_mutex);
  58 }
  59
  60 sector_t ide_gd_capacity(ide_drive_t *drive)
  61 {
  62         return drive->capacity64;
  63 }
  64
  65 static int ide_gd_probe(ide_drive_t *);
  66
  67 static void ide_gd_remove(ide_drive_t *drive)
  68 {
  69         struct ide_disk_obj *idkp = drive->driver_data;
  70         struct gendisk *g = idkp->disk;
  71
  72         ide_proc_unregister_driver(drive, idkp->driver);
  73         device_del(&idkp->dev);
  74         del_gendisk(g);
  75         drive->disk_ops->flush(drive);
  76
  77         mutex_lock(&ide_disk_ref_mutex);
  78         put_device(&idkp->dev);
  79         mutex_unlock(&ide_disk_ref_mutex);
  80 }
  81
  82 static void ide_disk_release(struct device *dev)
  83 {
  84         struct ide_disk_obj *idkp = to_ide_drv(dev, ide_disk_obj);
  85         ide_drive_t *drive = idkp->drive;
  86         struct gendisk *g = idkp->disk;
  87
  88         drive->disk_ops = NULL;
  89         drive->driver_data = NULL;
  90         g->private_data = NULL;
  91         put_disk(g);
  92         kfree(idkp);
  93 }
  94
  95 /*
  96  * On HPA drives the capacity needs to be
  97  * reinitialized on resume otherwise the disk
  98  * can not be used and a hard reset is required
  99  */
 100 static void ide_gd_resume(ide_drive_t *drive)
 101 {
 102         if (ata_id_hpa_enabled(drive->id))
 103                 (void)drive->disk_ops->get_capacity(drive);
 104 }
 105
 106 static const struct dmi_system_id ide_coldreboot_table[] = {
 107         {
 108                 /* Acer TravelMate 66x cuts power during reboot */
 109                 .ident   = "Acer TravelMate 660",
 110                 .matches = {
 111                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 112                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 660"),
 113                 },
 114         },
 115
 116         { }     /* terminate list */
 117 };
 118
 119 static void ide_gd_shutdown(ide_drive_t *drive)
 120 {
 121 #ifdef  CONFIG_ALPHA
 122         /* On Alpha, halt(8) doesn't actually turn the machine off,
 123            it puts you into the sort of firmware monitor. Typically,
 124            it's used to boot another kernel image, so it's not much
 125            different from reboot(8). Therefore, we don't need to
 126            spin down the disk in this case, especially since Alpha
 127            firmware doesn't handle disks in standby mode properly.
 128            On the other hand, it's reasonably safe to turn the power
 129            off when the shutdown process reaches the firmware prompt,
 130            as the firmware initialization takes rather long time -
 131            at least 10 seconds, which should be sufficient for
 132            the disk to expire its write cache. */
 133         if (system_state != SYSTEM_POWER_OFF) {
 134 #else
 135         if (system_state == SYSTEM_RESTART &&
 136                 !dmi_check_system(ide_coldreboot_table)) {
 137 #endif
 138                 drive->disk_ops->flush(drive);
 139                 return;
 140         }
 141
 142         printk(KERN_INFO "Shutdown: %s\n", drive->name);
 143
 144         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
 145 }
 146
 147 #ifdef CONFIG_IDE_PROC_FS
 148 static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
 149 {
 150         return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
 151 }
 152
 153 static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive)
 154 {
 155         return (drive->media == ide_disk) ? ide_disk_settings
 156                                           : ide_floppy_settings;
 157 }
 158 #endif
 159
 160 static ide_startstop_t ide_gd_do_request(ide_drive_t *drive,
 161                                          struct request *rq, sector_t sector)
 162 {
 163         return drive->disk_ops->do_request(drive, rq, sector);
 164 }
 165
 166 static struct ide_driver ide_gd_driver = {
 167         .gen_driver = {
 168                 .owner          = THIS_MODULE,
 169                 .name           = "ide-gd",
 170                 .bus            = &ide_bus_type,
 171         },
 172         .probe                  = ide_gd_probe,
 173         .remove                 = ide_gd_remove,
 174         .resume                 = ide_gd_resume,
 175         .shutdown               = ide_gd_shutdown,
 176         .version                = IDE_GD_VERSION,
 177         .do_request             = ide_gd_do_request,
 178 #ifdef CONFIG_IDE_PROC_FS
 179         .proc_entries           = ide_disk_proc_entries,
 180         .proc_devsets           = ide_disk_proc_devsets,
 181 #endif
 182 };
 183
 184 static int ide_gd_open(struct block_device *bdev, fmode_t mode)
 185 {
 186         struct gendisk *disk = bdev->bd_disk;
 187         struct ide_disk_obj *idkp;
 188         ide_drive_t *drive;
 189         int ret = 0;
 190
 191         idkp = ide_disk_get(disk);
 192         if (idkp == NULL)
 193                 return -ENXIO;
 194
 195         drive = idkp->drive;
 196
 197         ide_debug_log(IDE_DBG_FUNC, "enter");
 198
 199         idkp->openers++;
 200
 201         if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
 202                 drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
 203                 /* Just in case */
 204
 205                 ret = drive->disk_ops->init_media(drive, disk);
 206
 207                 /*
 208                  * Allow O_NDELAY to open a drive without a disk, or with an
 209                  * unreadable disk, so that we can get the format capacity
 210                  * of the drive or begin the format - Sam
 211                  */
 212                 if (ret && (mode & FMODE_NDELAY) == 0) {
 213                         ret = -EIO;
 214                         goto out_put_idkp;
 215                 }
 216
 217                 if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) {
 218                         ret = -EROFS;
 219                         goto out_put_idkp;
 220                 }
 221
 222                 /*
 223                  * Ignore the return code from door_lock,
 224                  * since the open() has already succeeded,
 225                  * and the door_lock is irrelevant at this point.
 226                  */
 227                 drive->disk_ops->set_doorlock(drive, disk, 1);
 228                 if (__invalidate_device(bdev, true))
 229                         pr_warn("VFS: busy inodes on changed media %s\n",
 230                                 bdev->bd_disk->disk_name);
 231                 drive->disk_ops->get_capacity(drive);
 232                 set_capacity(disk, ide_gd_capacity(drive));
 233                 set_bit(GD_NEED_PART_SCAN, &disk->state);
 234         } else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
 235                 ret = -EBUSY;
 236                 goto out_put_idkp;
 237         }
 238         return 0;
 239
 240 out_put_idkp:
 241         idkp->openers--;
 242         ide_disk_put(idkp);
 243         return ret;
 244 }
 245
 246 static int ide_gd_unlocked_open(struct block_device *bdev, fmode_t mode)
 247 {
 248         int ret;
 249
 250         mutex_lock(&ide_gd_mutex);
 251         ret = ide_gd_open(bdev, mode);
 252         mutex_unlock(&ide_gd_mutex);
 253
 254         return ret;
 255 }
 256
 257
 258 static void ide_gd_release(struct gendisk *disk, fmode_t mode)
 259 {
 260         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
 261         ide_drive_t *drive = idkp->drive;
 262
 263         ide_debug_log(IDE_DBG_FUNC, "enter");
 264
 265         mutex_lock(&ide_gd_mutex);
 266         if (idkp->openers == 1)
 267                 drive->disk_ops->flush(drive);
 268
 269         if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
 270                 drive->disk_ops->set_doorlock(drive, disk, 0);
 271                 drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
 272         }
 273
 274         idkp->openers--;
 275
 276         ide_disk_put(idkp);
 277         mutex_unlock(&ide_gd_mutex);
 278 }
 279
 280 static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 281 {
 282         struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
 283         ide_drive_t *drive = idkp->drive;
 284
 285         geo->heads = drive->bios_head;
 286         geo->sectors = drive->bios_sect;
 287         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
 288         return 0;
 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_ioctl(struct block_device *bdev, fmode_t mode,
 302                              unsigned int cmd, unsigned long arg)
 303 {
 304         struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
 305         ide_drive_t *drive = idkp->drive;
 306
 307         return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
 308 }
 309
 310 #ifdef CONFIG_COMPAT
 311 static int ide_gd_compat_ioctl(struct block_device *bdev, fmode_t mode,
 312                                unsigned int cmd, unsigned long arg)
 313 {
 314         struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
 315         ide_drive_t *drive = idkp->drive;
 316
 317         if (!drive->disk_ops->compat_ioctl)
 318                 return -ENOIOCTLCMD;
 319
 320         return drive->disk_ops->compat_ioctl(drive, bdev, mode, cmd, arg);
 321 }
 322 #endif
 323
 324 static const struct block_device_operations ide_gd_ops = {
 325         .owner                  = THIS_MODULE,
 326         .open                   = ide_gd_unlocked_open,
 327         .release                = ide_gd_release,
 328         .ioctl                  = ide_gd_ioctl,
 329 #ifdef CONFIG_COMPAT
 330         .compat_ioctl           = ide_gd_compat_ioctl,
 331 #endif
 332         .getgeo                 = ide_gd_getgeo,
 333         .unlock_native_capacity = ide_gd_unlock_native_capacity,
 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, "%s", 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->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         g->events = DISK_EVENT_MEDIA_CHANGE;
 403         device_add_disk(&drive->gendev, g, NULL);
 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");