config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / mca / mca-proc.c
1 /* -*- mode: c; c-basic-offset: 8 -*- */
2
3 /*
4  * MCA bus support functions for the proc fs.
5  *
6  * NOTE: this code *requires* the legacy MCA api.
7  *
8  * Legacy API means the API that operates in terms of MCA slot number
9  *
10  * (C) 2002 James Bottomley <James.Bottomley@HansenPartnership.com>
11  *
12 **-----------------------------------------------------------------------------
13 **  
14 **  This program is free software; you can redistribute it and/or modify
15 **  it under the terms of the GNU General Public License as published by
16 **  the Free Software Foundation; either version 2 of the License, or
17 **  (at your option) any later version.
18 **
19 **  This program is distributed in the hope that it will be useful,
20 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
21 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 **  GNU General Public License for more details.
23 **
24 **  You should have received a copy of the GNU General Public License
25 **  along with this program; if not, write to the Free Software
26 **  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 **
28 **-----------------------------------------------------------------------------
29  */
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/proc_fs.h>
33 #include <linux/mca.h>
34
35 static int get_mca_info_helper(struct mca_device *mca_dev, char *page, int len)
36 {
37         int j;
38
39         for(j=0; j<8; j++)
40                 len += sprintf(page+len, "%02x ",
41                                mca_dev ? mca_dev->pos[j] : 0xff);
42         len += sprintf(page+len, " %s\n", mca_dev ? mca_dev->name : "");
43         return len;
44 }
45
46 static int get_mca_info(char *page, char **start, off_t off,
47                         int count, int *eof, void *data)
48 {
49         int i, len = 0;
50
51         if(MCA_bus) {
52                 struct mca_device *mca_dev;
53                 /* Format POS registers of eight MCA slots */
54
55                 for(i=0; i<MCA_MAX_SLOT_NR; i++) {
56                         mca_dev = mca_find_device_by_slot(i);
57
58                         len += sprintf(page+len, "Slot %d: ", i+1);
59                         len = get_mca_info_helper(mca_dev, page, len);
60                 }
61
62                 /* Format POS registers of integrated video subsystem */
63
64                 mca_dev = mca_find_device_by_slot(MCA_INTEGVIDEO);
65                 len += sprintf(page+len, "Video : ");
66                 len = get_mca_info_helper(mca_dev, page, len);
67
68                 /* Format POS registers of integrated SCSI subsystem */
69
70                 mca_dev = mca_find_device_by_slot(MCA_INTEGSCSI);
71                 len += sprintf(page+len, "SCSI  : ");
72                 len = get_mca_info_helper(mca_dev, page, len);
73
74                 /* Format POS registers of motherboard */
75
76                 mca_dev = mca_find_device_by_slot(MCA_MOTHERBOARD);
77                 len += sprintf(page+len, "Planar: ");
78                 len = get_mca_info_helper(mca_dev, page, len);
79         } else {
80                 /* Leave it empty if MCA not detected - this should *never*
81                  * happen!
82                  */
83         }
84
85         if (len <= off+count) *eof = 1;
86         *start = page + off;
87         len -= off;
88         if (len>count) len = count;
89         if (len<0) len = 0;
90         return len;
91 }
92
93 /*--------------------------------------------------------------------*/
94
95 static int mca_default_procfn(char* buf, struct mca_device *mca_dev)
96 {
97         int len = 0, i;
98         int slot = mca_dev->slot;
99
100         /* Print out the basic information */
101
102         if(slot < MCA_MAX_SLOT_NR) {
103                 len += sprintf(buf+len, "Slot: %d\n", slot+1);
104         } else if(slot == MCA_INTEGSCSI) {
105                 len += sprintf(buf+len, "Integrated SCSI Adapter\n");
106         } else if(slot == MCA_INTEGVIDEO) {
107                 len += sprintf(buf+len, "Integrated Video Adapter\n");
108         } else if(slot == MCA_MOTHERBOARD) {
109                 len += sprintf(buf+len, "Motherboard\n");
110         }
111         if (mca_dev->name[0]) {
112
113                 /* Drivers might register a name without /proc handler... */
114
115                 len += sprintf(buf+len, "Adapter Name: %s\n",
116                                mca_dev->name);
117         } else {
118                 len += sprintf(buf+len, "Adapter Name: Unknown\n");
119         }
120         len += sprintf(buf+len, "Id: %02x%02x\n",
121                 mca_dev->pos[1], mca_dev->pos[0]);
122         len += sprintf(buf+len, "Enabled: %s\nPOS: ",
123                 mca_device_status(mca_dev) == MCA_ADAPTER_NORMAL ?
124                         "Yes" : "No");
125         for(i=0; i<8; i++) {
126                 len += sprintf(buf+len, "%02x ", mca_dev->pos[i]);
127         }
128         len += sprintf(buf+len, "\nDriver Installed: %s",
129                 mca_device_claimed(mca_dev) ? "Yes" : "No");
130         buf[len++] = '\n';
131         buf[len] = 0;
132
133         return len;
134 } /* mca_default_procfn() */
135
136 static int get_mca_machine_info(char* page, char **start, off_t off,
137                                  int count, int *eof, void *data)
138 {
139         int len = 0;
140
141         len += sprintf(page+len, "Model Id: 0x%x\n", machine_id);
142         len += sprintf(page+len, "Submodel Id: 0x%x\n", machine_submodel_id);
143         len += sprintf(page+len, "BIOS Revision: 0x%x\n", BIOS_revision);
144
145         if (len <= off+count) *eof = 1;
146         *start = page + off;
147         len -= off;
148         if (len>count) len = count;
149         if (len<0) len = 0;
150         return len;
151 }
152
153 static int mca_read_proc(char *page, char **start, off_t off,
154                                  int count, int *eof, void *data)
155 {
156         struct mca_device *mca_dev = (struct mca_device *)data;
157         int len = 0;
158
159         /* Get the standard info */
160
161         len = mca_default_procfn(page, mca_dev);
162
163         /* Do any device-specific processing, if there is any */
164
165         if(mca_dev->procfn) {
166                 len += mca_dev->procfn(page+len, mca_dev->slot,
167                                        mca_dev->proc_dev);
168         }
169         if (len <= off+count) *eof = 1;
170         *start = page + off;
171         len -= off;
172         if (len>count) len = count;
173         if (len<0) len = 0;
174         return len;
175 } /* mca_read_proc() */
176
177 /*--------------------------------------------------------------------*/
178
179 void __init mca_do_proc_init(void)
180 {
181         int i;
182         struct proc_dir_entry *proc_mca;
183         struct proc_dir_entry* node = NULL;
184         struct mca_device *mca_dev;
185
186         proc_mca = proc_mkdir("mca", NULL);
187         create_proc_read_entry("pos",0,proc_mca,get_mca_info,NULL);
188         create_proc_read_entry("machine",0,proc_mca,get_mca_machine_info,NULL);
189
190         /* Initialize /proc/mca entries for existing adapters */
191
192         for(i = 0; i < MCA_NUMADAPTERS; i++) {
193                 enum MCA_AdapterStatus status;
194                 mca_dev = mca_find_device_by_slot(i);
195                 if(!mca_dev)
196                         continue;
197
198                 mca_dev->procfn = NULL;
199
200                 if(i < MCA_MAX_SLOT_NR) sprintf(mca_dev->procname,"slot%d", i+1);
201                 else if(i == MCA_INTEGVIDEO) sprintf(mca_dev->procname,"video");
202                 else if(i == MCA_INTEGSCSI) sprintf(mca_dev->procname,"scsi");
203                 else if(i == MCA_MOTHERBOARD) sprintf(mca_dev->procname,"planar");
204
205                 status = mca_device_status(mca_dev);
206                 if (status != MCA_ADAPTER_NORMAL &&
207                     status != MCA_ADAPTER_DISABLED)
208                         continue;
209
210                 node = create_proc_read_entry(mca_dev->procname, 0, proc_mca,
211                                               mca_read_proc, (void *)mca_dev);
212
213                 if(node == NULL) {
214                         printk("Failed to allocate memory for MCA proc-entries!");
215                         return;
216                 }
217         }
218
219 } /* mca_do_proc_init() */
220
221 /**
222  *      mca_set_adapter_procfn - Set the /proc callback
223  *      @slot: slot to configure
224  *      @procfn: callback function to call for /proc
225  *      @dev: device information passed to the callback
226  *
227  *      This sets up an information callback for /proc/mca/slot?.  The
228  *      function is called with the buffer, slot, and device pointer (or
229  *      some equally informative context information, or nothing, if you
230  *      prefer), and is expected to put useful information into the
231  *      buffer.  The adapter name, ID, and POS registers get printed
232  *      before this is called though, so don't do it again.
233  *
234  *      This should be called with a %NULL @procfn when a module
235  *      unregisters, thus preventing kernel crashes and other such
236  *      nastiness.
237  */
238
239 void mca_set_adapter_procfn(int slot, MCA_ProcFn procfn, void* proc_dev)
240 {
241         struct mca_device *mca_dev = mca_find_device_by_slot(slot);
242
243         if(!mca_dev)
244                 return;
245
246         mca_dev->procfn = procfn;
247         mca_dev->proc_dev = proc_dev;
248 }
249 EXPORT_SYMBOL(mca_set_adapter_procfn);