1 /*-
2 * Copyright (c) 2016-2017 Ilya Bakulin
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * Copyright (c) 2010 Broadcom Corporation
27 *
28 * Permission to use, copy, modify, and/or distribute this software for any
29 * purpose with or without fee is hereby granted, provided that the above
30 * copyright notice and this permission notice appear in all copies.
31 *
32 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
33 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
34 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
35 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
36 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
37 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
38 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
39 *
40 * $FreeBSD$
41 */
42
43 #include <sys/cdefs.h>
44 __FBSDID("$FreeBSD$");
45
46 #include <sys/ioctl.h>
47 #include <sys/stdint.h>
48 #include <sys/types.h>
49 #include <sys/stat.h>
50 #include <sys/endian.h>
51 #include <sys/sbuf.h>
52 #include <sys/mman.h>
53
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #include <unistd.h>
58 #include <inttypes.h>
59 #include <limits.h>
60 #include <fcntl.h>
61 #include <ctype.h>
62 #include <err.h>
63 #include <libutil.h>
64 #include <unistd.h>
65
66 #include <cam/cam.h>
67 #include <cam/cam_debug.h>
68 #include <cam/cam_ccb.h>
69 #include <cam/mmc/mmc_all.h>
70 #include <camlib.h>
71
72 #include "linux_compat.h"
73 #include "linux_sdio_compat.h"
74 #include "cam_sdio.h"
75 #include "brcmfmac_sdio.h"
76 #include "brcmfmac_bus.h"
77
78 static void probe_bcrm(struct cam_device *dev);
79
80 /*
81 * How Linux driver works
82 *
83 * The probing begins by calling brcmf_ops_sdio_probe() which is defined as probe function in struct sdio_driver. http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c#L1126
84 *
85 * The driver does black magic by copying func struct for F2 and setting func number to zero there, to create an F0 func structure :)
86 * Driver state changes to BRCMF_SDIOD_DOWN.
87 * ops_sdio_probe() then calls brcmf_sdio_probe() -- at this point it has filled in sdiodev struct with the pointers to all three functions (F0, F1, F2).
88 *
89 * brcmf_sdiod_probe() sets block sizes for F1 and F2. It sets F1 block size to 64 and F2 to 512, not consulting the values stored in SDIO CCCR / FBR registers!
90 * Then it increases timeout for F2 (what is this?!)
91 * Then it enables F1
92 * Then it attaches "freezer" (without PM this is NOP)
93 * Finally it calls brcmf_sdio_probe() http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c#L4082
94 *
95 * Here high-level workqueues and sg tables are allocated.
96 * It then calls brcmf_sdio_probe_attach()
97 *
98 * Here at the beginning there is a pr_debug() call with brcmf_sdiod_regrl() inside to addr #define SI_ENUM_BASE 0x18000000.
99 * Return value is 0x16044330.
100 * Then turns off PLL: byte-write BRCMF_INIT_CLKCTL1 (0x28) -> SBSDIO_FUNC1_CHIPCLKCSR (0x1000E)
101 * Then it reads value back, should be 0xe8.
102 * Then calls brcmf_chip_attach()
103 *
104 * http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c#L1054
105 * This func enumerates and resets all the cores on the dongle.
106 * - brcmf_sdio_buscoreprep(): force clock to ALPAvail req only:
107 * SBSDIO_FORCE_HW_CLKREQ_OFF | SBSDIO_ALP_AVAIL_REQ -> SBSDIO_FUNC1_CHIPCLKCSR
108 * Wait up to 15ms to !SBSDIO_ALPAV(clkval) of the value from CLKCSR.
109 * Force ALP:
110 * SBSDIO_FORCE_HW_CLKREQ_OFF | SBSDIO_FORCE_ALP (0x21)-> SBSDIO_FUNC1_CHIPCLKCSR
111 * Disaable SDIO pullups:
112 * byte 0 -> SBSDIO_FUNC1_SDIOPULLUP (0x0001000f)
113 *
114 * Calls brcmf_chip_recognition()
115 * http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c#L908
116 * Read 0x18000000. Get 0x16044330: chip 4330 rev 4
117 * AXI chip, call brcmf_chip_dmp_erom_scan() to get info about all cores.
118 * Then brcmf_chip_cores_check() to check that CPU and RAM are found,
119 *
120 * Setting cores to passive: not clear which of CR4/CA7/CM3 our chip has.
121 * Quite a few r/w calls to different parts of the chip to reset cores....
122 * Finally get_raminfo() called to fill in RAM info:
123 * brcmf_chip_get_raminfo: RAM: base=0x0 size=294912 (0x48000) sr=0 (0x0)
124 * http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c#L700
125 *
126 * Then brcmf_chip_setup() is called, this prints and fills in chipcommon rev and PMU caps:
127 * brcmf_chip_setup: ccrev=39, pmurev=12, pmucaps=0x19583c0c
128 * http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c#L1015
129 * Bus-specific setup code is NOP for SDIO.
130 *
131 * brcmf_sdio_kso_init() is called.
132 * Here it first reads 0x1 from SBSDIO_FUNC1_SLEEPCSR 0x18000650 and then writes it back... WTF?
133 *
134 * brcmf_sdio_drivestrengthinit() is called
135 * http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c#L3630
136 *
137 * Set card control so an SDIO card reset does a WLAN backplane reset
138 * set PMUControl so a backplane reset does PMU state reload
139 * === end of brcmf_sdio_probe_attach ===
140
141 **** Finished reading at http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c#L4152, line 2025 in the dump
142
143 * === How register reading works ===
144 * http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c#L357
145 * The address to read from is written to three byte-sized registers of F1:
146 * - SBSDIO_FUNC1_SBADDRLOW 0x1000A
147 * - SBSDIO_FUNC1_SBADDRMID 0x1000B
148 * - SBSDIO_FUNC1_SBADDRHIGH 0x1000C
149 * If this is 32-bit read , a flag is set. The address is ANDed with SBSDIO_SB_OFT_ADDR_MASK which is 0x07FFF.
150 * Then brcmf_sdiod_regrw_helper() is called to read the reply.
151 * http://lxr.free-electrons.com/source/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c#L306
152 * Based on the address it figures out where to read it from (CCCR / FBR in F0, or somewhere in F1).
153 * Reads are retried three times.
154 * 1-byte IO is done with CMD52, more is read with CMD53 with address increment (not FIFO mode).
155 * http://lxr.free-electrons.com/source/drivers/mmc/core/sdio_io.c#L458
156 * ==================================
157 *
158 *
159 */
160
161 /* BRCM-specific functions */
162 #define SDIOH_API_ACCESS_RETRY_LIMIT 2
163 #define SI_ENUM_BASE 0x18000000
164 #define REPLY_MAGIC 0x16044330
165 #define brcmf_err(fmt, ...) brcmf_dbg(0, fmt, ##__VA_ARGS__)
166 #define brcmf_dbg(level, fmt, ...) printf(fmt, ##__VA_ARGS__)
167
168 struct brcmf_sdio_dev {
169 struct cam_device *cam_dev;
170 u32 sbwad; /* Save backplane window address */
171 struct brcmf_bus *bus_if;
172 enum brcmf_sdiod_state state;
173 struct sdio_func *func[8];
174 };
175
176 void brcmf_bus_change_state(struct brcmf_bus *bus, enum brcmf_bus_state state);
177 void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
178 enum brcmf_sdiod_state state);
179 static int brcmf_sdiod_request_data(struct brcmf_sdio_dev *sdiodev, u8 fn, u32 addr,
180 u8 regsz, void *data, bool write);
181 static int brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address);
182 static int brcmf_sdiod_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr);
183 u32 brcmf_sdiod_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret);
184
185 static void bailout(int ret);
186
187 static void
bailout(int ret)188 bailout(int ret) {
189 if (ret == 0)
190 return;
191 errx(1, "Operation returned error %d", ret);
192 }
193
194 void
brcmf_bus_change_state(struct brcmf_bus * bus,enum brcmf_bus_state state)195 brcmf_bus_change_state(struct brcmf_bus *bus, enum brcmf_bus_state state)
196 {
197 bus->state = state;
198 }
199
brcmf_sdiod_change_state(struct brcmf_sdio_dev * sdiodev,enum brcmf_sdiod_state state)200 void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
201 enum brcmf_sdiod_state state)
202 {
203 if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM ||
204 state == sdiodev->state)
205 return;
206
207 //brcmf_dbg(TRACE, "%d -> %d\n", sdiodev->state, state);
208 switch (sdiodev->state) {
209 case BRCMF_SDIOD_DATA:
210 /* any other state means bus interface is down */
211 brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_DOWN);
212 break;
213 case BRCMF_SDIOD_DOWN:
214 /* transition from DOWN to DATA means bus interface is up */
215 if (state == BRCMF_SDIOD_DATA)
216 brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_UP);
217 break;
218 default:
219 break;
220 }
221 sdiodev->state = state;
222 }
223
brcmf_sdiod_f0_writeb(struct sdio_func * func,uint regaddr,u8 byte)224 static inline int brcmf_sdiod_f0_writeb(struct sdio_func *func,
225 uint regaddr, u8 byte) {
226 int err_ret;
227
228 /*
229 * Can only directly write to some F0 registers.
230 * Handle CCCR_IENx and CCCR_ABORT command
231 * as a special case.
232 */
233 if ((regaddr == SDIO_CCCR_ABORT) ||
234 (regaddr == SDIO_CCCR_IENx))
235 sdio_writeb(func, byte, regaddr, &err_ret);
236 else
237 sdio_f0_writeb(func, byte, regaddr, &err_ret);
238
239 return err_ret;
240 }
241
brcmf_sdiod_request_data(struct brcmf_sdio_dev * sdiodev,u8 fn,u32 addr,u8 regsz,void * data,bool write)242 static int brcmf_sdiod_request_data(struct brcmf_sdio_dev *sdiodev, u8 fn, u32 addr, u8 regsz, void *data, bool write)
243 {
244 struct sdio_func *func;
245 int ret = -EINVAL;
246
247 brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
248 write, fn, addr, regsz);
249
250 /* only allow byte access on F0 */
251 if (WARN_ON(regsz > 1 && !fn))
252 return -EINVAL;
253 func = sdiodev->func[fn];
254
255 switch (regsz) {
256 case sizeof(u8):
257 if (write) {
258 if (fn)
259 sdio_writeb(func, *(u8 *)data, addr, &ret);
260 else
261 ret = brcmf_sdiod_f0_writeb(func, addr,
262 *(u8 *)data);
263 } else {
264 if (fn)
265 *(u8 *)data = sdio_readb(func, addr, &ret);
266 else
267 *(u8 *)data = sdio_f0_readb(func, addr, &ret);
268 }
269 break;
270 case sizeof(u16):
271 if (write)
272 sdio_writew(func, *(u16 *)data, addr, &ret);
273 else
274 *(u16 *)data = sdio_readw(func, addr, &ret);
275 break;
276 case sizeof(u32):
277 if (write)
278 sdio_writel(func, *(u32 *)data, addr, &ret);
279 else
280 *(u32 *)data = sdio_readl(func, addr, &ret);
281 break;
282 default:
283 brcmf_err("invalid size: %d\n", regsz);
284 break;
285 }
286
287 if (ret)
288 brcmf_dbg(SDIO, "failed to %s data F%d@0x%05x, err: %d\n",
289 write ? "write" : "read", fn, addr, ret);
290
291 return ret;
292 }
293
294 static int
brcmf_sdiod_addrprep(struct brcmf_sdio_dev * sdiodev,uint width,u32 * addr)295 brcmf_sdiod_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr)
296 {
297 uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
298 int err = 0;
299
300 if (bar0 != sdiodev->sbwad) {
301 err = brcmf_sdiod_set_sbaddr_window(sdiodev, bar0);
302 if (err)
303 return err;
304
305 sdiodev->sbwad = bar0;
306 }
307
308 *addr &= SBSDIO_SB_OFT_ADDR_MASK;
309
310 if (width == 4)
311 *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
312
313 return 0;
314 }
315
brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev * sdiodev,u32 addr,u8 regsz,void * data,bool write)316 static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr, u8 regsz, void *data, bool write) {
317 u8 func;
318 s32 retry = 0;
319 int ret;
320
321 if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
322 return -ENOMEDIUM;
323
324 /*
325 * figure out how to read the register based on address range
326 * 0x00 ~ 0x7FF: function 0 CCCR and FBR
327 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
328 * The rest: function 1 silicon backplane core registers
329 */
330 if ((addr & ~REG_F0_REG_MASK) == 0)
331 func = SDIO_FUNC_0;
332 else
333 func = SDIO_FUNC_1;
334
335 do {
336 if (!write)
337 memset(data, 0, regsz);
338 /* for retry wait for 1 ms till bus get settled down */
339 if (retry)
340 usleep_range(1000, 2000);
341 ret = brcmf_sdiod_request_data(sdiodev, func, addr, regsz,
342 data, write);
343 } while (ret != 0 && ret != -ENOMEDIUM &&
344 retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
345
346 if (ret == -ENOMEDIUM)
347 brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
348 else if (ret != 0) {
349 /*
350 * SleepCSR register access can fail when
351 * waking up the device so reduce this noise
352 * in the logs.
353 */
354 if (addr != SBSDIO_FUNC1_SLEEPCSR)
355 brcmf_err("failed to %s data F%d@0x%05x, err: %d\n",
356 write ? "write" : "read", func, addr, ret);
357 else
358 brcmf_dbg(SDIO, "failed to %s data F%d@0x%05x, err: %d\n",
359 write ? "write" : "read", func, addr, ret);
360 }
361 return ret;
362 }
363
364 static int
brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev * sdiodev,u32 address)365 brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
366 {
367 int err = 0, i;
368 u8 addr[3];
369
370 if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
371 return -ENOMEDIUM;
372
373 addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
374 addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;
375 addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;
376
377 for (i = 0; i < 3; i++) {
378 err = brcmf_sdiod_regrw_helper(sdiodev,
379 SBSDIO_FUNC1_SBADDRLOW + i,
380 sizeof(u8), &addr[i], true);
381 if (err) {
382 brcmf_err("failed at addr: 0x%0x\n",
383 SBSDIO_FUNC1_SBADDRLOW + i);
384 break;
385 }
386 }
387
388 return err;
389 }
390
brcmf_sdiod_regrl(struct brcmf_sdio_dev * sdiodev,u32 addr,int * ret)391 u32 brcmf_sdiod_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
392 {
393 u32 data = 0;
394 int retval;
395
396 brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
397 retval = brcmf_sdiod_addrprep(sdiodev, sizeof(data), &addr);
398 if (retval)
399 goto done;
400 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
401 false);
402 brcmf_dbg(SDIO, "data:0x%08x\n", data);
403
404 done:
405 if (ret)
406 *ret = retval;
407
408 return data;
409 }
410
411 /********************************************************/
412 __unused
413 static void
probe_bcrm(struct cam_device * dev)414 probe_bcrm(struct cam_device *dev) {
415 uint32_t cis_addr;
416 struct cis_info info;
417
418 sdio_card_set_bus_width(dev, bus_width_4);
419 cis_addr = sdio_get_common_cis_addr(dev);
420 printf("CIS address: %04X\n", cis_addr);
421
422 memset(&info, 0, sizeof(info));
423 sdio_func_read_cis(dev, 0, cis_addr, &info);
424 printf("Vendor 0x%04X product 0x%04X\n", info.man_id, info.prod_id);
425 }
426
427 __unused static uint8_t*
mmap_fw()428 mmap_fw() {
429 const char fw_path[] = "/home/kibab/repos/fbsd-bbb/brcm-firmware/brcmfmac4330-sdio.bin";
430 struct stat sb;
431 uint8_t *fw_ptr;
432
433 int fd = open(fw_path, O_RDONLY);
434 if (fd < 0)
435 errx(1, "Cannot open firmware file");
436 if (fstat(fd, &sb) < 0)
437 errx(1, "Cannot get file stat");
438 fw_ptr = mmap(NULL, sb.st_size, PROT_READ, 0, fd, 0);
439 if (fw_ptr == MAP_FAILED)
440 errx(1, "Cannot map the file");
441
442 return fw_ptr;
443 }
444
445 static void
usage()446 usage() {
447 printf("sdiotool -u <pass_dev_unit>\n");
448 exit(0);
449 }
450
451 struct card_info {
452 uint8_t num_funcs;
453 struct cis_info f[8];
454 };
455
456 /*
457 * TODO: We should add SDIO card info about at least number of
458 * available functions to struct cam_device and use it instead
459 * of checking for man_id = 0x00 for detecting number of functions
460 */
461 static void
get_sdio_card_info(struct cam_device * dev,struct card_info * ci)462 get_sdio_card_info(struct cam_device *dev, struct card_info *ci) {
463 uint32_t cis_addr;
464 uint32_t fbr_addr;
465 int ret;
466
467 cis_addr = sdio_get_common_cis_addr(dev);
468
469 memset(ci, 0, sizeof(struct card_info));
470 sdio_func_read_cis(dev, 0, cis_addr, &ci->f[0]);
471 printf("F0: Vendor 0x%04X product 0x%04X max block size %d bytes\n",
472 ci->f[0].man_id, ci->f[0].prod_id, ci->f[0].max_block_size);
473 for (int i = 1; i <= 7; i++) {
474 fbr_addr = SD_IO_FBR_START * i + 0x9;
475 cis_addr = sdio_read_1(dev, 0, fbr_addr++, &ret);bailout(ret);
476 cis_addr |= sdio_read_1(dev, 0, fbr_addr++, &ret) << 8;
477 cis_addr |= sdio_read_1(dev, 0, fbr_addr++, &ret) << 16;
478 sdio_func_read_cis(dev, i, cis_addr, &ci->f[i]);
479 printf("F%d: Vendor 0x%04X product 0x%04X max block size %d bytes\n",
480 i, ci->f[i].man_id, ci->f[i].prod_id, ci->f[i].max_block_size);
481 if (ci->f[i].man_id == 0) {
482 printf("F%d doesn't exist\n", i);
483 break;
484 }
485 ci->num_funcs++;
486 }
487 }
488
489 int
main(int argc,char ** argv)490 main(int argc, char **argv) {
491 char device[] = "pass";
492 int unit = 0;
493 int func = 0;
494 __unused uint8_t *fw_ptr;
495 int ch;
496 struct cam_device *cam_dev;
497 int ret;
498 struct card_info ci;
499
500 //fw_ptr = mmap_fw();
501
502 while ((ch = getopt(argc, argv, "fu:")) != -1) {
503 switch (ch) {
504 case 'u':
505 unit = (int) strtol(optarg, NULL, 10);
506 break;
507 case 'f':
508 func = (int) strtol(optarg, NULL, 10);
509 break;
510 case '?':
511 default:
512 usage();
513 }
514 }
515 argc -= optind;
516 argv += optind;
517
518 if ((cam_dev = cam_open_spec_device(device, unit, O_RDWR, NULL)) == NULL)
519 errx(1, "Cannot open device");
520
521 get_sdio_card_info(cam_dev, &ci);
522
523 /* For now, everything non-broadcom is out of the question */
524 if (ci.f[0].man_id != 0x02D0) {
525 printf("The card is not a Broadcom device\n");
526 exit(1);
527 }
528 /* Init structures */
529 struct brcmf_sdio_dev brcmf_dev;
530 struct brcmf_bus bus_if;
531 struct sdio_func f0, f1, f2;
532 bus_if.state = BRCMF_BUS_DOWN;
533 brcmf_dev.cam_dev = cam_dev;
534 brcmf_dev.bus_if = &bus_if;
535 brcmf_dev.state = BRCMF_SDIOD_DOWN;
536
537 /* Fill in functions */
538 brcmf_dev.func[0] = &f0;
539 brcmf_dev.func[1] = &f1;
540 brcmf_dev.func[2] = &f2;
541
542 brcmf_dev.func[0]->dev = brcmf_dev.func[1]->dev
543 = brcmf_dev.func[2]->dev = cam_dev;
544 brcmf_dev.func[0]->num = 0;
545 brcmf_dev.func[1]->num = 1;
546 brcmf_dev.func[2]->num = 2;
547
548 ret = sdio_func_enable(cam_dev, 1, 1);bailout(ret);
549 uint32_t magic = brcmf_sdiod_regrl(&brcmf_dev, 0x18000000, &ret);
550 printf("Magic = %08x\n", magic);
551 if (magic != REPLY_MAGIC) {
552 errx(1, "Reply magic is incorrect: expected %08x, got %08x",
553 REPLY_MAGIC, magic);
554 }
555 cam_close_spec_device(cam_dev);
556 }
557