if_xe_pccard.c revision 119418 
1/*
2 * Copyright (c) 2002 Takeshi Shibagaki
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
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: head/sys/dev/xe/if_xe_pccard.c 119418 2003-08-24 17:55:58Z obrien $");
29
30/* xe pccard interface driver */
31
32#include <sys/param.h>
33#include <sys/systm.h>
34#include <sys/kernel.h>
35#include <sys/socket.h>
36
37#include <sys/module.h>
38#include <sys/bus.h>
39
40#include <machine/bus.h>
41#include <machine/resource.h>
42#include <sys/rman.h>
43
44#include <net/ethernet.h>
45#include <net/if.h>
46#include <net/if_arp.h>
47#include <net/if_media.h>
48#include <net/if_mib.h>
49
50
51#include <dev/xe/if_xereg.h>
52#include <dev/xe/if_xevar.h>
53
54#include <dev/pccard/pccardvar.h>
55#include <dev/pccard/pccarddevs.h>
56#include "card_if.h"
57
58#define XE_VENDOR_ID_XIRCOM 0x0105
59#define XE_VENDOR_ID_COMPAQ_1 0x0138
60#define XE_VENDOR_ID_COMPAQ_2 0x0183
61#define XE_VENDOR_ID_INTEL 0x0089
62#define XE_VENDOR_ID_UNKNOWN 0
63
64struct xe_vendor_table {
65	u_int32_t vendor_id;
66	char *vendor_desc;
67} xe_vendor_devs[] = {
68	{ XE_VENDOR_ID_XIRCOM, "Xircom" },
69	{ XE_VENDOR_ID_COMPAQ_1, "Compaq" },
70	{ XE_VENDOR_ID_COMPAQ_2, "Compaq" },
71	{ XE_VENDOR_ID_INTEL, "Intel" },
72	{ XE_VENDOR_ID_UNKNOWN, "Unknown" }
73};
74
75#define XE_CARD_TYPE_FLAGS_NO 0x0
76#define XE_CARD_TYPE_FLAGS_CE2 0x1
77#define XE_CARD_TYPE_FLAGS_MOHAWK 0x2
78#define XE_CARD_TYPE_FLAGS_DINGO 0x4
79#define XE_PROD_UMASK 0x100f
80#define XE_PROD_MODEM_UMASK 0x1000
81#define XE_PROD_SINGLE_ID1 0x1
82#define XE_PROD_SINGLE_ID2 0x2
83#define XE_PROD_SINGLE_ID3 0x3
84#define XE_PROD_MULTI_ID1 0x1001
85#define XE_PROD_MULTI_ID2 0x1002
86#define XE_PROD_MULTI_ID3 0x1003
87#define XE_PROD_MULTI_ID4 0x1004
88#define XE_PROD_MULTI_ID5 0x1005
89#define XE_PROD_MULTI_ID6 0x1006
90#define XE_PROD_MULTI_ID7 0x1007
91
92struct xe_card_type_table {
93	u_int32_t prod_type;
94	char *card_type_desc;
95	u_int32_t flags;
96} xe_card_type_devs[] = {
97	{ XE_PROD_MULTI_ID1, "CEM", XE_CARD_TYPE_FLAGS_NO },
98	{ XE_PROD_MULTI_ID2, "CEM2", XE_CARD_TYPE_FLAGS_CE2 },
99	{ XE_PROD_MULTI_ID3, "CEM3", XE_CARD_TYPE_FLAGS_CE2 },
100	{ XE_PROD_MULTI_ID4, "CEM33", XE_CARD_TYPE_FLAGS_CE2 },
101	{ XE_PROD_MULTI_ID5, "CEM56M", XE_CARD_TYPE_FLAGS_MOHAWK },
102	{ XE_PROD_MULTI_ID6, "CEM56", XE_CARD_TYPE_FLAGS_MOHAWK |
103					XE_CARD_TYPE_FLAGS_DINGO },
104	{ XE_PROD_MULTI_ID7, "CEM56", XE_CARD_TYPE_FLAGS_MOHAWK |
105					XE_CARD_TYPE_FLAGS_DINGO },
106	{ XE_PROD_SINGLE_ID1, "CE", XE_CARD_TYPE_FLAGS_NO },
107	{ XE_PROD_SINGLE_ID2, "CE2", XE_CARD_TYPE_FLAGS_CE2 },
108	{ XE_PROD_SINGLE_ID3, "CE3", XE_CARD_TYPE_FLAGS_MOHAWK },
109	{ 0, NULL,  -1 }
110};
111
112/*
113 * Prototypes
114 */
115static int xe_cem56fix(device_t dev);
116static struct xe_vendor_table *xe_vendor_lookup(u_int32_t devid,
117					struct xe_vendor_table *tbl);
118static struct xe_card_type_table *xe_card_type_lookup(u_int32_t devid,
119					struct xe_card_type_table *tbl);
120
121/*
122 * Fixing for RealPort cards - they need a little furtling to get the
123 * ethernet working. But this codes don't work well in NEWCARD.
124 */
125static int
126xe_cem56fix(device_t dev)
127{
128	struct xe_softc *sc = (struct xe_softc *) device_get_softc(dev);
129	bus_space_tag_t bst;
130	bus_space_handle_t bsh;
131	struct resource *r;
132	int rid;
133	int ioport;
134
135	device_printf(dev, "Realport port 0x%0lx, size 0x%0lx\n",
136		bus_get_resource_start(dev, SYS_RES_IOPORT, sc->port_rid),
137		bus_get_resource_count(dev, SYS_RES_IOPORT, sc->port_rid));
138
139	rid = 0;
140	r = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 0,
141			       ~0, 4 << 10, RF_ACTIVE);
142	if (!r) {
143		device_printf(dev, "Can't map in attribute memory\n");
144		return (-1);
145	}
146
147	bsh = rman_get_bushandle(r);
148	bst = rman_get_bustag(r);
149
150	CARD_SET_RES_FLAGS(device_get_parent(dev), dev, SYS_RES_MEMORY, rid,
151			   PCCARD_A_MEM_ATTR);
152
153	bus_space_write_1(bst, bsh, DINGO_ECOR, DINGO_ECOR_IRQ_LEVEL |
154						DINGO_ECOR_INT_ENABLE |
155						DINGO_ECOR_IOB_ENABLE |
156						DINGO_ECOR_ETH_ENABLE);
157	ioport = bus_get_resource_start(dev, SYS_RES_IOPORT, sc->port_rid);
158	bus_space_write_1(bst, bsh, DINGO_EBAR0, ioport & 0xff);
159	bus_space_write_1(bst, bsh, DINGO_EBAR1, (ioport >> 8) & 0xff);
160
161	bus_space_write_1(bst, bsh, DINGO_DCOR0, DINGO_DCOR0_SF_INT);
162	bus_space_write_1(bst, bsh, DINGO_DCOR1, DINGO_DCOR1_INT_LEVEL |
163						 DINGO_DCOR1_EEDIO);
164	bus_space_write_1(bst, bsh, DINGO_DCOR2, 0x00);
165	bus_space_write_1(bst, bsh, DINGO_DCOR3, 0x00);
166	bus_space_write_1(bst, bsh, DINGO_DCOR4, 0x00);
167
168	bus_release_resource(dev, SYS_RES_MEMORY, rid, r);
169
170	/* success! */
171	return (0);
172}
173
174static struct xe_vendor_table *
175xe_vendor_lookup(u_int32_t devid, struct xe_vendor_table *tbl)
176{
177	while(tbl->vendor_id) {
178		if(tbl->vendor_id == devid)
179			return (tbl);
180		tbl++;
181	}
182	return (tbl); /* return Unknown */
183}
184
185static struct xe_card_type_table *
186xe_card_type_lookup(u_int32_t devid, struct xe_card_type_table *tbl)
187{
188	while(tbl->prod_type) {
189		if(tbl->prod_type == (devid & XE_PROD_UMASK))
190			return (tbl);
191		tbl++;
192	}
193	return (NULL);
194}
195
196/*
197 * PCMCIA probe routine.
198 * Identify the device.  Called from the bus driver when the card is
199 * inserted or otherwise powers up.
200 */
201static int
202xe_pccard_probe(device_t dev)
203{
204	struct xe_softc *scp = (struct xe_softc *) device_get_softc(dev);
205	u_int32_t vendor,prodid,prod;
206	u_int16_t prodext;
207	char *cis3_str=NULL;
208	struct xe_vendor_table *vendor_itm;
209	struct xe_card_type_table *card_itm;
210	int i;
211
212	/*
213	 * PCCARD_CISTPL_MANFID = 0x20
214	 */
215	pccard_get_vendor(dev, &vendor);
216	vendor_itm = xe_vendor_lookup(vendor, &xe_vendor_devs[0]);
217	if (vendor_itm == NULL)
218		return (ENODEV);
219	scp->vendor = vendor_itm->vendor_desc;
220	pccard_get_product(dev, &prodid);
221	pccard_get_prodext(dev, &prodext);
222	/*
223	 * prod(new) =  rev, media, prod(old)
224	 * prod(new) =  (don't care), (care 0x10 bit), (care 0x0f bit)
225	 */
226	prod = (prodid << 8) | prodext;
227	card_itm = xe_card_type_lookup(prod, &xe_card_type_devs[0]);
228	if (card_itm == NULL)
229		return (ENODEV);
230	scp->card_type = card_itm->card_type_desc;
231	if (card_itm->prod_type & XE_PROD_MODEM_UMASK)
232		scp->modem = 1;
233	for(i=1; i!=XE_CARD_TYPE_FLAGS_DINGO; i=i<<1) {
234		switch(i & card_itm->flags) {
235		case XE_CARD_TYPE_FLAGS_CE2:
236			scp->ce2 = 1; break;
237		case XE_CARD_TYPE_FLAGS_MOHAWK:
238			scp->mohawk = 1; break;
239		case XE_CARD_TYPE_FLAGS_DINGO:
240			scp->dingo = 1; break;
241		}
242	}
243	/*
244	 * PCCARD_CISTPL_VERS_1 = 0x15
245	 */
246	pccard_get_cis3_str(dev, &cis3_str);
247	if (strcmp(scp->card_type, "CE") == 0)
248		if (strcmp(cis3_str, "CE2") ==0)
249			scp->card_type = "CE2"; /* Look for "CE2" string */
250
251	/*
252	 * PCCARD_CISTPL_FUNCE = 0x22
253	 */
254	pccard_get_ether(dev, scp->arpcom.ac_enaddr);
255
256	/* Reject unsupported cards */
257	if(strcmp(scp->card_type, "CE") == 0
258	|| strcmp(scp->card_type, "CEM") == 0) {
259		device_printf(dev, "Sorry, your %s card is not supported :(\n",
260				scp->card_type);
261		return (ENODEV);
262	}
263
264	/* Success */
265	return (0);
266}
267
268/*
269 * Attach a device.
270 */
271static int
272xe_pccard_attach(device_t dev)
273{
274	struct xe_softc *scp = device_get_softc(dev);
275	int err;
276
277	if ((err = xe_activate(dev)) != 0)
278		return (err);
279
280	/* Hack RealPorts into submission */
281	if (scp->dingo && xe_cem56fix(dev) < 0) {
282		device_printf(dev, "Unable to fix your RealPort\n");
283		xe_deactivate(dev);
284		return (ENODEV);
285	}
286	if ((err = xe_attach(dev))) {
287		device_printf(dev, "xe_attach() failed! (%d)\n", err);
288		return (err);
289	}
290	return (0);
291}
292
293/*
294 * The device entry is being removed, probably because someone ejected the
295 * card.  The interface should have been brought down manually before calling
296 * this function; if not you may well lose packets.  In any case, I shut down
297 * the card and the interface, and hope for the best.
298 */
299static int
300xe_pccard_detach(device_t dev)
301{
302	struct xe_softc *sc = device_get_softc(dev);
303
304	sc->arpcom.ac_if.if_flags &= ~IFF_RUNNING;
305	ether_ifdetach(&sc->arpcom.ac_if);
306	xe_deactivate(dev);
307	return (0);
308}
309
310static const struct pccard_product xe_pccard_products[] = {
311	PCMCIA_CARD(ACCTON, EN2226, 0),
312	PCMCIA_CARD(COMPAQ2, CPQ_10_100, 0),	/* Maybe Paralon Techologies, Inc */
313	PCMCIA_CARD(INTEL, EEPRO100, 0),
314	PCMCIA_CARD(XIRCOM, CE, 0),
315	PCMCIA_CARD(XIRCOM, CE2, 0),
316	PCMCIA_CARD(XIRCOM, CE3, 0),
317	PCMCIA_CARD(XIRCOM, CEM, 0),
318	PCMCIA_CARD(XIRCOM, CEM28, 0),
319	PCMCIA_CARD(XIRCOM, CEM33, 0),
320	PCMCIA_CARD(XIRCOM, CEM56, 0),
321	PCMCIA_CARD(XIRCOM, REM56, 0),
322        { NULL }
323};
324
325static int
326xe_pccard_match(device_t dev)
327{
328	const struct pccard_product *pp;
329
330	if ((pp = pccard_product_lookup(dev, xe_pccard_products,
331	     sizeof(xe_pccard_products[0]), NULL)) != NULL) {
332		if (pp->pp_name != NULL)
333			device_set_desc(dev, pp->pp_name);
334		return (0);
335	}
336	return (EIO);
337}
338
339static device_method_t xe_pccard_methods[] = {
340        /* Device interface */
341        DEVMETHOD(device_probe,         pccard_compat_probe),
342        DEVMETHOD(device_attach,        pccard_compat_attach),
343        DEVMETHOD(device_detach,        xe_pccard_detach),
344
345        /* Card interface */
346        DEVMETHOD(card_compat_match,    xe_pccard_match),
347        DEVMETHOD(card_compat_probe,    xe_pccard_probe),
348        DEVMETHOD(card_compat_attach,   xe_pccard_attach),
349
350        { 0, 0 }
351};
352
353static driver_t xe_pccard_driver = {
354        "xe",
355        xe_pccard_methods,
356        sizeof(struct xe_softc),
357};
358
359devclass_t xe_devclass;
360
361DRIVER_MODULE(xe, pccard, xe_pccard_driver, xe_devclass, 0, 0);
362