blob: a3133d7b2a0cf91b259eb3fb19db091b4c88bd86 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 1997-1998 Mark Lord
Alan Coxccd32e22008-11-02 21:40:08 +01003 * Copyright (C) 2003 Red Hat
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02004 *
5 * Some code was moved here from ide.c, see it for original copyrights.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7
8/*
9 * This is the /proc/ide/ filesystem implementation.
10 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 */
16
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/module.h>
18
19#include <asm/uaccess.h>
20#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/proc_fs.h>
22#include <linux/stat.h>
23#include <linux/mm.h>
24#include <linux/pci.h>
25#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/ide.h>
27#include <linux/seq_file.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090028#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#include <asm/io.h>
31
Bartlomiej Zolnierkiewicz5cbf79c2007-05-10 00:01:11 +020032static struct proc_dir_entry *proc_ide_root;
33
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070034static int ide_imodel_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070036 ide_hwif_t *hwif = (ide_hwif_t *) m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 const char *name;
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 switch (hwif->chipset) {
Paolo Ciarrocchi441e92d2008-04-26 17:36:40 +020040 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;
Paolo Ciarrocchi441e92d2008-04-26 17:36:40 +020048 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;
Paolo Ciarrocchi441e92d2008-04-26 17:36:40 +020052 case ide_acorn: name = "acorn"; break;
53 default: name = "(unknown)"; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 }
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070055 seq_printf(m, "%s\n", name);
56 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057}
58
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070059static int ide_imodel_proc_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070061 return single_open(file, ide_imodel_proc_show, PDE(inode)->data);
62}
63
64static const struct file_operations ide_imodel_proc_fops = {
65 .owner = THIS_MODULE,
66 .open = ide_imodel_proc_open,
67 .read = seq_read,
68 .llseek = seq_lseek,
69 .release = single_release,
70};
71
72static int ide_mate_proc_show(struct seq_file *m, void *v)
73{
74 ide_hwif_t *hwif = (ide_hwif_t *) m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Bartlomiej Zolnierkiewicz4283e1b2008-06-30 20:14:45 +020076 if (hwif && hwif->mate)
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070077 seq_printf(m, "%s\n", hwif->mate->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 else
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070079 seq_printf(m, "(none)\n");
80 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081}
82
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070083static int ide_mate_proc_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070085 return single_open(file, ide_mate_proc_show, PDE(inode)->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070088static const struct file_operations ide_mate_proc_fops = {
89 .owner = THIS_MODULE,
90 .open = ide_mate_proc_open,
91 .read = seq_read,
92 .llseek = seq_lseek,
93 .release = single_release,
94};
95
96static int ide_channel_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -070098 ide_hwif_t *hwif = (ide_hwif_t *) m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700100 seq_printf(m, "%c\n", hwif->channel ? '1' : '0');
101 return 0;
102}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700104static int ide_channel_proc_open(struct inode *inode, struct file *file)
105{
106 return single_open(file, ide_channel_proc_show, PDE(inode)->data);
107}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700109static const struct file_operations ide_channel_proc_fops = {
110 .owner = THIS_MODULE,
111 .open = ide_channel_proc_open,
112 .read = seq_read,
113 .llseek = seq_lseek,
114 .release = single_release,
115};
Bartlomiej Zolnierkiewicz151a6702008-10-10 22:39:28 +0200116
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700117static int ide_identify_proc_show(struct seq_file *m, void *v)
118{
119 ide_drive_t *drive = (ide_drive_t *)m->private;
120 u8 *buf;
121
122 if (!drive) {
123 seq_putc(m, '\n');
124 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 }
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700126
127 buf = kmalloc(SECTOR_SIZE, GFP_KERNEL);
128 if (!buf)
129 return -ENOMEM;
130 if (taskfile_lib_get_identify(drive, buf) == 0) {
131 __le16 *val = (__le16 *)buf;
132 int i;
133
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' : ' ');
137 }
138 } else
139 seq_putc(m, buf[0]);
140 kfree(buf);
141 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
143
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700144static int ide_identify_proc_open(struct inode *inode, struct file *file)
145{
146 return single_open(file, ide_identify_proc_show, PDE(inode)->data);
147}
148
149static const struct file_operations ide_identify_proc_fops = {
150 .owner = THIS_MODULE,
151 .open = ide_identify_proc_open,
152 .read = seq_read,
153 .llseek = seq_lseek,
154 .release = single_release,
155};
156
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200157/**
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200158 * ide_find_setting - find a specific setting
159 * @st: setting table pointer
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200160 * @name: setting name
161 *
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200162 * Scan's the setting table for a matching entry and returns
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200163 * this or NULL if no entry is found. The caller must hold the
164 * setting semaphore
165 */
166
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200167static
168const struct ide_proc_devset *ide_find_setting(const struct ide_proc_devset *st,
169 char *name)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200170{
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200171 while (st->name) {
172 if (strcmp(st->name, name) == 0)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200173 break;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200174 st++;
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200175 }
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200176 return st->name ? st : NULL;
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200177}
178
179/**
180 * ide_read_setting - read an IDE setting
181 * @drive: drive to read from
182 * @setting: drive setting
183 *
184 * Read a drive setting and return the value. The caller
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200185 * must hold the ide_setting_mtx when making this call.
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200186 *
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
189 * be told apart
190 */
191
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200192static int ide_read_setting(ide_drive_t *drive,
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200193 const struct ide_proc_devset *setting)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200194{
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200195 const struct ide_devset *ds = setting->setting;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200196 int val = -EINVAL;
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200197
Bartlomiej Zolnierkiewicz1f473e92008-12-29 20:27:29 +0100198 if (ds->get)
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200199 val = ds->get(drive);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200200
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200201 return val;
202}
203
204/**
205 * ide_write_setting - read an IDE setting
206 * @drive: drive to read from
207 * @setting: drive setting
208 * @val: value
209 *
210 * Write a drive setting if it is possible. The caller
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200211 * must hold the ide_setting_mtx when making this call.
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200212 *
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
215 * be told apart
216 *
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.
220 */
221
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200222static int ide_write_setting(ide_drive_t *drive,
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200223 const struct ide_proc_devset *setting, int val)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200224{
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200225 const struct ide_devset *ds = setting->setting;
226
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200227 if (!capable(CAP_SYS_ADMIN))
228 return -EACCES;
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200229 if (!ds->set)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200230 return -EPERM;
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200231 if ((ds->flags & DS_SYNC)
232 && (val < setting->min || val > setting->max))
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200233 return -EINVAL;
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200234 return ide_devset_execute(drive, ds, val);
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200235}
236
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200237ide_devset_get(xfer_rate, current_speed);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200238
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200239static int set_xfer_rate (ide_drive_t *drive, int arg)
240{
Bartlomiej Zolnierkiewicz22aa4b32009-03-27 12:46:37 +0100241 struct ide_cmd cmd;
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200242
Bartlomiej Zolnierkiewicz3b2a5c72008-07-23 19:55:56 +0200243 if (arg < XFER_PIO_0 || arg > XFER_UDMA_6)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200244 return -EINVAL;
245
Bartlomiej Zolnierkiewicz22aa4b32009-03-27 12:46:37 +0100246 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;
Sergei Shtylyov60f85012009-04-08 14:13:01 +0200250 cmd.valid.out.tf = IDE_VALID_FEATURE | IDE_VALID_NSECT;
251 cmd.valid.in.tf = IDE_VALID_NSECT;
Bartlomiej Zolnierkiewicz665d66e2009-06-23 11:35:51 +0000252 cmd.tf_flags = IDE_TFLAG_SET_XFER;
Bartlomiej Zolnierkiewicz34f5d5a2008-01-26 20:13:12 +0100253
Bartlomiej Zolnierkiewicz665d66e2009-06-23 11:35:51 +0000254 return ide_no_data_taskfile(drive, &cmd);
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200255}
256
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200257ide_devset_rw(current_speed, xfer_rate);
258ide_devset_rw_field(init_speed, init_speed);
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200259ide_devset_rw_flag(nice1, IDE_DFLAG_NICE1);
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200260ide_devset_rw_field(number, dn);
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200261
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200262static 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),
Hannes Eder71bfc7a2009-03-05 16:10:56 +0100272 { NULL },
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200273};
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275static void proc_ide_settings_warn(void)
276{
Marcin Slusarz01f1afa2009-09-22 16:29:00 -0700277 printk_once(KERN_WARNING "Warning: /proc/ide/hd?/settings interface is "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 "obsolete, and will be removed soon!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279}
280
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700281static int ide_settings_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282{
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200283 const struct ide_proc_devset *setting, *g, *d;
284 const struct ide_devset *ds;
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700285 ide_drive_t *drive = (ide_drive_t *) m->private;
286 int rc, mul_factor, div_factor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 proc_ide_settings_warn();
289
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200290 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200291 g = ide_generic_settings;
292 d = drive->settings;
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700293 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");
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200295 while (g->name || (d && d->name)) {
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200296 /* read settings in the alphabetical order */
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200297 if (g->name && d && d->name) {
298 if (strcmp(d->name, g->name) < 0)
299 setting = d++;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200300 else
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200301 setting = g++;
302 } else if (d && d->name) {
303 setting = d++;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200304 } else
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200305 setting = g++;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200306 mul_factor = setting->mulf ? setting->mulf(drive) : 1;
307 div_factor = setting->divf ? setting->divf(drive) : 1;
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700308 seq_printf(m, "%-24s", setting->name);
Paolo Ciarrocchi441e92d2008-04-26 17:36:40 +0200309 rc = ide_read_setting(drive, setting);
310 if (rc >= 0)
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700311 seq_printf(m, "%-16d", rc * mul_factor / div_factor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 else
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700313 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);
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200315 ds = setting->setting;
316 if (ds->get)
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700317 seq_printf(m, "r");
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200318 if (ds->set)
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700319 seq_printf(m, "w");
320 seq_printf(m, "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 }
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200322 mutex_unlock(&ide_setting_mtx);
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700323 return 0;
324}
325
326static int ide_settings_proc_open(struct inode *inode, struct file *file)
327{
328 return single_open(file, ide_settings_proc_show, PDE(inode)->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329}
330
331#define MAX_LEN 30
332
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700333static ssize_t ide_settings_proc_write(struct file *file, const char __user *buffer,
334 size_t count, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700336 ide_drive_t *drive = (ide_drive_t *) PDE(file->f_path.dentry->d_inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 char name[MAX_LEN + 1];
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200338 int for_real = 0, mul_factor, div_factor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 unsigned long n;
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200340
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200341 const struct ide_proc_devset *setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 char *buf, *s;
343
344 if (!capable(CAP_SYS_ADMIN))
345 return -EACCES;
346
347 proc_ide_settings_warn();
348
349 if (count >= PAGE_SIZE)
350 return -EINVAL;
351
352 s = buf = (char *)__get_free_page(GFP_USER);
353 if (!buf)
354 return -ENOMEM;
355
356 if (copy_from_user(buf, buffer, count)) {
357 free_page((unsigned long)buf);
358 return -EFAULT;
359 }
360
361 buf[count] = '\0';
362
363 /*
364 * Skip over leading whitespace
365 */
366 while (count && isspace(*s)) {
367 --count;
368 ++s;
369 }
370 /*
371 * Do one full pass to verify all parameters,
372 * then do another to actually write the new settings.
373 */
374 do {
375 char *p = s;
376 n = count;
377 while (n > 0) {
378 unsigned val;
379 char *q = p;
380
381 while (n > 0 && *p != ':') {
382 --n;
383 p++;
384 }
385 if (*p != ':')
386 goto parse_error;
387 if (p - q > MAX_LEN)
388 goto parse_error;
389 memcpy(name, q, p - q);
390 name[p - q] = 0;
391
392 if (n > 0) {
393 --n;
394 p++;
395 } else
396 goto parse_error;
397
398 val = simple_strtoul(p, &q, 10);
399 n -= q - p;
400 p = q;
401 if (n > 0 && !isspace(*p))
402 goto parse_error;
403 while (n > 0 && isspace(*p)) {
404 --n;
405 ++p;
406 }
407
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200408 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200409 /* generic settings first, then driver specific ones */
410 setting = ide_find_setting(ide_generic_settings, name);
Paolo Ciarrocchi441e92d2008-04-26 17:36:40 +0200411 if (!setting) {
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200412 if (drive->settings)
413 setting = ide_find_setting(drive->settings, name);
414 if (!setting) {
415 mutex_unlock(&ide_setting_mtx);
416 goto parse_error;
417 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 }
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200419 if (for_real) {
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);
423 }
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200424 mutex_unlock(&ide_setting_mtx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426 } while (!for_real++);
427 free_page((unsigned long)buf);
428 return count;
429parse_error:
430 free_page((unsigned long)buf);
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700431 printk("%s(): parse error\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 return -EINVAL;
433}
434
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700435static const struct file_operations ide_settings_proc_fops = {
436 .owner = THIS_MODULE,
437 .open = ide_settings_proc_open,
438 .read = seq_read,
439 .llseek = seq_lseek,
440 .release = single_release,
441 .write = ide_settings_proc_write,
442};
443
444static int ide_capacity_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700446 seq_printf(m, "%llu\n", (long long)0x7fffffff);
447 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448}
449
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700450static int ide_capacity_proc_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700452 return single_open(file, ide_capacity_proc_show, NULL);
453}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700455const struct file_operations ide_capacity_proc_fops = {
456 .owner = THIS_MODULE,
457 .open = ide_capacity_proc_open,
458 .read = seq_read,
459 .llseek = seq_lseek,
460 .release = single_release,
461};
462EXPORT_SYMBOL_GPL(ide_capacity_proc_fops);
463
464static int ide_geometry_proc_show(struct seq_file *m, void *v)
465{
466 ide_drive_t *drive = (ide_drive_t *) m->private;
467
468 seq_printf(m, "physical %d/%d/%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 drive->cyl, drive->head, drive->sect);
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700470 seq_printf(m, "logical %d/%d/%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 drive->bios_cyl, drive->bios_head, drive->bios_sect);
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700472 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473}
474
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700475static int ide_geometry_proc_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700477 return single_open(file, ide_geometry_proc_show, PDE(inode)->data);
478}
479
480const struct file_operations ide_geometry_proc_fops = {
481 .owner = THIS_MODULE,
482 .open = ide_geometry_proc_open,
483 .read = seq_read,
484 .llseek = seq_lseek,
485 .release = single_release,
486};
487EXPORT_SYMBOL(ide_geometry_proc_fops);
488
489static int ide_dmodel_proc_show(struct seq_file *seq, void *v)
490{
491 ide_drive_t *drive = (ide_drive_t *) seq->private;
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200492 char *m = (char *)&drive->id[ATA_ID_PROD];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700494 seq_printf(seq, "%.40s\n", m[0] ? m : "(none)");
495 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496}
497
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700498static int ide_dmodel_proc_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700500 return single_open(file, ide_dmodel_proc_show, PDE(inode)->data);
501}
502
503static const struct file_operations ide_dmodel_proc_fops = {
504 .owner = THIS_MODULE,
505 .open = ide_dmodel_proc_open,
506 .read = seq_read,
507 .llseek = seq_lseek,
508 .release = single_release,
509};
510
511static int ide_driver_proc_show(struct seq_file *m, void *v)
512{
513 ide_drive_t *drive = (ide_drive_t *)m->private;
Bartlomiej Zolnierkiewicz7f3c8682009-01-06 17:20:53 +0100514 struct device *dev = &drive->gendev;
515 struct ide_driver *ide_drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200517 if (dev->driver) {
Bartlomiej Zolnierkiewicz7f3c8682009-01-06 17:20:53 +0100518 ide_drv = to_ide_driver(dev->driver);
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700519 seq_printf(m, "%s version %s\n",
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200520 dev->driver->name, ide_drv->version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 } else
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700522 seq_printf(m, "ide-default version 0.9.newide\n");
523 return 0;
524}
525
526static int ide_driver_proc_open(struct inode *inode, struct file *file)
527{
528 return single_open(file, ide_driver_proc_show, PDE(inode)->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529}
530
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200531static int ide_replace_subdriver(ide_drive_t *drive, const char *driver)
532{
533 struct device *dev = &drive->gendev;
534 int ret = 1;
Randy Dunlap349ae232006-10-03 01:14:23 -0700535 int err;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200536
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200537 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));
Randy Dunlap349ae232006-10-03 01:14:23 -0700540 err = device_attach(dev);
541 if (err < 0)
542 printk(KERN_WARNING "IDE: %s: device_attach error: %d\n",
Harvey Harrisoneb639632008-04-26 22:25:20 +0200543 __func__, err);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200544 drive->driver_req[0] = 0;
Randy Dunlap349ae232006-10-03 01:14:23 -0700545 if (dev->driver == NULL) {
546 err = device_attach(dev);
547 if (err < 0)
548 printk(KERN_WARNING
549 "IDE: %s: device_attach(2) error: %d\n",
Harvey Harrisoneb639632008-04-26 22:25:20 +0200550 __func__, err);
Randy Dunlap349ae232006-10-03 01:14:23 -0700551 }
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200552 if (dev->driver && !strcmp(dev->driver->name, driver))
553 ret = 0;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200554
555 return ret;
556}
557
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700558static ssize_t ide_driver_proc_write(struct file *file, const char __user *buffer,
559 size_t count, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700561 ide_drive_t *drive = (ide_drive_t *) PDE(file->f_path.dentry->d_inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 char name[32];
563
564 if (!capable(CAP_SYS_ADMIN))
565 return -EACCES;
566 if (count > 31)
567 count = 31;
568 if (copy_from_user(name, buffer, count))
569 return -EFAULT;
570 name[count] = '\0';
571 if (ide_replace_subdriver(drive, name))
572 return -EINVAL;
573 return count;
574}
575
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700576static const struct file_operations ide_driver_proc_fops = {
577 .owner = THIS_MODULE,
578 .open = ide_driver_proc_open,
579 .read = seq_read,
580 .llseek = seq_lseek,
581 .release = single_release,
582 .write = ide_driver_proc_write,
583};
584
585static int ide_media_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700587 ide_drive_t *drive = (ide_drive_t *) m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 const char *media;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
590 switch (drive->media) {
Paolo Ciarrocchi441e92d2008-04-26 17:36:40 +0200591 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 }
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700598 seq_puts(m, media);
599 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700602static int ide_media_proc_open(struct inode *inode, struct file *file)
603{
604 return single_open(file, ide_media_proc_show, PDE(inode)->data);
605}
606
607static const struct file_operations ide_media_proc_fops = {
608 .owner = THIS_MODULE,
609 .open = ide_media_proc_open,
610 .read = seq_read,
611 .llseek = seq_lseek,
612 .release = single_release,
613};
614
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615static ide_proc_entry_t generic_drive_entries[] = {
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700616 { "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},
621 {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622};
623
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200624static void ide_add_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
626 struct proc_dir_entry *ent;
627
628 if (!dir || !p)
629 return;
630 while (p->name != NULL) {
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700631 ent = proc_create_data(p->name, p->mode, dir, p->proc_fops, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 if (!ent) return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 p++;
634 }
635}
636
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200637static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
639 if (!dir || !p)
640 return;
641 while (p->name != NULL) {
642 remove_proc_entry(p->name, dir);
643 p++;
644 }
645}
646
Bartlomiej Zolnierkiewicz7f3c8682009-01-06 17:20:53 +0100647void ide_proc_register_driver(ide_drive_t *drive, struct ide_driver *driver)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200648{
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200649 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz79cb3802008-10-17 18:09:13 +0200650 drive->settings = driver->proc_devsets(drive);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200651 mutex_unlock(&ide_setting_mtx);
652
Bartlomiej Zolnierkiewicz79cb3802008-10-17 18:09:13 +0200653 ide_add_proc_entries(drive->proc, driver->proc_entries(drive), drive);
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200654}
655
656EXPORT_SYMBOL(ide_proc_register_driver);
657
658/**
659 * ide_proc_unregister_driver - remove driver specific data
660 * @drive: drive
661 * @driver: driver
662 *
663 * Clean up the driver specific /proc files and IDE settings
664 * for a given drive.
665 *
Bartlomiej Zolnierkiewicz1f473e92008-12-29 20:27:29 +0100666 * Takes ide_setting_mtx.
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200667 */
668
Bartlomiej Zolnierkiewicz7f3c8682009-01-06 17:20:53 +0100669void ide_proc_unregister_driver(ide_drive_t *drive, struct ide_driver *driver)
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200670{
Bartlomiej Zolnierkiewicz79cb3802008-10-17 18:09:13 +0200671 ide_remove_proc_entries(drive->proc, driver->proc_entries(drive));
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200672
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200673 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200674 /*
Bartlomiej Zolnierkiewicz1f473e92008-12-29 20:27:29 +0100675 * ide_setting_mtx protects both the settings list and the use
676 * of settings (we cannot take a setting out that is being used).
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200677 */
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200678 drive->settings = NULL;
Matthias Kaehlckef9383c42007-07-09 23:17:56 +0200679 mutex_unlock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200680}
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200681EXPORT_SYMBOL(ide_proc_unregister_driver);
682
Bartlomiej Zolnierkiewiczd9270a32008-02-02 19:56:43 +0100683void ide_proc_port_register_devices(ide_hwif_t *hwif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 struct proc_dir_entry *ent;
686 struct proc_dir_entry *parent = hwif->proc;
Bartlomiej Zolnierkiewicz2bd24a12009-01-06 17:20:56 +0100687 ide_drive_t *drive;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 char name[64];
Bartlomiej Zolnierkiewicz2bd24a12009-01-06 17:20:56 +0100689 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Bartlomiej Zolnierkiewicz2bd24a12009-01-06 17:20:56 +0100691 ide_port_for_each_dev(i, drive, hwif) {
Bartlomiej Zolnierkiewicz1902a252009-03-24 23:22:40 +0100692 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 continue;
694
695 drive->proc = proc_mkdir(drive->name, parent);
696 if (drive->proc)
697 ide_add_proc_entries(drive->proc, generic_drive_entries, drive);
Paolo Ciarrocchi441e92d2008-04-26 17:36:40 +0200698 sprintf(name, "ide%d/%s", (drive->name[2]-'a')/2, drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 ent = proc_symlink(drive->name, proc_ide_root, name);
700 if (!ent) return;
701 }
702}
703
Bartlomiej Zolnierkiewicz5b0c4b32008-04-18 00:46:22 +0200704void ide_proc_unregister_device(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
706 if (drive->proc) {
707 ide_remove_proc_entries(drive->proc, generic_drive_entries);
708 remove_proc_entry(drive->name, proc_ide_root);
Bartlomiej Zolnierkiewicz5b0c4b32008-04-18 00:46:22 +0200709 remove_proc_entry(drive->name, drive->hwif->proc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 drive->proc = NULL;
711 }
712}
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714static ide_proc_entry_t hwif_entries[] = {
Alexey Dobriyan6d703a82009-09-01 17:52:57 -0700715 { "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 },
718 {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719};
720
Bartlomiej Zolnierkiewicz5cbf79c2007-05-10 00:01:11 +0200721void ide_proc_register_port(ide_hwif_t *hwif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722{
Bartlomiej Zolnierkiewicz5cbf79c2007-05-10 00:01:11 +0200723 if (!hwif->proc) {
724 hwif->proc = proc_mkdir(hwif->name, proc_ide_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Bartlomiej Zolnierkiewicz5cbf79c2007-05-10 00:01:11 +0200726 if (!hwif->proc)
727 return;
728
729 ide_add_proc_entries(hwif->proc, hwif_entries, hwif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 }
731}
732
Bartlomiej Zolnierkiewicz5cbf79c2007-05-10 00:01:11 +0200733void ide_proc_unregister_port(ide_hwif_t *hwif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
735 if (hwif->proc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 ide_remove_proc_entries(hwif->proc, hwif_entries);
737 remove_proc_entry(hwif->name, proc_ide_root);
738 hwif->proc = NULL;
739 }
740}
741
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200742static int proc_print_driver(struct device_driver *drv, void *data)
743{
Bartlomiej Zolnierkiewicz7f3c8682009-01-06 17:20:53 +0100744 struct ide_driver *ide_drv = to_ide_driver(drv);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200745 struct seq_file *s = data;
746
747 seq_printf(s, "%s version %s\n", drv->name, ide_drv->version);
748
749 return 0;
750}
751
752static int ide_drivers_show(struct seq_file *s, void *p)
753{
Randy Dunlap349ae232006-10-03 01:14:23 -0700754 int err;
755
756 err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver);
757 if (err < 0)
758 printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n",
Harvey Harrisoneb639632008-04-26 22:25:20 +0200759 __func__, err);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200760 return 0;
761}
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763static int ide_drivers_open(struct inode *inode, struct file *file)
764{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200765 return single_open(file, &ide_drivers_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200767
Arjan van de Ven2b8693c2007-02-12 00:55:32 -0800768static const struct file_operations ide_drivers_operations = {
Denis V. Lunevc7705f32008-04-29 01:02:35 -0700769 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 .open = ide_drivers_open,
771 .read = seq_read,
772 .llseek = seq_lseek,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200773 .release = single_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774};
775
776void proc_ide_create(void)
777{
Bartlomiej Zolnierkiewicz5cbf79c2007-05-10 00:01:11 +0200778 proc_ide_root = proc_mkdir("ide", NULL);
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 if (!proc_ide_root)
781 return;
782
Denis V. Lunevc7705f32008-04-29 01:02:35 -0700783 proc_create("drivers", 0, proc_ide_root, &ide_drivers_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784}
785
786void proc_ide_destroy(void)
787{
Zhang, Yanmin643bdc62005-05-16 21:53:11 -0700788 remove_proc_entry("drivers", proc_ide_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 remove_proc_entry("ide", NULL);
790}