Commit | Line | Data |
---|---|---|
5fef0e5c BZ |
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 | ||
11 | #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT) | |
12 | #define IDE_DISK_MINORS (1 << PARTN_BITS) | |
13 | #else | |
14 | #define IDE_DISK_MINORS 0 | |
15 | #endif | |
16 | ||
17 | #include "ide-disk.h" | |
806f80a6 | 18 | #include "ide-floppy.h" |
5fef0e5c BZ |
19 | |
20 | #define IDE_GD_VERSION "1.18" | |
21 | ||
806f80a6 BZ |
22 | /* module parameters */ |
23 | static unsigned long debug_mask; | |
24 | module_param(debug_mask, ulong, 0644); | |
25 | ||
5fef0e5c BZ |
26 | static DEFINE_MUTEX(ide_disk_ref_mutex); |
27 | ||
8fed4368 | 28 | static void ide_disk_release(struct device *); |
5fef0e5c BZ |
29 | |
30 | static struct ide_disk_obj *ide_disk_get(struct gendisk *disk) | |
31 | { | |
32 | struct ide_disk_obj *idkp = NULL; | |
33 | ||
34 | mutex_lock(&ide_disk_ref_mutex); | |
35 | idkp = ide_drv_g(disk, ide_disk_obj); | |
36 | if (idkp) { | |
37 | if (ide_device_get(idkp->drive)) | |
38 | idkp = NULL; | |
39 | else | |
8fed4368 | 40 | get_device(&idkp->dev); |
5fef0e5c BZ |
41 | } |
42 | mutex_unlock(&ide_disk_ref_mutex); | |
43 | return idkp; | |
44 | } | |
45 | ||
46 | static void ide_disk_put(struct ide_disk_obj *idkp) | |
47 | { | |
48 | ide_drive_t *drive = idkp->drive; | |
49 | ||
50 | mutex_lock(&ide_disk_ref_mutex); | |
8fed4368 | 51 | put_device(&idkp->dev); |
5fef0e5c BZ |
52 | ide_device_put(drive); |
53 | mutex_unlock(&ide_disk_ref_mutex); | |
54 | } | |
55 | ||
56 | sector_t ide_gd_capacity(ide_drive_t *drive) | |
57 | { | |
58 | return drive->capacity64; | |
59 | } | |
60 | ||
61 | static int ide_gd_probe(ide_drive_t *); | |
62 | ||
63 | static void ide_gd_remove(ide_drive_t *drive) | |
64 | { | |
65 | struct ide_disk_obj *idkp = drive->driver_data; | |
66 | struct gendisk *g = idkp->disk; | |
67 | ||
68 | ide_proc_unregister_driver(drive, idkp->driver); | |
8fed4368 | 69 | device_del(&idkp->dev); |
5fef0e5c | 70 | del_gendisk(g); |
806f80a6 | 71 | drive->disk_ops->flush(drive); |
5fef0e5c | 72 | |
8fed4368 BZ |
73 | mutex_lock(&ide_disk_ref_mutex); |
74 | put_device(&idkp->dev); | |
75 | mutex_unlock(&ide_disk_ref_mutex); | |
5fef0e5c BZ |
76 | } |
77 | ||
8fed4368 | 78 | static void ide_disk_release(struct device *dev) |
5fef0e5c | 79 | { |
8fed4368 | 80 | struct ide_disk_obj *idkp = to_ide_drv(dev, ide_disk_obj); |
5fef0e5c BZ |
81 | ide_drive_t *drive = idkp->drive; |
82 | struct gendisk *g = idkp->disk; | |
83 | ||
806f80a6 | 84 | drive->disk_ops = NULL; |
5fef0e5c BZ |
85 | drive->driver_data = NULL; |
86 | g->private_data = NULL; | |
87 | put_disk(g); | |
88 | kfree(idkp); | |
89 | } | |
90 | ||
91 | /* | |
92 | * On HPA drives the capacity needs to be | |
93 | * reinitilized on resume otherwise the disk | |
94 | * can not be used and a hard reset is required | |
95 | */ | |
96 | static void ide_gd_resume(ide_drive_t *drive) | |
97 | { | |
98 | if (ata_id_hpa_enabled(drive->id)) | |
806f80a6 | 99 | (void)drive->disk_ops->get_capacity(drive); |
5fef0e5c BZ |
100 | } |
101 | ||
102 | static void ide_gd_shutdown(ide_drive_t *drive) | |
103 | { | |
104 | #ifdef CONFIG_ALPHA | |
105 | /* On Alpha, halt(8) doesn't actually turn the machine off, | |
106 | it puts you into the sort of firmware monitor. Typically, | |
107 | it's used to boot another kernel image, so it's not much | |
108 | different from reboot(8). Therefore, we don't need to | |
109 | spin down the disk in this case, especially since Alpha | |
110 | firmware doesn't handle disks in standby mode properly. | |
111 | On the other hand, it's reasonably safe to turn the power | |
112 | off when the shutdown process reaches the firmware prompt, | |
113 | as the firmware initialization takes rather long time - | |
114 | at least 10 seconds, which should be sufficient for | |
115 | the disk to expire its write cache. */ | |
116 | if (system_state != SYSTEM_POWER_OFF) { | |
117 | #else | |
118 | if (system_state == SYSTEM_RESTART) { | |
119 | #endif | |
806f80a6 | 120 | drive->disk_ops->flush(drive); |
5fef0e5c BZ |
121 | return; |
122 | } | |
123 | ||
124 | printk(KERN_INFO "Shutdown: %s\n", drive->name); | |
125 | ||
126 | drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND); | |
127 | } | |
128 | ||
79cb3803 BZ |
129 | #ifdef CONFIG_IDE_PROC_FS |
130 | static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive) | |
131 | { | |
806f80a6 | 132 | return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc; |
79cb3803 BZ |
133 | } |
134 | ||
135 | static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive) | |
136 | { | |
806f80a6 BZ |
137 | return (drive->media == ide_disk) ? ide_disk_settings |
138 | : ide_floppy_settings; | |
79cb3803 BZ |
139 | } |
140 | #endif | |
141 | ||
806f80a6 BZ |
142 | static ide_startstop_t ide_gd_do_request(ide_drive_t *drive, |
143 | struct request *rq, sector_t sector) | |
144 | { | |
145 | return drive->disk_ops->do_request(drive, rq, sector); | |
146 | } | |
147 | ||
148 | static int ide_gd_end_request(ide_drive_t *drive, int uptodate, int nrsecs) | |
149 | { | |
150 | return drive->disk_ops->end_request(drive, uptodate, nrsecs); | |
151 | } | |
152 | ||
7f3c868b | 153 | static struct ide_driver ide_gd_driver = { |
5fef0e5c BZ |
154 | .gen_driver = { |
155 | .owner = THIS_MODULE, | |
806f80a6 | 156 | .name = "ide-gd", |
5fef0e5c BZ |
157 | .bus = &ide_bus_type, |
158 | }, | |
159 | .probe = ide_gd_probe, | |
160 | .remove = ide_gd_remove, | |
161 | .resume = ide_gd_resume, | |
162 | .shutdown = ide_gd_shutdown, | |
163 | .version = IDE_GD_VERSION, | |
806f80a6 BZ |
164 | .do_request = ide_gd_do_request, |
165 | .end_request = ide_gd_end_request, | |
5fef0e5c | 166 | #ifdef CONFIG_IDE_PROC_FS |
79cb3803 BZ |
167 | .proc_entries = ide_disk_proc_entries, |
168 | .proc_devsets = ide_disk_proc_devsets, | |
5fef0e5c BZ |
169 | #endif |
170 | }; | |
171 | ||
b2f21e05 | 172 | static int ide_gd_open(struct block_device *bdev, fmode_t mode) |
5fef0e5c | 173 | { |
b2f21e05 | 174 | struct gendisk *disk = bdev->bd_disk; |
5fef0e5c BZ |
175 | struct ide_disk_obj *idkp; |
176 | ide_drive_t *drive; | |
806f80a6 | 177 | int ret = 0; |
5fef0e5c BZ |
178 | |
179 | idkp = ide_disk_get(disk); | |
180 | if (idkp == NULL) | |
181 | return -ENXIO; | |
182 | ||
183 | drive = idkp->drive; | |
184 | ||
806f80a6 BZ |
185 | ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__); |
186 | ||
5fef0e5c BZ |
187 | idkp->openers++; |
188 | ||
189 | if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) { | |
806f80a6 BZ |
190 | drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS; |
191 | /* Just in case */ | |
192 | ||
193 | ret = drive->disk_ops->init_media(drive, disk); | |
194 | ||
195 | /* | |
196 | * Allow O_NDELAY to open a drive without a disk, or with an | |
197 | * unreadable disk, so that we can get the format capacity | |
198 | * of the drive or begin the format - Sam | |
199 | */ | |
b2f21e05 | 200 | if (ret && (mode & FMODE_NDELAY) == 0) { |
806f80a6 BZ |
201 | ret = -EIO; |
202 | goto out_put_idkp; | |
203 | } | |
204 | ||
b2f21e05 | 205 | if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) { |
806f80a6 BZ |
206 | ret = -EROFS; |
207 | goto out_put_idkp; | |
208 | } | |
209 | ||
5fef0e5c BZ |
210 | /* |
211 | * Ignore the return code from door_lock, | |
212 | * since the open() has already succeeded, | |
213 | * and the door_lock is irrelevant at this point. | |
214 | */ | |
806f80a6 | 215 | drive->disk_ops->set_doorlock(drive, disk, 1); |
cedd120c | 216 | drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED; |
b2f21e05 | 217 | check_disk_change(bdev); |
806f80a6 BZ |
218 | } else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) { |
219 | ret = -EBUSY; | |
220 | goto out_put_idkp; | |
5fef0e5c BZ |
221 | } |
222 | return 0; | |
806f80a6 BZ |
223 | |
224 | out_put_idkp: | |
225 | idkp->openers--; | |
226 | ide_disk_put(idkp); | |
227 | return ret; | |
5fef0e5c BZ |
228 | } |
229 | ||
b2f21e05 | 230 | static int ide_gd_release(struct gendisk *disk, fmode_t mode) |
5fef0e5c | 231 | { |
5fef0e5c BZ |
232 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); |
233 | ide_drive_t *drive = idkp->drive; | |
234 | ||
806f80a6 BZ |
235 | ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__); |
236 | ||
5fef0e5c | 237 | if (idkp->openers == 1) |
806f80a6 | 238 | drive->disk_ops->flush(drive); |
5fef0e5c | 239 | |
806f80a6 BZ |
240 | if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) { |
241 | drive->disk_ops->set_doorlock(drive, disk, 0); | |
242 | drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS; | |
243 | } | |
5fef0e5c BZ |
244 | |
245 | idkp->openers--; | |
246 | ||
247 | ide_disk_put(idkp); | |
248 | ||
249 | return 0; | |
250 | } | |
251 | ||
252 | static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo) | |
253 | { | |
254 | struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj); | |
255 | ide_drive_t *drive = idkp->drive; | |
256 | ||
257 | geo->heads = drive->bios_head; | |
258 | geo->sectors = drive->bios_sect; | |
259 | geo->cylinders = (u16)drive->bios_cyl; /* truncate */ | |
260 | return 0; | |
261 | } | |
262 | ||
263 | static int ide_gd_media_changed(struct gendisk *disk) | |
264 | { | |
265 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | |
266 | ide_drive_t *drive = idkp->drive; | |
cedd120c | 267 | int ret; |
5fef0e5c BZ |
268 | |
269 | /* do not scan partitions twice if this is a removable device */ | |
270 | if (drive->dev_flags & IDE_DFLAG_ATTACH) { | |
271 | drive->dev_flags &= ~IDE_DFLAG_ATTACH; | |
272 | return 0; | |
273 | } | |
274 | ||
cedd120c BZ |
275 | ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED); |
276 | drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED; | |
277 | ||
278 | return ret; | |
5fef0e5c BZ |
279 | } |
280 | ||
281 | static int ide_gd_revalidate_disk(struct gendisk *disk) | |
282 | { | |
283 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | |
52ebb438 BP |
284 | ide_drive_t *drive = idkp->drive; |
285 | ||
286 | if (ide_gd_media_changed(disk)) | |
287 | drive->disk_ops->get_capacity(drive); | |
288 | ||
289 | set_capacity(disk, ide_gd_capacity(drive)); | |
5fef0e5c BZ |
290 | return 0; |
291 | } | |
292 | ||
b2f21e05 | 293 | static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode, |
806f80a6 BZ |
294 | unsigned int cmd, unsigned long arg) |
295 | { | |
806f80a6 BZ |
296 | struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj); |
297 | ide_drive_t *drive = idkp->drive; | |
298 | ||
b2f21e05 | 299 | return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg); |
806f80a6 BZ |
300 | } |
301 | ||
5fef0e5c BZ |
302 | static struct block_device_operations ide_gd_ops = { |
303 | .owner = THIS_MODULE, | |
b2f21e05 AV |
304 | .open = ide_gd_open, |
305 | .release = ide_gd_release, | |
306 | .locked_ioctl = ide_gd_ioctl, | |
5fef0e5c BZ |
307 | .getgeo = ide_gd_getgeo, |
308 | .media_changed = ide_gd_media_changed, | |
309 | .revalidate_disk = ide_gd_revalidate_disk | |
310 | }; | |
311 | ||
312 | static int ide_gd_probe(ide_drive_t *drive) | |
313 | { | |
806f80a6 | 314 | const struct ide_disk_ops *disk_ops = NULL; |
5fef0e5c BZ |
315 | struct ide_disk_obj *idkp; |
316 | struct gendisk *g; | |
317 | ||
318 | /* strstr("foo", "") is non-NULL */ | |
806f80a6 BZ |
319 | if (!strstr("ide-gd", drive->driver_req)) |
320 | goto failed; | |
321 | ||
322 | #ifdef CONFIG_IDE_GD_ATA | |
323 | if (drive->media == ide_disk) | |
324 | disk_ops = &ide_ata_disk_ops; | |
325 | #endif | |
326 | #ifdef CONFIG_IDE_GD_ATAPI | |
327 | if (drive->media == ide_floppy) | |
328 | disk_ops = &ide_atapi_disk_ops; | |
329 | #endif | |
330 | if (disk_ops == NULL) | |
5fef0e5c BZ |
331 | goto failed; |
332 | ||
806f80a6 BZ |
333 | if (disk_ops->check(drive, DRV_NAME) == 0) { |
334 | printk(KERN_ERR PFX "%s: not supported by this driver\n", | |
335 | drive->name); | |
5fef0e5c | 336 | goto failed; |
806f80a6 | 337 | } |
5fef0e5c BZ |
338 | |
339 | idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); | |
806f80a6 BZ |
340 | if (!idkp) { |
341 | printk(KERN_ERR PFX "%s: can't allocate a disk structure\n", | |
342 | drive->name); | |
5fef0e5c | 343 | goto failed; |
806f80a6 | 344 | } |
5fef0e5c BZ |
345 | |
346 | g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif)); | |
347 | if (!g) | |
348 | goto out_free_idkp; | |
349 | ||
350 | ide_init_disk(g, drive); | |
351 | ||
8fed4368 BZ |
352 | idkp->dev.parent = &drive->gendev; |
353 | idkp->dev.release = ide_disk_release; | |
354 | dev_set_name(&idkp->dev, dev_name(&drive->gendev)); | |
355 | ||
356 | if (device_register(&idkp->dev)) | |
357 | goto out_free_disk; | |
5fef0e5c BZ |
358 | |
359 | idkp->drive = drive; | |
360 | idkp->driver = &ide_gd_driver; | |
361 | idkp->disk = g; | |
362 | ||
363 | g->private_data = &idkp->driver; | |
364 | ||
365 | drive->driver_data = idkp; | |
806f80a6 BZ |
366 | drive->debug_mask = debug_mask; |
367 | drive->disk_ops = disk_ops; | |
5fef0e5c | 368 | |
806f80a6 | 369 | disk_ops->setup(drive); |
5fef0e5c BZ |
370 | |
371 | set_capacity(g, ide_gd_capacity(drive)); | |
372 | ||
373 | g->minors = IDE_DISK_MINORS; | |
374 | g->driverfs_dev = &drive->gendev; | |
375 | g->flags |= GENHD_FL_EXT_DEVT; | |
376 | if (drive->dev_flags & IDE_DFLAG_REMOVABLE) | |
377 | g->flags = GENHD_FL_REMOVABLE; | |
378 | g->fops = &ide_gd_ops; | |
379 | add_disk(g); | |
380 | return 0; | |
381 | ||
8fed4368 BZ |
382 | out_free_disk: |
383 | put_disk(g); | |
5fef0e5c BZ |
384 | out_free_idkp: |
385 | kfree(idkp); | |
386 | failed: | |
387 | return -ENODEV; | |
388 | } | |
389 | ||
390 | static int __init ide_gd_init(void) | |
391 | { | |
806f80a6 | 392 | printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n"); |
5fef0e5c BZ |
393 | return driver_register(&ide_gd_driver.gen_driver); |
394 | } | |
395 | ||
396 | static void __exit ide_gd_exit(void) | |
397 | { | |
398 | driver_unregister(&ide_gd_driver.gen_driver); | |
399 | } | |
400 | ||
401 | MODULE_ALIAS("ide:*m-disk*"); | |
402 | MODULE_ALIAS("ide-disk"); | |
806f80a6 BZ |
403 | MODULE_ALIAS("ide:*m-floppy*"); |
404 | MODULE_ALIAS("ide-floppy"); | |
5fef0e5c BZ |
405 | module_init(ide_gd_init); |
406 | module_exit(ide_gd_exit); | |
407 | MODULE_LICENSE("GPL"); | |
806f80a6 | 408 | MODULE_DESCRIPTION("generic ATA/ATAPI disk driver"); |