Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 LT |
2 | * Copyright (C) 1997-1998 Mark Lord |
3 | * Copyright (C) 2003 Red Hat <alan@redhat.com> | |
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 | |
15 | * | |
16 | * Also useful, "cat /proc/ide0/hda/[identify, smart_values, | |
17 | * smart_thresholds, capabilities]" will issue an IDENTIFY / | |
18 | * PACKET_IDENTIFY / SMART_READ_VALUES / SMART_READ_THRESHOLDS / | |
19 | * SENSE CAPABILITIES command to /dev/hda, and then dump out the | |
20 | * returned data as 256 16-bit words. The "hdparm" utility will | |
21 | * be updated someday soon to use this mechanism. | |
22 | * | |
23 | */ | |
24 | ||
1da177e4 LT |
25 | #include <linux/module.h> |
26 | ||
27 | #include <asm/uaccess.h> | |
28 | #include <linux/errno.h> | |
1da177e4 LT |
29 | #include <linux/proc_fs.h> |
30 | #include <linux/stat.h> | |
31 | #include <linux/mm.h> | |
32 | #include <linux/pci.h> | |
33 | #include <linux/ctype.h> | |
34 | #include <linux/hdreg.h> | |
35 | #include <linux/ide.h> | |
36 | #include <linux/seq_file.h> | |
37 | ||
38 | #include <asm/io.h> | |
39 | ||
5cbf79cd BZ |
40 | static struct proc_dir_entry *proc_ide_root; |
41 | ||
1da177e4 LT |
42 | static int proc_ide_read_imodel |
43 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
44 | { | |
45 | ide_hwif_t *hwif = (ide_hwif_t *) data; | |
46 | int len; | |
47 | const char *name; | |
48 | ||
1da177e4 | 49 | switch (hwif->chipset) { |
441e92da PC |
50 | case ide_generic: name = "generic"; break; |
51 | case ide_pci: name = "pci"; break; | |
52 | case ide_cmd640: name = "cmd640"; break; | |
53 | case ide_dtc2278: name = "dtc2278"; break; | |
54 | case ide_ali14xx: name = "ali14xx"; break; | |
55 | case ide_qd65xx: name = "qd65xx"; break; | |
56 | case ide_umc8672: name = "umc8672"; break; | |
57 | case ide_ht6560b: name = "ht6560b"; break; | |
58 | case ide_rz1000: name = "rz1000"; break; | |
59 | case ide_trm290: name = "trm290"; break; | |
60 | case ide_cmd646: name = "cmd646"; break; | |
61 | case ide_cy82c693: name = "cy82c693"; break; | |
62 | case ide_4drives: name = "4drives"; break; | |
63 | case ide_pmac: name = "mac-io"; break; | |
64 | case ide_au1xxx: name = "au1xxx"; break; | |
65 | case ide_palm3710: name = "palm3710"; break; | |
441e92da PC |
66 | case ide_acorn: name = "acorn"; break; |
67 | default: name = "(unknown)"; break; | |
1da177e4 LT |
68 | } |
69 | len = sprintf(page, "%s\n", name); | |
441e92da | 70 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
71 | } |
72 | ||
73 | static int proc_ide_read_mate | |
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 | ||
4283e1ba | 79 | if (hwif && hwif->mate) |
1da177e4 LT |
80 | len = sprintf(page, "%s\n", hwif->mate->name); |
81 | else | |
82 | len = sprintf(page, "(none)\n"); | |
441e92da | 83 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
84 | } |
85 | ||
86 | static int proc_ide_read_channel | |
87 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
88 | { | |
89 | ide_hwif_t *hwif = (ide_hwif_t *) data; | |
90 | int len; | |
91 | ||
92 | page[0] = hwif->channel ? '1' : '0'; | |
93 | page[1] = '\n'; | |
94 | len = 2; | |
441e92da | 95 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
96 | } |
97 | ||
98 | static int proc_ide_read_identify | |
99 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
100 | { | |
101 | ide_drive_t *drive = (ide_drive_t *)data; | |
102 | int len = 0, i = 0; | |
103 | int err = 0; | |
104 | ||
105 | len = sprintf(page, "\n"); | |
106 | ||
107 | if (drive) { | |
7fa897b9 | 108 | __le16 *val = (__le16 *)page; |
1da177e4 LT |
109 | |
110 | err = taskfile_lib_get_identify(drive, page); | |
111 | if (!err) { | |
112 | char *out = ((char *)page) + (SECTOR_WORDS * 4); | |
113 | page = out; | |
114 | do { | |
115 | out += sprintf(out, "%04x%c", | |
7fa897b9 | 116 | le16_to_cpup(val), (++i & 7) ? ' ' : '\n'); |
1da177e4 LT |
117 | val += 1; |
118 | } while (i < (SECTOR_WORDS * 2)); | |
119 | len = out - page; | |
120 | } | |
121 | } | |
441e92da | 122 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
123 | } |
124 | ||
7662d046 BZ |
125 | /** |
126 | * __ide_add_setting - add an ide setting option | |
127 | * @drive: drive to use | |
128 | * @name: setting name | |
129 | * @rw: true if the function is read write | |
130 | * @data_type: type of data | |
131 | * @min: range minimum | |
132 | * @max: range maximum | |
133 | * @mul_factor: multiplication scale | |
134 | * @div_factor: divison scale | |
135 | * @data: private data field | |
136 | * @set: setting | |
137 | * @auto_remove: setting auto removal flag | |
138 | * | |
139 | * Removes the setting named from the device if it is present. | |
140 | * The function takes the settings_lock to protect against | |
141 | * parallel changes. This function must not be called from IRQ | |
142 | * context. Returns 0 on success or -1 on failure. | |
143 | * | |
144 | * BUGS: This code is seriously over-engineered. There is also | |
145 | * magic about how the driver specific features are setup. If | |
146 | * a driver is attached we assume the driver settings are auto | |
147 | * remove. | |
148 | */ | |
149 | ||
150 | static int __ide_add_setting(ide_drive_t *drive, const char *name, int rw, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set, int auto_remove) | |
151 | { | |
152 | ide_settings_t **p = (ide_settings_t **) &drive->settings, *setting = NULL; | |
153 | ||
f9383c42 | 154 | mutex_lock(&ide_setting_mtx); |
7662d046 BZ |
155 | while ((*p) && strcmp((*p)->name, name) < 0) |
156 | p = &((*p)->next); | |
157 | if ((setting = kzalloc(sizeof(*setting), GFP_KERNEL)) == NULL) | |
158 | goto abort; | |
159 | if ((setting->name = kmalloc(strlen(name) + 1, GFP_KERNEL)) == NULL) | |
160 | goto abort; | |
161 | strcpy(setting->name, name); | |
162 | setting->rw = rw; | |
163 | setting->data_type = data_type; | |
164 | setting->min = min; | |
165 | setting->max = max; | |
166 | setting->mul_factor = mul_factor; | |
167 | setting->div_factor = div_factor; | |
168 | setting->data = data; | |
169 | setting->set = set; | |
170 | ||
171 | setting->next = *p; | |
172 | if (auto_remove) | |
173 | setting->auto_remove = 1; | |
174 | *p = setting; | |
f9383c42 | 175 | mutex_unlock(&ide_setting_mtx); |
7662d046 BZ |
176 | return 0; |
177 | abort: | |
f9383c42 | 178 | mutex_unlock(&ide_setting_mtx); |
7662d046 BZ |
179 | kfree(setting); |
180 | return -1; | |
181 | } | |
182 | ||
183 | int ide_add_setting(ide_drive_t *drive, const char *name, int rw, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set) | |
184 | { | |
185 | return __ide_add_setting(drive, name, rw, data_type, min, max, mul_factor, div_factor, data, set, 1); | |
186 | } | |
187 | ||
188 | EXPORT_SYMBOL(ide_add_setting); | |
189 | ||
190 | /** | |
191 | * __ide_remove_setting - remove an ide setting option | |
192 | * @drive: drive to use | |
193 | * @name: setting name | |
194 | * | |
195 | * Removes the setting named from the device if it is present. | |
196 | * The caller must hold the setting semaphore. | |
197 | */ | |
198 | ||
441e92da | 199 | static void __ide_remove_setting(ide_drive_t *drive, char *name) |
7662d046 BZ |
200 | { |
201 | ide_settings_t **p, *setting; | |
202 | ||
203 | p = (ide_settings_t **) &drive->settings; | |
204 | ||
205 | while ((*p) && strcmp((*p)->name, name)) | |
206 | p = &((*p)->next); | |
441e92da PC |
207 | setting = (*p); |
208 | if (setting == NULL) | |
7662d046 BZ |
209 | return; |
210 | ||
211 | (*p) = setting->next; | |
212 | ||
213 | kfree(setting->name); | |
214 | kfree(setting); | |
215 | } | |
216 | ||
217 | /** | |
218 | * auto_remove_settings - remove driver specific settings | |
219 | * @drive: drive | |
220 | * | |
221 | * Automatically remove all the driver specific settings for this | |
222 | * drive. This function may not be called from IRQ context. The | |
f9383c42 | 223 | * caller must hold ide_setting_mtx. |
7662d046 BZ |
224 | */ |
225 | ||
441e92da | 226 | static void auto_remove_settings(ide_drive_t *drive) |
7662d046 BZ |
227 | { |
228 | ide_settings_t *setting; | |
229 | repeat: | |
230 | setting = drive->settings; | |
231 | while (setting) { | |
232 | if (setting->auto_remove) { | |
233 | __ide_remove_setting(drive, setting->name); | |
234 | goto repeat; | |
235 | } | |
236 | setting = setting->next; | |
237 | } | |
238 | } | |
239 | ||
240 | /** | |
241 | * ide_find_setting_by_name - find a drive specific setting | |
242 | * @drive: drive to scan | |
243 | * @name: setting name | |
244 | * | |
245 | * Scan's the device setting table for a matching entry and returns | |
246 | * this or NULL if no entry is found. The caller must hold the | |
247 | * setting semaphore | |
248 | */ | |
249 | ||
250 | static ide_settings_t *ide_find_setting_by_name(ide_drive_t *drive, char *name) | |
251 | { | |
252 | ide_settings_t *setting = drive->settings; | |
253 | ||
254 | while (setting) { | |
255 | if (strcmp(setting->name, name) == 0) | |
256 | break; | |
257 | setting = setting->next; | |
258 | } | |
259 | return setting; | |
260 | } | |
261 | ||
262 | /** | |
263 | * ide_read_setting - read an IDE setting | |
264 | * @drive: drive to read from | |
265 | * @setting: drive setting | |
266 | * | |
267 | * Read a drive setting and return the value. The caller | |
f9383c42 | 268 | * must hold the ide_setting_mtx when making this call. |
7662d046 BZ |
269 | * |
270 | * BUGS: the data return and error are the same return value | |
271 | * so an error -EINVAL and true return of the same value cannot | |
272 | * be told apart | |
273 | */ | |
274 | ||
275 | static int ide_read_setting(ide_drive_t *drive, ide_settings_t *setting) | |
276 | { | |
277 | int val = -EINVAL; | |
278 | unsigned long flags; | |
279 | ||
280 | if ((setting->rw & SETTING_READ)) { | |
281 | spin_lock_irqsave(&ide_lock, flags); | |
441e92da PC |
282 | switch (setting->data_type) { |
283 | case TYPE_BYTE: | |
284 | val = *((u8 *) setting->data); | |
285 | break; | |
286 | case TYPE_SHORT: | |
287 | val = *((u16 *) setting->data); | |
288 | break; | |
289 | case TYPE_INT: | |
290 | val = *((u32 *) setting->data); | |
291 | break; | |
7662d046 BZ |
292 | } |
293 | spin_unlock_irqrestore(&ide_lock, flags); | |
294 | } | |
295 | return val; | |
296 | } | |
297 | ||
298 | /** | |
299 | * ide_write_setting - read an IDE setting | |
300 | * @drive: drive to read from | |
301 | * @setting: drive setting | |
302 | * @val: value | |
303 | * | |
304 | * Write a drive setting if it is possible. The caller | |
f9383c42 | 305 | * must hold the ide_setting_mtx when making this call. |
7662d046 BZ |
306 | * |
307 | * BUGS: the data return and error are the same return value | |
308 | * so an error -EINVAL and true return of the same value cannot | |
309 | * be told apart | |
310 | * | |
311 | * FIXME: This should be changed to enqueue a special request | |
312 | * to the driver to change settings, and then wait on a sema for completion. | |
313 | * The current scheme of polling is kludgy, though safe enough. | |
314 | */ | |
315 | ||
316 | static int ide_write_setting(ide_drive_t *drive, ide_settings_t *setting, int val) | |
317 | { | |
318 | if (!capable(CAP_SYS_ADMIN)) | |
319 | return -EACCES; | |
320 | if (setting->set) | |
321 | return setting->set(drive, val); | |
322 | if (!(setting->rw & SETTING_WRITE)) | |
323 | return -EPERM; | |
324 | if (val < setting->min || val > setting->max) | |
325 | return -EINVAL; | |
326 | if (ide_spin_wait_hwgroup(drive)) | |
327 | return -EBUSY; | |
328 | switch (setting->data_type) { | |
441e92da PC |
329 | case TYPE_BYTE: |
330 | *((u8 *) setting->data) = val; | |
331 | break; | |
332 | case TYPE_SHORT: | |
333 | *((u16 *) setting->data) = val; | |
334 | break; | |
335 | case TYPE_INT: | |
336 | *((u32 *) setting->data) = val; | |
337 | break; | |
7662d046 BZ |
338 | } |
339 | spin_unlock_irq(&ide_lock); | |
340 | return 0; | |
341 | } | |
342 | ||
343 | static int set_xfer_rate (ide_drive_t *drive, int arg) | |
344 | { | |
34f5d5ae | 345 | ide_task_t task; |
7662d046 BZ |
346 | int err; |
347 | ||
3b2a5c71 | 348 | if (arg < XFER_PIO_0 || arg > XFER_UDMA_6) |
7662d046 BZ |
349 | return -EINVAL; |
350 | ||
34f5d5ae BZ |
351 | memset(&task, 0, sizeof(task)); |
352 | task.tf.command = WIN_SETFEATURES; | |
353 | task.tf.feature = SETFEATURES_XFER; | |
354 | task.tf.nsect = (u8)arg; | |
355 | task.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT | | |
356 | IDE_TFLAG_IN_NSECT; | |
357 | ||
358 | err = ide_no_data_taskfile(drive, &task); | |
7662d046 | 359 | |
3b2a5c71 | 360 | if (!err) { |
7662d046 BZ |
361 | ide_set_xfer_rate(drive, (u8) arg); |
362 | ide_driveid_update(drive); | |
363 | } | |
364 | return err; | |
365 | } | |
366 | ||
367 | /** | |
368 | * ide_add_generic_settings - generic ide settings | |
369 | * @drive: drive being configured | |
370 | * | |
371 | * Add the generic parts of the system settings to the /proc files. | |
f9383c42 | 372 | * The caller must not be holding the ide_setting_mtx. |
7662d046 BZ |
373 | */ |
374 | ||
375 | void ide_add_generic_settings (ide_drive_t *drive) | |
376 | { | |
377 | /* | |
378 | * drive setting name read/write access data type min max mul_factor div_factor data pointer set function | |
379 | */ | |
380 | __ide_add_setting(drive, "io_32bit", drive->no_io_32bit ? SETTING_READ : SETTING_RW, TYPE_BYTE, 0, 1 + (SUPPORT_VLB_SYNC << 1), 1, 1, &drive->io_32bit, set_io_32bit, 0); | |
381 | __ide_add_setting(drive, "keepsettings", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->keep_settings, NULL, 0); | |
382 | __ide_add_setting(drive, "nice1", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nice1, NULL, 0); | |
383 | __ide_add_setting(drive, "pio_mode", SETTING_WRITE, TYPE_BYTE, 0, 255, 1, 1, NULL, set_pio_mode, 0); | |
384 | __ide_add_setting(drive, "unmaskirq", drive->no_unmask ? SETTING_READ : SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->unmask, NULL, 0); | |
385 | __ide_add_setting(drive, "using_dma", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->using_dma, set_using_dma, 0); | |
386 | __ide_add_setting(drive, "init_speed", SETTING_RW, TYPE_BYTE, 0, 70, 1, 1, &drive->init_speed, NULL, 0); | |
387 | __ide_add_setting(drive, "current_speed", SETTING_RW, TYPE_BYTE, 0, 70, 1, 1, &drive->current_speed, set_xfer_rate, 0); | |
388 | __ide_add_setting(drive, "number", SETTING_RW, TYPE_BYTE, 0, 3, 1, 1, &drive->dn, NULL, 0); | |
389 | } | |
390 | ||
1da177e4 LT |
391 | static void proc_ide_settings_warn(void) |
392 | { | |
441e92da | 393 | static int warned; |
1da177e4 LT |
394 | |
395 | if (warned) | |
396 | return; | |
397 | ||
398 | printk(KERN_WARNING "Warning: /proc/ide/hd?/settings interface is " | |
399 | "obsolete, and will be removed soon!\n"); | |
400 | warned = 1; | |
401 | } | |
402 | ||
403 | static int proc_ide_read_settings | |
404 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
405 | { | |
406 | ide_drive_t *drive = (ide_drive_t *) data; | |
407 | ide_settings_t *setting = (ide_settings_t *) drive->settings; | |
408 | char *out = page; | |
409 | int len, rc, mul_factor, div_factor; | |
410 | ||
411 | proc_ide_settings_warn(); | |
412 | ||
f9383c42 | 413 | mutex_lock(&ide_setting_mtx); |
1da177e4 LT |
414 | out += sprintf(out, "name\t\t\tvalue\t\tmin\t\tmax\t\tmode\n"); |
415 | out += sprintf(out, "----\t\t\t-----\t\t---\t\t---\t\t----\n"); | |
441e92da | 416 | while (setting) { |
1da177e4 LT |
417 | mul_factor = setting->mul_factor; |
418 | div_factor = setting->div_factor; | |
419 | out += sprintf(out, "%-24s", setting->name); | |
441e92da PC |
420 | rc = ide_read_setting(drive, setting); |
421 | if (rc >= 0) | |
1da177e4 LT |
422 | out += sprintf(out, "%-16d", rc * mul_factor / div_factor); |
423 | else | |
424 | out += sprintf(out, "%-16s", "write-only"); | |
425 | out += sprintf(out, "%-16d%-16d", (setting->min * mul_factor + div_factor - 1) / div_factor, setting->max * mul_factor / div_factor); | |
426 | if (setting->rw & SETTING_READ) | |
427 | out += sprintf(out, "r"); | |
428 | if (setting->rw & SETTING_WRITE) | |
429 | out += sprintf(out, "w"); | |
430 | out += sprintf(out, "\n"); | |
431 | setting = setting->next; | |
432 | } | |
433 | len = out - page; | |
f9383c42 | 434 | mutex_unlock(&ide_setting_mtx); |
441e92da | 435 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
436 | } |
437 | ||
438 | #define MAX_LEN 30 | |
439 | ||
440 | static int proc_ide_write_settings(struct file *file, const char __user *buffer, | |
441 | unsigned long count, void *data) | |
442 | { | |
443 | ide_drive_t *drive = (ide_drive_t *) data; | |
444 | char name[MAX_LEN + 1]; | |
445 | int for_real = 0; | |
446 | unsigned long n; | |
447 | ide_settings_t *setting; | |
448 | char *buf, *s; | |
449 | ||
450 | if (!capable(CAP_SYS_ADMIN)) | |
451 | return -EACCES; | |
452 | ||
453 | proc_ide_settings_warn(); | |
454 | ||
455 | if (count >= PAGE_SIZE) | |
456 | return -EINVAL; | |
457 | ||
458 | s = buf = (char *)__get_free_page(GFP_USER); | |
459 | if (!buf) | |
460 | return -ENOMEM; | |
461 | ||
462 | if (copy_from_user(buf, buffer, count)) { | |
463 | free_page((unsigned long)buf); | |
464 | return -EFAULT; | |
465 | } | |
466 | ||
467 | buf[count] = '\0'; | |
468 | ||
469 | /* | |
470 | * Skip over leading whitespace | |
471 | */ | |
472 | while (count && isspace(*s)) { | |
473 | --count; | |
474 | ++s; | |
475 | } | |
476 | /* | |
477 | * Do one full pass to verify all parameters, | |
478 | * then do another to actually write the new settings. | |
479 | */ | |
480 | do { | |
481 | char *p = s; | |
482 | n = count; | |
483 | while (n > 0) { | |
484 | unsigned val; | |
485 | char *q = p; | |
486 | ||
487 | while (n > 0 && *p != ':') { | |
488 | --n; | |
489 | p++; | |
490 | } | |
491 | if (*p != ':') | |
492 | goto parse_error; | |
493 | if (p - q > MAX_LEN) | |
494 | goto parse_error; | |
495 | memcpy(name, q, p - q); | |
496 | name[p - q] = 0; | |
497 | ||
498 | if (n > 0) { | |
499 | --n; | |
500 | p++; | |
501 | } else | |
502 | goto parse_error; | |
503 | ||
504 | val = simple_strtoul(p, &q, 10); | |
505 | n -= q - p; | |
506 | p = q; | |
507 | if (n > 0 && !isspace(*p)) | |
508 | goto parse_error; | |
509 | while (n > 0 && isspace(*p)) { | |
510 | --n; | |
511 | ++p; | |
512 | } | |
513 | ||
f9383c42 | 514 | mutex_lock(&ide_setting_mtx); |
1da177e4 | 515 | setting = ide_find_setting_by_name(drive, name); |
441e92da | 516 | if (!setting) { |
f9383c42 | 517 | mutex_unlock(&ide_setting_mtx); |
1da177e4 LT |
518 | goto parse_error; |
519 | } | |
520 | if (for_real) | |
521 | ide_write_setting(drive, setting, val * setting->div_factor / setting->mul_factor); | |
f9383c42 | 522 | mutex_unlock(&ide_setting_mtx); |
1da177e4 LT |
523 | } |
524 | } while (!for_real++); | |
525 | free_page((unsigned long)buf); | |
526 | return count; | |
527 | parse_error: | |
528 | free_page((unsigned long)buf); | |
529 | printk("proc_ide_write_settings(): parse error\n"); | |
530 | return -EINVAL; | |
531 | } | |
532 | ||
533 | int proc_ide_read_capacity | |
534 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
535 | { | |
441e92da PC |
536 | int len = sprintf(page, "%llu\n", (long long)0x7fffffff); |
537 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); | |
1da177e4 LT |
538 | } |
539 | ||
540 | EXPORT_SYMBOL_GPL(proc_ide_read_capacity); | |
541 | ||
542 | int proc_ide_read_geometry | |
543 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
544 | { | |
545 | ide_drive_t *drive = (ide_drive_t *) data; | |
546 | char *out = page; | |
547 | int len; | |
548 | ||
441e92da | 549 | out += sprintf(out, "physical %d/%d/%d\n", |
1da177e4 | 550 | drive->cyl, drive->head, drive->sect); |
441e92da | 551 | out += sprintf(out, "logical %d/%d/%d\n", |
1da177e4 LT |
552 | drive->bios_cyl, drive->bios_head, drive->bios_sect); |
553 | ||
554 | len = out - page; | |
441e92da | 555 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
556 | } |
557 | ||
558 | EXPORT_SYMBOL(proc_ide_read_geometry); | |
559 | ||
560 | static int proc_ide_read_dmodel | |
561 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
562 | { | |
563 | ide_drive_t *drive = (ide_drive_t *) data; | |
564 | struct hd_driveid *id = drive->id; | |
565 | int len; | |
566 | ||
567 | len = sprintf(page, "%.40s\n", | |
568 | (id && id->model[0]) ? (char *)id->model : "(none)"); | |
441e92da | 569 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
570 | } |
571 | ||
572 | static int proc_ide_read_driver | |
573 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
574 | { | |
575 | ide_drive_t *drive = (ide_drive_t *) data; | |
8604affd BZ |
576 | struct device *dev = &drive->gendev; |
577 | ide_driver_t *ide_drv; | |
1da177e4 LT |
578 | int len; |
579 | ||
8604affd BZ |
580 | if (dev->driver) { |
581 | ide_drv = container_of(dev->driver, ide_driver_t, gen_driver); | |
1da177e4 | 582 | len = sprintf(page, "%s version %s\n", |
8604affd | 583 | dev->driver->name, ide_drv->version); |
1da177e4 LT |
584 | } else |
585 | len = sprintf(page, "ide-default version 0.9.newide\n"); | |
441e92da | 586 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
587 | } |
588 | ||
8604affd BZ |
589 | static int ide_replace_subdriver(ide_drive_t *drive, const char *driver) |
590 | { | |
591 | struct device *dev = &drive->gendev; | |
592 | int ret = 1; | |
349ae23f | 593 | int err; |
8604affd | 594 | |
8604affd BZ |
595 | device_release_driver(dev); |
596 | /* FIXME: device can still be in use by previous driver */ | |
597 | strlcpy(drive->driver_req, driver, sizeof(drive->driver_req)); | |
349ae23f RD |
598 | err = device_attach(dev); |
599 | if (err < 0) | |
600 | printk(KERN_WARNING "IDE: %s: device_attach error: %d\n", | |
eb63963a | 601 | __func__, err); |
8604affd | 602 | drive->driver_req[0] = 0; |
349ae23f RD |
603 | if (dev->driver == NULL) { |
604 | err = device_attach(dev); | |
605 | if (err < 0) | |
606 | printk(KERN_WARNING | |
607 | "IDE: %s: device_attach(2) error: %d\n", | |
eb63963a | 608 | __func__, err); |
349ae23f | 609 | } |
8604affd BZ |
610 | if (dev->driver && !strcmp(dev->driver->name, driver)) |
611 | ret = 0; | |
8604affd BZ |
612 | |
613 | return ret; | |
614 | } | |
615 | ||
1da177e4 LT |
616 | static int proc_ide_write_driver |
617 | (struct file *file, const char __user *buffer, unsigned long count, void *data) | |
618 | { | |
619 | ide_drive_t *drive = (ide_drive_t *) data; | |
620 | char name[32]; | |
621 | ||
622 | if (!capable(CAP_SYS_ADMIN)) | |
623 | return -EACCES; | |
624 | if (count > 31) | |
625 | count = 31; | |
626 | if (copy_from_user(name, buffer, count)) | |
627 | return -EFAULT; | |
628 | name[count] = '\0'; | |
629 | if (ide_replace_subdriver(drive, name)) | |
630 | return -EINVAL; | |
631 | return count; | |
632 | } | |
633 | ||
634 | static int proc_ide_read_media | |
635 | (char *page, char **start, off_t off, int count, int *eof, void *data) | |
636 | { | |
637 | ide_drive_t *drive = (ide_drive_t *) data; | |
638 | const char *media; | |
639 | int len; | |
640 | ||
641 | switch (drive->media) { | |
441e92da PC |
642 | case ide_disk: media = "disk\n"; break; |
643 | case ide_cdrom: media = "cdrom\n"; break; | |
644 | case ide_tape: media = "tape\n"; break; | |
645 | case ide_floppy: media = "floppy\n"; break; | |
646 | case ide_optical: media = "optical\n"; break; | |
647 | default: media = "UNKNOWN\n"; break; | |
1da177e4 | 648 | } |
441e92da | 649 | strcpy(page, media); |
1da177e4 | 650 | len = strlen(media); |
441e92da | 651 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
1da177e4 LT |
652 | } |
653 | ||
654 | static ide_proc_entry_t generic_drive_entries[] = { | |
441e92da PC |
655 | { "driver", S_IFREG|S_IRUGO, proc_ide_read_driver, |
656 | proc_ide_write_driver }, | |
657 | { "identify", S_IFREG|S_IRUSR, proc_ide_read_identify, NULL }, | |
658 | { "media", S_IFREG|S_IRUGO, proc_ide_read_media, NULL }, | |
659 | { "model", S_IFREG|S_IRUGO, proc_ide_read_dmodel, NULL }, | |
660 | { "settings", S_IFREG|S_IRUSR|S_IWUSR, proc_ide_read_settings, | |
661 | proc_ide_write_settings }, | |
1da177e4 LT |
662 | { NULL, 0, NULL, NULL } |
663 | }; | |
664 | ||
7662d046 | 665 | static void ide_add_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p, void *data) |
1da177e4 LT |
666 | { |
667 | struct proc_dir_entry *ent; | |
668 | ||
669 | if (!dir || !p) | |
670 | return; | |
671 | while (p->name != NULL) { | |
672 | ent = create_proc_entry(p->name, p->mode, dir); | |
673 | if (!ent) return; | |
1da177e4 LT |
674 | ent->data = data; |
675 | ent->read_proc = p->read_proc; | |
676 | ent->write_proc = p->write_proc; | |
677 | p++; | |
678 | } | |
679 | } | |
680 | ||
7662d046 | 681 | static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p) |
1da177e4 LT |
682 | { |
683 | if (!dir || !p) | |
684 | return; | |
685 | while (p->name != NULL) { | |
686 | remove_proc_entry(p->name, dir); | |
687 | p++; | |
688 | } | |
689 | } | |
690 | ||
7662d046 BZ |
691 | void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver) |
692 | { | |
693 | ide_add_proc_entries(drive->proc, driver->proc, drive); | |
694 | } | |
695 | ||
696 | EXPORT_SYMBOL(ide_proc_register_driver); | |
697 | ||
698 | /** | |
699 | * ide_proc_unregister_driver - remove driver specific data | |
700 | * @drive: drive | |
701 | * @driver: driver | |
702 | * | |
703 | * Clean up the driver specific /proc files and IDE settings | |
704 | * for a given drive. | |
705 | * | |
f9383c42 | 706 | * Takes ide_setting_mtx and ide_lock. |
7662d046 BZ |
707 | * Caller must hold none of the locks. |
708 | */ | |
709 | ||
710 | void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver) | |
711 | { | |
712 | unsigned long flags; | |
713 | ||
714 | ide_remove_proc_entries(drive->proc, driver->proc); | |
715 | ||
f9383c42 | 716 | mutex_lock(&ide_setting_mtx); |
7662d046 BZ |
717 | spin_lock_irqsave(&ide_lock, flags); |
718 | /* | |
f9383c42 | 719 | * ide_setting_mtx protects the settings list |
7662d046 BZ |
720 | * ide_lock protects the use of settings |
721 | * | |
722 | * so we need to hold both, ide_settings_sem because we want to | |
723 | * modify the settings list, and ide_lock because we cannot take | |
724 | * a setting out that is being used. | |
725 | * | |
726 | * OTOH both ide_{read,write}_setting are only ever used under | |
f9383c42 | 727 | * ide_setting_mtx. |
7662d046 BZ |
728 | */ |
729 | auto_remove_settings(drive); | |
730 | spin_unlock_irqrestore(&ide_lock, flags); | |
f9383c42 | 731 | mutex_unlock(&ide_setting_mtx); |
7662d046 | 732 | } |
7662d046 BZ |
733 | EXPORT_SYMBOL(ide_proc_unregister_driver); |
734 | ||
d9270a3f | 735 | void ide_proc_port_register_devices(ide_hwif_t *hwif) |
1da177e4 LT |
736 | { |
737 | int d; | |
738 | struct proc_dir_entry *ent; | |
739 | struct proc_dir_entry *parent = hwif->proc; | |
740 | char name[64]; | |
741 | ||
742 | for (d = 0; d < MAX_DRIVES; d++) { | |
743 | ide_drive_t *drive = &hwif->drives[d]; | |
744 | ||
745 | if (!drive->present) | |
746 | continue; | |
747 | if (drive->proc) | |
748 | continue; | |
749 | ||
750 | drive->proc = proc_mkdir(drive->name, parent); | |
751 | if (drive->proc) | |
752 | ide_add_proc_entries(drive->proc, generic_drive_entries, drive); | |
441e92da | 753 | sprintf(name, "ide%d/%s", (drive->name[2]-'a')/2, drive->name); |
1da177e4 LT |
754 | ent = proc_symlink(drive->name, proc_ide_root, name); |
755 | if (!ent) return; | |
756 | } | |
757 | } | |
758 | ||
5b0c4b30 | 759 | void ide_proc_unregister_device(ide_drive_t *drive) |
1da177e4 LT |
760 | { |
761 | if (drive->proc) { | |
762 | ide_remove_proc_entries(drive->proc, generic_drive_entries); | |
763 | remove_proc_entry(drive->name, proc_ide_root); | |
5b0c4b30 | 764 | remove_proc_entry(drive->name, drive->hwif->proc); |
1da177e4 LT |
765 | drive->proc = NULL; |
766 | } | |
767 | } | |
768 | ||
1da177e4 LT |
769 | static ide_proc_entry_t hwif_entries[] = { |
770 | { "channel", S_IFREG|S_IRUGO, proc_ide_read_channel, NULL }, | |
771 | { "mate", S_IFREG|S_IRUGO, proc_ide_read_mate, NULL }, | |
772 | { "model", S_IFREG|S_IRUGO, proc_ide_read_imodel, NULL }, | |
773 | { NULL, 0, NULL, NULL } | |
774 | }; | |
775 | ||
5cbf79cd | 776 | void ide_proc_register_port(ide_hwif_t *hwif) |
1da177e4 | 777 | { |
5cbf79cd BZ |
778 | if (!hwif->proc) { |
779 | hwif->proc = proc_mkdir(hwif->name, proc_ide_root); | |
1da177e4 | 780 | |
5cbf79cd BZ |
781 | if (!hwif->proc) |
782 | return; | |
783 | ||
784 | ide_add_proc_entries(hwif->proc, hwif_entries, hwif); | |
1da177e4 LT |
785 | } |
786 | } | |
787 | ||
5cbf79cd | 788 | void ide_proc_unregister_port(ide_hwif_t *hwif) |
1da177e4 LT |
789 | { |
790 | if (hwif->proc) { | |
1da177e4 LT |
791 | ide_remove_proc_entries(hwif->proc, hwif_entries); |
792 | remove_proc_entry(hwif->name, proc_ide_root); | |
793 | hwif->proc = NULL; | |
794 | } | |
795 | } | |
796 | ||
8604affd BZ |
797 | static int proc_print_driver(struct device_driver *drv, void *data) |
798 | { | |
799 | ide_driver_t *ide_drv = container_of(drv, ide_driver_t, gen_driver); | |
800 | struct seq_file *s = data; | |
801 | ||
802 | seq_printf(s, "%s version %s\n", drv->name, ide_drv->version); | |
803 | ||
804 | return 0; | |
805 | } | |
806 | ||
807 | static int ide_drivers_show(struct seq_file *s, void *p) | |
808 | { | |
349ae23f RD |
809 | int err; |
810 | ||
811 | err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver); | |
812 | if (err < 0) | |
813 | printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n", | |
eb63963a | 814 | __func__, err); |
8604affd BZ |
815 | return 0; |
816 | } | |
817 | ||
1da177e4 LT |
818 | static int ide_drivers_open(struct inode *inode, struct file *file) |
819 | { | |
8604affd | 820 | return single_open(file, &ide_drivers_show, NULL); |
1da177e4 | 821 | } |
8604affd | 822 | |
2b8693c0 | 823 | static const struct file_operations ide_drivers_operations = { |
c7705f34 | 824 | .owner = THIS_MODULE, |
1da177e4 LT |
825 | .open = ide_drivers_open, |
826 | .read = seq_read, | |
827 | .llseek = seq_lseek, | |
8604affd | 828 | .release = single_release, |
1da177e4 LT |
829 | }; |
830 | ||
831 | void proc_ide_create(void) | |
832 | { | |
5cbf79cd BZ |
833 | proc_ide_root = proc_mkdir("ide", NULL); |
834 | ||
1da177e4 LT |
835 | if (!proc_ide_root) |
836 | return; | |
837 | ||
c7705f34 | 838 | proc_create("drivers", 0, proc_ide_root, &ide_drivers_operations); |
1da177e4 LT |
839 | } |
840 | ||
841 | void proc_ide_destroy(void) | |
842 | { | |
643bdc6f | 843 | remove_proc_entry("drivers", proc_ide_root); |
1da177e4 LT |
844 | remove_proc_entry("ide", NULL); |
845 | } |