Merge branch 'master' of ssh://master.kernel.org/pub/scm/linux/kernel/git/linville...
[kernel.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
41 /* And the same for proc */
42 int proc_dolasatstring(ctl_table *table, int write,
43                        void *buffer, size_t *lenp, loff_t *ppos)
44 {
45         int r;
46
47         r = proc_dostring(table, write, buffer, lenp, ppos);
48         if ((!write) || r)
49                 return r;
50
51         lasat_write_eeprom_info();
52
53         return 0;
54 }
55
56 /* proc function to write EEPROM after changing int entry */
57 int proc_dolasatint(ctl_table *table, int write,
58                        void *buffer, size_t *lenp, loff_t *ppos)
59 {
60         int r;
61
62         r = proc_dointvec(table, write, buffer, lenp, ppos);
63         if ((!write) || r)
64                 return r;
65
66         lasat_write_eeprom_info();
67
68         return 0;
69 }
70
71 #ifdef CONFIG_DS1603
72 static int rtctmp;
73
74 /* proc function to read/write RealTime Clock */
75 int proc_dolasatrtc(ctl_table *table, int write,
76                        void *buffer, size_t *lenp, loff_t *ppos)
77 {
78         struct timespec ts;
79         int r;
80
81         if (!write) {
82                 read_persistent_clock(&ts);
83                 rtctmp = ts.tv_sec;
84                 /* check for time < 0 and set to 0 */
85                 if (rtctmp < 0)
86                         rtctmp = 0;
87         }
88         r = proc_dointvec(table, write, buffer, lenp, ppos);
89         if (r)
90                 return r;
91
92         if (write)
93                 rtc_mips_set_mmss(rtctmp);
94
95         return 0;
96 }
97 #endif
98
99 #ifdef CONFIG_INET
100 int proc_lasat_ip(ctl_table *table, int write,
101                        void *buffer, size_t *lenp, loff_t *ppos)
102 {
103         unsigned int ip;
104         char *p, c;
105         int len;
106         char ipbuf[32];
107
108         if (!table->data || !table->maxlen || !*lenp ||
109             (*ppos && !write)) {
110                 *lenp = 0;
111                 return 0;
112         }
113
114         if (write) {
115                 len = 0;
116                 p = buffer;
117                 while (len < *lenp) {
118                         if (get_user(c, p++))
119                                 return -EFAULT;
120                         if (c == 0 || c == '\n')
121                                 break;
122                         len++;
123                 }
124                 if (len >= sizeof(ipbuf)-1)
125                         len = sizeof(ipbuf) - 1;
126                 if (copy_from_user(ipbuf, buffer, len))
127                         return -EFAULT;
128                 ipbuf[len] = 0;
129                 *ppos += *lenp;
130                 /* Now see if we can convert it to a valid IP */
131                 ip = in_aton(ipbuf);
132                 *(unsigned int *)(table->data) = ip;
133                 lasat_write_eeprom_info();
134         } else {
135                 ip = *(unsigned int *)(table->data);
136                 sprintf(ipbuf, "%d.%d.%d.%d",
137                         (ip)       & 0xff,
138                         (ip >>  8) & 0xff,
139                         (ip >> 16) & 0xff,
140                         (ip >> 24) & 0xff);
141                 len = strlen(ipbuf);
142                 if (len > *lenp)
143                         len = *lenp;
144                 if (len)
145                         if (copy_to_user(buffer, ipbuf, len))
146                                 return -EFAULT;
147                 if (len < *lenp) {
148                         if (put_user('\n', ((char *) buffer) + len))
149                                 return -EFAULT;
150                         len++;
151                 }
152                 *lenp = len;
153                 *ppos += len;
154         }
155
156         return 0;
157 }
158 #endif
159
160 int proc_lasat_prid(ctl_table *table, int write,
161                        void *buffer, size_t *lenp, loff_t *ppos)
162 {
163         int r;
164
165         r = proc_dointvec(table, write, buffer, lenp, ppos);
166         if (r < 0)
167                 return r;
168         if (write) {
169                 lasat_board_info.li_eeprom_info.prid =
170                         lasat_board_info.li_prid;
171                 lasat_write_eeprom_info();
172                 lasat_init_board_info();
173         }
174         return 0;
175 }
176
177 extern int lasat_boot_to_service;
178
179 static ctl_table lasat_table[] = {
180         {
181                 .procname       = "cpu-hz",
182                 .data           = &lasat_board_info.li_cpu_hz,
183                 .maxlen         = sizeof(int),
184                 .mode           = 0444,
185                 .proc_handler   = proc_dointvec,
186         },
187         {
188                 .procname       = "bus-hz",
189                 .data           = &lasat_board_info.li_bus_hz,
190                 .maxlen         = sizeof(int),
191                 .mode           = 0444,
192                 .proc_handler   = proc_dointvec,
193         },
194         {
195                 .procname       = "bmid",
196                 .data           = &lasat_board_info.li_bmid,
197                 .maxlen         = sizeof(int),
198                 .mode           = 0444,
199                 .proc_handler   = proc_dointvec,
200         },
201         {
202                 .procname       = "prid",
203                 .data           = &lasat_board_info.li_prid,
204                 .maxlen         = sizeof(int),
205                 .mode           = 0644,
206                 .proc_handler   = proc_lasat_prid,
207         },
208 #ifdef CONFIG_INET
209         {
210                 .procname       = "ipaddr",
211                 .data           = &lasat_board_info.li_eeprom_info.ipaddr,
212                 .maxlen         = sizeof(int),
213                 .mode           = 0644,
214                 .proc_handler   = proc_lasat_ip,
215         },
216         {
217                 .procname       = "netmask",
218                 .data           = &lasat_board_info.li_eeprom_info.netmask,
219                 .maxlen         = sizeof(int),
220                 .mode           = 0644,
221                 .proc_handler   = proc_lasat_ip,
222         },
223 #endif
224         {
225                 .procname       = "passwd_hash",
226                 .data           = &lasat_board_info.li_eeprom_info.passwd_hash,
227                 .maxlen         =
228                         sizeof(lasat_board_info.li_eeprom_info.passwd_hash),
229                 .mode           = 0600,
230                 .proc_handler   = proc_dolasatstring,
231         },
232         {
233                 .procname       = "boot-service",
234                 .data           = &lasat_boot_to_service,
235                 .maxlen         = sizeof(int),
236                 .mode           = 0644,
237                 .proc_handler   = proc_dointvec,
238         },
239 #ifdef CONFIG_DS1603
240         {
241                 .procname       = "rtc",
242                 .data           = &rtctmp,
243                 .maxlen         = sizeof(int),
244                 .mode           = 0644,
245                 .proc_handler   = proc_dolasatrtc,
246         },
247 #endif
248         {
249                 .procname       = "namestr",
250                 .data           = &lasat_board_info.li_namestr,
251                 .maxlen         = sizeof(lasat_board_info.li_namestr),
252                 .mode           = 0444,
253                 .proc_handler   = proc_dostring,
254         },
255         {
256                 .procname       = "typestr",
257                 .data           = &lasat_board_info.li_typestr,
258                 .maxlen         = sizeof(lasat_board_info.li_typestr),
259                 .mode           = 0444,
260                 .proc_handler   = proc_dostring,
261         },
262         {}
263 };
264
265 static ctl_table lasat_root_table[] = {
266         {
267                 .procname       = "lasat",
268                 .mode           =  0555,
269                 .child          = lasat_table
270         },
271         {}
272 };
273
274 static int __init lasat_register_sysctl(void)
275 {
276         struct ctl_table_header *lasat_table_header;
277
278         lasat_table_header =
279                 register_sysctl_table(lasat_root_table);
280         if (!lasat_table_header) {
281                 printk(KERN_ERR "Unable to register LASAT sysctl\n");
282                 return -ENOMEM;
283         }
284
285         return 0;
286 }
287
288 __initcall(lasat_register_sysctl);