1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * PCMCIA high-level CIS access functions 4 * 5 * The initial developer of the original code is David A. Hinds 6 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 7 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 8 * 9 * Copyright (C) 1999 David A. Hinds 10 * Copyright (C) 2004-2010 Dominik Brodowski 11 */ 12 13 #include <linux/slab.h> 14 #include <linux/module.h> 15 #include <linux/kernel.h> 16 #include <linux/netdevice.h> 17 #include <linux/etherdevice.h> 18 19 #include <pcmcia/cisreg.h> 20 #include <pcmcia/cistpl.h> 21 #include <pcmcia/ss.h> 22 #include <pcmcia/ds.h> 23 #include "cs_internal.h" 24 25 26 /** 27 * pccard_read_tuple() - internal CIS tuple access 28 * @s: the struct pcmcia_socket where the card is inserted 29 * @function: the device function we loop for 30 * @code: which CIS code shall we look for? 31 * @parse: buffer where the tuple shall be parsed (or NULL, if no parse) 32 * 33 * pccard_read_tuple() reads out one tuple and attempts to parse it 34 */ 35 int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function, 36 cisdata_t code, void *parse) 37 { 38 tuple_t tuple; 39 cisdata_t *buf; 40 int ret; 41 42 buf = kmalloc(256, GFP_KERNEL); 43 if (buf == NULL) { 44 dev_warn(&s->dev, "no memory to read tuple\n"); 45 return -ENOMEM; 46 } 47 tuple.DesiredTuple = code; 48 tuple.Attributes = 0; 49 if (function == BIND_FN_ALL) 50 tuple.Attributes = TUPLE_RETURN_COMMON; 51 ret = pccard_get_first_tuple(s, function, &tuple); 52 if (ret != 0) 53 goto done; 54 tuple.TupleData = buf; 55 tuple.TupleOffset = 0; 56 tuple.TupleDataMax = 255; 57 ret = pccard_get_tuple_data(s, &tuple); 58 if (ret != 0) 59 goto done; 60 ret = pcmcia_parse_tuple(&tuple, parse); 61 done: 62 kfree(buf); 63 return ret; 64 } 65 66 67 /** 68 * pccard_loop_tuple() - loop over tuples in the CIS 69 * @s: the struct pcmcia_socket where the card is inserted 70 * @function: the device function we loop for 71 * @code: which CIS code shall we look for? 72 * @parse: buffer where the tuple shall be parsed (or NULL, if no parse) 73 * @priv_data: private data to be passed to the loop_tuple function. 74 * @loop_tuple: function to call for each CIS entry of type @function. IT 75 * gets passed the raw tuple, the paresed tuple (if @parse is 76 * set) and @priv_data. 77 * 78 * pccard_loop_tuple() loops over all CIS entries of type @function, and 79 * calls the @loop_tuple function for each entry. If the call to @loop_tuple 80 * returns 0, the loop exits. Returns 0 on success or errorcode otherwise. 81 */ 82 static int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function, 83 cisdata_t code, cisparse_t *parse, void *priv_data, 84 int (*loop_tuple) (tuple_t *tuple, 85 cisparse_t *parse, 86 void *priv_data)) 87 { 88 tuple_t tuple; 89 cisdata_t *buf; 90 int ret; 91 92 buf = kzalloc(256, GFP_KERNEL); 93 if (buf == NULL) { 94 dev_warn(&s->dev, "no memory to read tuple\n"); 95 return -ENOMEM; 96 } 97 98 tuple.TupleData = buf; 99 tuple.TupleDataMax = 255; 100 tuple.TupleOffset = 0; 101 tuple.DesiredTuple = code; 102 tuple.Attributes = 0; 103 104 ret = pccard_get_first_tuple(s, function, &tuple); 105 while (!ret) { 106 if (pccard_get_tuple_data(s, &tuple)) 107 goto next_entry; 108 109 if (parse) 110 if (pcmcia_parse_tuple(&tuple, parse)) 111 goto next_entry; 112 113 ret = loop_tuple(&tuple, parse, priv_data); 114 if (!ret) 115 break; 116 117 next_entry: 118 ret = pccard_get_next_tuple(s, function, &tuple); 119 } 120 121 kfree(buf); 122 return ret; 123 } 124 125 126 /* 127 * pcmcia_io_cfg_data_width() - convert cfgtable to data path width parameter 128 */ 129 static int pcmcia_io_cfg_data_width(unsigned int flags) 130 { 131 if (!(flags & CISTPL_IO_8BIT)) 132 return IO_DATA_PATH_WIDTH_16; 133 if (!(flags & CISTPL_IO_16BIT)) 134 return IO_DATA_PATH_WIDTH_8; 135 return IO_DATA_PATH_WIDTH_AUTO; 136 } 137 138 139 struct pcmcia_cfg_mem { 140 struct pcmcia_device *p_dev; 141 int (*conf_check) (struct pcmcia_device *p_dev, void *priv_data); 142 void *priv_data; 143 cisparse_t parse; 144 cistpl_cftable_entry_t dflt; 145 }; 146 147 /* 148 * pcmcia_do_loop_config() - internal helper for pcmcia_loop_config() 149 * 150 * pcmcia_do_loop_config() is the internal callback for the call from 151 * pcmcia_loop_config() to pccard_loop_tuple(). Data is transferred 152 * by a struct pcmcia_cfg_mem. 153 */ 154 static int pcmcia_do_loop_config(tuple_t *tuple, cisparse_t *parse, void *priv) 155 { 156 struct pcmcia_cfg_mem *cfg_mem = priv; 157 struct pcmcia_device *p_dev = cfg_mem->p_dev; 158 cistpl_cftable_entry_t *cfg = &parse->cftable_entry; 159 cistpl_cftable_entry_t *dflt = &cfg_mem->dflt; 160 unsigned int flags = p_dev->config_flags; 161 unsigned int vcc = p_dev->socket->socket.Vcc; 162 163 dev_dbg(&p_dev->dev, "testing configuration %x, autoconf %x\n", 164 cfg->index, flags); 165 166 /* default values */ 167 cfg_mem->p_dev->config_index = cfg->index; 168 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) 169 cfg_mem->dflt = *cfg; 170 171 /* check for matching Vcc? */ 172 if (flags & CONF_AUTO_CHECK_VCC) { 173 if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) { 174 if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) 175 return -ENODEV; 176 } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) { 177 if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) 178 return -ENODEV; 179 } 180 } 181 182 /* set Vpp? */ 183 if (flags & CONF_AUTO_SET_VPP) { 184 if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) 185 p_dev->vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000; 186 else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM)) 187 p_dev->vpp = 188 dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000; 189 } 190 191 /* enable audio? */ 192 if ((flags & CONF_AUTO_AUDIO) && (cfg->flags & CISTPL_CFTABLE_AUDIO)) 193 p_dev->config_flags |= CONF_ENABLE_SPKR; 194 195 196 /* IO window settings? */ 197 if (flags & CONF_AUTO_SET_IO) { 198 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io; 199 int i = 0; 200 201 p_dev->resource[0]->start = p_dev->resource[0]->end = 0; 202 p_dev->resource[1]->start = p_dev->resource[1]->end = 0; 203 if (io->nwin == 0) 204 return -ENODEV; 205 206 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; 207 p_dev->resource[0]->flags |= 208 pcmcia_io_cfg_data_width(io->flags); 209 if (io->nwin > 1) { 210 /* For multifunction cards, by convention, we 211 * configure the network function with window 0, 212 * and serial with window 1 */ 213 i = (io->win[1].len > io->win[0].len); 214 p_dev->resource[1]->flags = p_dev->resource[0]->flags; 215 p_dev->resource[1]->start = io->win[1-i].base; 216 p_dev->resource[1]->end = io->win[1-i].len; 217 } 218 p_dev->resource[0]->start = io->win[i].base; 219 p_dev->resource[0]->end = io->win[i].len; 220 p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK; 221 } 222 223 /* MEM window settings? */ 224 if (flags & CONF_AUTO_SET_IOMEM) { 225 /* so far, we only set one memory window */ 226 cistpl_mem_t *mem = (cfg->mem.nwin) ? &cfg->mem : &dflt->mem; 227 228 p_dev->resource[2]->start = p_dev->resource[2]->end = 0; 229 if (mem->nwin == 0) 230 return -ENODEV; 231 232 p_dev->resource[2]->start = mem->win[0].host_addr; 233 p_dev->resource[2]->end = mem->win[0].len; 234 if (p_dev->resource[2]->end < 0x1000) 235 p_dev->resource[2]->end = 0x1000; 236 p_dev->card_addr = mem->win[0].card_addr; 237 } 238 239 dev_dbg(&p_dev->dev, 240 "checking configuration %x: %pr %pr %pr (%d lines)\n", 241 p_dev->config_index, p_dev->resource[0], p_dev->resource[1], 242 p_dev->resource[2], p_dev->io_lines); 243 244 return cfg_mem->conf_check(p_dev, cfg_mem->priv_data); 245 } 246 247 /** 248 * pcmcia_loop_config() - loop over configuration options 249 * @p_dev: the struct pcmcia_device which we need to loop for. 250 * @conf_check: function to call for each configuration option. 251 * It gets passed the struct pcmcia_device and private data 252 * being passed to pcmcia_loop_config() 253 * @priv_data: private data to be passed to the conf_check function. 254 * 255 * pcmcia_loop_config() loops over all configuration options, and calls 256 * the driver-specific conf_check() for each one, checking whether 257 * it is a valid one. Returns 0 on success or errorcode otherwise. 258 */ 259 int pcmcia_loop_config(struct pcmcia_device *p_dev, 260 int (*conf_check) (struct pcmcia_device *p_dev, 261 void *priv_data), 262 void *priv_data) 263 { 264 struct pcmcia_cfg_mem *cfg_mem; 265 int ret; 266 267 cfg_mem = kzalloc(sizeof(struct pcmcia_cfg_mem), GFP_KERNEL); 268 if (cfg_mem == NULL) 269 return -ENOMEM; 270 271 cfg_mem->p_dev = p_dev; 272 cfg_mem->conf_check = conf_check; 273 cfg_mem->priv_data = priv_data; 274 275 ret = pccard_loop_tuple(p_dev->socket, p_dev->func, 276 CISTPL_CFTABLE_ENTRY, &cfg_mem->parse, 277 cfg_mem, pcmcia_do_loop_config); 278 279 kfree(cfg_mem); 280 return ret; 281 } 282 EXPORT_SYMBOL(pcmcia_loop_config); 283 284 285 struct pcmcia_loop_mem { 286 struct pcmcia_device *p_dev; 287 void *priv_data; 288 int (*loop_tuple) (struct pcmcia_device *p_dev, 289 tuple_t *tuple, 290 void *priv_data); 291 }; 292 293 /* 294 * pcmcia_do_loop_tuple() - internal helper for pcmcia_loop_config() 295 * 296 * pcmcia_do_loop_tuple() is the internal callback for the call from 297 * pcmcia_loop_tuple() to pccard_loop_tuple(). Data is transferred 298 * by a struct pcmcia_cfg_mem. 299 */ 300 static int pcmcia_do_loop_tuple(tuple_t *tuple, cisparse_t *parse, void *priv) 301 { 302 struct pcmcia_loop_mem *loop = priv; 303 304 return loop->loop_tuple(loop->p_dev, tuple, loop->priv_data); 305 }; 306 307 /** 308 * pcmcia_loop_tuple() - loop over tuples in the CIS 309 * @p_dev: the struct pcmcia_device which we need to loop for. 310 * @code: which CIS code shall we look for? 311 * @priv_data: private data to be passed to the loop_tuple function. 312 * @loop_tuple: function to call for each CIS entry of type @function. IT 313 * gets passed the raw tuple and @priv_data. 314 * 315 * pcmcia_loop_tuple() loops over all CIS entries of type @function, and 316 * calls the @loop_tuple function for each entry. If the call to @loop_tuple 317 * returns 0, the loop exits. Returns 0 on success or errorcode otherwise. 318 */ 319 int pcmcia_loop_tuple(struct pcmcia_device *p_dev, cisdata_t code, 320 int (*loop_tuple) (struct pcmcia_device *p_dev, 321 tuple_t *tuple, 322 void *priv_data), 323 void *priv_data) 324 { 325 struct pcmcia_loop_mem loop = { 326 .p_dev = p_dev, 327 .loop_tuple = loop_tuple, 328 .priv_data = priv_data}; 329 330 return pccard_loop_tuple(p_dev->socket, p_dev->func, code, NULL, 331 &loop, pcmcia_do_loop_tuple); 332 } 333 EXPORT_SYMBOL(pcmcia_loop_tuple); 334 335 336 struct pcmcia_loop_get { 337 size_t len; 338 cisdata_t **buf; 339 }; 340 341 /* 342 * pcmcia_do_get_tuple() - internal helper for pcmcia_get_tuple() 343 * 344 * pcmcia_do_get_tuple() is the internal callback for the call from 345 * pcmcia_get_tuple() to pcmcia_loop_tuple(). As we're only interested in 346 * the first tuple, return 0 unconditionally. Create a memory buffer large 347 * enough to hold the content of the tuple, and fill it with the tuple data. 348 * The caller is responsible to free the buffer. 349 */ 350 static int pcmcia_do_get_tuple(struct pcmcia_device *p_dev, tuple_t *tuple, 351 void *priv) 352 { 353 struct pcmcia_loop_get *get = priv; 354 355 *get->buf = kzalloc(tuple->TupleDataLen, GFP_KERNEL); 356 if (*get->buf) { 357 get->len = tuple->TupleDataLen; 358 memcpy(*get->buf, tuple->TupleData, tuple->TupleDataLen); 359 } else 360 dev_dbg(&p_dev->dev, "do_get_tuple: out of memory\n"); 361 return 0; 362 } 363 364 /** 365 * pcmcia_get_tuple() - get first tuple from CIS 366 * @p_dev: the struct pcmcia_device which we need to loop for. 367 * @code: which CIS code shall we look for? 368 * @buf: pointer to store the buffer to. 369 * 370 * pcmcia_get_tuple() gets the content of the first CIS entry of type @code. 371 * It returns the buffer length (or zero). The caller is responsible to free 372 * the buffer passed in @buf. 373 */ 374 size_t pcmcia_get_tuple(struct pcmcia_device *p_dev, cisdata_t code, 375 unsigned char **buf) 376 { 377 struct pcmcia_loop_get get = { 378 .len = 0, 379 .buf = buf, 380 }; 381 382 *get.buf = NULL; 383 pcmcia_loop_tuple(p_dev, code, pcmcia_do_get_tuple, &get); 384 385 return get.len; 386 } 387 EXPORT_SYMBOL(pcmcia_get_tuple); 388 389 #ifdef CONFIG_NET 390 /* 391 * pcmcia_do_get_mac() - internal helper for pcmcia_get_mac_from_cis() 392 * 393 * pcmcia_do_get_mac() is the internal callback for the call from 394 * pcmcia_get_mac_from_cis() to pcmcia_loop_tuple(). We check whether the 395 * tuple contains a proper LAN_NODE_ID of length 6, and copy the data 396 * to struct net_device->dev_addr[i]. 397 */ 398 static int pcmcia_do_get_mac(struct pcmcia_device *p_dev, tuple_t *tuple, 399 void *priv) 400 { 401 struct net_device *dev = priv; 402 403 if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID) 404 return -EINVAL; 405 if (tuple->TupleDataLen < ETH_ALEN + 2) { 406 dev_warn(&p_dev->dev, "Invalid CIS tuple length for " 407 "LAN_NODE_ID\n"); 408 return -EINVAL; 409 } 410 411 if (tuple->TupleData[1] != ETH_ALEN) { 412 dev_warn(&p_dev->dev, "Invalid header for LAN_NODE_ID\n"); 413 return -EINVAL; 414 } 415 eth_hw_addr_set(dev, &tuple->TupleData[2]); 416 return 0; 417 } 418 419 /** 420 * pcmcia_get_mac_from_cis() - read out MAC address from CISTPL_FUNCE 421 * @p_dev: the struct pcmcia_device for which we want the address. 422 * @dev: a properly prepared struct net_device to store the info to. 423 * 424 * pcmcia_get_mac_from_cis() reads out the hardware MAC address from 425 * CISTPL_FUNCE and stores it into struct net_device *dev->dev_addr which 426 * must be set up properly by the driver (see examples!). 427 */ 428 int pcmcia_get_mac_from_cis(struct pcmcia_device *p_dev, struct net_device *dev) 429 { 430 return pcmcia_loop_tuple(p_dev, CISTPL_FUNCE, pcmcia_do_get_mac, dev); 431 } 432 EXPORT_SYMBOL(pcmcia_get_mac_from_cis); 433 434 #endif /* CONFIG_NET */ 435