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