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
24static unsigned long debug_mask;
25module_param(debug_mask, ulong, 0644);
26
27static DEFINE_MUTEX(ide_disk_ref_mutex);
28
29static void ide_disk_release(struct device *);
30
31static 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
47static 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
57sector_t ide_gd_capacity(ide_drive_t *drive)
58{
59 return drive->capacity64;
60}
61
62static int ide_gd_probe(ide_drive_t *);
63
64static 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
79static 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
94
95
96
97static 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
103static const struct dmi_system_id ide_coldreboot_table[] = {
104 {
105
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 { }
114};
115
116static void ide_gd_shutdown(ide_drive_t *drive)
117{
118#ifdef CONFIG_ALPHA
119
120
121
122
123
124
125
126
127
128
129
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
145static 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
150static 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
157static 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
163static 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
181static 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
201
202 ret = drive->disk_ops->init_media(drive, disk);
203
204
205
206
207
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
221
222
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
233out_put_idkp:
234 idkp->openers--;
235 ide_disk_put(idkp);
236 return ret;
237}
238
239static 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
261static 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;
269 return 0;
270}
271
272static 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
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
290static unsigned long long ide_gd_set_capacity(struct gendisk *disk,
291 unsigned long long capacity)
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->set_capacity)
298 return disk_ops->set_capacity(drive, capacity);
299
300 return drive->capacity64;
301}
302
303static int ide_gd_revalidate_disk(struct gendisk *disk)
304{
305 struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
306 ide_drive_t *drive = idkp->drive;
307
308 if (ide_gd_media_changed(disk))
309 drive->disk_ops->get_capacity(drive);
310
311 set_capacity(disk, ide_gd_capacity(drive));
312 return 0;
313}
314
315static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
316 unsigned int cmd, unsigned long arg)
317{
318 struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
319 ide_drive_t *drive = idkp->drive;
320
321 return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
322}
323
324static const struct block_device_operations ide_gd_ops = {
325 .owner = THIS_MODULE,
326 .open = ide_gd_open,
327 .release = ide_gd_release,
328 .locked_ioctl = ide_gd_ioctl,
329 .getgeo = ide_gd_getgeo,
330 .media_changed = ide_gd_media_changed,
331 .set_capacity = ide_gd_set_capacity,
332 .revalidate_disk = ide_gd_revalidate_disk
333};
334
335static int ide_gd_probe(ide_drive_t *drive)
336{
337 const struct ide_disk_ops *disk_ops = NULL;
338 struct ide_disk_obj *idkp;
339 struct gendisk *g;
340
341
342 if (!strstr("ide-gd", drive->driver_req))
343 goto failed;
344
345#ifdef CONFIG_IDE_GD_ATA
346 if (drive->media == ide_disk)
347 disk_ops = &ide_ata_disk_ops;
348#endif
349#ifdef CONFIG_IDE_GD_ATAPI
350 if (drive->media == ide_floppy)
351 disk_ops = &ide_atapi_disk_ops;
352#endif
353 if (disk_ops == NULL)
354 goto failed;
355
356 if (disk_ops->check(drive, DRV_NAME) == 0) {
357 printk(KERN_ERR PFX "%s: not supported by this driver\n",
358 drive->name);
359 goto failed;
360 }
361
362 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
363 if (!idkp) {
364 printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
365 drive->name);
366 goto failed;
367 }
368
369 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
370 if (!g)
371 goto out_free_idkp;
372
373 ide_init_disk(g, drive);
374
375 idkp->dev.parent = &drive->gendev;
376 idkp->dev.release = ide_disk_release;
377 dev_set_name(&idkp->dev, dev_name(&drive->gendev));
378
379 if (device_register(&idkp->dev))
380 goto out_free_disk;
381
382 idkp->drive = drive;
383 idkp->driver = &ide_gd_driver;
384 idkp->disk = g;
385
386 g->private_data = &idkp->driver;
387
388 drive->driver_data = idkp;
389 drive->debug_mask = debug_mask;
390 drive->disk_ops = disk_ops;
391
392 disk_ops->setup(drive);
393
394 set_capacity(g, ide_gd_capacity(drive));
395
396 g->minors = IDE_DISK_MINORS;
397 g->driverfs_dev = &drive->gendev;
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 add_disk(g);
403 return 0;
404
405out_free_disk:
406 put_disk(g);
407out_free_idkp:
408 kfree(idkp);
409failed:
410 return -ENODEV;
411}
412
413static int __init ide_gd_init(void)
414{
415 printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
416 return driver_register(&ide_gd_driver.gen_driver);
417}
418
419static void __exit ide_gd_exit(void)
420{
421 driver_unregister(&ide_gd_driver.gen_driver);
422}
423
424MODULE_ALIAS("ide:*m-disk*");
425MODULE_ALIAS("ide-disk");
426MODULE_ALIAS("ide:*m-floppy*");
427MODULE_ALIAS("ide-floppy");
428module_init(ide_gd_init);
429module_exit(ide_gd_exit);
430MODULE_LICENSE("GPL");
431MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");
432