aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless')
-rw-r--r--drivers/net/wireless/airo_cs.c71
-rw-r--r--drivers/net/wireless/atmel_cs.c69
-rw-r--r--drivers/net/wireless/hostap/hostap_cs.c8
-rw-r--r--drivers/net/wireless/libertas/if_cs.c30
-rw-r--r--drivers/net/wireless/orinoco/orinoco_cs.c44
-rw-r--r--drivers/net/wireless/orinoco/spectrum_cs.c44
-rw-r--r--drivers/net/wireless/ray_cs.c35
-rw-r--r--drivers/net/wireless/wl3501_cs.c35
8 files changed, 1 insertions, 335 deletions
diff --git a/drivers/net/wireless/airo_cs.c b/drivers/net/wireless/airo_cs.c
index b084278f36b..df2484d4547 100644
--- a/drivers/net/wireless/airo_cs.c
+++ b/drivers/net/wireless/airo_cs.c
@@ -53,42 +53,15 @@ MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
53 53
54/*====================================================================*/ 54/*====================================================================*/
55 55
56/*
57 The event() function is this driver's Card Services event handler.
58 It will be called by Card Services when an appropriate card status
59 event is received. The config() and release() entry points are
60 used to configure or release a socket, in response to card
61 insertion and ejection events. They are invoked from the airo_cs
62 event handler.
63*/
64
65static int airo_config(struct pcmcia_device *link); 56static int airo_config(struct pcmcia_device *link);
66static void airo_release(struct pcmcia_device *link); 57static void airo_release(struct pcmcia_device *link);
67 58
68/*
69 The attach() and detach() entry points are used to create and destroy
70 "instances" of the driver, where each instance represents everything
71 needed to manage one actual PCMCIA card.
72*/
73
74static void airo_detach(struct pcmcia_device *p_dev); 59static void airo_detach(struct pcmcia_device *p_dev);
75 60
76typedef struct local_info_t { 61typedef struct local_info_t {
77 struct net_device *eth_dev; 62 struct net_device *eth_dev;
78} local_info_t; 63} local_info_t;
79 64
80/*======================================================================
81
82 airo_attach() creates an "instance" of the driver, allocating
83 local data structures for one device. The device is registered
84 with Card Services.
85
86 The dev_link structure is initialized, but we don't actually
87 configure the card at this point -- we wait until we receive a
88 card insertion event.
89
90 ======================================================================*/
91
92static int airo_probe(struct pcmcia_device *p_dev) 65static int airo_probe(struct pcmcia_device *p_dev)
93{ 66{
94 local_info_t *local; 67 local_info_t *local;
@@ -106,15 +79,6 @@ static int airo_probe(struct pcmcia_device *p_dev)
106 return airo_config(p_dev); 79 return airo_config(p_dev);
107} /* airo_attach */ 80} /* airo_attach */
108 81
109/*======================================================================
110
111 This deletes a driver "instance". The device is de-registered
112 with Card Services. If it has been released, all local data
113 structures are freed. Otherwise, the structures will be freed
114 when the device is released.
115
116 ======================================================================*/
117
118static void airo_detach(struct pcmcia_device *link) 82static void airo_detach(struct pcmcia_device *link)
119{ 83{
120 dev_dbg(&link->dev, "airo_detach\n"); 84 dev_dbg(&link->dev, "airo_detach\n");
@@ -129,14 +93,6 @@ static void airo_detach(struct pcmcia_device *link)
129 kfree(link->priv); 93 kfree(link->priv);
130} /* airo_detach */ 94} /* airo_detach */
131 95
132/*======================================================================
133
134 airo_config() is scheduled to run after a CARD_INSERTION event
135 is received, to configure the PCMCIA socket, and to make the
136 device available to the system.
137
138 ======================================================================*/
139
140static int airo_cs_config_check(struct pcmcia_device *p_dev, void *priv_data) 96static int airo_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
141{ 97{
142 if (p_dev->config_index == 0) 98 if (p_dev->config_index == 0)
@@ -158,20 +114,6 @@ static int airo_config(struct pcmcia_device *link)
158 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP | 114 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
159 CONF_AUTO_AUDIO | CONF_AUTO_SET_IO; 115 CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;
160 116
161 /*
162 * In this loop, we scan the CIS for configuration table
163 * entries, each of which describes a valid card
164 * configuration, including voltage, IO window, memory window,
165 * and interrupt settings.
166 *
167 * We make no assumptions about the card to be configured: we
168 * use just the information available in the CIS. In an ideal
169 * world, this would work for any PCMCIA card, but it requires
170 * a complete and accurate CIS. In practice, a driver usually
171 * "knows" most of these things without consulting the CIS,
172 * and most client drivers will only use the CIS to fill in
173 * implementation-defined details.
174 */
175 ret = pcmcia_loop_config(link, airo_cs_config_check, NULL); 117 ret = pcmcia_loop_config(link, airo_cs_config_check, NULL);
176 if (ret) 118 if (ret)
177 goto failed; 119 goto failed;
@@ -179,11 +121,6 @@ static int airo_config(struct pcmcia_device *link)
179 if (!link->irq) 121 if (!link->irq)
180 goto failed; 122 goto failed;
181 123
182 /*
183 This actually configures the PCMCIA socket -- setting up
184 the I/O windows and the interrupt mapping, and putting the
185 card and host interface into "Memory and IO" mode.
186 */
187 ret = pcmcia_enable_device(link); 124 ret = pcmcia_enable_device(link);
188 if (ret) 125 if (ret)
189 goto failed; 126 goto failed;
@@ -200,14 +137,6 @@ static int airo_config(struct pcmcia_device *link)
200 return -ENODEV; 137 return -ENODEV;
201} /* airo_config */ 138} /* airo_config */
202 139
203/*======================================================================
204
205 After a card is removed, airo_release() will unregister the
206 device, and release the PCMCIA configuration. If the device is
207 still open, this will be postponed until it is closed.
208
209 ======================================================================*/
210
211static void airo_release(struct pcmcia_device *link) 140static void airo_release(struct pcmcia_device *link)
212{ 141{
213 dev_dbg(&link->dev, "airo_release\n"); 142 dev_dbg(&link->dev, "airo_release\n");
diff --git a/drivers/net/wireless/atmel_cs.c b/drivers/net/wireless/atmel_cs.c
index fabe91a8db2..c96e19da294 100644
--- a/drivers/net/wireless/atmel_cs.c
+++ b/drivers/net/wireless/atmel_cs.c
@@ -63,42 +63,15 @@ MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards");
63 63
64/*====================================================================*/ 64/*====================================================================*/
65 65
66/*
67 The event() function is this driver's Card Services event handler.
68 It will be called by Card Services when an appropriate card status
69 event is received. The config() and release() entry points are
70 used to configure or release a socket, in response to card
71 insertion and ejection events. They are invoked from the atmel_cs
72 event handler.
73*/
74
75static int atmel_config(struct pcmcia_device *link); 66static int atmel_config(struct pcmcia_device *link);
76static void atmel_release(struct pcmcia_device *link); 67static void atmel_release(struct pcmcia_device *link);
77 68
78/*
79 The attach() and detach() entry points are used to create and destroy
80 "instances" of the driver, where each instance represents everything
81 needed to manage one actual PCMCIA card.
82*/
83
84static void atmel_detach(struct pcmcia_device *p_dev); 69static void atmel_detach(struct pcmcia_device *p_dev);
85 70
86typedef struct local_info_t { 71typedef struct local_info_t {
87 struct net_device *eth_dev; 72 struct net_device *eth_dev;
88} local_info_t; 73} local_info_t;
89 74
90/*======================================================================
91
92 atmel_attach() creates an "instance" of the driver, allocating
93 local data structures for one device. The device is registered
94 with Card Services.
95
96 The dev_link structure is initialized, but we don't actually
97 configure the card at this point -- we wait until we receive a
98 card insertion event.
99
100 ======================================================================*/
101
102static int atmel_probe(struct pcmcia_device *p_dev) 75static int atmel_probe(struct pcmcia_device *p_dev)
103{ 76{
104 local_info_t *local; 77 local_info_t *local;
@@ -116,15 +89,6 @@ static int atmel_probe(struct pcmcia_device *p_dev)
116 return atmel_config(p_dev); 89 return atmel_config(p_dev);
117} /* atmel_attach */ 90} /* atmel_attach */
118 91
119/*======================================================================
120
121 This deletes a driver "instance". The device is de-registered
122 with Card Services. If it has been released, all local data
123 structures are freed. Otherwise, the structures will be freed
124 when the device is released.
125
126 ======================================================================*/
127
128static void atmel_detach(struct pcmcia_device *link) 92static void atmel_detach(struct pcmcia_device *link)
129{ 93{
130 dev_dbg(&link->dev, "atmel_detach\n"); 94 dev_dbg(&link->dev, "atmel_detach\n");
@@ -134,14 +98,6 @@ static void atmel_detach(struct pcmcia_device *link)
134 kfree(link->priv); 98 kfree(link->priv);
135} 99}
136 100
137/*======================================================================
138
139 atmel_config() is scheduled to run after a CARD_INSERTION event
140 is received, to configure the PCMCIA socket, and to make the
141 device available to the system.
142
143 ======================================================================*/
144
145/* Call-back function to interrogate PCMCIA-specific information 101/* Call-back function to interrogate PCMCIA-specific information
146 about the current existance of the card */ 102 about the current existance of the card */
147static int card_present(void *arg) 103static int card_present(void *arg)
@@ -176,18 +132,6 @@ static int atmel_config(struct pcmcia_device *link)
176 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP | 132 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
177 CONF_AUTO_AUDIO | CONF_AUTO_SET_IO; 133 CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;
178 134
179 /*
180 In this loop, we scan the CIS for configuration table entries,
181 each of which describes a valid card configuration, including
182 voltage, IO window, memory window, and interrupt settings.
183
184 We make no assumptions about the card to be configured: we use
185 just the information available in the CIS. In an ideal world,
186 this would work for any PCMCIA card, but it requires a complete
187 and accurate CIS. In practice, a driver usually "knows" most of
188 these things without consulting the CIS, and most client drivers
189 will only use the CIS to fill in implementation-defined details.
190 */
191 if (pcmcia_loop_config(link, atmel_config_check, NULL)) 135 if (pcmcia_loop_config(link, atmel_config_check, NULL))
192 goto failed; 136 goto failed;
193 137
@@ -196,11 +140,6 @@ static int atmel_config(struct pcmcia_device *link)
196 goto failed; 140 goto failed;
197 } 141 }
198 142
199 /*
200 This actually configures the PCMCIA socket -- setting up
201 the I/O windows and the interrupt mapping, and putting the
202 card and host interface into "Memory and IO" mode.
203 */
204 ret = pcmcia_enable_device(link); 143 ret = pcmcia_enable_device(link);
205 if (ret) 144 if (ret)
206 goto failed; 145 goto failed;
@@ -223,14 +162,6 @@ static int atmel_config(struct pcmcia_device *link)
223 return -ENODEV; 162 return -ENODEV;
224} 163}
225 164
226/*======================================================================
227
228 After a card is removed, atmel_release() will unregister the
229 device, and release the PCMCIA configuration. If the device is
230 still open, this will be postponed until it is closed.
231
232 ======================================================================*/
233
234static void atmel_release(struct pcmcia_device *link) 165static void atmel_release(struct pcmcia_device *link)
235{ 166{
236 struct net_device *dev = ((local_info_t*)link->priv)->eth_dev; 167 struct net_device *dev = ((local_info_t*)link->priv)->eth_dev;
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index ba645701179..bd8a4134ede 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -466,9 +466,6 @@ static void prism2_detach(struct pcmcia_device *link)
466} 466}
467 467
468 468
469/* run after a CARD_INSERTION event is received to configure the PCMCIA
470 * socket and make the device available to the system */
471
472static int prism2_config_check(struct pcmcia_device *p_dev, void *priv_data) 469static int prism2_config_check(struct pcmcia_device *p_dev, void *priv_data)
473{ 470{
474 if (p_dev->config_index == 0) 471 if (p_dev->config_index == 0)
@@ -530,11 +527,6 @@ static int prism2_config(struct pcmcia_device *link)
530 if (ret) 527 if (ret)
531 goto failed_unlock; 528 goto failed_unlock;
532 529
533 /*
534 * This actually configures the PCMCIA socket -- setting up
535 * the I/O windows and the interrupt mapping, and putting the
536 * card and host interface into "Memory and IO" mode.
537 */
538 ret = pcmcia_enable_device(link); 530 ret = pcmcia_enable_device(link);
539 if (ret) 531 if (ret)
540 goto failed_unlock; 532 goto failed_unlock;
diff --git a/drivers/net/wireless/libertas/if_cs.c b/drivers/net/wireless/libertas/if_cs.c
index c2bd2f0304b..ff1280f4133 100644
--- a/drivers/net/wireless/libertas/if_cs.c
+++ b/drivers/net/wireless/libertas/if_cs.c
@@ -760,15 +760,6 @@ static int if_cs_host_to_card(struct lbs_private *priv,
760} 760}
761 761
762 762
763/********************************************************************/
764/* Card Services */
765/********************************************************************/
766
767/*
768 * After a card is removed, if_cs_release() will unregister the
769 * device, and release the PCMCIA configuration. If the device is
770 * still open, this will be postponed until it is closed.
771 */
772static void if_cs_release(struct pcmcia_device *p_dev) 763static void if_cs_release(struct pcmcia_device *p_dev)
773{ 764{
774 struct if_cs_card *card = p_dev->priv; 765 struct if_cs_card *card = p_dev->priv;
@@ -784,16 +775,6 @@ static void if_cs_release(struct pcmcia_device *p_dev)
784} 775}
785 776
786 777
787/*
788 * This creates an "instance" of the driver, allocating local data
789 * structures for one device. The device is registered with Card
790 * Services.
791 *
792 * The dev_link structure is initialized, but we don't actually
793 * configure the card at this point -- we wait until we receive a card
794 * insertion event.
795 */
796
797static int if_cs_ioprobe(struct pcmcia_device *p_dev, void *priv_data) 778static int if_cs_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
798{ 779{
799 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; 780 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
@@ -849,11 +830,6 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
849 goto out1; 830 goto out1;
850 } 831 }
851 832
852 /*
853 * This actually configures the PCMCIA socket -- setting up
854 * the I/O windows and the interrupt mapping, and putting the
855 * card and host interface into "Memory and IO" mode.
856 */
857 ret = pcmcia_enable_device(p_dev); 833 ret = pcmcia_enable_device(p_dev);
858 if (ret) { 834 if (ret) {
859 lbs_pr_err("error in pcmcia_enable_device\n"); 835 lbs_pr_err("error in pcmcia_enable_device\n");
@@ -950,12 +926,6 @@ out:
950} 926}
951 927
952 928
953/*
954 * This deletes a driver "instance". The device is de-registered with
955 * Card Services. If it has been released, all local data structures
956 * are freed. Otherwise, the structures will be freed when the device
957 * is released.
958 */
959static void if_cs_detach(struct pcmcia_device *p_dev) 929static void if_cs_detach(struct pcmcia_device *p_dev)
960{ 930{
961 struct if_cs_card *card = p_dev->priv; 931 struct if_cs_card *card = p_dev->priv;
diff --git a/drivers/net/wireless/orinoco/orinoco_cs.c b/drivers/net/wireless/orinoco/orinoco_cs.c
index 2b1f554af0b..71b3d68b940 100644
--- a/drivers/net/wireless/orinoco/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco/orinoco_cs.c
@@ -92,14 +92,6 @@ orinoco_cs_hard_reset(struct orinoco_private *priv)
92/* PCMCIA stuff */ 92/* PCMCIA stuff */
93/********************************************************************/ 93/********************************************************************/
94 94
95/*
96 * This creates an "instance" of the driver, allocating local data
97 * structures for one device. The device is registered with Card
98 * Services.
99 *
100 * The dev_link structure is initialized, but we don't actually
101 * configure the card at this point -- we wait until we receive a card
102 * insertion event. */
103static int 95static int
104orinoco_cs_probe(struct pcmcia_device *link) 96orinoco_cs_probe(struct pcmcia_device *link)
105{ 97{
@@ -119,12 +111,6 @@ orinoco_cs_probe(struct pcmcia_device *link)
119 return orinoco_cs_config(link); 111 return orinoco_cs_config(link);
120} /* orinoco_cs_attach */ 112} /* orinoco_cs_attach */
121 113
122/*
123 * This deletes a driver "instance". The device is de-registered with
124 * Card Services. If it has been released, all local data structures
125 * are freed. Otherwise, the structures will be freed when the device
126 * is released.
127 */
128static void orinoco_cs_detach(struct pcmcia_device *link) 114static void orinoco_cs_detach(struct pcmcia_device *link)
129{ 115{
130 struct orinoco_private *priv = link->priv; 116 struct orinoco_private *priv = link->priv;
@@ -136,12 +122,6 @@ static void orinoco_cs_detach(struct pcmcia_device *link)
136 free_orinocodev(priv); 122 free_orinocodev(priv);
137} /* orinoco_cs_detach */ 123} /* orinoco_cs_detach */
138 124
139/*
140 * orinoco_cs_config() is scheduled to run after a CARD_INSERTION
141 * event is received, to configure the PCMCIA socket, and to make the
142 * device available to the system.
143 */
144
145static int orinoco_cs_config_check(struct pcmcia_device *p_dev, void *priv_data) 125static int orinoco_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
146{ 126{
147 if (p_dev->config_index == 0) 127 if (p_dev->config_index == 0)
@@ -158,20 +138,6 @@ orinoco_cs_config(struct pcmcia_device *link)
158 int ret; 138 int ret;
159 void __iomem *mem; 139 void __iomem *mem;
160 140
161 /*
162 * In this loop, we scan the CIS for configuration table
163 * entries, each of which describes a valid card
164 * configuration, including voltage, IO window, memory window,
165 * and interrupt settings.
166 *
167 * We make no assumptions about the card to be configured: we
168 * use just the information available in the CIS. In an ideal
169 * world, this would work for any PCMCIA card, but it requires
170 * a complete and accurate CIS. In practice, a driver usually
171 * "knows" most of these things without consulting the CIS,
172 * and most client drivers will only use the CIS to fill in
173 * implementation-defined details.
174 */
175 link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC | 141 link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC |
176 CONF_AUTO_SET_IO | CONF_ENABLE_IRQ; 142 CONF_AUTO_SET_IO | CONF_ENABLE_IRQ;
177 if (ignore_cis_vcc) 143 if (ignore_cis_vcc)
@@ -199,11 +165,6 @@ orinoco_cs_config(struct pcmcia_device *link)
199 165
200 hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING); 166 hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
201 167
202 /*
203 * This actually configures the PCMCIA socket -- setting up
204 * the I/O windows and the interrupt mapping, and putting the
205 * card and host interface into "Memory and IO" mode.
206 */
207 ret = pcmcia_enable_device(link); 168 ret = pcmcia_enable_device(link);
208 if (ret) 169 if (ret)
209 goto failed; 170 goto failed;
@@ -228,11 +189,6 @@ orinoco_cs_config(struct pcmcia_device *link)
228 return -ENODEV; 189 return -ENODEV;
229} /* orinoco_cs_config */ 190} /* orinoco_cs_config */
230 191
231/*
232 * After a card is removed, orinoco_cs_release() will unregister the
233 * device, and release the PCMCIA configuration. If the device is
234 * still open, this will be postponed until it is closed.
235 */
236static void 192static void
237orinoco_cs_release(struct pcmcia_device *link) 193orinoco_cs_release(struct pcmcia_device *link)
238{ 194{
diff --git a/drivers/net/wireless/orinoco/spectrum_cs.c b/drivers/net/wireless/orinoco/spectrum_cs.c
index 1314cf204f1..fb859a5ad2e 100644
--- a/drivers/net/wireless/orinoco/spectrum_cs.c
+++ b/drivers/net/wireless/orinoco/spectrum_cs.c
@@ -153,14 +153,6 @@ spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle)
153/* PCMCIA stuff */ 153/* PCMCIA stuff */
154/********************************************************************/ 154/********************************************************************/
155 155
156/*
157 * This creates an "instance" of the driver, allocating local data
158 * structures for one device. The device is registered with Card
159 * Services.
160 *
161 * The dev_link structure is initialized, but we don't actually
162 * configure the card at this point -- we wait until we receive a card
163 * insertion event. */
164static int 156static int
165spectrum_cs_probe(struct pcmcia_device *link) 157spectrum_cs_probe(struct pcmcia_device *link)
166{ 158{
@@ -181,12 +173,6 @@ spectrum_cs_probe(struct pcmcia_device *link)
181 return spectrum_cs_config(link); 173 return spectrum_cs_config(link);
182} /* spectrum_cs_attach */ 174} /* spectrum_cs_attach */
183 175
184/*
185 * This deletes a driver "instance". The device is de-registered with
186 * Card Services. If it has been released, all local data structures
187 * are freed. Otherwise, the structures will be freed when the device
188 * is released.
189 */
190static void spectrum_cs_detach(struct pcmcia_device *link) 176static void spectrum_cs_detach(struct pcmcia_device *link)
191{ 177{
192 struct orinoco_private *priv = link->priv; 178 struct orinoco_private *priv = link->priv;
@@ -198,12 +184,6 @@ static void spectrum_cs_detach(struct pcmcia_device *link)
198 free_orinocodev(priv); 184 free_orinocodev(priv);
199} /* spectrum_cs_detach */ 185} /* spectrum_cs_detach */
200 186
201/*
202 * spectrum_cs_config() is scheduled to run after a CARD_INSERTION
203 * event is received, to configure the PCMCIA socket, and to make the
204 * device available to the system.
205 */
206
207static int spectrum_cs_config_check(struct pcmcia_device *p_dev, 187static int spectrum_cs_config_check(struct pcmcia_device *p_dev,
208 void *priv_data) 188 void *priv_data)
209{ 189{
@@ -221,20 +201,6 @@ spectrum_cs_config(struct pcmcia_device *link)
221 int ret; 201 int ret;
222 void __iomem *mem; 202 void __iomem *mem;
223 203
224 /*
225 * In this loop, we scan the CIS for configuration table
226 * entries, each of which describes a valid card
227 * configuration, including voltage, IO window, memory window,
228 * and interrupt settings.
229 *
230 * We make no assumptions about the card to be configured: we
231 * use just the information available in the CIS. In an ideal
232 * world, this would work for any PCMCIA card, but it requires
233 * a complete and accurate CIS. In practice, a driver usually
234 * "knows" most of these things without consulting the CIS,
235 * and most client drivers will only use the CIS to fill in
236 * implementation-defined details.
237 */
238 link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC | 204 link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC |
239 CONF_AUTO_SET_IO | CONF_ENABLE_IRQ; 205 CONF_AUTO_SET_IO | CONF_ENABLE_IRQ;
240 if (ignore_cis_vcc) 206 if (ignore_cis_vcc)
@@ -263,11 +229,6 @@ spectrum_cs_config(struct pcmcia_device *link)
263 hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING); 229 hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
264 hw->eeprom_pda = true; 230 hw->eeprom_pda = true;
265 231
266 /*
267 * This actually configures the PCMCIA socket -- setting up
268 * the I/O windows and the interrupt mapping, and putting the
269 * card and host interface into "Memory and IO" mode.
270 */
271 ret = pcmcia_enable_device(link); 232 ret = pcmcia_enable_device(link);
272 if (ret) 233 if (ret)
273 goto failed; 234 goto failed;
@@ -296,11 +257,6 @@ spectrum_cs_config(struct pcmcia_device *link)
296 return -ENODEV; 257 return -ENODEV;
297} /* spectrum_cs_config */ 258} /* spectrum_cs_config */
298 259
299/*
300 * After a card is removed, spectrum_cs_release() will unregister the
301 * device, and release the PCMCIA configuration. If the device is
302 * still open, this will be postponed until it is closed.
303 */
304static void 260static void
305spectrum_cs_release(struct pcmcia_device *link) 261spectrum_cs_release(struct pcmcia_device *link)
306{ 262{
diff --git a/drivers/net/wireless/ray_cs.c b/drivers/net/wireless/ray_cs.c
index b5a2c9e31de..af5b17ce5a1 100644
--- a/drivers/net/wireless/ray_cs.c
+++ b/drivers/net/wireless/ray_cs.c
@@ -168,13 +168,6 @@ static int bc;
168 */ 168 */
169static char *phy_addr = NULL; 169static char *phy_addr = NULL;
170 170
171
172/* A struct pcmcia_device structure has fields for most things that are needed
173 to keep track of a socket, but there will usually be some device
174 specific information that also needs to be kept track of. The
175 'priv' pointer in a struct pcmcia_device structure can be used to point to
176 a device-specific private data structure, like this.
177*/
178static unsigned int ray_mem_speed = 500; 171static unsigned int ray_mem_speed = 500;
179 172
180/* WARNING: THIS DRIVER IS NOT CAPABLE OF HANDLING MULTIPLE DEVICES! */ 173/* WARNING: THIS DRIVER IS NOT CAPABLE OF HANDLING MULTIPLE DEVICES! */
@@ -289,14 +282,6 @@ static const struct net_device_ops ray_netdev_ops = {
289 .ndo_validate_addr = eth_validate_addr, 282 .ndo_validate_addr = eth_validate_addr,
290}; 283};
291 284
292/*=============================================================================
293 ray_attach() creates an "instance" of the driver, allocating
294 local data structures for one device. The device is registered
295 with Card Services.
296 The dev_link structure is initialized, but we don't actually
297 configure the card at this point -- we wait until we receive a
298 card insertion event.
299=============================================================================*/
300static int ray_probe(struct pcmcia_device *p_dev) 285static int ray_probe(struct pcmcia_device *p_dev)
301{ 286{
302 ray_dev_t *local; 287 ray_dev_t *local;
@@ -351,12 +336,6 @@ fail_alloc_dev:
351 return -ENOMEM; 336 return -ENOMEM;
352} /* ray_attach */ 337} /* ray_attach */
353 338
354/*=============================================================================
355 This deletes a driver "instance". The device is de-registered
356 with Card Services. If it has been released, all local data
357 structures are freed. Otherwise, the structures will be freed
358 when the device is released.
359=============================================================================*/
360static void ray_detach(struct pcmcia_device *link) 339static void ray_detach(struct pcmcia_device *link)
361{ 340{
362 struct net_device *dev; 341 struct net_device *dev;
@@ -379,11 +358,6 @@ static void ray_detach(struct pcmcia_device *link)
379 dev_dbg(&link->dev, "ray_cs ray_detach ending\n"); 358 dev_dbg(&link->dev, "ray_cs ray_detach ending\n");
380} /* ray_detach */ 359} /* ray_detach */
381 360
382/*=============================================================================
383 ray_config() is run after a CARD_INSERTION event
384 is received, to configure the PCMCIA socket, and to make the
385 ethernet device available to the system.
386=============================================================================*/
387#define MAX_TUPLE_SIZE 128 361#define MAX_TUPLE_SIZE 128
388static int ray_config(struct pcmcia_device *link) 362static int ray_config(struct pcmcia_device *link)
389{ 363{
@@ -409,9 +383,6 @@ static int ray_config(struct pcmcia_device *link)
409 goto failed; 383 goto failed;
410 dev->irq = link->irq; 384 dev->irq = link->irq;
411 385
412 /* This actually configures the PCMCIA socket -- setting up
413 the I/O windows and the interrupt mapping.
414 */
415 ret = pcmcia_enable_device(link); 386 ret = pcmcia_enable_device(link);
416 if (ret) 387 if (ret)
417 goto failed; 388 goto failed;
@@ -771,11 +742,7 @@ static void join_net(u_long data)
771 local->card_status = CARD_DOING_ACQ; 742 local->card_status = CARD_DOING_ACQ;
772} 743}
773 744
774/*============================================================================ 745
775 After a card is removed, ray_release() will unregister the net
776 device, and release the PCMCIA configuration. If the device is
777 still open, this will be postponed until it is closed.
778=============================================================================*/
779static void ray_release(struct pcmcia_device *link) 746static void ray_release(struct pcmcia_device *link)
780{ 747{
781 struct net_device *dev = link->priv; 748 struct net_device *dev = link->priv;
diff --git a/drivers/net/wireless/wl3501_cs.c b/drivers/net/wireless/wl3501_cs.c
index d3ed38f558f..ca3f8961fa2 100644
--- a/drivers/net/wireless/wl3501_cs.c
+++ b/drivers/net/wireless/wl3501_cs.c
@@ -77,13 +77,6 @@
77#define WL3501_RESUME 0 77#define WL3501_RESUME 0
78#define WL3501_SUSPEND 1 78#define WL3501_SUSPEND 1
79 79
80/*
81 * The event() function is this driver's Card Services event handler. It will
82 * be called by Card Services when an appropriate card status event is
83 * received. The config() and release() entry points are used to configure or
84 * release a socket, in response to card insertion and ejection events. They
85 * are invoked from the wl24 event handler.
86 */
87static int wl3501_config(struct pcmcia_device *link); 80static int wl3501_config(struct pcmcia_device *link);
88static void wl3501_release(struct pcmcia_device *link); 81static void wl3501_release(struct pcmcia_device *link);
89 82
@@ -1868,15 +1861,6 @@ static const struct net_device_ops wl3501_netdev_ops = {
1868 .ndo_validate_addr = eth_validate_addr, 1861 .ndo_validate_addr = eth_validate_addr,
1869}; 1862};
1870 1863
1871/**
1872 * wl3501_attach - creates an "instance" of the driver
1873 *
1874 * Creates an "instance" of the driver, allocating local data structures for
1875 * one device. The device is registered with Card Services.
1876 *
1877 * The dev_link structure is initialized, but we don't actually configure the
1878 * card at this point -- we wait until we receive a card insertion event.
1879 */
1880static int wl3501_probe(struct pcmcia_device *p_dev) 1864static int wl3501_probe(struct pcmcia_device *p_dev)
1881{ 1865{
1882 struct net_device *dev; 1866 struct net_device *dev;
@@ -1912,14 +1896,6 @@ out_link:
1912 return -ENOMEM; 1896 return -ENOMEM;
1913} 1897}
1914 1898
1915/**
1916 * wl3501_config - configure the PCMCIA socket and make eth device available
1917 * @link - FILL_IN
1918 *
1919 * wl3501_config() is scheduled to run after a CARD_INSERTION event is
1920 * received, to configure the PCMCIA socket, and to make the ethernet device
1921 * available to the system.
1922 */
1923static int wl3501_config(struct pcmcia_device *link) 1899static int wl3501_config(struct pcmcia_device *link)
1924{ 1900{
1925 struct net_device *dev = link->priv; 1901 struct net_device *dev = link->priv;
@@ -1950,9 +1926,6 @@ static int wl3501_config(struct pcmcia_device *link)
1950 if (ret) 1926 if (ret)
1951 goto failed; 1927 goto failed;
1952 1928
1953 /* This actually configures the PCMCIA socket -- setting up the I/O
1954 * windows and the interrupt mapping. */
1955
1956 ret = pcmcia_enable_device(link); 1929 ret = pcmcia_enable_device(link);
1957 if (ret) 1930 if (ret)
1958 goto failed; 1931 goto failed;
@@ -2008,14 +1981,6 @@ failed:
2008 return -ENODEV; 1981 return -ENODEV;
2009} 1982}
2010 1983
2011/**
2012 * wl3501_release - unregister the net, release PCMCIA configuration
2013 * @arg - link
2014 *
2015 * After a card is removed, wl3501_release() will unregister the net device,
2016 * and release the PCMCIA configuration. If the device is still open, this
2017 * will be postponed until it is closed.
2018 */
2019static void wl3501_release(struct pcmcia_device *link) 1984static void wl3501_release(struct pcmcia_device *link)
2020{ 1985{
2021 pcmcia_disable_device(link); 1986 pcmcia_disable_device(link);
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-21 21:50:31 -0400