Merge branch 'core-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / drivers / ide / ide-proc.c
1 /*
2  *  Copyright (C) 1997-1998     Mark Lord
3  *  Copyright (C) 2003          Red Hat <alan@redhat.com>
4  *
5  *  Some code was moved here from ide.c, see it for original copyrights.
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
25 #include <linux/module.h>
26
27 #include <asm/uaccess.h>
28 #include <linux/errno.h>
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
40 static struct proc_dir_entry *proc_ide_root;
41
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
49         switch (hwif->chipset) {
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;
66         case ide_acorn:         name = "acorn";         break;
67         default:                name = "(unknown)";     break;
68         }
69         len = sprintf(page, "%s\n", name);
70         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
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
79         if (hwif && hwif->mate)
80                 len = sprintf(page, "%s\n", hwif->mate->name);
81         else
82                 len = sprintf(page, "(none)\n");
83         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
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;
95         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
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) {
108                 unsigned short *val = (unsigned short *) page;
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",
116                                         le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
117                                 val += 1;
118                         } while (i < (SECTOR_WORDS * 2));
119                         len = out - page;
120                 }
121         }
122         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
123 }
124
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
154         mutex_lock(&ide_setting_mtx);
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;
175         mutex_unlock(&ide_setting_mtx);
176         return 0;
177 abort:
178         mutex_unlock(&ide_setting_mtx);
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
199 static void __ide_remove_setting(ide_drive_t *drive, char *name)
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);
207         setting = (*p);
208         if (setting == NULL)
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
223  *      caller must hold ide_setting_mtx.
224  */
225
226 static void auto_remove_settings(ide_drive_t *drive)
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
268  *      must hold the ide_setting_mtx when making this call.
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);
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;
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
305  *      must hold the ide_setting_mtx when making this call.
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) {
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;
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 {
345         ide_task_t task;
346         int err;
347
348         if (arg < 0 || arg > 70)
349                 return -EINVAL;
350
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);
359
360         if (!err && arg) {
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.
372  *      The caller must not be holding the ide_setting_mtx.
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
391 static void proc_ide_settings_warn(void)
392 {
393         static int warned;
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
413         mutex_lock(&ide_setting_mtx);
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");
416         while (setting) {
417                 mul_factor = setting->mul_factor;
418                 div_factor = setting->div_factor;
419                 out += sprintf(out, "%-24s", setting->name);
420                 rc = ide_read_setting(drive, setting);
421                 if (rc >= 0)
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;
434         mutex_unlock(&ide_setting_mtx);
435         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
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
514                         mutex_lock(&ide_setting_mtx);
515                         setting = ide_find_setting_by_name(drive, name);
516                         if (!setting) {
517                                 mutex_unlock(&ide_setting_mtx);
518                                 goto parse_error;
519                         }
520                         if (for_real)
521                                 ide_write_setting(drive, setting, val * setting->div_factor / setting->mul_factor);
522                         mutex_unlock(&ide_setting_mtx);
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 {
536         int len = sprintf(page, "%llu\n", (long long)0x7fffffff);
537         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
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
549         out += sprintf(out, "physical     %d/%d/%d\n",
550                         drive->cyl, drive->head, drive->sect);
551         out += sprintf(out, "logical      %d/%d/%d\n",
552                         drive->bios_cyl, drive->bios_head, drive->bios_sect);
553
554         len = out - page;
555         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
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)");
569         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
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;
576         struct device   *dev = &drive->gendev;
577         ide_driver_t    *ide_drv;
578         int             len;
579
580         if (dev->driver) {
581                 ide_drv = container_of(dev->driver, ide_driver_t, gen_driver);
582                 len = sprintf(page, "%s version %s\n",
583                                 dev->driver->name, ide_drv->version);
584         } else
585                 len = sprintf(page, "ide-default version 0.9.newide\n");
586         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
587 }
588
589 static int ide_replace_subdriver(ide_drive_t *drive, const char *driver)
590 {
591         struct device *dev = &drive->gendev;
592         int ret = 1;
593         int err;
594
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));
598         err = device_attach(dev);
599         if (err < 0)
600                 printk(KERN_WARNING "IDE: %s: device_attach error: %d\n",
601                         __func__, err);
602         drive->driver_req[0] = 0;
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",
608                                 __func__, err);
609         }
610         if (dev->driver && !strcmp(dev->driver->name, driver))
611                 ret = 0;
612
613         return ret;
614 }
615
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) {
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;
648         }
649         strcpy(page, media);
650         len = strlen(media);
651         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
652 }
653
654 static ide_proc_entry_t generic_drive_entries[] = {
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 },
662         { NULL, 0, NULL, NULL }
663 };
664
665 static void ide_add_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p, void *data)
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;
674                 ent->data = data;
675                 ent->read_proc = p->read_proc;
676                 ent->write_proc = p->write_proc;
677                 p++;
678         }
679 }
680
681 static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p)
682 {
683         if (!dir || !p)
684                 return;
685         while (p->name != NULL) {
686                 remove_proc_entry(p->name, dir);
687                 p++;
688         }
689 }
690
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  *
706  *      Takes ide_setting_mtx and ide_lock.
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
716         mutex_lock(&ide_setting_mtx);
717         spin_lock_irqsave(&ide_lock, flags);
718         /*
719          * ide_setting_mtx protects the settings list
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
727          * ide_setting_mtx.
728          */
729         auto_remove_settings(drive);
730         spin_unlock_irqrestore(&ide_lock, flags);
731         mutex_unlock(&ide_setting_mtx);
732 }
733 EXPORT_SYMBOL(ide_proc_unregister_driver);
734
735 void ide_proc_port_register_devices(ide_hwif_t *hwif)
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);
753                 sprintf(name, "ide%d/%s", (drive->name[2]-'a')/2, drive->name);
754                 ent = proc_symlink(drive->name, proc_ide_root, name);
755                 if (!ent) return;
756         }
757 }
758
759 void ide_proc_unregister_device(ide_drive_t *drive)
760 {
761         if (drive->proc) {
762                 ide_remove_proc_entries(drive->proc, generic_drive_entries);
763                 remove_proc_entry(drive->name, proc_ide_root);
764                 remove_proc_entry(drive->name, drive->hwif->proc);
765                 drive->proc = NULL;
766         }
767 }
768
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
776 void ide_proc_register_port(ide_hwif_t *hwif)
777 {
778         if (!hwif->proc) {
779                 hwif->proc = proc_mkdir(hwif->name, proc_ide_root);
780
781                 if (!hwif->proc)
782                         return;
783
784                 ide_add_proc_entries(hwif->proc, hwif_entries, hwif);
785         }
786 }
787
788 void ide_proc_unregister_port(ide_hwif_t *hwif)
789 {
790         if (hwif->proc) {
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
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 {
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",
814                         __func__, err);
815         return 0;
816 }
817
818 static int ide_drivers_open(struct inode *inode, struct file *file)
819 {
820         return single_open(file, &ide_drivers_show, NULL);
821 }
822
823 static const struct file_operations ide_drivers_operations = {
824         .owner          = THIS_MODULE,
825         .open           = ide_drivers_open,
826         .read           = seq_read,
827         .llseek         = seq_lseek,
828         .release        = single_release,
829 };
830
831 void proc_ide_create(void)
832 {
833         proc_ide_root = proc_mkdir("ide", NULL);
834
835         if (!proc_ide_root)
836                 return;
837
838         proc_create("drivers", 0, proc_ide_root, &ide_drivers_operations);
839 }
840
841 void proc_ide_destroy(void)
842 {
843         remove_proc_entry("drivers", proc_ide_root);
844         remove_proc_entry("ide", NULL);
845 }