• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Broadcom B43 wireless driver
3  *
4  * SDIO over Sonics Silicon Backplane bus glue for b43.
5  *
6  * Copyright (C) 2009 Albert Herranz
7  * Copyright (C) 2009 Michael Buesch <m@bues.ch>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or (at
12  * your option) any later version.
13  */
14 
15 #include <linux/kernel.h>
16 #include <linux/mmc/card.h>
17 #include <linux/mmc/sdio_func.h>
18 #include <linux/mmc/sdio_ids.h>
19 #include <linux/slab.h>
20 #include <linux/ssb/ssb.h>
21 
22 #include "sdio.h"
23 #include "b43.h"
24 
25 
26 #define HNBU_CHIPID		0x01	/* vendor & device id */
27 
28 #define B43_SDIO_BLOCK_SIZE	64	/* rx fifo max size in bytes */
29 
30 
31 static const struct b43_sdio_quirk {
32 	u16 vendor;
33 	u16 device;
34 	unsigned int quirks;
35 } b43_sdio_quirks[] = {
36 	{ 0x14E4, 0x4318, SSB_QUIRK_SDIO_READ_AFTER_WRITE32, },
37 	{ },
38 };
39 
40 
b43_sdio_get_quirks(u16 vendor,u16 device)41 static unsigned int b43_sdio_get_quirks(u16 vendor, u16 device)
42 {
43 	const struct b43_sdio_quirk *q;
44 
45 	for (q = b43_sdio_quirks; q->quirks; q++) {
46 		if (vendor == q->vendor && device == q->device)
47 			return q->quirks;
48 	}
49 
50 	return 0;
51 }
52 
b43_sdio_interrupt_dispatcher(struct sdio_func * func)53 static void b43_sdio_interrupt_dispatcher(struct sdio_func *func)
54 {
55 	struct b43_sdio *sdio = sdio_get_drvdata(func);
56 	struct b43_wldev *dev = sdio->irq_handler_opaque;
57 
58 	if (unlikely(b43_status(dev) < B43_STAT_STARTED))
59 		return;
60 
61 	sdio_release_host(func);
62 	sdio->irq_handler(dev);
63 	sdio_claim_host(func);
64 }
65 
b43_sdio_request_irq(struct b43_wldev * dev,void (* handler)(struct b43_wldev * dev))66 int b43_sdio_request_irq(struct b43_wldev *dev,
67 			 void (*handler)(struct b43_wldev *dev))
68 {
69 	struct ssb_bus *bus = dev->dev->sdev->bus;
70 	struct sdio_func *func = bus->host_sdio;
71 	struct b43_sdio *sdio = sdio_get_drvdata(func);
72 	int err;
73 
74 	sdio->irq_handler_opaque = dev;
75 	sdio->irq_handler = handler;
76 	sdio_claim_host(func);
77 	err = sdio_claim_irq(func, b43_sdio_interrupt_dispatcher);
78 	sdio_release_host(func);
79 
80 	return err;
81 }
82 
b43_sdio_free_irq(struct b43_wldev * dev)83 void b43_sdio_free_irq(struct b43_wldev *dev)
84 {
85 	struct ssb_bus *bus = dev->dev->sdev->bus;
86 	struct sdio_func *func = bus->host_sdio;
87 	struct b43_sdio *sdio = sdio_get_drvdata(func);
88 
89 	sdio_claim_host(func);
90 	sdio_release_irq(func);
91 	sdio_release_host(func);
92 	sdio->irq_handler_opaque = NULL;
93 	sdio->irq_handler = NULL;
94 }
95 
b43_sdio_probe(struct sdio_func * func,const struct sdio_device_id * id)96 static int b43_sdio_probe(struct sdio_func *func,
97 				    const struct sdio_device_id *id)
98 {
99 	struct b43_sdio *sdio;
100 	struct sdio_func_tuple *tuple;
101 	u16 vendor = 0, device = 0;
102 	int error;
103 
104 	/* Look for the card chip identifier. */
105 	tuple = func->tuples;
106 	while (tuple) {
107 		switch (tuple->code) {
108 		case 0x80:
109 			switch (tuple->data[0]) {
110 			case HNBU_CHIPID:
111 				if (tuple->size != 5)
112 					break;
113 				vendor = tuple->data[1] | (tuple->data[2]<<8);
114 				device = tuple->data[3] | (tuple->data[4]<<8);
115 				dev_info(&func->dev, "Chip ID %04x:%04x\n",
116 					 vendor, device);
117 				break;
118 			default:
119 				break;
120 			}
121 			break;
122 		default:
123 			break;
124 		}
125 		tuple = tuple->next;
126 	}
127 	if (!vendor || !device) {
128 		error = -ENODEV;
129 		goto out;
130 	}
131 
132 	sdio_claim_host(func);
133 	error = sdio_set_block_size(func, B43_SDIO_BLOCK_SIZE);
134 	if (error) {
135 		dev_err(&func->dev, "failed to set block size to %u bytes,"
136 			" error %d\n", B43_SDIO_BLOCK_SIZE, error);
137 		goto err_release_host;
138 	}
139 	error = sdio_enable_func(func);
140 	if (error) {
141 		dev_err(&func->dev, "failed to enable func, error %d\n", error);
142 		goto err_release_host;
143 	}
144 	sdio_release_host(func);
145 
146 	sdio = kzalloc(sizeof(*sdio), GFP_KERNEL);
147 	if (!sdio) {
148 		error = -ENOMEM;
149 		dev_err(&func->dev, "failed to allocate ssb bus\n");
150 		goto err_disable_func;
151 	}
152 	error = ssb_bus_sdiobus_register(&sdio->ssb, func,
153 					 b43_sdio_get_quirks(vendor, device));
154 	if (error) {
155 		dev_err(&func->dev, "failed to register ssb sdio bus,"
156 			" error %d\n", error);
157 		goto err_free_ssb;
158 	}
159 	sdio_set_drvdata(func, sdio);
160 
161 	return 0;
162 
163 err_free_ssb:
164 	kfree(sdio);
165 err_disable_func:
166 	sdio_claim_host(func);
167 	sdio_disable_func(func);
168 err_release_host:
169 	sdio_release_host(func);
170 out:
171 	return error;
172 }
173 
b43_sdio_remove(struct sdio_func * func)174 static void b43_sdio_remove(struct sdio_func *func)
175 {
176 	struct b43_sdio *sdio = sdio_get_drvdata(func);
177 
178 	ssb_bus_unregister(&sdio->ssb);
179 	sdio_claim_host(func);
180 	sdio_disable_func(func);
181 	sdio_release_host(func);
182 	kfree(sdio);
183 	sdio_set_drvdata(func, NULL);
184 }
185 
186 static const struct sdio_device_id b43_sdio_ids[] = {
187 	{ SDIO_DEVICE(0x02d0, 0x044b) }, /* Nintendo Wii WLAN daughter card */
188 	{ SDIO_DEVICE(0x0092, 0x0004) }, /* C-guys, Inc. EW-CG1102GC */
189 	{ },
190 };
191 
192 static struct sdio_driver b43_sdio_driver = {
193 	.name		= "b43-sdio",
194 	.id_table	= b43_sdio_ids,
195 	.probe		= b43_sdio_probe,
196 	.remove		= b43_sdio_remove,
197 };
198 
b43_sdio_init(void)199 int b43_sdio_init(void)
200 {
201 	return sdio_register_driver(&b43_sdio_driver);
202 }
203 
b43_sdio_exit(void)204 void b43_sdio_exit(void)
205 {
206 	sdio_unregister_driver(&b43_sdio_driver);
207 }
208