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
ide_disk_get(struct gendisk * disk)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
ide_disk_put(struct ide_disk_obj * idkp)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
ide_gd_capacity(ide_drive_t * drive)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
ide_gd_remove(ide_drive_t * drive)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
ide_disk_release(struct device * dev)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 */
ide_gd_resume(ide_drive_t * drive)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
ide_gd_shutdown(ide_drive_t * drive)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");
433
