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