Commit | Line | Data |
---|---|---|
09c434b8 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
5fef0e5c BZ |
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> | |
b0aedb04 | 11 | #include <linux/dmi.h> |
5a0e3ad6 | 12 | #include <linux/slab.h> |
5fef0e5c BZ |
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" | |
806f80a6 | 21 | #include "ide-floppy.h" |
5fef0e5c BZ |
22 | |
23 | #define IDE_GD_VERSION "1.18" | |
24 | ||
806f80a6 | 25 | /* module parameters */ |
2a48fc0a | 26 | static DEFINE_MUTEX(ide_gd_mutex); |
806f80a6 BZ |
27 | static unsigned long debug_mask; |
28 | module_param(debug_mask, ulong, 0644); | |
29 | ||
5fef0e5c BZ |
30 | static DEFINE_MUTEX(ide_disk_ref_mutex); |
31 | ||
8fed4368 | 32 | static void ide_disk_release(struct device *); |
5fef0e5c BZ |
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 | |
8fed4368 | 44 | get_device(&idkp->dev); |
5fef0e5c BZ |
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); | |
8fed4368 | 55 | put_device(&idkp->dev); |
5fef0e5c BZ |
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); | |
8fed4368 | 73 | device_del(&idkp->dev); |
5fef0e5c | 74 | del_gendisk(g); |
806f80a6 | 75 | drive->disk_ops->flush(drive); |
5fef0e5c | 76 | |
8fed4368 BZ |
77 | mutex_lock(&ide_disk_ref_mutex); |
78 | put_device(&idkp->dev); | |
79 | mutex_unlock(&ide_disk_ref_mutex); | |
5fef0e5c BZ |
80 | } |
81 | ||
8fed4368 | 82 | static void ide_disk_release(struct device *dev) |
5fef0e5c | 83 | { |
8fed4368 | 84 | struct ide_disk_obj *idkp = to_ide_drv(dev, ide_disk_obj); |
5fef0e5c BZ |
85 | ide_drive_t *drive = idkp->drive; |
86 | struct gendisk *g = idkp->disk; | |
87 | ||
806f80a6 | 88 | drive->disk_ops = NULL; |
5fef0e5c BZ |
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 | |
421f91d2 | 97 | * reinitialized on resume otherwise the disk |
5fef0e5c BZ |
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)) | |
806f80a6 | 103 | (void)drive->disk_ops->get_capacity(drive); |
5fef0e5c BZ |
104 | } |
105 | ||
b0aedb04 BP |
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 | ||
5fef0e5c BZ |
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 | |
b0aedb04 BP |
135 | if (system_state == SYSTEM_RESTART && |
136 | !dmi_check_system(ide_coldreboot_table)) { | |
5fef0e5c | 137 | #endif |
806f80a6 | 138 | drive->disk_ops->flush(drive); |
5fef0e5c BZ |
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 | ||
79cb3803 BZ |
147 | #ifdef CONFIG_IDE_PROC_FS |
148 | static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive) | |
149 | { | |
806f80a6 | 150 | return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc; |
79cb3803 BZ |
151 | } |
152 | ||
153 | static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive) | |
154 | { | |
806f80a6 BZ |
155 | return (drive->media == ide_disk) ? ide_disk_settings |
156 | : ide_floppy_settings; | |
79cb3803 BZ |
157 | } |
158 | #endif | |
159 | ||
806f80a6 BZ |
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 | ||
7f3c868b | 166 | static struct ide_driver ide_gd_driver = { |
5fef0e5c BZ |
167 | .gen_driver = { |
168 | .owner = THIS_MODULE, | |
806f80a6 | 169 | .name = "ide-gd", |
5fef0e5c BZ |
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, | |
806f80a6 | 177 | .do_request = ide_gd_do_request, |
5fef0e5c | 178 | #ifdef CONFIG_IDE_PROC_FS |
79cb3803 BZ |
179 | .proc_entries = ide_disk_proc_entries, |
180 | .proc_devsets = ide_disk_proc_devsets, | |
5fef0e5c BZ |
181 | #endif |
182 | }; | |
183 | ||
b2f21e05 | 184 | static int ide_gd_open(struct block_device *bdev, fmode_t mode) |
5fef0e5c | 185 | { |
b2f21e05 | 186 | struct gendisk *disk = bdev->bd_disk; |
5fef0e5c BZ |
187 | struct ide_disk_obj *idkp; |
188 | ide_drive_t *drive; | |
806f80a6 | 189 | int ret = 0; |
5fef0e5c BZ |
190 | |
191 | idkp = ide_disk_get(disk); | |
192 | if (idkp == NULL) | |
193 | return -ENXIO; | |
194 | ||
195 | drive = idkp->drive; | |
196 | ||
088b1b88 | 197 | ide_debug_log(IDE_DBG_FUNC, "enter"); |
806f80a6 | 198 | |
5fef0e5c BZ |
199 | idkp->openers++; |
200 | ||
201 | if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) { | |
806f80a6 BZ |
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 | */ | |
b2f21e05 | 212 | if (ret && (mode & FMODE_NDELAY) == 0) { |
806f80a6 BZ |
213 | ret = -EIO; |
214 | goto out_put_idkp; | |
215 | } | |
216 | ||
b2f21e05 | 217 | if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) { |
806f80a6 BZ |
218 | ret = -EROFS; |
219 | goto out_put_idkp; | |
220 | } | |
221 | ||
5fef0e5c BZ |
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 | */ | |
806f80a6 | 227 | drive->disk_ops->set_doorlock(drive, disk, 1); |
fec2cf60 CH |
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)); | |
38430f08 | 233 | set_bit(GD_NEED_PART_SCAN, &disk->state); |
806f80a6 BZ |
234 | } else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) { |
235 | ret = -EBUSY; | |
236 | goto out_put_idkp; | |
5fef0e5c BZ |
237 | } |
238 | return 0; | |
806f80a6 BZ |
239 | |
240 | out_put_idkp: | |
241 | idkp->openers--; | |
242 | ide_disk_put(idkp); | |
243 | return ret; | |
5fef0e5c BZ |
244 | } |
245 | ||
6e9624b8 AB |
246 | static int ide_gd_unlocked_open(struct block_device *bdev, fmode_t mode) |
247 | { | |
248 | int ret; | |
249 | ||
2a48fc0a | 250 | mutex_lock(&ide_gd_mutex); |
6e9624b8 | 251 | ret = ide_gd_open(bdev, mode); |
2a48fc0a | 252 | mutex_unlock(&ide_gd_mutex); |
6e9624b8 AB |
253 | |
254 | return ret; | |
255 | } | |
256 | ||
257 | ||
db2a144b | 258 | static void ide_gd_release(struct gendisk *disk, fmode_t mode) |
5fef0e5c | 259 | { |
5fef0e5c BZ |
260 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); |
261 | ide_drive_t *drive = idkp->drive; | |
262 | ||
088b1b88 | 263 | ide_debug_log(IDE_DBG_FUNC, "enter"); |
806f80a6 | 264 | |
2a48fc0a | 265 | mutex_lock(&ide_gd_mutex); |
5fef0e5c | 266 | if (idkp->openers == 1) |
806f80a6 | 267 | drive->disk_ops->flush(drive); |
5fef0e5c | 268 | |
806f80a6 BZ |
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 | } | |
5fef0e5c BZ |
273 | |
274 | idkp->openers--; | |
275 | ||
276 | ide_disk_put(idkp); | |
2a48fc0a | 277 | mutex_unlock(&ide_gd_mutex); |
5fef0e5c BZ |
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 | ||
c3e33e04 | 291 | static void ide_gd_unlock_native_capacity(struct gendisk *disk) |
e957b60d BZ |
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 | ||
c3e33e04 TH |
297 | if (disk_ops->unlock_native_capacity) |
298 | disk_ops->unlock_native_capacity(drive); | |
e957b60d BZ |
299 | } |
300 | ||
b2f21e05 | 301 | static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode, |
806f80a6 BZ |
302 | unsigned int cmd, unsigned long arg) |
303 | { | |
806f80a6 BZ |
304 | struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj); |
305 | ide_drive_t *drive = idkp->drive; | |
306 | ||
b2f21e05 | 307 | return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg); |
806f80a6 BZ |
308 | } |
309 | ||
c103d6ee AB |
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 | ||
83d5cde4 | 324 | static const struct block_device_operations ide_gd_ops = { |
5fef0e5c | 325 | .owner = THIS_MODULE, |
6e9624b8 | 326 | .open = ide_gd_unlocked_open, |
b2f21e05 | 327 | .release = ide_gd_release, |
8a6cfeb6 | 328 | .ioctl = ide_gd_ioctl, |
c103d6ee | 329 | #ifdef CONFIG_COMPAT |
03264ddd | 330 | .compat_ioctl = ide_gd_compat_ioctl, |
c103d6ee | 331 | #endif |
5fef0e5c | 332 | .getgeo = ide_gd_getgeo, |
c3e33e04 | 333 | .unlock_native_capacity = ide_gd_unlock_native_capacity, |
5fef0e5c BZ |
334 | }; |
335 | ||
336 | static int ide_gd_probe(ide_drive_t *drive) | |
337 | { | |
806f80a6 | 338 | const struct ide_disk_ops *disk_ops = NULL; |
5fef0e5c BZ |
339 | struct ide_disk_obj *idkp; |
340 | struct gendisk *g; | |
341 | ||
342 | /* strstr("foo", "") is non-NULL */ | |
806f80a6 BZ |
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) | |
5fef0e5c BZ |
355 | goto failed; |
356 | ||
806f80a6 BZ |
357 | if (disk_ops->check(drive, DRV_NAME) == 0) { |
358 | printk(KERN_ERR PFX "%s: not supported by this driver\n", | |
359 | drive->name); | |
5fef0e5c | 360 | goto failed; |
806f80a6 | 361 | } |
5fef0e5c BZ |
362 | |
363 | idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); | |
806f80a6 BZ |
364 | if (!idkp) { |
365 | printk(KERN_ERR PFX "%s: can't allocate a disk structure\n", | |
366 | drive->name); | |
5fef0e5c | 367 | goto failed; |
806f80a6 | 368 | } |
5fef0e5c BZ |
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 | ||
8fed4368 BZ |
376 | idkp->dev.parent = &drive->gendev; |
377 | idkp->dev.release = ide_disk_release; | |
02aa2a37 | 378 | dev_set_name(&idkp->dev, "%s", dev_name(&drive->gendev)); |
8fed4368 BZ |
379 | |
380 | if (device_register(&idkp->dev)) | |
381 | goto out_free_disk; | |
5fef0e5c BZ |
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; | |
806f80a6 BZ |
390 | drive->debug_mask = debug_mask; |
391 | drive->disk_ops = disk_ops; | |
5fef0e5c | 392 | |
806f80a6 | 393 | disk_ops->setup(drive); |
5fef0e5c BZ |
394 | |
395 | set_capacity(g, ide_gd_capacity(drive)); | |
396 | ||
397 | g->minors = IDE_DISK_MINORS; | |
5fef0e5c BZ |
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; | |
3c12c8e9 | 402 | g->events = DISK_EVENT_MEDIA_CHANGE; |
fef912bf | 403 | device_add_disk(&drive->gendev, g, NULL); |
5fef0e5c BZ |
404 | return 0; |
405 | ||
8fed4368 BZ |
406 | out_free_disk: |
407 | put_disk(g); | |
5fef0e5c BZ |
408 | out_free_idkp: |
409 | kfree(idkp); | |
410 | failed: | |
411 | return -ENODEV; | |
412 | } | |
413 | ||
414 | static int __init ide_gd_init(void) | |
415 | { | |
806f80a6 | 416 | printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n"); |
5fef0e5c BZ |
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"); | |
806f80a6 BZ |
427 | MODULE_ALIAS("ide:*m-floppy*"); |
428 | MODULE_ALIAS("ide-floppy"); | |
5fef0e5c BZ |
429 | module_init(ide_gd_init); |
430 | module_exit(ide_gd_exit); | |
431 | MODULE_LICENSE("GPL"); | |
806f80a6 | 432 | MODULE_DESCRIPTION("generic ATA/ATAPI disk driver"); |