Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 | 2 | * Copyright (C) 1997-1998 Mark Lord |
ccd32e22 | 3 | * Copyright (C) 2003 Red Hat |
7662d046 BZ |
4 | * |
5 | * Some code was moved here from ide.c, see it for original copyrights. | |
1da177e4 LT |
6 | */ |
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 | |
1da177e4 LT |
15 | */ |
16 | ||
1da177e4 LT |
17 | #include <linux/module.h> |
18 | ||
19 | #include <asm/uaccess.h> | |
20 | #include <linux/errno.h> | |
1da177e4 LT |
21 | #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> | |
1da177e4 LT |
26 | #include <linux/ide.h> |
27 | #include <linux/seq_file.h> | |
28 | ||
29 | #include <asm/io.h> | |
30 | ||
5cbf79cd BZ |
31 | static struct proc_dir_entry *proc_ide_root; |
32 | ||
6d703a81 | 33 | static int ide_imodel_proc_show(struct seq_file *m, void *v) |
1da177e4 | 34 | { |
6d703a81 | 35 | ide_hwif_t *hwif = (ide_hwif_t *) m->private; |
1da177e4 LT |
36 | const char *name; |
37 | ||
1da177e4 | 38 | switch (hwif->chipset) { |
441e92da PC |
39 | case ide_generic: name = "generic"; break; |
40 | case ide_pci: name = "pci"; break; | |
41 | case ide_cmd640: name = "cmd640"; break; | |
42 | case ide_dtc2278: name = "dtc2278"; break; | |
43 | case ide_ali14xx: name = "ali14xx"; break; | |
44 | case ide_qd65xx: name = "qd65xx"; break; | |
45 | case ide_umc8672: name = "umc8672"; break; | |
46 | case ide_ht6560b: name = "ht6560b"; break; | |
441e92da PC |
47 | case ide_4drives: name = "4drives"; break; |
48 | case ide_pmac: name = "mac-io"; break; | |
49 | case ide_au1xxx: name = "au1xxx"; break; | |
50 | case ide_palm3710: name = "palm3710"; break; | |
441e92da PC |
51 | case ide_acorn: name = "acorn"; break; |
52 | default: name = "(unknown)"; break; | |
1da177e4 | 53 | } |
6d703a81 AD |
54 | seq_printf(m, "%s\n", name); |
55 | return 0; | |
1da177e4 LT |
56 | } |
57 | ||
6d703a81 | 58 | static int ide_imodel_proc_open(struct inode *inode, struct file *file) |
1da177e4 | 59 | { |
6d703a81 AD |
60 | return single_open(file, ide_imodel_proc_show, PDE(inode)->data); |
61 | } | |
62 | ||
63 | static const struct file_operations ide_imodel_proc_fops = { | |
64 | .owner = THIS_MODULE, | |
65 | .open = ide_imodel_proc_open, | |
66 | .read = seq_read, | |
67 | .llseek = seq_lseek, | |
68 | .release = single_release, | |
69 | }; | |
70 | ||
71 | static int ide_mate_proc_show(struct seq_file *m, void *v) | |
72 | { | |
73 | ide_hwif_t *hwif = (ide_hwif_t *) m->private; | |
1da177e4 | 74 | |
4283e1ba | 75 | if (hwif && hwif->mate) |
6d703a81 | 76 | seq_printf(m, "%s\n", hwif->mate->name); |
1da177e4 | 77 | else |
6d703a81 AD |
78 | seq_printf(m, "(none)\n"); |
79 | return 0; | |
1da177e4 LT |
80 | } |
81 | ||
6d703a81 | 82 | static int ide_mate_proc_open(struct inode *inode, struct file *file) |
1da177e4 | 83 | { |
6d703a81 AD |
84 | return single_open(file, ide_mate_proc_show, PDE(inode)->data); |
85 | } | |
1da177e4 | 86 | |
6d703a81 AD |
87 | static const struct file_operations ide_mate_proc_fops = { |
88 | .owner = THIS_MODULE, | |
89 | .open = ide_mate_proc_open, | |
90 | .read = seq_read, | |
91 | .llseek = seq_lseek, | |
92 | .release = single_release, | |
93 | }; | |
94 | ||
95 | static int ide_channel_proc_show(struct seq_file *m, void *v) | |
96 | { | |
97 | ide_hwif_t *hwif = (ide_hwif_t *) m->private; | |
98 | ||
99 | seq_printf(m, "%c\n", hwif->channel ? '1' : '0'); | |
100 | return 0; | |
1da177e4 LT |
101 | } |
102 | ||
6d703a81 | 103 | static int ide_channel_proc_open(struct inode *inode, struct file *file) |
1da177e4 | 104 | { |
6d703a81 AD |
105 | return single_open(file, ide_channel_proc_show, PDE(inode)->data); |
106 | } | |
107 | ||
108 | static const struct file_operations ide_channel_proc_fops = { | |
109 | .owner = THIS_MODULE, | |
110 | .open = ide_channel_proc_open, | |
111 | .read = seq_read, | |
112 | .llseek = seq_lseek, | |
113 | .release = single_release, | |
114 | }; | |
1da177e4 | 115 | |
6d703a81 AD |
116 | static int ide_identify_proc_show(struct seq_file *m, void *v) |
117 | { | |
118 | ide_drive_t *drive = (ide_drive_t *)m->private; | |
119 | u8 *buf; | |
1da177e4 | 120 | |
6d703a81 AD |
121 | if (!drive) { |
122 | seq_putc(m, '\n'); | |
123 | return 0; | |
124 | } | |
1da177e4 | 125 | |
6d703a81 AD |
126 | buf = kmalloc(SECTOR_SIZE, GFP_KERNEL); |
127 | if (!buf) | |
128 | return -ENOMEM; | |
129 | if (taskfile_lib_get_identify(drive, buf) == 0) { | |
130 | __le16 *val = (__le16 *)buf; | |
131 | int i; | |
151a6701 | 132 | |
6d703a81 AD |
133 | for (i = 0; i < SECTOR_SIZE / 2; i++) { |
134 | seq_printf(m, "%04x%c", le16_to_cpu(val[i]), | |
135 | (i % 8) == 7 ? '\n' : ' '); | |
1da177e4 | 136 | } |
6d703a81 AD |
137 | } else |
138 | seq_putc(m, buf[0]); | |
139 | kfree(buf); | |
140 | return 0; | |
1da177e4 LT |
141 | } |
142 | ||
6d703a81 AD |
143 | static int ide_identify_proc_open(struct inode *inode, struct file *file) |
144 | { | |
145 | return single_open(file, ide_identify_proc_show, PDE(inode)->data); | |
146 | } | |
147 | ||
148 | static const struct file_operations ide_identify_proc_fops = { | |
149 | .owner = THIS_MODULE, | |
150 | .open = ide_identify_proc_open, | |
151 | .read = seq_read, | |
152 | .llseek = seq_lseek, | |
153 | .release = single_release, | |
154 | }; | |
155 | ||
7662d046 | 156 | /** |
8185d5aa BZ |
157 | * ide_find_setting - find a specific setting |
158 | * @st: setting table pointer | |
7662d046 | 159 | * @name: setting name |
7662d046 | 160 | * |
8185d5aa | 161 | * Scan's the setting table for a matching entry and returns |
7662d046 BZ |
162 | * this or NULL if no entry is found. The caller must hold the |
163 | * setting semaphore | |
164 | */ | |
165 | ||
92f1f8fd EO |
166 | static |
167 | const struct ide_proc_devset *ide_find_setting(const struct ide_proc_devset *st, | |
168 | char *name) | |
7662d046 | 169 | { |
92f1f8fd EO |
170 | while (st->name) { |
171 | if (strcmp(st->name, name) == 0) | |
7662d046 | 172 | break; |
8185d5aa | 173 | st++; |
7662d046 | 174 | } |
92f1f8fd | 175 | return st->name ? st : NULL; |
7662d046 BZ |
176 | } |
177 | ||
178 | /** | |
179 | * ide_read_setting - read an IDE setting | |
180 | * @drive: drive to read from | |
181 | * @setting: drive setting | |
182 | * | |
183 | * Read a drive setting and return the value. The caller | |
f9383c42 | 184 | * must hold the ide_setting_mtx when making this call. |
7662d046 BZ |
185 | * |
186 | * BUGS: the data return and error are the same return value | |
187 | * so an error -EINVAL and true return of the same value cannot | |
188 | * be told apart | |
189 | */ | |
190 | ||
8185d5aa | 191 | static int ide_read_setting(ide_drive_t *drive, |
92f1f8fd | 192 | const struct ide_proc_devset *setting) |
7662d046 | 193 | { |
92f1f8fd | 194 | const struct ide_devset *ds = setting->setting; |
8185d5aa BZ |
195 | int val = -EINVAL; |
196 | ||
1f473e9c | 197 | if (ds->get) |
92f1f8fd | 198 | val = ds->get(drive); |
8185d5aa | 199 | |
7662d046 BZ |
200 | return val; |
201 | } | |
202 | ||
203 | /** | |
204 | * ide_write_setting - read an IDE setting | |
205 | * @drive: drive to read from | |
206 | * @setting: drive setting | |
207 | * @val: value | |
208 | * | |
209 | * Write a drive setting if it is possible. The caller | |
f9383c42 | 210 | * must hold the ide_setting_mtx when making this call. |
7662d046 BZ |
211 | * |
212 | * BUGS: the data return and error are the same return value | |
213 | * so an error -EINVAL and true return of the same value cannot | |
214 | * be told apart | |
215 | * | |
216 | * FIXME: This should be changed to enqueue a special request | |
217 | * to the driver to change settings, and then wait on a sema for completion. | |
218 | * The current scheme of polling is kludgy, though safe enough. | |
219 | */ | |
220 | ||
8185d5aa | 221 | static int ide_write_setting(ide_drive_t *drive, |
92f1f8fd | 222 | const struct ide_proc_devset *setting, int val) |
7662d046 | 223 | { |
92f1f8fd EO |
224 | const struct ide_devset *ds = setting->setting; |
225 | ||
7662d046 BZ |
226 | if (!capable(CAP_SYS_ADMIN)) |
227 | return -EACCES; | |
92f1f8fd | 228 | if (!ds->set) |
7662d046 | 229 | return -EPERM; |
92f1f8fd EO |
230 | if ((ds->flags & DS_SYNC) |
231 | && (val < setting->min || val > setting->max)) | |
7662d046 | 232 | return -EINVAL; |
92f1f8fd | 233 | return ide_devset_execute(drive, ds, val); |
7662d046 BZ |
234 | } |
235 | ||
92f1f8fd | 236 | ide_devset_get(xfer_rate, current_speed); |
8185d5aa | 237 | |
7662d046 BZ |
238 | static int set_xfer_rate (ide_drive_t *drive, int arg) |
239 | { | |
22aa4b32 | 240 | struct ide_cmd cmd; |
7662d046 | 241 | |
3b2a5c71 | 242 | if (arg < XFER_PIO_0 || arg > XFER_UDMA_6) |
7662d046 BZ |
243 | return -EINVAL; |
244 | ||
22aa4b32 BZ |
245 | memset(&cmd, 0, sizeof(cmd)); |
246 | cmd.tf.command = ATA_CMD_SET_FEATURES; | |
247 | cmd.tf.feature = SETFEATURES_XFER; | |
248 | cmd.tf.nsect = (u8)arg; | |
60f85019 SS |
249 | cmd.valid.out.tf = IDE_VALID_FEATURE | IDE_VALID_NSECT; |
250 | cmd.valid.in.tf = IDE_VALID_NSECT; | |
665d66e8 | 251 | cmd.tf_flags = IDE_TFLAG_SET_XFER; |
34f5d5ae | 252 | |
665d66e8 | 253 | return ide_no_data_taskfile(drive, &cmd); |
7662d046 BZ |
254 | } |
255 | ||
92f1f8fd EO |
256 | ide_devset_rw(current_speed, xfer_rate); |
257 | ide_devset_rw_field(init_speed, init_speed); | |
97100fc8 | 258 | ide_devset_rw_flag(nice1, IDE_DFLAG_NICE1); |
92f1f8fd EO |
259 | ide_devset_rw_field(number, dn); |
260 | ||
261 | static const struct ide_proc_devset ide_generic_settings[] = { | |
262 | IDE_PROC_DEVSET(current_speed, 0, 70), | |
263 | IDE_PROC_DEVSET(init_speed, 0, 70), | |
264 | IDE_PROC_DEVSET(io_32bit, 0, 1 + (SUPPORT_VLB_SYNC << 1)), | |
265 | IDE_PROC_DEVSET(keepsettings, 0, 1), | |
266 | IDE_PROC_DEVSET(nice1, 0, 1), | |
267 | IDE_PROC_DEVSET(number, 0, 3), | |
268 | IDE_PROC_DEVSET(pio_mode, 0, 255), | |
269 | IDE_PROC_DEVSET(unmaskirq, 0, 1), | |
270 | IDE_PROC_DEVSET(using_dma, 0, 1), | |
71bfc7a7 | 271 | { NULL }, |
8185d5aa | 272 | }; |
7662d046 | 273 | |
1da177e4 LT |
274 | static void proc_ide_settings_warn(void) |
275 | { | |
441e92da | 276 | static int warned; |
1da177e4 LT |
277 | |
278 | if (warned) | |
279 | return; | |
280 | ||
281 | printk(KERN_WARNING "Warning: /proc/ide/hd?/settings interface is " | |
282 | "obsolete, and will be removed soon!\n"); | |
283 | warned = 1; | |
284 | } | |
285 | ||
6d703a81 | 286 | static int ide_settings_proc_show(struct seq_file *m, void *v) |
1da177e4 | 287 | { |
92f1f8fd EO |
288 | const struct ide_proc_devset *setting, *g, *d; |
289 | const struct ide_devset *ds; | |
6d703a81 AD |
290 | ide_drive_t *drive = (ide_drive_t *) m->private; |
291 | int rc, mul_factor, div_factor; | |
1da177e4 LT |
292 | |
293 | proc_ide_settings_warn(); | |
294 | ||
f9383c42 | 295 | mutex_lock(&ide_setting_mtx); |
8185d5aa BZ |
296 | g = ide_generic_settings; |
297 | d = drive->settings; | |
6d703a81 AD |
298 | seq_printf(m, "name\t\t\tvalue\t\tmin\t\tmax\t\tmode\n"); |
299 | seq_printf(m, "----\t\t\t-----\t\t---\t\t---\t\t----\n"); | |
92f1f8fd | 300 | while (g->name || (d && d->name)) { |
8185d5aa | 301 | /* read settings in the alphabetical order */ |
92f1f8fd EO |
302 | if (g->name && d && d->name) { |
303 | if (strcmp(d->name, g->name) < 0) | |
304 | setting = d++; | |
8185d5aa | 305 | else |
92f1f8fd EO |
306 | setting = g++; |
307 | } else if (d && d->name) { | |
308 | setting = d++; | |
8185d5aa | 309 | } else |
92f1f8fd | 310 | setting = g++; |
8185d5aa BZ |
311 | mul_factor = setting->mulf ? setting->mulf(drive) : 1; |
312 | div_factor = setting->divf ? setting->divf(drive) : 1; | |
6d703a81 | 313 | seq_printf(m, "%-24s", setting->name); |
441e92da PC |
314 | rc = ide_read_setting(drive, setting); |
315 | if (rc >= 0) | |
6d703a81 | 316 | seq_printf(m, "%-16d", rc * mul_factor / div_factor); |
1da177e4 | 317 | else |
6d703a81 AD |
318 | seq_printf(m, "%-16s", "write-only"); |
319 | seq_printf(m, "%-16d%-16d", (setting->min * mul_factor + div_factor - 1) / div_factor, setting->max * mul_factor / div_factor); | |
92f1f8fd EO |
320 | ds = setting->setting; |
321 | if (ds->get) | |
6d703a81 | 322 | seq_printf(m, "r"); |
92f1f8fd | 323 | if (ds->set) |
6d703a81 AD |
324 | seq_printf(m, "w"); |
325 | seq_printf(m, "\n"); | |
1da177e4 | 326 | } |
f9383c42 | 327 | mutex_unlock(&ide_setting_mtx); |
6d703a81 AD |
328 | return 0; |
329 | } | |
330 | ||
331 | static int ide_settings_proc_open(struct inode *inode, struct file *file) | |
332 | { | |
333 | return single_open(file, ide_settings_proc_show, PDE(inode)->data); | |
1da177e4 LT |
334 | } |
335 | ||
336 | #define MAX_LEN 30 | |
337 | ||
6d703a81 AD |
338 | static ssize_t ide_settings_proc_write(struct file *file, const char __user *buffer, |
339 | size_t count, loff_t *pos) | |
1da177e4 | 340 | { |
6d703a81 | 341 | ide_drive_t *drive = (ide_drive_t *) PDE(file->f_path.dentry->d_inode)->data; |
1da177e4 | 342 | char name[MAX_LEN + 1]; |
8185d5aa | 343 | int for_real = 0, mul_factor, div_factor; |
1da177e4 | 344 | unsigned long n; |
8185d5aa | 345 | |
92f1f8fd | 346 | const struct ide_proc_devset *setting; |
1da177e4 LT |
347 | char *buf, *s; |
348 | ||
349 | if (!capable(CAP_SYS_ADMIN)) | |
350 | return -EACCES; | |
351 | ||
352 | proc_ide_settings_warn(); | |
353 | ||
354 | if (count >= PAGE_SIZE) | |
355 | return -EINVAL; | |
356 | ||
357 | s = buf = (char *)__get_free_page(GFP_USER); | |
358 | if (!buf) | |
359 | return -ENOMEM; | |
360 | ||
361 | if (copy_from_user(buf, buffer, count)) { | |
362 | free_page((unsigned long)buf); | |
363 | return -EFAULT; | |
364 | } | |
365 | ||
366 | buf[count] = '\0'; | |
367 | ||
368 | /* | |
369 | * Skip over leading whitespace | |
370 | */ | |
371 | while (count && isspace(*s)) { | |
372 | --count; | |
373 | ++s; | |
374 | } | |
375 | /* | |
376 | * Do one full pass to verify all parameters, | |
377 | * then do another to actually write the new settings. | |
378 | */ | |
379 | do { | |
380 | char *p = s; | |
381 | n = count; | |
382 | while (n > 0) { | |
383 | unsigned val; | |
384 | char *q = p; | |
385 | ||
386 | while (n > 0 && *p != ':') { | |
387 | --n; | |
388 | p++; | |
389 | } | |
390 | if (*p != ':') | |
391 | goto parse_error; | |
392 | if (p - q > MAX_LEN) | |
393 | goto parse_error; | |
394 | memcpy(name, q, p - q); | |
395 | name[p - q] = 0; | |
396 | ||
397 | if (n > 0) { | |
398 | --n; | |
399 | p++; | |
400 | } else | |
401 | goto parse_error; | |
402 | ||
403 | val = simple_strtoul(p, &q, 10); | |
404 | n -= q - p; | |
405 | p = q; | |
406 | if (n > 0 && !isspace(*p)) | |
407 | goto parse_error; | |
408 | while (n > 0 && isspace(*p)) { | |
409 | --n; | |
410 | ++p; | |
411 | } | |
412 | ||
f9383c42 | 413 | mutex_lock(&ide_setting_mtx); |
8185d5aa BZ |
414 | /* generic settings first, then driver specific ones */ |
415 | setting = ide_find_setting(ide_generic_settings, name); | |
441e92da | 416 | if (!setting) { |
8185d5aa BZ |
417 | if (drive->settings) |
418 | setting = ide_find_setting(drive->settings, name); | |
419 | if (!setting) { | |
420 | mutex_unlock(&ide_setting_mtx); | |
421 | goto parse_error; | |
422 | } | |
423 | } | |
424 | if (for_real) { | |
425 | mul_factor = setting->mulf ? setting->mulf(drive) : 1; | |
426 | div_factor = setting->divf ? setting->divf(drive) : 1; | |
427 | ide_write_setting(drive, setting, val * div_factor / mul_factor); | |
1da177e4 | 428 | } |
f9383c42 | 429 | mutex_unlock(&ide_setting_mtx); |
1da177e4 LT |
430 | } |
431 | } while (!for_real++); | |
432 | free_page((unsigned long)buf); | |
433 | return count; | |
434 | parse_error: | |
435 | free_page((unsigned long)buf); | |
6d703a81 | 436 | printk("%s(): parse error\n", __func__); |
1da177e4 LT |
437 | return -EINVAL; |
438 | } | |
439 | ||
6d703a81 AD |
440 | static const struct file_operations ide_settings_proc_fops = { |
441 | .owner = THIS_MODULE, | |
442 | .open = ide_settings_proc_open, | |
443 | .read = seq_read, | |
444 | .llseek = seq_lseek, | |
445 | .release = single_release, | |
446 | .write = ide_settings_proc_write, | |
447 | }; | |
448 | ||
449 | static int ide_capacity_proc_show(struct seq_file *m, void *v) | |
1da177e4 | 450 | { |
6d703a81 AD |
451 | seq_printf(m, "%llu\n", (long long)0x7fffffff); |
452 | return 0; | |
1da177e4 LT |
453 | } |
454 | ||
6d703a81 AD |
455 | static int ide_capacity_proc_open(struct inode *inode, struct file *file) |
456 | { | |
457 | return single_open(file, ide_capacity_proc_show, NULL); | |
458 | } | |
459 | ||
460 | const struct file_operations ide_capacity_proc_fops = { | |
461 | .owner = THIS_MODULE, | |
462 | .open = ide_capacity_proc_open, | |
463 | .read = seq_read, | |
464 | .llseek = seq_lseek, | |
465 | .release = single_release, | |
466 | }; | |
467 | EXPORT_SYMBOL_GPL(ide_capacity_proc_fops); | |
1da177e4 | 468 | |
6d703a81 | 469 | static int ide_geometry_proc_show(struct seq_file *m, void *v) |
1da177e4 | 470 | { |
6d703a81 | 471 | ide_drive_t *drive = (ide_drive_t *) m->private; |
1da177e4 | 472 | |
6d703a81 | 473 | seq_printf(m, "physical %d/%d/%d\n", |
1da177e4 | 474 | drive->cyl, drive->head, drive->sect); |
6d703a81 | 475 | seq_printf(m, "logical %d/%d/%d\n", |
1da177e4 | 476 | drive->bios_cyl, drive->bios_head, drive->bios_sect); |
6d703a81 AD |
477 | return 0; |
478 | } | |
1da177e4 | 479 | |
6d703a81 AD |
480 | static int ide_geometry_proc_open(struct inode *inode, struct file *file) |
481 | { | |
482 | return single_open(file, ide_geometry_proc_show, PDE(inode)->data); | |
1da177e4 LT |
483 | } |
484 | ||
6d703a81 AD |
485 | const struct file_operations ide_geometry_proc_fops = { |
486 | .owner = THIS_MODULE, | |
487 | .open = ide_geometry_proc_open, | |
488 | .read = seq_read, | |
489 | .llseek = seq_lseek, | |
490 | .release = single_release, | |
491 | }; | |
492 | EXPORT_SYMBOL(ide_geometry_proc_fops); | |
1da177e4 | 493 | |
6d703a81 | 494 | static int ide_dmodel_proc_show(struct seq_file *seq, void *v) |
1da177e4 | 495 | { |
6d703a81 | 496 | ide_drive_t *drive = (ide_drive_t *) seq->private; |
4dde4492 | 497 | char *m = (char *)&drive->id[ATA_ID_PROD]; |
1da177e4 | 498 | |
6d703a81 AD |
499 | seq_printf(seq, "%.40s\n", m[0] ? m : "(none)"); |
500 | return 0; | |
1da177e4 LT |
501 | } |
502 | ||
6d703a81 | 503 | static int ide_dmodel_proc_open(struct inode *inode, struct file *file) |
1da177e4 | 504 | { |
6d703a81 AD |
505 | return single_open(file, ide_dmodel_proc_show, PDE(inode)->data); |
506 | } | |
507 | ||
508 | static const struct file_operations ide_dmodel_proc_fops = { | |
509 | .owner = THIS_MODULE, | |
510 | .open = ide_dmodel_proc_open, | |
511 | .read = seq_read, | |
512 | .llseek = seq_lseek, | |
513 | .release = single_release, | |
514 | }; | |
515 | ||
516 | static int ide_driver_proc_show(struct seq_file *m, void *v) | |
517 | { | |
518 | ide_drive_t *drive = (ide_drive_t *)m->private; | |
7f3c868b BZ |
519 | struct device *dev = &drive->gendev; |
520 | struct ide_driver *ide_drv; | |
1da177e4 | 521 | |
8604affd | 522 | if (dev->driver) { |
7f3c868b | 523 | ide_drv = to_ide_driver(dev->driver); |
6d703a81 | 524 | seq_printf(m, "%s version %s\n", |
8604affd | 525 | dev->driver->name, ide_drv->version); |
1da177e4 | 526 | } else |
6d703a81 AD |
527 | seq_printf(m, "ide-default version 0.9.newide\n"); |
528 | return 0; | |
529 | } | |
530 | ||
531 | static int ide_driver_proc_open(struct inode *inode, struct file *file) | |
532 | { | |
533 | return single_open(file, ide_driver_proc_show, PDE(inode)->data); | |
1da177e4 LT |
534 | } |
535 | ||
8604affd BZ |
536 | static int ide_replace_subdriver(ide_drive_t *drive, const char *driver) |
537 | { | |
538 | struct device *dev = &drive->gendev; | |
539 | int ret = 1; | |
349ae23f | 540 | int err; |
8604affd | 541 | |
8604affd BZ |
542 | device_release_driver(dev); |
543 | /* FIXME: device can still be in use by previous driver */ | |
544 | strlcpy(drive->driver_req, driver, sizeof(drive->driver_req)); | |
349ae23f RD |
545 | err = device_attach(dev); |
546 | if (err < 0) | |
547 | printk(KERN_WARNING "IDE: %s: device_attach error: %d\n", | |
eb63963a | 548 | __func__, err); |
8604affd | 549 | drive->driver_req[0] = 0; |
349ae23f RD |
550 | if (dev->driver == NULL) { |
551 | err = device_attach(dev); | |
552 | if (err < 0) | |
553 | printk(KERN_WARNING | |
554 | "IDE: %s: device_attach(2) error: %d\n", | |
eb63963a | 555 | __func__, err); |
349ae23f | 556 | } |
8604affd BZ |
557 | if (dev->driver && !strcmp(dev->driver->name, driver)) |
558 | ret = 0; | |
8604affd BZ |
559 | |
560 | return ret; | |
561 | } | |
562 | ||
6d703a81 AD |
563 | static ssize_t ide_driver_proc_write(struct file *file, const char __user *buffer, |
564 | size_t count, loff_t *pos) | |
1da177e4 | 565 | { |
6d703a81 | 566 | ide_drive_t *drive = (ide_drive_t *) PDE(file->f_path.dentry->d_inode)->data; |
1da177e4 LT |
567 | char name[32]; |
568 | ||
569 | if (!capable(CAP_SYS_ADMIN)) | |
570 | return -EACCES; | |
571 | if (count > 31) | |
572 | count = 31; | |
573 | if (copy_from_user(name, buffer, count)) | |
574 | return -EFAULT; | |
575 | name[count] = '\0'; | |
576 | if (ide_replace_subdriver(drive, name)) | |
577 | return -EINVAL; | |
578 | return count; | |
579 | } | |
580 | ||
6d703a81 AD |
581 | static const struct file_operations ide_driver_proc_fops = { |
582 | .owner = THIS_MODULE, | |
583 | .open = ide_driver_proc_open, | |
584 | .read = seq_read, | |
585 | .llseek = seq_lseek, | |
586 | .release = single_release, | |
587 | .write = ide_driver_proc_write, | |
588 | }; | |
589 | ||
590 | static int ide_media_proc_show(struct seq_file *m, void *v) | |
1da177e4 | 591 | { |
6d703a81 | 592 | ide_drive_t *drive = (ide_drive_t *) m->private; |
1da177e4 | 593 | const char *media; |
1da177e4 LT |
594 | |
595 | switch (drive->media) { | |
441e92da PC |
596 | case ide_disk: media = "disk\n"; break; |
597 | case ide_cdrom: media = "cdrom\n"; break; | |
598 | case ide_tape: media = "tape\n"; break; | |
599 | case ide_floppy: media = "floppy\n"; break; | |
600 | case ide_optical: media = "optical\n"; break; | |
601 | default: media = "UNKNOWN\n"; break; | |
1da177e4 | 602 | } |
6d703a81 AD |
603 | seq_puts(m, media); |
604 | return 0; | |
605 | } | |
606 | ||
607 | static int ide_media_proc_open(struct inode *inode, struct file *file) | |
608 | { | |
609 | return single_open(file, ide_media_proc_show, PDE(inode)->data); | |
1da177e4 LT |
610 | } |
611 | ||
6d703a81 AD |
612 | static const struct file_operations ide_media_proc_fops = { |
613 | .owner = THIS_MODULE, | |
614 | .open = ide_media_proc_open, | |
615 | .read = seq_read, | |
616 | .llseek = seq_lseek, | |
617 | .release = single_release, | |
618 | }; | |
619 | ||
1da177e4 | 620 | static ide_proc_entry_t generic_drive_entries[] = { |
6d703a81 AD |
621 | { "driver", S_IFREG|S_IRUGO, &ide_driver_proc_fops }, |
622 | { "identify", S_IFREG|S_IRUSR, &ide_identify_proc_fops}, | |
623 | { "media", S_IFREG|S_IRUGO, &ide_media_proc_fops }, | |
624 | { "model", S_IFREG|S_IRUGO, &ide_dmodel_proc_fops }, | |
625 | { "settings", S_IFREG|S_IRUSR|S_IWUSR, &ide_settings_proc_fops}, | |
626 | {} | |
1da177e4 LT |
627 | }; |
628 | ||
7662d046 | 629 | static void ide_add_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p, void *data) |
1da177e4 LT |
630 | { |
631 | struct proc_dir_entry *ent; | |
632 | ||
633 | if (!dir || !p) | |
634 | return; | |
635 | while (p->name != NULL) { | |
6d703a81 | 636 | ent = proc_create_data(p->name, p->mode, dir, p->proc_fops, data); |
1da177e4 | 637 | if (!ent) return; |
1da177e4 LT |
638 | p++; |
639 | } | |
640 | } | |
641 | ||
7662d046 | 642 | static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p) |
1da177e4 LT |
643 | { |
644 | if (!dir || !p) | |
645 | return; | |
646 | while (p->name != NULL) { | |
647 | remove_proc_entry(p->name, dir); | |
648 | p++; | |
649 | } | |
650 | } | |
651 | ||
7f3c868b | 652 | void ide_proc_register_driver(ide_drive_t *drive, struct ide_driver *driver) |
7662d046 | 653 | { |
8185d5aa | 654 | mutex_lock(&ide_setting_mtx); |
79cb3803 | 655 | drive->settings = driver->proc_devsets(drive); |
8185d5aa BZ |
656 | mutex_unlock(&ide_setting_mtx); |
657 | ||
79cb3803 | 658 | ide_add_proc_entries(drive->proc, driver->proc_entries(drive), drive); |
7662d046 BZ |
659 | } |
660 | ||
661 | EXPORT_SYMBOL(ide_proc_register_driver); | |
662 | ||
663 | /** | |
664 | * ide_proc_unregister_driver - remove driver specific data | |
665 | * @drive: drive | |
666 | * @driver: driver | |
667 | * | |
668 | * Clean up the driver specific /proc files and IDE settings | |
669 | * for a given drive. | |
670 | * | |
1f473e9c | 671 | * Takes ide_setting_mtx. |
7662d046 BZ |
672 | */ |
673 | ||
7f3c868b | 674 | void ide_proc_unregister_driver(ide_drive_t *drive, struct ide_driver *driver) |
7662d046 | 675 | { |
79cb3803 | 676 | ide_remove_proc_entries(drive->proc, driver->proc_entries(drive)); |
7662d046 | 677 | |
f9383c42 | 678 | mutex_lock(&ide_setting_mtx); |
7662d046 | 679 | /* |
1f473e9c BZ |
680 | * ide_setting_mtx protects both the settings list and the use |
681 | * of settings (we cannot take a setting out that is being used). | |
7662d046 | 682 | */ |
8185d5aa | 683 | drive->settings = NULL; |
f9383c42 | 684 | mutex_unlock(&ide_setting_mtx); |
7662d046 | 685 | } |
7662d046 BZ |
686 | EXPORT_SYMBOL(ide_proc_unregister_driver); |
687 | ||
d9270a3f | 688 | void ide_proc_port_register_devices(ide_hwif_t *hwif) |
1da177e4 | 689 | { |
1da177e4 LT |
690 | struct proc_dir_entry *ent; |
691 | struct proc_dir_entry *parent = hwif->proc; | |
2bd24a1c | 692 | ide_drive_t *drive; |
1da177e4 | 693 | char name[64]; |
2bd24a1c | 694 | int i; |
1da177e4 | 695 | |
2bd24a1c | 696 | ide_port_for_each_dev(i, drive, hwif) { |
1902a253 | 697 | if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0) |
1da177e4 LT |
698 | continue; |
699 | ||
700 | drive->proc = proc_mkdir(drive->name, parent); | |
701 | if (drive->proc) | |
702 | ide_add_proc_entries(drive->proc, generic_drive_entries, drive); | |
441e92da | 703 | sprintf(name, "ide%d/%s", (drive->name[2]-'a')/2, drive->name); |
1da177e4 LT |
704 | ent = proc_symlink(drive->name, proc_ide_root, name); |
705 | if (!ent) return; | |
706 | } | |
707 | } | |
708 | ||
5b0c4b30 | 709 | void ide_proc_unregister_device(ide_drive_t *drive) |
1da177e4 LT |
710 | { |
711 | if (drive->proc) { | |
712 | ide_remove_proc_entries(drive->proc, generic_drive_entries); | |
713 | remove_proc_entry(drive->name, proc_ide_root); | |
5b0c4b30 | 714 | remove_proc_entry(drive->name, drive->hwif->proc); |
1da177e4 LT |
715 | drive->proc = NULL; |
716 | } | |
717 | } | |
718 | ||
1da177e4 | 719 | static ide_proc_entry_t hwif_entries[] = { |
6d703a81 AD |
720 | { "channel", S_IFREG|S_IRUGO, &ide_channel_proc_fops }, |
721 | { "mate", S_IFREG|S_IRUGO, &ide_mate_proc_fops }, | |
722 | { "model", S_IFREG|S_IRUGO, &ide_imodel_proc_fops }, | |
723 | {} | |
1da177e4 LT |
724 | }; |
725 | ||
5cbf79cd | 726 | void ide_proc_register_port(ide_hwif_t *hwif) |
1da177e4 | 727 | { |
5cbf79cd BZ |
728 | if (!hwif->proc) { |
729 | hwif->proc = proc_mkdir(hwif->name, proc_ide_root); | |
1da177e4 | 730 | |
5cbf79cd BZ |
731 | if (!hwif->proc) |
732 | return; | |
733 | ||
734 | ide_add_proc_entries(hwif->proc, hwif_entries, hwif); | |
1da177e4 LT |
735 | } |
736 | } | |
737 | ||
5cbf79cd | 738 | void ide_proc_unregister_port(ide_hwif_t *hwif) |
1da177e4 LT |
739 | { |
740 | if (hwif->proc) { | |
1da177e4 LT |
741 | ide_remove_proc_entries(hwif->proc, hwif_entries); |
742 | remove_proc_entry(hwif->name, proc_ide_root); | |
743 | hwif->proc = NULL; | |
744 | } | |
745 | } | |
746 | ||
8604affd BZ |
747 | static int proc_print_driver(struct device_driver *drv, void *data) |
748 | { | |
7f3c868b | 749 | struct ide_driver *ide_drv = to_ide_driver(drv); |
8604affd BZ |
750 | struct seq_file *s = data; |
751 | ||
752 | seq_printf(s, "%s version %s\n", drv->name, ide_drv->version); | |
753 | ||
754 | return 0; | |
755 | } | |
756 | ||
757 | static int ide_drivers_show(struct seq_file *s, void *p) | |
758 | { | |
349ae23f RD |
759 | int err; |
760 | ||
761 | err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver); | |
762 | if (err < 0) | |
763 | printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n", | |
eb63963a | 764 | __func__, err); |
8604affd BZ |
765 | return 0; |
766 | } | |
767 | ||
1da177e4 LT |
768 | static int ide_drivers_open(struct inode *inode, struct file *file) |
769 | { | |
8604affd | 770 | return single_open(file, &ide_drivers_show, NULL); |
1da177e4 | 771 | } |
8604affd | 772 | |
2b8693c0 | 773 | static const struct file_operations ide_drivers_operations = { |
c7705f34 | 774 | .owner = THIS_MODULE, |
1da177e4 LT |
775 | .open = ide_drivers_open, |
776 | .read = seq_read, | |
777 | .llseek = seq_lseek, | |
8604affd | 778 | .release = single_release, |
1da177e4 LT |
779 | }; |
780 | ||
781 | void proc_ide_create(void) | |
782 | { | |
5cbf79cd BZ |
783 | proc_ide_root = proc_mkdir("ide", NULL); |
784 | ||
1da177e4 LT |
785 | if (!proc_ide_root) |
786 | return; | |
787 | ||
c7705f34 | 788 | proc_create("drivers", 0, proc_ide_root, &ide_drivers_operations); |
1da177e4 LT |
789 | } |
790 | ||
791 | void proc_ide_destroy(void) | |
792 | { | |
643bdc6f | 793 | remove_proc_entry("drivers", proc_ide_root); |
1da177e4 LT |
794 | remove_proc_entry("ide", NULL); |
795 | } |