sysctl: simplify ->strategy
[linux-2.6.git] / arch / mips / lasat / sysctl.c
1 /*
2  * Thomas Horsten <thh@lasat.com>
3  * Copyright (C) 2000 LASAT Networks A/S.
4  *
5  *  This program is free software; you can distribute it and/or modify it
6  *  under the terms of the GNU General Public License (Version 2) as
7  *  published by the Free Software Foundation.
8  *
9  *  This program is distributed in the hope it will be useful, but WITHOUT
10  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  *  for more details.
13  *
14  *  You should have received a copy of the GNU General Public License along
15  *  with this program; if not, write to the Free Software Foundation, Inc.,
16  *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
17  *
18  * Routines specific to the LASAT boards
19  */
20 #include <linux/types.h>
21 #include <asm/lasat/lasat.h>
22
23 #include <linux/module.h>
24 #include <linux/sysctl.h>
25 #include <linux/stddef.h>
26 #include <linux/init.h>
27 #include <linux/fs.h>
28 #include <linux/ctype.h>
29 #include <linux/string.h>
30 #include <linux/net.h>
31 #include <linux/inet.h>
32 #include <linux/uaccess.h>
33
34 #include <asm/time.h>
35
36 #ifdef CONFIG_DS1603
37 #include "ds1603.h"
38 #endif
39
40 /* Strategy function to write EEPROM after changing string entry */
41 int sysctl_lasatstring(ctl_table *table,
42                 void *oldval, size_t *oldlenp,
43                 void *newval, size_t newlen)
44 {
45         int r;
46
47         r = sysctl_string(table, oldval, oldlenp, newval, newlen);
48         if (r < 0)
49                 return r;
50
51         if (newval && newlen)
52                 lasat_write_eeprom_info();
53
54         return 0;
55 }
56
57
58 /* And the same for proc */
59 int proc_dolasatstring(ctl_table *table, int write, struct file *filp,
60                        void *buffer, size_t *lenp, loff_t *ppos)
61 {
62         int r;
63
64         r = proc_dostring(table, write, filp, buffer, lenp, ppos);
65         if ((!write) || r)
66                 return r;
67
68         lasat_write_eeprom_info();
69
70         return 0;
71 }
72
73 /* proc function to write EEPROM after changing int entry */
74 int proc_dolasatint(ctl_table *table, int write, struct file *filp,
75                        void *buffer, size_t *lenp, loff_t *ppos)
76 {
77         int r;
78
79         r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
80         if ((!write) || r)
81                 return r;
82
83         lasat_write_eeprom_info();
84
85         return 0;
86 }
87
88 #ifdef CONFIG_DS1603
89 static int rtctmp;
90
91 /* proc function to read/write RealTime Clock */
92 int proc_dolasatrtc(ctl_table *table, int write, struct file *filp,
93                        void *buffer, size_t *lenp, loff_t *ppos)
94 {
95         int r;
96
97         if (!write) {
98                 rtctmp = read_persistent_clock();
99                 /* check for time < 0 and set to 0 */
100                 if (rtctmp < 0)
101                         rtctmp = 0;
102         }
103         r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
104         if (r)
105                 return r;
106
107         if (write)
108                 rtc_mips_set_mmss(rtctmp);
109
110         return 0;
111 }
112 #endif
113
114 /* Sysctl for setting the IP addresses */
115 int sysctl_lasat_intvec(ctl_table *table,
116                     void *oldval, size_t *oldlenp,
117                     void *newval, size_t newlen)
118 {
119         int r;
120
121         r = sysctl_intvec(table, oldval, oldlenp, newval, newlen);
122         if (r < 0)
123                 return r;
124
125         if (newval && newlen)
126                 lasat_write_eeprom_info();
127
128         return 0;
129 }
130
131 #ifdef CONFIG_DS1603
132 /* Same for RTC */
133 int sysctl_lasat_rtc(ctl_table *table,
134                     void *oldval, size_t *oldlenp,
135                     void *newval, size_t newlen)
136 {
137         int r;
138
139         rtctmp = read_persistent_clock();
140         if (rtctmp < 0)
141                 rtctmp = 0;
142         r = sysctl_intvec(table, oldval, oldlenp, newval, newlen);
143         if (r < 0)
144                 return r;
145         if (newval && newlen)
146                 rtc_mips_set_mmss(rtctmp);
147
148         return r;
149 }
150 #endif
151
152 #ifdef CONFIG_INET
153 int proc_lasat_ip(ctl_table *table, int write, struct file *filp,
154                        void *buffer, size_t *lenp, loff_t *ppos)
155 {
156         unsigned int ip;
157         char *p, c;
158         int len;
159         char ipbuf[32];
160
161         if (!table->data || !table->maxlen || !*lenp ||
162             (*ppos && !write)) {
163                 *lenp = 0;
164                 return 0;
165         }
166
167         if (write) {
168                 len = 0;
169                 p = buffer;
170                 while (len < *lenp) {
171                         if (get_user(c, p++))
172                                 return -EFAULT;
173                         if (c == 0 || c == '\n')
174                                 break;
175                         len++;
176                 }
177                 if (len >= sizeof(ipbuf)-1)
178                         len = sizeof(ipbuf) - 1;
179                 if (copy_from_user(ipbuf, buffer, len))
180                         return -EFAULT;
181                 ipbuf[len] = 0;
182                 *ppos += *lenp;
183                 /* Now see if we can convert it to a valid IP */
184                 ip = in_aton(ipbuf);
185                 *(unsigned int *)(table->data) = ip;
186                 lasat_write_eeprom_info();
187         } else {
188                 ip = *(unsigned int *)(table->data);
189                 sprintf(ipbuf, "%d.%d.%d.%d",
190                         (ip)       & 0xff,
191                         (ip >>  8) & 0xff,
192                         (ip >> 16) & 0xff,
193                         (ip >> 24) & 0xff);
194                 len = strlen(ipbuf);
195                 if (len > *lenp)
196                         len = *lenp;
197                 if (len)
198                         if (copy_to_user(buffer, ipbuf, len))
199                                 return -EFAULT;
200                 if (len < *lenp) {
201                         if (put_user('\n', ((char *) buffer) + len))
202                                 return -EFAULT;
203                         len++;
204                 }
205                 *lenp = len;
206                 *ppos += len;
207         }
208
209         return 0;
210 }
211 #endif
212
213 static int sysctl_lasat_prid(ctl_table *table,
214                                      void *oldval, size_t *oldlenp,
215                                      void *newval, size_t newlen)
216 {
217         int r;
218
219         r = sysctl_intvec(table, oldval, oldlenp, newval, newlen);
220         if (r < 0)
221                 return r;
222         if (newval && newlen) {
223                 lasat_board_info.li_eeprom_info.prid = *(int *)newval;
224                 lasat_write_eeprom_info();
225                 lasat_init_board_info();
226         }
227         return 0;
228 }
229
230 int proc_lasat_prid(ctl_table *table, int write, struct file *filp,
231                        void *buffer, size_t *lenp, loff_t *ppos)
232 {
233         int r;
234
235         r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
236         if (r < 0)
237                 return r;
238         if (write) {
239                 lasat_board_info.li_eeprom_info.prid =
240                         lasat_board_info.li_prid;
241                 lasat_write_eeprom_info();
242                 lasat_init_board_info();
243         }
244         return 0;
245 }
246
247 extern int lasat_boot_to_service;
248
249 static ctl_table lasat_table[] = {
250         {
251                 .ctl_name       = CTL_UNNUMBERED,
252                 .procname       = "cpu-hz",
253                 .data           = &lasat_board_info.li_cpu_hz,
254                 .maxlen         = sizeof(int),
255                 .mode           = 0444,
256                 .proc_handler   = &proc_dointvec,
257                 .strategy       = &sysctl_intvec
258         },
259         {
260                 .ctl_name       = CTL_UNNUMBERED,
261                 .procname       = "bus-hz",
262                 .data           = &lasat_board_info.li_bus_hz,
263                 .maxlen         = sizeof(int),
264                 .mode           = 0444,
265                 .proc_handler   = &proc_dointvec,
266                 .strategy       = &sysctl_intvec
267         },
268         {
269                 .ctl_name       = CTL_UNNUMBERED,
270                 .procname       = "bmid",
271                 .data           = &lasat_board_info.li_bmid,
272                 .maxlen         = sizeof(int),
273                 .mode           = 0444,
274                 .proc_handler   = &proc_dointvec,
275                 .strategy       = &sysctl_intvec
276         },
277         {
278                 .ctl_name       = CTL_UNNUMBERED,
279                 .procname       = "prid",
280                 .data           = &lasat_board_info.li_prid,
281                 .maxlen         = sizeof(int),
282                 .mode           = 0644,
283                 .proc_handler   = &proc_lasat_prid,
284                 .strategy       = &sysctl_lasat_prid
285         },
286 #ifdef CONFIG_INET
287         {
288                 .ctl_name       = CTL_UNNUMBERED,
289                 .procname       = "ipaddr",
290                 .data           = &lasat_board_info.li_eeprom_info.ipaddr,
291                 .maxlen         = sizeof(int),
292                 .mode           = 0644,
293                 .proc_handler   = &proc_lasat_ip,
294                 .strategy       = &sysctl_lasat_intvec
295         },
296         {
297                 .ctl_name       = CTL_UNNUMBERED,
298                 .procname       = "netmask",
299                 .data           = &lasat_board_info.li_eeprom_info.netmask,
300                 .maxlen         = sizeof(int),
301                 .mode           = 0644,
302                 .proc_handler   = &proc_lasat_ip,
303                 .strategy       = &sysctl_lasat_intvec
304         },
305 #endif
306         {
307                 .ctl_name       = CTL_UNNUMBERED,
308                 .procname       = "passwd_hash",
309                 .data           = &lasat_board_info.li_eeprom_info.passwd_hash,
310                 .maxlen         =
311                         sizeof(lasat_board_info.li_eeprom_info.passwd_hash),
312                 .mode           = 0600,
313                 .proc_handler   = &proc_dolasatstring,
314                 .strategy       = &sysctl_lasatstring
315         },
316         {
317                 .ctl_name       = CTL_UNNUMBERED,
318                 .procname       = "boot-service",
319                 .data           = &lasat_boot_to_service,
320                 .maxlen         = sizeof(int),
321                 .mode           = 0644,
322                 .proc_handler   = &proc_dointvec,
323                 .strategy       = &sysctl_intvec
324         },
325 #ifdef CONFIG_DS1603
326         {
327                 .ctl_name       = CTL_UNNUMBERED,
328                 .procname       = "rtc",
329                 .data           = &rtctmp,
330                 .maxlen         = sizeof(int),
331                 .mode           = 0644,
332                 .proc_handler   = &proc_dolasatrtc,
333                 .strategy       = &sysctl_lasat_rtc
334         },
335 #endif
336         {
337                 .ctl_name       = CTL_UNNUMBERED,
338                 .procname       = "namestr",
339                 .data           = &lasat_board_info.li_namestr,
340                 .maxlen         = sizeof(lasat_board_info.li_namestr),
341                 .mode           = 0444,
342                 .proc_handler   = &proc_dostring,
343                 .strategy       = &sysctl_string
344         },
345         {
346                 .ctl_name       = CTL_UNNUMBERED,
347                 .procname       = "typestr",
348                 .data           = &lasat_board_info.li_typestr,
349                 .maxlen         = sizeof(lasat_board_info.li_typestr),
350                 .mode           = 0444,
351                 .proc_handler   = &proc_dostring,
352                 .strategy       = &sysctl_string
353         },
354         {}
355 };
356
357 static ctl_table lasat_root_table[] = {
358         {
359                 .ctl_name       = CTL_UNNUMBERED,
360                 .procname       = "lasat",
361                 .mode           =  0555,
362                 .child          = lasat_table
363         },
364         {}
365 };
366
367 static int __init lasat_register_sysctl(void)
368 {
369         struct ctl_table_header *lasat_table_header;
370
371         lasat_table_header =
372                 register_sysctl_table(lasat_root_table);
373         if (!lasat_table_header) {
374                 printk(KERN_ERR "Unable to register LASAT sysctl\n");
375                 return -ENOMEM;
376         }
377
378         return 0;
379 }
380
381 __initcall(lasat_register_sysctl);