pcmcia: move high level CIS access code to separate file
[linux-2.6.git] / drivers / pcmcia / pcmcia_cis.c
1 /*
2  * PCMCIA high-level CIS access functions
3  *
4  * The initial developer of the original code is David A. Hinds
5  * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
6  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
7  *
8  * Copyright (C) 1999        David A. Hinds
9  * Copyright (C) 2004-2009   Dominik Brodowski
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  *
15  */
16
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/netdevice.h>
20
21 #include <pcmcia/cs_types.h>
22 #include <pcmcia/cisreg.h>
23 #include <pcmcia/cistpl.h>
24 #include <pcmcia/ss.h>
25 #include <pcmcia/cs.h>
26 #include <pcmcia/ds.h>
27 #include "cs_internal.h"
28
29
30 /**
31  * pccard_read_tuple() - internal CIS tuple access
32  * @s:          the struct pcmcia_socket where the card is inserted
33  * @function:   the device function we loop for
34  * @code:       which CIS code shall we look for?
35  * @parse:      buffer where the tuple shall be parsed (or NULL, if no parse)
36  *
37  * pccard_read_tuple() reads out one tuple and attempts to parse it
38  */
39 int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function,
40                 cisdata_t code, void *parse)
41 {
42         tuple_t tuple;
43         cisdata_t *buf;
44         int ret;
45
46         buf = kmalloc(256, GFP_KERNEL);
47         if (buf == NULL) {
48                 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n");
49                 return -ENOMEM;
50         }
51         tuple.DesiredTuple = code;
52         tuple.Attributes = 0;
53         if (function == BIND_FN_ALL)
54                 tuple.Attributes = TUPLE_RETURN_COMMON;
55         ret = pccard_get_first_tuple(s, function, &tuple);
56         if (ret != 0)
57                 goto done;
58         tuple.TupleData = buf;
59         tuple.TupleOffset = 0;
60         tuple.TupleDataMax = 255;
61         ret = pccard_get_tuple_data(s, &tuple);
62         if (ret != 0)
63                 goto done;
64         ret = pcmcia_parse_tuple(&tuple, parse);
65 done:
66         kfree(buf);
67         return ret;
68 }
69
70
71 /**
72  * pccard_loop_tuple() - loop over tuples in the CIS
73  * @s:          the struct pcmcia_socket where the card is inserted
74  * @function:   the device function we loop for
75  * @code:       which CIS code shall we look for?
76  * @parse:      buffer where the tuple shall be parsed (or NULL, if no parse)
77  * @priv_data:  private data to be passed to the loop_tuple function.
78  * @loop_tuple: function to call for each CIS entry of type @function. IT
79  *              gets passed the raw tuple, the paresed tuple (if @parse is
80  *              set) and @priv_data.
81  *
82  * pccard_loop_tuple() loops over all CIS entries of type @function, and
83  * calls the @loop_tuple function for each entry. If the call to @loop_tuple
84  * returns 0, the loop exits. Returns 0 on success or errorcode otherwise.
85  */
86 int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function,
87                       cisdata_t code, cisparse_t *parse, void *priv_data,
88                       int (*loop_tuple) (tuple_t *tuple,
89                                          cisparse_t *parse,
90                                          void *priv_data))
91 {
92         tuple_t tuple;
93         cisdata_t *buf;
94         int ret;
95
96         buf = kzalloc(256, GFP_KERNEL);
97         if (buf == NULL) {
98                 dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n");
99                 return -ENOMEM;
100         }
101
102         tuple.TupleData = buf;
103         tuple.TupleDataMax = 255;
104         tuple.TupleOffset = 0;
105         tuple.DesiredTuple = code;
106         tuple.Attributes = 0;
107
108         ret = pccard_get_first_tuple(s, function, &tuple);
109         while (!ret) {
110                 if (pccard_get_tuple_data(s, &tuple))
111                         goto next_entry;
112
113                 if (parse)
114                         if (pcmcia_parse_tuple(&tuple, parse))
115                                 goto next_entry;
116
117                 ret = loop_tuple(&tuple, parse, priv_data);
118                 if (!ret)
119                         break;
120
121 next_entry:
122                 ret = pccard_get_next_tuple(s, function, &tuple);
123         }
124
125         kfree(buf);
126         return ret;
127 }
128
129 struct pcmcia_cfg_mem {
130         struct pcmcia_device *p_dev;
131         void *priv_data;
132         int (*conf_check) (struct pcmcia_device *p_dev,
133                            cistpl_cftable_entry_t *cfg,
134                            cistpl_cftable_entry_t *dflt,
135                            unsigned int vcc,
136                            void *priv_data);
137         cisparse_t parse;
138         cistpl_cftable_entry_t dflt;
139 };
140
141 /**
142  * pcmcia_do_loop_config() - internal helper for pcmcia_loop_config()
143  *
144  * pcmcia_do_loop_config() is the internal callback for the call from
145  * pcmcia_loop_config() to pccard_loop_tuple(). Data is transferred
146  * by a struct pcmcia_cfg_mem.
147  */
148 static int pcmcia_do_loop_config(tuple_t *tuple, cisparse_t *parse, void *priv)
149 {
150         cistpl_cftable_entry_t *cfg = &parse->cftable_entry;
151         struct pcmcia_cfg_mem *cfg_mem = priv;
152
153         /* default values */
154         cfg_mem->p_dev->conf.ConfigIndex = cfg->index;
155         if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
156                 cfg_mem->dflt = *cfg;
157
158         return cfg_mem->conf_check(cfg_mem->p_dev, cfg, &cfg_mem->dflt,
159                                    cfg_mem->p_dev->socket->socket.Vcc,
160                                    cfg_mem->priv_data);
161 }
162
163 /**
164  * pcmcia_loop_config() - loop over configuration options
165  * @p_dev:      the struct pcmcia_device which we need to loop for.
166  * @conf_check: function to call for each configuration option.
167  *              It gets passed the struct pcmcia_device, the CIS data
168  *              describing the configuration option, and private data
169  *              being passed to pcmcia_loop_config()
170  * @priv_data:  private data to be passed to the conf_check function.
171  *
172  * pcmcia_loop_config() loops over all configuration options, and calls
173  * the driver-specific conf_check() for each one, checking whether
174  * it is a valid one. Returns 0 on success or errorcode otherwise.
175  */
176 int pcmcia_loop_config(struct pcmcia_device *p_dev,
177                        int      (*conf_check)   (struct pcmcia_device *p_dev,
178                                                  cistpl_cftable_entry_t *cfg,
179                                                  cistpl_cftable_entry_t *dflt,
180                                                  unsigned int vcc,
181                                                  void *priv_data),
182                        void *priv_data)
183 {
184         struct pcmcia_cfg_mem *cfg_mem;
185         int ret;
186
187         cfg_mem = kzalloc(sizeof(struct pcmcia_cfg_mem), GFP_KERNEL);
188         if (cfg_mem == NULL)
189                 return -ENOMEM;
190
191         cfg_mem->p_dev = p_dev;
192         cfg_mem->conf_check = conf_check;
193         cfg_mem->priv_data = priv_data;
194
195         ret = pccard_loop_tuple(p_dev->socket, p_dev->func,
196                                 CISTPL_CFTABLE_ENTRY, &cfg_mem->parse,
197                                 cfg_mem, pcmcia_do_loop_config);
198
199         kfree(cfg_mem);
200         return ret;
201 }
202 EXPORT_SYMBOL(pcmcia_loop_config);
203
204
205 struct pcmcia_loop_mem {
206         struct pcmcia_device *p_dev;
207         void *priv_data;
208         int (*loop_tuple) (struct pcmcia_device *p_dev,
209                            tuple_t *tuple,
210                            void *priv_data);
211 };
212
213 /**
214  * pcmcia_do_loop_tuple() - internal helper for pcmcia_loop_config()
215  *
216  * pcmcia_do_loop_tuple() is the internal callback for the call from
217  * pcmcia_loop_tuple() to pccard_loop_tuple(). Data is transferred
218  * by a struct pcmcia_cfg_mem.
219  */
220 static int pcmcia_do_loop_tuple(tuple_t *tuple, cisparse_t *parse, void *priv)
221 {
222         struct pcmcia_loop_mem *loop = priv;
223
224         return loop->loop_tuple(loop->p_dev, tuple, loop->priv_data);
225 };
226
227 /**
228  * pcmcia_loop_tuple() - loop over tuples in the CIS
229  * @p_dev:      the struct pcmcia_device which we need to loop for.
230  * @code:       which CIS code shall we look for?
231  * @priv_data:  private data to be passed to the loop_tuple function.
232  * @loop_tuple: function to call for each CIS entry of type @function. IT
233  *              gets passed the raw tuple and @priv_data.
234  *
235  * pcmcia_loop_tuple() loops over all CIS entries of type @function, and
236  * calls the @loop_tuple function for each entry. If the call to @loop_tuple
237  * returns 0, the loop exits. Returns 0 on success or errorcode otherwise.
238  */
239 int pcmcia_loop_tuple(struct pcmcia_device *p_dev, cisdata_t code,
240                       int (*loop_tuple) (struct pcmcia_device *p_dev,
241                                          tuple_t *tuple,
242                                          void *priv_data),
243                       void *priv_data)
244 {
245         struct pcmcia_loop_mem loop = {
246                 .p_dev = p_dev,
247                 .loop_tuple = loop_tuple,
248                 .priv_data = priv_data};
249
250         return pccard_loop_tuple(p_dev->socket, p_dev->func, code, NULL,
251                                  &loop, pcmcia_do_loop_tuple);
252 }
253 EXPORT_SYMBOL(pcmcia_loop_tuple);
254
255
256 struct pcmcia_loop_get {
257         size_t len;
258         cisdata_t **buf;
259 };
260
261 /**
262  * pcmcia_do_get_tuple() - internal helper for pcmcia_get_tuple()
263  *
264  * pcmcia_do_get_tuple() is the internal callback for the call from
265  * pcmcia_get_tuple() to pcmcia_loop_tuple(). As we're only interested in
266  * the first tuple, return 0 unconditionally. Create a memory buffer large
267  * enough to hold the content of the tuple, and fill it with the tuple data.
268  * The caller is responsible to free the buffer.
269  */
270 static int pcmcia_do_get_tuple(struct pcmcia_device *p_dev, tuple_t *tuple,
271                                void *priv)
272 {
273         struct pcmcia_loop_get *get = priv;
274
275         *get->buf = kzalloc(tuple->TupleDataLen, GFP_KERNEL);
276         if (*get->buf) {
277                 get->len = tuple->TupleDataLen;
278                 memcpy(*get->buf, tuple->TupleData, tuple->TupleDataLen);
279         } else
280                 dev_dbg(&p_dev->dev, "do_get_tuple: out of memory\n");
281         return 0;
282 }
283
284 /**
285  * pcmcia_get_tuple() - get first tuple from CIS
286  * @p_dev:      the struct pcmcia_device which we need to loop for.
287  * @code:       which CIS code shall we look for?
288  * @buf:        pointer to store the buffer to.
289  *
290  * pcmcia_get_tuple() gets the content of the first CIS entry of type @code.
291  * It returns the buffer length (or zero). The caller is responsible to free
292  * the buffer passed in @buf.
293  */
294 size_t pcmcia_get_tuple(struct pcmcia_device *p_dev, cisdata_t code,
295                         unsigned char **buf)
296 {
297         struct pcmcia_loop_get get = {
298                 .len = 0,
299                 .buf = buf,
300         };
301
302         *get.buf = NULL;
303         pcmcia_loop_tuple(p_dev, code, pcmcia_do_get_tuple, &get);
304
305         return get.len;
306 }
307 EXPORT_SYMBOL(pcmcia_get_tuple);
308
309
310 /**
311  * pcmcia_do_get_mac() - internal helper for pcmcia_get_mac_from_cis()
312  *
313  * pcmcia_do_get_mac() is the internal callback for the call from
314  * pcmcia_get_mac_from_cis() to pcmcia_loop_tuple(). We check whether the
315  * tuple contains a proper LAN_NODE_ID of length 6, and copy the data
316  * to struct net_device->dev_addr[i].
317  */
318 static int pcmcia_do_get_mac(struct pcmcia_device *p_dev, tuple_t *tuple,
319                              void *priv)
320 {
321         struct net_device *dev = priv;
322         int i;
323
324         if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
325                 return -EINVAL;
326         if (tuple->TupleDataLen < ETH_ALEN + 2) {
327                 dev_warn(&p_dev->dev, "Invalid CIS tuple length for "
328                         "LAN_NODE_ID\n");
329                 return -EINVAL;
330         }
331
332         if (tuple->TupleData[1] != ETH_ALEN) {
333                 dev_warn(&p_dev->dev, "Invalid header for LAN_NODE_ID\n");
334                 return -EINVAL;
335         }
336         for (i = 0; i < 6; i++)
337                 dev->dev_addr[i] = tuple->TupleData[i+2];
338         return 0;
339 }
340
341 /**
342  * pcmcia_get_mac_from_cis() - read out MAC address from CISTPL_FUNCE
343  * @p_dev:      the struct pcmcia_device for which we want the address.
344  * @dev:        a properly prepared struct net_device to store the info to.
345  *
346  * pcmcia_get_mac_from_cis() reads out the hardware MAC address from
347  * CISTPL_FUNCE and stores it into struct net_device *dev->dev_addr which
348  * must be set up properly by the driver (see examples!).
349  */
350 int pcmcia_get_mac_from_cis(struct pcmcia_device *p_dev, struct net_device *dev)
351 {
352         return pcmcia_loop_tuple(p_dev, CISTPL_FUNCE, pcmcia_do_get_mac, dev);
353 }
354 EXPORT_SYMBOL(pcmcia_get_mac_from_cis);
355