2 * Copyright (C) 1997-1998 Mark Lord
3 * Copyright (C) 2003 Red Hat
5 * Some code was moved here from ide.c, see it for original copyrights.
9 * This is the /proc/ide/ filesystem implementation.
11 * Drive/Driver settings can be retrieved by reading the drive's
12 * "settings" files. e.g. "cat /proc/ide0/hda/settings"
13 * To write a new value "val" into a specific setting "name", use:
14 * echo "name:val" >/proc/ide/ide0/hda/settings
17 #include <linux/module.h>
19 #include <asm/uaccess.h>
20 #include <linux/errno.h>
21 #include <linux/proc_fs.h>
22 #include <linux/stat.h>
24 #include <linux/pci.h>
25 #include <linux/ctype.h>
26 #include <linux/ide.h>
27 #include <linux/seq_file.h>
28 #include <linux/slab.h>
32 static struct proc_dir_entry
*proc_ide_root
;
34 static int ide_imodel_proc_show(struct seq_file
*m
, void *v
)
36 ide_hwif_t
*hwif
= (ide_hwif_t
*) m
->private;
39 switch (hwif
->chipset
) {
40 case ide_generic
: name
= "generic"; break;
41 case ide_pci
: name
= "pci"; break;
42 case ide_cmd640
: name
= "cmd640"; break;
43 case ide_dtc2278
: name
= "dtc2278"; break;
44 case ide_ali14xx
: name
= "ali14xx"; break;
45 case ide_qd65xx
: name
= "qd65xx"; break;
46 case ide_umc8672
: name
= "umc8672"; break;
47 case ide_ht6560b
: name
= "ht6560b"; break;
48 case ide_4drives
: name
= "4drives"; break;
49 case ide_pmac
: name
= "mac-io"; break;
50 case ide_au1xxx
: name
= "au1xxx"; break;
51 case ide_palm3710
: name
= "palm3710"; break;
52 case ide_acorn
: name
= "acorn"; break;
53 default: name
= "(unknown)"; break;
55 seq_printf(m
, "%s\n", name
);
59 static int ide_imodel_proc_open(struct inode
*inode
, struct file
*file
)
61 return single_open(file
, ide_imodel_proc_show
, PDE(inode
)->data
);
64 static const struct file_operations ide_imodel_proc_fops
= {
66 .open
= ide_imodel_proc_open
,
69 .release
= single_release
,
72 static int ide_mate_proc_show(struct seq_file
*m
, void *v
)
74 ide_hwif_t
*hwif
= (ide_hwif_t
*) m
->private;
76 if (hwif
&& hwif
->mate
)
77 seq_printf(m
, "%s\n", hwif
->mate
->name
);
79 seq_printf(m
, "(none)\n");
83 static int ide_mate_proc_open(struct inode
*inode
, struct file
*file
)
85 return single_open(file
, ide_mate_proc_show
, PDE(inode
)->data
);
88 static const struct file_operations ide_mate_proc_fops
= {
90 .open
= ide_mate_proc_open
,
93 .release
= single_release
,
96 static int ide_channel_proc_show(struct seq_file
*m
, void *v
)
98 ide_hwif_t
*hwif
= (ide_hwif_t
*) m
->private;
100 seq_printf(m
, "%c\n", hwif
->channel
? '1' : '0');
104 static int ide_channel_proc_open(struct inode
*inode
, struct file
*file
)
106 return single_open(file
, ide_channel_proc_show
, PDE(inode
)->data
);
109 static const struct file_operations ide_channel_proc_fops
= {
110 .owner
= THIS_MODULE
,
111 .open
= ide_channel_proc_open
,
114 .release
= single_release
,
117 static int ide_identify_proc_show(struct seq_file
*m
, void *v
)
119 ide_drive_t
*drive
= (ide_drive_t
*)m
->private;
127 buf
= kmalloc(SECTOR_SIZE
, GFP_KERNEL
);
130 if (taskfile_lib_get_identify(drive
, buf
) == 0) {
131 __le16
*val
= (__le16
*)buf
;
134 for (i
= 0; i
< SECTOR_SIZE
/ 2; i
++) {
135 seq_printf(m
, "%04x%c", le16_to_cpu(val
[i
]),
136 (i
% 8) == 7 ? '\n' : ' ');
144 static int ide_identify_proc_open(struct inode
*inode
, struct file
*file
)
146 return single_open(file
, ide_identify_proc_show
, PDE(inode
)->data
);
149 static const struct file_operations ide_identify_proc_fops
= {
150 .owner
= THIS_MODULE
,
151 .open
= ide_identify_proc_open
,
154 .release
= single_release
,
158 * ide_find_setting - find a specific setting
159 * @st: setting table pointer
160 * @name: setting name
162 * Scan's the setting table for a matching entry and returns
163 * this or NULL if no entry is found. The caller must hold the
168 const struct ide_proc_devset
*ide_find_setting(const struct ide_proc_devset
*st
,
172 if (strcmp(st
->name
, name
) == 0)
176 return st
->name
? st
: NULL
;
180 * ide_read_setting - read an IDE setting
181 * @drive: drive to read from
182 * @setting: drive setting
184 * Read a drive setting and return the value. The caller
185 * must hold the ide_setting_mtx when making this call.
187 * BUGS: the data return and error are the same return value
188 * so an error -EINVAL and true return of the same value cannot
192 static int ide_read_setting(ide_drive_t
*drive
,
193 const struct ide_proc_devset
*setting
)
195 const struct ide_devset
*ds
= setting
->setting
;
199 val
= ds
->get(drive
);
205 * ide_write_setting - read an IDE setting
206 * @drive: drive to read from
207 * @setting: drive setting
210 * Write a drive setting if it is possible. The caller
211 * must hold the ide_setting_mtx when making this call.
213 * BUGS: the data return and error are the same return value
214 * so an error -EINVAL and true return of the same value cannot
217 * FIXME: This should be changed to enqueue a special request
218 * to the driver to change settings, and then wait on a sema for completion.
219 * The current scheme of polling is kludgy, though safe enough.
222 static int ide_write_setting(ide_drive_t
*drive
,
223 const struct ide_proc_devset
*setting
, int val
)
225 const struct ide_devset
*ds
= setting
->setting
;
227 if (!capable(CAP_SYS_ADMIN
))
231 if ((ds
->flags
& DS_SYNC
)
232 && (val
< setting
->min
|| val
> setting
->max
))
234 return ide_devset_execute(drive
, ds
, val
);
237 ide_devset_get(xfer_rate
, current_speed
);
239 static int set_xfer_rate (ide_drive_t
*drive
, int arg
)
243 if (arg
< XFER_PIO_0
|| arg
> XFER_UDMA_6
)
246 memset(&cmd
, 0, sizeof(cmd
));
247 cmd
.tf
.command
= ATA_CMD_SET_FEATURES
;
248 cmd
.tf
.feature
= SETFEATURES_XFER
;
249 cmd
.tf
.nsect
= (u8
)arg
;
250 cmd
.valid
.out
.tf
= IDE_VALID_FEATURE
| IDE_VALID_NSECT
;
251 cmd
.valid
.in
.tf
= IDE_VALID_NSECT
;
252 cmd
.tf_flags
= IDE_TFLAG_SET_XFER
;
254 return ide_no_data_taskfile(drive
, &cmd
);
257 ide_devset_rw(current_speed
, xfer_rate
);
258 ide_devset_rw_field(init_speed
, init_speed
);
259 ide_devset_rw_flag(nice1
, IDE_DFLAG_NICE1
);
260 ide_devset_rw_field(number
, dn
);
262 static const struct ide_proc_devset ide_generic_settings
[] = {
263 IDE_PROC_DEVSET(current_speed
, 0, 70),
264 IDE_PROC_DEVSET(init_speed
, 0, 70),
265 IDE_PROC_DEVSET(io_32bit
, 0, 1 + (SUPPORT_VLB_SYNC
<< 1)),
266 IDE_PROC_DEVSET(keepsettings
, 0, 1),
267 IDE_PROC_DEVSET(nice1
, 0, 1),
268 IDE_PROC_DEVSET(number
, 0, 3),
269 IDE_PROC_DEVSET(pio_mode
, 0, 255),
270 IDE_PROC_DEVSET(unmaskirq
, 0, 1),
271 IDE_PROC_DEVSET(using_dma
, 0, 1),
275 static void proc_ide_settings_warn(void)
277 printk_once(KERN_WARNING
"Warning: /proc/ide/hd?/settings interface is "
278 "obsolete, and will be removed soon!\n");
281 static int ide_settings_proc_show(struct seq_file
*m
, void *v
)
283 const struct ide_proc_devset
*setting
, *g
, *d
;
284 const struct ide_devset
*ds
;
285 ide_drive_t
*drive
= (ide_drive_t
*) m
->private;
286 int rc
, mul_factor
, div_factor
;
288 proc_ide_settings_warn();
290 mutex_lock(&ide_setting_mtx
);
291 g
= ide_generic_settings
;
293 seq_printf(m
, "name\t\t\tvalue\t\tmin\t\tmax\t\tmode\n");
294 seq_printf(m
, "----\t\t\t-----\t\t---\t\t---\t\t----\n");
295 while (g
->name
|| (d
&& d
->name
)) {
296 /* read settings in the alphabetical order */
297 if (g
->name
&& d
&& d
->name
) {
298 if (strcmp(d
->name
, g
->name
) < 0)
302 } else if (d
&& d
->name
) {
306 mul_factor
= setting
->mulf
? setting
->mulf(drive
) : 1;
307 div_factor
= setting
->divf
? setting
->divf(drive
) : 1;
308 seq_printf(m
, "%-24s", setting
->name
);
309 rc
= ide_read_setting(drive
, setting
);
311 seq_printf(m
, "%-16d", rc
* mul_factor
/ div_factor
);
313 seq_printf(m
, "%-16s", "write-only");
314 seq_printf(m
, "%-16d%-16d", (setting
->min
* mul_factor
+ div_factor
- 1) / div_factor
, setting
->max
* mul_factor
/ div_factor
);
315 ds
= setting
->setting
;
322 mutex_unlock(&ide_setting_mtx
);
326 static int ide_settings_proc_open(struct inode
*inode
, struct file
*file
)
328 return single_open(file
, ide_settings_proc_show
, PDE(inode
)->data
);
333 static ssize_t
ide_settings_proc_write(struct file
*file
, const char __user
*buffer
,
334 size_t count
, loff_t
*pos
)
336 ide_drive_t
*drive
= (ide_drive_t
*) PDE(file
->f_path
.dentry
->d_inode
)->data
;
337 char name
[MAX_LEN
+ 1];
338 int for_real
= 0, mul_factor
, div_factor
;
341 const struct ide_proc_devset
*setting
;
344 if (!capable(CAP_SYS_ADMIN
))
347 proc_ide_settings_warn();
349 if (count
>= PAGE_SIZE
)
352 s
= buf
= (char *)__get_free_page(GFP_USER
);
356 if (copy_from_user(buf
, buffer
, count
)) {
357 free_page((unsigned long)buf
);
364 * Skip over leading whitespace
366 while (count
&& isspace(*s
)) {
371 * Do one full pass to verify all parameters,
372 * then do another to actually write the new settings.
381 while (n
> 0 && *p
!= ':') {
389 memcpy(name
, q
, p
- q
);
398 val
= simple_strtoul(p
, &q
, 10);
401 if (n
> 0 && !isspace(*p
))
403 while (n
> 0 && isspace(*p
)) {
408 mutex_lock(&ide_setting_mtx
);
409 /* generic settings first, then driver specific ones */
410 setting
= ide_find_setting(ide_generic_settings
, name
);
413 setting
= ide_find_setting(drive
->settings
, name
);
415 mutex_unlock(&ide_setting_mtx
);
420 mul_factor
= setting
->mulf
? setting
->mulf(drive
) : 1;
421 div_factor
= setting
->divf
? setting
->divf(drive
) : 1;
422 ide_write_setting(drive
, setting
, val
* div_factor
/ mul_factor
);
424 mutex_unlock(&ide_setting_mtx
);
426 } while (!for_real
++);
427 free_page((unsigned long)buf
);
430 free_page((unsigned long)buf
);
431 printk("%s(): parse error\n", __func__
);
435 static const struct file_operations ide_settings_proc_fops
= {
436 .owner
= THIS_MODULE
,
437 .open
= ide_settings_proc_open
,
440 .release
= single_release
,
441 .write
= ide_settings_proc_write
,
444 static int ide_capacity_proc_show(struct seq_file
*m
, void *v
)
446 seq_printf(m
, "%llu\n", (long long)0x7fffffff);
450 static int ide_capacity_proc_open(struct inode
*inode
, struct file
*file
)
452 return single_open(file
, ide_capacity_proc_show
, NULL
);
455 const struct file_operations ide_capacity_proc_fops
= {
456 .owner
= THIS_MODULE
,
457 .open
= ide_capacity_proc_open
,
460 .release
= single_release
,
462 EXPORT_SYMBOL_GPL(ide_capacity_proc_fops
);
464 static int ide_geometry_proc_show(struct seq_file
*m
, void *v
)
466 ide_drive_t
*drive
= (ide_drive_t
*) m
->private;
468 seq_printf(m
, "physical %d/%d/%d\n",
469 drive
->cyl
, drive
->head
, drive
->sect
);
470 seq_printf(m
, "logical %d/%d/%d\n",
471 drive
->bios_cyl
, drive
->bios_head
, drive
->bios_sect
);
475 static int ide_geometry_proc_open(struct inode
*inode
, struct file
*file
)
477 return single_open(file
, ide_geometry_proc_show
, PDE(inode
)->data
);
480 const struct file_operations ide_geometry_proc_fops
= {
481 .owner
= THIS_MODULE
,
482 .open
= ide_geometry_proc_open
,
485 .release
= single_release
,
487 EXPORT_SYMBOL(ide_geometry_proc_fops
);
489 static int ide_dmodel_proc_show(struct seq_file
*seq
, void *v
)
491 ide_drive_t
*drive
= (ide_drive_t
*) seq
->private;
492 char *m
= (char *)&drive
->id
[ATA_ID_PROD
];
494 seq_printf(seq
, "%.40s\n", m
[0] ? m
: "(none)");
498 static int ide_dmodel_proc_open(struct inode
*inode
, struct file
*file
)
500 return single_open(file
, ide_dmodel_proc_show
, PDE(inode
)->data
);
503 static const struct file_operations ide_dmodel_proc_fops
= {
504 .owner
= THIS_MODULE
,
505 .open
= ide_dmodel_proc_open
,
508 .release
= single_release
,
511 static int ide_driver_proc_show(struct seq_file
*m
, void *v
)
513 ide_drive_t
*drive
= (ide_drive_t
*)m
->private;
514 struct device
*dev
= &drive
->gendev
;
515 struct ide_driver
*ide_drv
;
518 ide_drv
= to_ide_driver(dev
->driver
);
519 seq_printf(m
, "%s version %s\n",
520 dev
->driver
->name
, ide_drv
->version
);
522 seq_printf(m
, "ide-default version 0.9.newide\n");
526 static int ide_driver_proc_open(struct inode
*inode
, struct file
*file
)
528 return single_open(file
, ide_driver_proc_show
, PDE(inode
)->data
);
531 static int ide_replace_subdriver(ide_drive_t
*drive
, const char *driver
)
533 struct device
*dev
= &drive
->gendev
;
537 device_release_driver(dev
);
538 /* FIXME: device can still be in use by previous driver */
539 strlcpy(drive
->driver_req
, driver
, sizeof(drive
->driver_req
));
540 err
= device_attach(dev
);
542 printk(KERN_WARNING
"IDE: %s: device_attach error: %d\n",
544 drive
->driver_req
[0] = 0;
545 if (dev
->driver
== NULL
) {
546 err
= device_attach(dev
);
549 "IDE: %s: device_attach(2) error: %d\n",
552 if (dev
->driver
&& !strcmp(dev
->driver
->name
, driver
))
558 static ssize_t
ide_driver_proc_write(struct file
*file
, const char __user
*buffer
,
559 size_t count
, loff_t
*pos
)
561 ide_drive_t
*drive
= (ide_drive_t
*) PDE(file
->f_path
.dentry
->d_inode
)->data
;
564 if (!capable(CAP_SYS_ADMIN
))
568 if (copy_from_user(name
, buffer
, count
))
571 if (ide_replace_subdriver(drive
, name
))
576 static const struct file_operations ide_driver_proc_fops
= {
577 .owner
= THIS_MODULE
,
578 .open
= ide_driver_proc_open
,
581 .release
= single_release
,
582 .write
= ide_driver_proc_write
,
585 static int ide_media_proc_show(struct seq_file
*m
, void *v
)
587 ide_drive_t
*drive
= (ide_drive_t
*) m
->private;
590 switch (drive
->media
) {
591 case ide_disk
: media
= "disk\n"; break;
592 case ide_cdrom
: media
= "cdrom\n"; break;
593 case ide_tape
: media
= "tape\n"; break;
594 case ide_floppy
: media
= "floppy\n"; break;
595 case ide_optical
: media
= "optical\n"; break;
596 default: media
= "UNKNOWN\n"; break;
602 static int ide_media_proc_open(struct inode
*inode
, struct file
*file
)
604 return single_open(file
, ide_media_proc_show
, PDE(inode
)->data
);
607 static const struct file_operations ide_media_proc_fops
= {
608 .owner
= THIS_MODULE
,
609 .open
= ide_media_proc_open
,
612 .release
= single_release
,
615 static ide_proc_entry_t generic_drive_entries
[] = {
616 { "driver", S_IFREG
|S_IRUGO
, &ide_driver_proc_fops
},
617 { "identify", S_IFREG
|S_IRUSR
, &ide_identify_proc_fops
},
618 { "media", S_IFREG
|S_IRUGO
, &ide_media_proc_fops
},
619 { "model", S_IFREG
|S_IRUGO
, &ide_dmodel_proc_fops
},
620 { "settings", S_IFREG
|S_IRUSR
|S_IWUSR
, &ide_settings_proc_fops
},
624 static void ide_add_proc_entries(struct proc_dir_entry
*dir
, ide_proc_entry_t
*p
, void *data
)
626 struct proc_dir_entry
*ent
;
630 while (p
->name
!= NULL
) {
631 ent
= proc_create_data(p
->name
, p
->mode
, dir
, p
->proc_fops
, data
);
637 static void ide_remove_proc_entries(struct proc_dir_entry
*dir
, ide_proc_entry_t
*p
)
641 while (p
->name
!= NULL
) {
642 remove_proc_entry(p
->name
, dir
);
647 void ide_proc_register_driver(ide_drive_t
*drive
, struct ide_driver
*driver
)
649 mutex_lock(&ide_setting_mtx
);
650 drive
->settings
= driver
->proc_devsets(drive
);
651 mutex_unlock(&ide_setting_mtx
);
653 ide_add_proc_entries(drive
->proc
, driver
->proc_entries(drive
), drive
);
656 EXPORT_SYMBOL(ide_proc_register_driver
);
659 * ide_proc_unregister_driver - remove driver specific data
663 * Clean up the driver specific /proc files and IDE settings
666 * Takes ide_setting_mtx.
669 void ide_proc_unregister_driver(ide_drive_t
*drive
, struct ide_driver
*driver
)
671 ide_remove_proc_entries(drive
->proc
, driver
->proc_entries(drive
));
673 mutex_lock(&ide_setting_mtx
);
675 * ide_setting_mtx protects both the settings list and the use
676 * of settings (we cannot take a setting out that is being used).
678 drive
->settings
= NULL
;
679 mutex_unlock(&ide_setting_mtx
);
681 EXPORT_SYMBOL(ide_proc_unregister_driver
);
683 void ide_proc_port_register_devices(ide_hwif_t
*hwif
)
685 struct proc_dir_entry
*ent
;
686 struct proc_dir_entry
*parent
= hwif
->proc
;
691 ide_port_for_each_dev(i
, drive
, hwif
) {
692 if ((drive
->dev_flags
& IDE_DFLAG_PRESENT
) == 0)
695 drive
->proc
= proc_mkdir(drive
->name
, parent
);
697 ide_add_proc_entries(drive
->proc
, generic_drive_entries
, drive
);
698 sprintf(name
, "ide%d/%s", (drive
->name
[2]-'a')/2, drive
->name
);
699 ent
= proc_symlink(drive
->name
, proc_ide_root
, name
);
704 void ide_proc_unregister_device(ide_drive_t
*drive
)
707 ide_remove_proc_entries(drive
->proc
, generic_drive_entries
);
708 remove_proc_entry(drive
->name
, proc_ide_root
);
709 remove_proc_entry(drive
->name
, drive
->hwif
->proc
);
714 static ide_proc_entry_t hwif_entries
[] = {
715 { "channel", S_IFREG
|S_IRUGO
, &ide_channel_proc_fops
},
716 { "mate", S_IFREG
|S_IRUGO
, &ide_mate_proc_fops
},
717 { "model", S_IFREG
|S_IRUGO
, &ide_imodel_proc_fops
},
721 void ide_proc_register_port(ide_hwif_t
*hwif
)
724 hwif
->proc
= proc_mkdir(hwif
->name
, proc_ide_root
);
729 ide_add_proc_entries(hwif
->proc
, hwif_entries
, hwif
);
733 void ide_proc_unregister_port(ide_hwif_t
*hwif
)
736 ide_remove_proc_entries(hwif
->proc
, hwif_entries
);
737 remove_proc_entry(hwif
->name
, proc_ide_root
);
742 static int proc_print_driver(struct device_driver
*drv
, void *data
)
744 struct ide_driver
*ide_drv
= to_ide_driver(drv
);
745 struct seq_file
*s
= data
;
747 seq_printf(s
, "%s version %s\n", drv
->name
, ide_drv
->version
);
752 static int ide_drivers_show(struct seq_file
*s
, void *p
)
756 err
= bus_for_each_drv(&ide_bus_type
, NULL
, s
, proc_print_driver
);
758 printk(KERN_WARNING
"IDE: %s: bus_for_each_drv error: %d\n",
763 static int ide_drivers_open(struct inode
*inode
, struct file
*file
)
765 return single_open(file
, &ide_drivers_show
, NULL
);
768 static const struct file_operations ide_drivers_operations
= {
769 .owner
= THIS_MODULE
,
770 .open
= ide_drivers_open
,
773 .release
= single_release
,
776 void proc_ide_create(void)
778 proc_ide_root
= proc_mkdir("ide", NULL
);
783 proc_create("drivers", 0, proc_ide_root
, &ide_drivers_operations
);
786 void proc_ide_destroy(void)
788 remove_proc_entry("drivers", proc_ide_root
);
789 remove_proc_entry("ide", NULL
);