2 * linux/drivers/ide/ide-proc.c Version 1.05 Mar 05, 2003
4 * Copyright (C) 1997-1998 Mark Lord
5 * Copyright (C) 2003 Red Hat <alan@redhat.com>
7 * Some code was moved here from ide.c, see it for original copyrights.
11 * This is the /proc/ide/ filesystem implementation.
13 * Drive/Driver settings can be retrieved by reading the drive's
14 * "settings" files. e.g. "cat /proc/ide0/hda/settings"
15 * To write a new value "val" into a specific setting "name", use:
16 * echo "name:val" >/proc/ide/ide0/hda/settings
18 * Also useful, "cat /proc/ide0/hda/[identify, smart_values,
19 * smart_thresholds, capabilities]" will issue an IDENTIFY /
20 * PACKET_IDENTIFY / SMART_READ_VALUES / SMART_READ_THRESHOLDS /
21 * SENSE CAPABILITIES command to /dev/hda, and then dump out the
22 * returned data as 256 16-bit words. The "hdparm" utility will
23 * be updated someday soon to use this mechanism.
27 #include <linux/module.h>
29 #include <asm/uaccess.h>
30 #include <linux/errno.h>
31 #include <linux/proc_fs.h>
32 #include <linux/stat.h>
34 #include <linux/pci.h>
35 #include <linux/ctype.h>
36 #include <linux/hdreg.h>
37 #include <linux/ide.h>
38 #include <linux/seq_file.h>
42 static struct proc_dir_entry
*proc_ide_root
;
44 static int proc_ide_read_imodel
45 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
47 ide_hwif_t
*hwif
= (ide_hwif_t
*) data
;
52 * Neither ide_unknown nor ide_forced should be set at this point.
54 switch (hwif
->chipset
) {
55 case ide_generic
: name
= "generic"; break;
56 case ide_pci
: name
= "pci"; break;
57 case ide_cmd640
: name
= "cmd640"; break;
58 case ide_dtc2278
: name
= "dtc2278"; break;
59 case ide_ali14xx
: name
= "ali14xx"; break;
60 case ide_qd65xx
: name
= "qd65xx"; break;
61 case ide_umc8672
: name
= "umc8672"; break;
62 case ide_ht6560b
: name
= "ht6560b"; break;
63 case ide_rz1000
: name
= "rz1000"; break;
64 case ide_trm290
: name
= "trm290"; break;
65 case ide_cmd646
: name
= "cmd646"; break;
66 case ide_cy82c693
: name
= "cy82c693"; break;
67 case ide_4drives
: name
= "4drives"; break;
68 case ide_pmac
: name
= "mac-io"; break;
69 case ide_au1xxx
: name
= "au1xxx"; break;
70 case ide_etrax100
: name
= "etrax100"; break;
71 case ide_acorn
: name
= "acorn"; break;
72 default: name
= "(unknown)"; break;
74 len
= sprintf(page
, "%s\n", name
);
75 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
78 static int proc_ide_read_mate
79 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
81 ide_hwif_t
*hwif
= (ide_hwif_t
*) data
;
84 if (hwif
&& hwif
->mate
&& hwif
->mate
->present
)
85 len
= sprintf(page
, "%s\n", hwif
->mate
->name
);
87 len
= sprintf(page
, "(none)\n");
88 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
91 static int proc_ide_read_channel
92 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
94 ide_hwif_t
*hwif
= (ide_hwif_t
*) data
;
97 page
[0] = hwif
->channel
? '1' : '0';
100 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
103 static int proc_ide_read_identify
104 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
106 ide_drive_t
*drive
= (ide_drive_t
*)data
;
110 len
= sprintf(page
, "\n");
113 unsigned short *val
= (unsigned short *) page
;
115 err
= taskfile_lib_get_identify(drive
, page
);
117 char *out
= ((char *)page
) + (SECTOR_WORDS
* 4);
120 out
+= sprintf(out
, "%04x%c",
121 le16_to_cpu(*val
), (++i
& 7) ? ' ' : '\n');
123 } while (i
< (SECTOR_WORDS
* 2));
127 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
131 * __ide_add_setting - add an ide setting option
132 * @drive: drive to use
133 * @name: setting name
134 * @rw: true if the function is read write
135 * @data_type: type of data
136 * @min: range minimum
137 * @max: range maximum
138 * @mul_factor: multiplication scale
139 * @div_factor: divison scale
140 * @data: private data field
142 * @auto_remove: setting auto removal flag
144 * Removes the setting named from the device if it is present.
145 * The function takes the settings_lock to protect against
146 * parallel changes. This function must not be called from IRQ
147 * context. Returns 0 on success or -1 on failure.
149 * BUGS: This code is seriously over-engineered. There is also
150 * magic about how the driver specific features are setup. If
151 * a driver is attached we assume the driver settings are auto
155 static int __ide_add_setting(ide_drive_t
*drive
, const char *name
, int rw
, int data_type
, int min
, int max
, int mul_factor
, int div_factor
, void *data
, ide_procset_t
*set
, int auto_remove
)
157 ide_settings_t
**p
= (ide_settings_t
**) &drive
->settings
, *setting
= NULL
;
159 mutex_lock(&ide_setting_mtx
);
160 while ((*p
) && strcmp((*p
)->name
, name
) < 0)
162 if ((setting
= kzalloc(sizeof(*setting
), GFP_KERNEL
)) == NULL
)
164 if ((setting
->name
= kmalloc(strlen(name
) + 1, GFP_KERNEL
)) == NULL
)
166 strcpy(setting
->name
, name
);
168 setting
->data_type
= data_type
;
171 setting
->mul_factor
= mul_factor
;
172 setting
->div_factor
= div_factor
;
173 setting
->data
= data
;
178 setting
->auto_remove
= 1;
180 mutex_unlock(&ide_setting_mtx
);
183 mutex_unlock(&ide_setting_mtx
);
188 int ide_add_setting(ide_drive_t
*drive
, const char *name
, int rw
, int data_type
, int min
, int max
, int mul_factor
, int div_factor
, void *data
, ide_procset_t
*set
)
190 return __ide_add_setting(drive
, name
, rw
, data_type
, min
, max
, mul_factor
, div_factor
, data
, set
, 1);
193 EXPORT_SYMBOL(ide_add_setting
);
196 * __ide_remove_setting - remove an ide setting option
197 * @drive: drive to use
198 * @name: setting name
200 * Removes the setting named from the device if it is present.
201 * The caller must hold the setting semaphore.
204 static void __ide_remove_setting (ide_drive_t
*drive
, char *name
)
206 ide_settings_t
**p
, *setting
;
208 p
= (ide_settings_t
**) &drive
->settings
;
210 while ((*p
) && strcmp((*p
)->name
, name
))
212 if ((setting
= (*p
)) == NULL
)
215 (*p
) = setting
->next
;
217 kfree(setting
->name
);
222 * auto_remove_settings - remove driver specific settings
225 * Automatically remove all the driver specific settings for this
226 * drive. This function may not be called from IRQ context. The
227 * caller must hold ide_setting_mtx.
230 static void auto_remove_settings (ide_drive_t
*drive
)
232 ide_settings_t
*setting
;
234 setting
= drive
->settings
;
236 if (setting
->auto_remove
) {
237 __ide_remove_setting(drive
, setting
->name
);
240 setting
= setting
->next
;
245 * ide_find_setting_by_name - find a drive specific setting
246 * @drive: drive to scan
247 * @name: setting name
249 * Scan's the device setting table for a matching entry and returns
250 * this or NULL if no entry is found. The caller must hold the
254 static ide_settings_t
*ide_find_setting_by_name(ide_drive_t
*drive
, char *name
)
256 ide_settings_t
*setting
= drive
->settings
;
259 if (strcmp(setting
->name
, name
) == 0)
261 setting
= setting
->next
;
267 * ide_read_setting - read an IDE setting
268 * @drive: drive to read from
269 * @setting: drive setting
271 * Read a drive setting and return the value. The caller
272 * must hold the ide_setting_mtx when making this call.
274 * BUGS: the data return and error are the same return value
275 * so an error -EINVAL and true return of the same value cannot
279 static int ide_read_setting(ide_drive_t
*drive
, ide_settings_t
*setting
)
284 if ((setting
->rw
& SETTING_READ
)) {
285 spin_lock_irqsave(&ide_lock
, flags
);
286 switch(setting
->data_type
) {
288 val
= *((u8
*) setting
->data
);
291 val
= *((u16
*) setting
->data
);
294 val
= *((u32
*) setting
->data
);
297 spin_unlock_irqrestore(&ide_lock
, flags
);
303 * ide_write_setting - read an IDE setting
304 * @drive: drive to read from
305 * @setting: drive setting
308 * Write a drive setting if it is possible. The caller
309 * must hold the ide_setting_mtx when making this call.
311 * BUGS: the data return and error are the same return value
312 * so an error -EINVAL and true return of the same value cannot
315 * FIXME: This should be changed to enqueue a special request
316 * to the driver to change settings, and then wait on a sema for completion.
317 * The current scheme of polling is kludgy, though safe enough.
320 static int ide_write_setting(ide_drive_t
*drive
, ide_settings_t
*setting
, int val
)
322 if (!capable(CAP_SYS_ADMIN
))
325 return setting
->set(drive
, val
);
326 if (!(setting
->rw
& SETTING_WRITE
))
328 if (val
< setting
->min
|| val
> setting
->max
)
330 if (ide_spin_wait_hwgroup(drive
))
332 switch (setting
->data_type
) {
334 *((u8
*) setting
->data
) = val
;
337 *((u16
*) setting
->data
) = val
;
340 *((u32
*) setting
->data
) = val
;
343 spin_unlock_irq(&ide_lock
);
347 static int set_xfer_rate (ide_drive_t
*drive
, int arg
)
351 if (arg
< 0 || arg
> 70)
354 err
= ide_wait_cmd(drive
,
355 WIN_SETFEATURES
, (u8
) arg
,
356 SETFEATURES_XFER
, 0, NULL
);
359 ide_set_xfer_rate(drive
, (u8
) arg
);
360 ide_driveid_update(drive
);
366 * ide_add_generic_settings - generic ide settings
367 * @drive: drive being configured
369 * Add the generic parts of the system settings to the /proc files.
370 * The caller must not be holding the ide_setting_mtx.
373 void ide_add_generic_settings (ide_drive_t
*drive
)
376 * drive setting name read/write access data type min max mul_factor div_factor data pointer set function
378 __ide_add_setting(drive
, "io_32bit", drive
->no_io_32bit
? SETTING_READ
: SETTING_RW
, TYPE_BYTE
, 0, 1 + (SUPPORT_VLB_SYNC
<< 1), 1, 1, &drive
->io_32bit
, set_io_32bit
, 0);
379 __ide_add_setting(drive
, "keepsettings", SETTING_RW
, TYPE_BYTE
, 0, 1, 1, 1, &drive
->keep_settings
, NULL
, 0);
380 __ide_add_setting(drive
, "nice1", SETTING_RW
, TYPE_BYTE
, 0, 1, 1, 1, &drive
->nice1
, NULL
, 0);
381 __ide_add_setting(drive
, "pio_mode", SETTING_WRITE
, TYPE_BYTE
, 0, 255, 1, 1, NULL
, set_pio_mode
, 0);
382 __ide_add_setting(drive
, "unmaskirq", drive
->no_unmask
? SETTING_READ
: SETTING_RW
, TYPE_BYTE
, 0, 1, 1, 1, &drive
->unmask
, NULL
, 0);
383 __ide_add_setting(drive
, "using_dma", SETTING_RW
, TYPE_BYTE
, 0, 1, 1, 1, &drive
->using_dma
, set_using_dma
, 0);
384 __ide_add_setting(drive
, "init_speed", SETTING_RW
, TYPE_BYTE
, 0, 70, 1, 1, &drive
->init_speed
, NULL
, 0);
385 __ide_add_setting(drive
, "current_speed", SETTING_RW
, TYPE_BYTE
, 0, 70, 1, 1, &drive
->current_speed
, set_xfer_rate
, 0);
386 __ide_add_setting(drive
, "number", SETTING_RW
, TYPE_BYTE
, 0, 3, 1, 1, &drive
->dn
, NULL
, 0);
389 static void proc_ide_settings_warn(void)
391 static int warned
= 0;
396 printk(KERN_WARNING
"Warning: /proc/ide/hd?/settings interface is "
397 "obsolete, and will be removed soon!\n");
401 static int proc_ide_read_settings
402 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
404 ide_drive_t
*drive
= (ide_drive_t
*) data
;
405 ide_settings_t
*setting
= (ide_settings_t
*) drive
->settings
;
407 int len
, rc
, mul_factor
, div_factor
;
409 proc_ide_settings_warn();
411 mutex_lock(&ide_setting_mtx
);
412 out
+= sprintf(out
, "name\t\t\tvalue\t\tmin\t\tmax\t\tmode\n");
413 out
+= sprintf(out
, "----\t\t\t-----\t\t---\t\t---\t\t----\n");
415 mul_factor
= setting
->mul_factor
;
416 div_factor
= setting
->div_factor
;
417 out
+= sprintf(out
, "%-24s", setting
->name
);
418 if ((rc
= ide_read_setting(drive
, setting
)) >= 0)
419 out
+= sprintf(out
, "%-16d", rc
* mul_factor
/ div_factor
);
421 out
+= sprintf(out
, "%-16s", "write-only");
422 out
+= sprintf(out
, "%-16d%-16d", (setting
->min
* mul_factor
+ div_factor
- 1) / div_factor
, setting
->max
* mul_factor
/ div_factor
);
423 if (setting
->rw
& SETTING_READ
)
424 out
+= sprintf(out
, "r");
425 if (setting
->rw
& SETTING_WRITE
)
426 out
+= sprintf(out
, "w");
427 out
+= sprintf(out
, "\n");
428 setting
= setting
->next
;
431 mutex_unlock(&ide_setting_mtx
);
432 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
437 static int proc_ide_write_settings(struct file
*file
, const char __user
*buffer
,
438 unsigned long count
, void *data
)
440 ide_drive_t
*drive
= (ide_drive_t
*) data
;
441 char name
[MAX_LEN
+ 1];
444 ide_settings_t
*setting
;
447 if (!capable(CAP_SYS_ADMIN
))
450 proc_ide_settings_warn();
452 if (count
>= PAGE_SIZE
)
455 s
= buf
= (char *)__get_free_page(GFP_USER
);
459 if (copy_from_user(buf
, buffer
, count
)) {
460 free_page((unsigned long)buf
);
467 * Skip over leading whitespace
469 while (count
&& isspace(*s
)) {
474 * Do one full pass to verify all parameters,
475 * then do another to actually write the new settings.
484 while (n
> 0 && *p
!= ':') {
492 memcpy(name
, q
, p
- q
);
501 val
= simple_strtoul(p
, &q
, 10);
504 if (n
> 0 && !isspace(*p
))
506 while (n
> 0 && isspace(*p
)) {
511 mutex_lock(&ide_setting_mtx
);
512 setting
= ide_find_setting_by_name(drive
, name
);
515 mutex_unlock(&ide_setting_mtx
);
519 ide_write_setting(drive
, setting
, val
* setting
->div_factor
/ setting
->mul_factor
);
520 mutex_unlock(&ide_setting_mtx
);
522 } while (!for_real
++);
523 free_page((unsigned long)buf
);
526 free_page((unsigned long)buf
);
527 printk("proc_ide_write_settings(): parse error\n");
531 int proc_ide_read_capacity
532 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
534 int len
= sprintf(page
,"%llu\n", (long long)0x7fffffff);
535 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
538 EXPORT_SYMBOL_GPL(proc_ide_read_capacity
);
540 int proc_ide_read_geometry
541 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
543 ide_drive_t
*drive
= (ide_drive_t
*) data
;
547 out
+= sprintf(out
,"physical %d/%d/%d\n",
548 drive
->cyl
, drive
->head
, drive
->sect
);
549 out
+= sprintf(out
,"logical %d/%d/%d\n",
550 drive
->bios_cyl
, drive
->bios_head
, drive
->bios_sect
);
553 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
556 EXPORT_SYMBOL(proc_ide_read_geometry
);
558 static int proc_ide_read_dmodel
559 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
561 ide_drive_t
*drive
= (ide_drive_t
*) data
;
562 struct hd_driveid
*id
= drive
->id
;
565 len
= sprintf(page
, "%.40s\n",
566 (id
&& id
->model
[0]) ? (char *)id
->model
: "(none)");
567 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
570 static int proc_ide_read_driver
571 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
573 ide_drive_t
*drive
= (ide_drive_t
*) data
;
574 struct device
*dev
= &drive
->gendev
;
575 ide_driver_t
*ide_drv
;
579 ide_drv
= container_of(dev
->driver
, ide_driver_t
, gen_driver
);
580 len
= sprintf(page
, "%s version %s\n",
581 dev
->driver
->name
, ide_drv
->version
);
583 len
= sprintf(page
, "ide-default version 0.9.newide\n");
584 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
587 static int ide_replace_subdriver(ide_drive_t
*drive
, const char *driver
)
589 struct device
*dev
= &drive
->gendev
;
593 device_release_driver(dev
);
594 /* FIXME: device can still be in use by previous driver */
595 strlcpy(drive
->driver_req
, driver
, sizeof(drive
->driver_req
));
596 err
= device_attach(dev
);
598 printk(KERN_WARNING
"IDE: %s: device_attach error: %d\n",
600 drive
->driver_req
[0] = 0;
601 if (dev
->driver
== NULL
) {
602 err
= device_attach(dev
);
605 "IDE: %s: device_attach(2) error: %d\n",
608 if (dev
->driver
&& !strcmp(dev
->driver
->name
, driver
))
614 static int proc_ide_write_driver
615 (struct file
*file
, const char __user
*buffer
, unsigned long count
, void *data
)
617 ide_drive_t
*drive
= (ide_drive_t
*) data
;
620 if (!capable(CAP_SYS_ADMIN
))
624 if (copy_from_user(name
, buffer
, count
))
627 if (ide_replace_subdriver(drive
, name
))
632 static int proc_ide_read_media
633 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
635 ide_drive_t
*drive
= (ide_drive_t
*) data
;
639 switch (drive
->media
) {
640 case ide_disk
: media
= "disk\n";
642 case ide_cdrom
: media
= "cdrom\n";
644 case ide_tape
: media
= "tape\n";
646 case ide_floppy
:media
= "floppy\n";
648 case ide_optical
:media
= "optical\n";
650 default: media
= "UNKNOWN\n";
655 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
658 static ide_proc_entry_t generic_drive_entries
[] = {
659 { "driver", S_IFREG
|S_IRUGO
, proc_ide_read_driver
, proc_ide_write_driver
},
660 { "identify", S_IFREG
|S_IRUSR
, proc_ide_read_identify
, NULL
},
661 { "media", S_IFREG
|S_IRUGO
, proc_ide_read_media
, NULL
},
662 { "model", S_IFREG
|S_IRUGO
, proc_ide_read_dmodel
, NULL
},
663 { "settings", S_IFREG
|S_IRUSR
|S_IWUSR
,proc_ide_read_settings
, proc_ide_write_settings
},
664 { NULL
, 0, NULL
, NULL
}
667 static void ide_add_proc_entries(struct proc_dir_entry
*dir
, ide_proc_entry_t
*p
, void *data
)
669 struct proc_dir_entry
*ent
;
673 while (p
->name
!= NULL
) {
674 ent
= create_proc_entry(p
->name
, p
->mode
, dir
);
677 ent
->read_proc
= p
->read_proc
;
678 ent
->write_proc
= p
->write_proc
;
683 static void ide_remove_proc_entries(struct proc_dir_entry
*dir
, ide_proc_entry_t
*p
)
687 while (p
->name
!= NULL
) {
688 remove_proc_entry(p
->name
, dir
);
693 void ide_proc_register_driver(ide_drive_t
*drive
, ide_driver_t
*driver
)
695 ide_add_proc_entries(drive
->proc
, driver
->proc
, drive
);
698 EXPORT_SYMBOL(ide_proc_register_driver
);
701 * ide_proc_unregister_driver - remove driver specific data
705 * Clean up the driver specific /proc files and IDE settings
708 * Takes ide_setting_mtx and ide_lock.
709 * Caller must hold none of the locks.
712 void ide_proc_unregister_driver(ide_drive_t
*drive
, ide_driver_t
*driver
)
716 ide_remove_proc_entries(drive
->proc
, driver
->proc
);
718 mutex_lock(&ide_setting_mtx
);
719 spin_lock_irqsave(&ide_lock
, flags
);
721 * ide_setting_mtx protects the settings list
722 * ide_lock protects the use of settings
724 * so we need to hold both, ide_settings_sem because we want to
725 * modify the settings list, and ide_lock because we cannot take
726 * a setting out that is being used.
728 * OTOH both ide_{read,write}_setting are only ever used under
731 auto_remove_settings(drive
);
732 spin_unlock_irqrestore(&ide_lock
, flags
);
733 mutex_unlock(&ide_setting_mtx
);
736 EXPORT_SYMBOL(ide_proc_unregister_driver
);
738 static void create_proc_ide_drives(ide_hwif_t
*hwif
)
741 struct proc_dir_entry
*ent
;
742 struct proc_dir_entry
*parent
= hwif
->proc
;
745 for (d
= 0; d
< MAX_DRIVES
; d
++) {
746 ide_drive_t
*drive
= &hwif
->drives
[d
];
753 drive
->proc
= proc_mkdir(drive
->name
, parent
);
755 ide_add_proc_entries(drive
->proc
, generic_drive_entries
, drive
);
756 sprintf(name
,"ide%d/%s", (drive
->name
[2]-'a')/2, drive
->name
);
757 ent
= proc_symlink(drive
->name
, proc_ide_root
, name
);
762 static void destroy_proc_ide_device(ide_hwif_t
*hwif
, ide_drive_t
*drive
)
765 ide_remove_proc_entries(drive
->proc
, generic_drive_entries
);
766 remove_proc_entry(drive
->name
, proc_ide_root
);
767 remove_proc_entry(drive
->name
, hwif
->proc
);
772 static void destroy_proc_ide_drives(ide_hwif_t
*hwif
)
776 for (d
= 0; d
< MAX_DRIVES
; d
++) {
777 ide_drive_t
*drive
= &hwif
->drives
[d
];
779 destroy_proc_ide_device(hwif
, drive
);
783 static ide_proc_entry_t hwif_entries
[] = {
784 { "channel", S_IFREG
|S_IRUGO
, proc_ide_read_channel
, NULL
},
785 { "mate", S_IFREG
|S_IRUGO
, proc_ide_read_mate
, NULL
},
786 { "model", S_IFREG
|S_IRUGO
, proc_ide_read_imodel
, NULL
},
787 { NULL
, 0, NULL
, NULL
}
790 void ide_proc_register_port(ide_hwif_t
*hwif
)
796 hwif
->proc
= proc_mkdir(hwif
->name
, proc_ide_root
);
801 ide_add_proc_entries(hwif
->proc
, hwif_entries
, hwif
);
804 create_proc_ide_drives(hwif
);
807 #ifdef CONFIG_BLK_DEV_IDEPCI
808 void ide_pci_create_host_proc(const char *name
, get_info_t
*get_info
)
810 create_proc_info_entry(name
, 0, proc_ide_root
, get_info
);
813 EXPORT_SYMBOL_GPL(ide_pci_create_host_proc
);
816 void ide_proc_unregister_port(ide_hwif_t
*hwif
)
819 destroy_proc_ide_drives(hwif
);
820 ide_remove_proc_entries(hwif
->proc
, hwif_entries
);
821 remove_proc_entry(hwif
->name
, proc_ide_root
);
826 static int proc_print_driver(struct device_driver
*drv
, void *data
)
828 ide_driver_t
*ide_drv
= container_of(drv
, ide_driver_t
, gen_driver
);
829 struct seq_file
*s
= data
;
831 seq_printf(s
, "%s version %s\n", drv
->name
, ide_drv
->version
);
836 static int ide_drivers_show(struct seq_file
*s
, void *p
)
840 err
= bus_for_each_drv(&ide_bus_type
, NULL
, s
, proc_print_driver
);
842 printk(KERN_WARNING
"IDE: %s: bus_for_each_drv error: %d\n",
847 static int ide_drivers_open(struct inode
*inode
, struct file
*file
)
849 return single_open(file
, &ide_drivers_show
, NULL
);
852 static const struct file_operations ide_drivers_operations
= {
853 .open
= ide_drivers_open
,
856 .release
= single_release
,
859 void proc_ide_create(void)
861 struct proc_dir_entry
*entry
;
863 proc_ide_root
= proc_mkdir("ide", NULL
);
868 entry
= create_proc_entry("drivers", 0, proc_ide_root
);
870 entry
->proc_fops
= &ide_drivers_operations
;
873 void proc_ide_destroy(void)
875 remove_proc_entry("drivers", proc_ide_root
);
876 remove_proc_entry("ide", NULL
);