summaryrefslogtreecommitdiff
path: root/target/linux/s3c24xx/patches-2.6.26/1232-0003-a6k-sdio-Use-pnp_alloc_dev-to-properly-initiali.patch
blob: 8b61dacba91cd8818f78be29b9aa76323580b9a8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
From 0e70d711fe8c81a98b77b35b56728e29a669a08b Mon Sep 17 00:00:00 2001
From: Holger Freyther <zecke@openmoko.org>
Date: Mon, 4 Aug 2008 08:34:39 +0100
Subject: [PATCH] 0003-a6k-sdio-Use-pnp_alloc_dev-to-properly-initialize.patch
 Signed-Off-By: Holger Freyther <zecke@openmoko.org>

---
 drivers/sdio/function/wlan/ar6000/hif/hif.c |    2 +-
 drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.c      |    6 +-
 drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.h      |    4 +-
 drivers/sdio/stack/busdriver/sdio_bus_os.c  |   78 ++++++++++++++-------------
 include/linux/sdio/sdio_busdriver.h         |    2 +-
 include/linux/sdio/sdio_hcd_defs.h          |    2 +-
 6 files changed, 48 insertions(+), 46 deletions(-)

diff --git a/drivers/sdio/function/wlan/ar6000/hif/hif.c b/drivers/sdio/function/wlan/ar6000/hif/hif.c
index 3d6d792..5171157 100644
--- a/drivers/sdio/function/wlan/ar6000/hif/hif.c
+++ b/drivers/sdio/function/wlan/ar6000/hif/hif.c
@@ -782,7 +782,7 @@ delHifDevice(SDDEVICE *handle)
 struct device*
 HIFGetOSDevice(HIF_DEVICE *device)
 {
-    return &device->handle->Device.dev;
+    return &device->handle->Device->dev;
 }
 
 static void ResetAllCards(void)
diff --git a/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.c b/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.c
index edb8523..09d81ee 100644
--- a/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.c
+++ b/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.c
@@ -1296,7 +1296,6 @@ struct s3c24xx_hcd_context hcd_context = {
 	.hcd.pContext = &hcd_context,
 	.hcd.pRequest = s3c24xx_hcd_request,
 	.hcd.pConfigure = s3c24xx_hcd_config,
-	.device.pnp_device.name = "sdio_s3c24xx_hcd",
 	.device.pnp_driver.name = "sdio_s3c24xx_hcd",
 	.device.pnp_driver.probe  = s3c24xx_hcd_pnp_probe,
 	.device.pnp_driver.remove = s3c24xx_hcd_pnp_remove,
@@ -1348,7 +1347,7 @@ static int s3c24xx_hcd_probe(struct platform_device * pdev)
 
 	status = SDIO_BusAddOSDevice(&hcd_context.device.dma,
 				     &hcd_context.device.pnp_driver,
-				     &hcd_context.device.pnp_device);
+				     &hcd_context.device.pnp_device, "sdio_s3c24xx_hcd");
 
  out:
 
@@ -1360,7 +1359,8 @@ static int s3c24xx_hcd_probe(struct platform_device * pdev)
  */
 static int s3c24xx_hcd_remove(struct platform_device * pdev) {
 	printk("S3C2440 SDIO host controller unloaded\n");
-	SDIO_BusRemoveOSDevice(&hcd_context.device.pnp_driver, &hcd_context.device.pnp_device);
+	SDIO_BusRemoveOSDevice(&hcd_context.device.pnp_driver, hcd_context.device.pnp_device);
+	kfree(hcd_context.device.pnp_device);
 
 	return 0;
 }
diff --git a/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.h b/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.h
index 47fdd33..f8b0912 100644
--- a/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.h
+++ b/drivers/sdio/hcd/s3c24xx/s3c24xx_hcd.h
@@ -8,8 +8,8 @@
 #define S3C24XX_HCD_DATA_WRITE      5
 
 struct s3c24xx_hcd_device {
-	OS_PNPDEVICE   pnp_device;     /* the OS device for this HCD */
-	OS_PNPDRIVER   pnp_driver;     /* the OS driver for this HCD */
+	OS_PNPDEVICE *pnp_device;     /* the OS device for this HCD */
+	OS_PNPDRIVER  pnp_driver;     /* the OS driver for this HCD */
 	SDDMA_DESCRIPTION dma;
 	struct clk * clock;
 	unsigned long max_clock_rate;
diff --git a/drivers/sdio/stack/busdriver/sdio_bus_os.c b/drivers/sdio/stack/busdriver/sdio_bus_os.c
index 2650d93..c6f68e6 100644
--- a/drivers/sdio/stack/busdriver/sdio_bus_os.c
+++ b/drivers/sdio/stack/busdriver/sdio_bus_os.c
@@ -415,8 +415,8 @@ struct pnp_protocol sdio_protocol = {
 */
 static int driver_probe(struct pnp_dev* pOSDevice, const struct pnp_device_id *pId)
 {
-    PSDDEVICE pDevice = SDDEVICE_FROM_OSDEVICE(pOSDevice);
-    PSDFUNCTION pFunction = pDevice->Device.dev.driver_data;
+    PSDDEVICE pDevice = SDDEVICE_FROM_OSDEVICE(&pOSDevice);
+    PSDFUNCTION pFunction = pDevice->Device->dev.driver_data;
 
     if (pFunction == NULL) {
         return -1;
@@ -496,34 +496,32 @@ static int UnregisterDriver(PSDFUNCTION pFunction)
 */
 SDIO_STATUS OS_InitializeDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction)
 {
-	char id_name[20];
+    char id_name[20];
 
-    memset(&pDevice->Device, 0, sizeof(pDevice->Device));
-    pDevice->Device.dev.driver_data = (PVOID)pFunction;
+    /* set the id as slot number/function number */
+    snprintf(id_name, sizeof(id_name) - 1, "SD_%02X%02X",
+             pDevice->pHcd->SlotNumber, (UINT)SDDEVICE_GET_SDIO_FUNCNO(pDevice));
+
+    pDevice->Device = pnp_alloc_dev(&sdio_protocol, pDevice->pHcd->SlotNumber + 1, id_name);
+    pDevice->Device->dev.driver_data = (PVOID)pFunction;
 //??    pDevice->Device.data = (PVOID)pFunction;
 //??    pDevice->Device.dev.driver = &pFunction->Driver.driver;
 //??    pDevice->Device.driver = &pFunction->Driver;
 //??    pDevice->Device.dev.release = release;
     /* get a unique device number, must be done with locks held */
     spin_lock(&InUseDevicesLock);
-    pDevice->Device.number = FirstClearBit(&InUseDevices);
-    SetBit(&InUseDevices, pDevice->Device.number);
+    pDevice->Device->number = FirstClearBit(&InUseDevices);
+    SetBit(&InUseDevices, pDevice->Device->number);
     spin_unlock(&InUseDevicesLock);
-    pDevice->Device.capabilities = PNP_REMOVABLE | PNP_DISABLE;
-    pDevice->Device.protocol = &sdio_protocol;
-    pDevice->Device.active = 1;
+    pDevice->Device->capabilities = PNP_REMOVABLE | PNP_DISABLE;
+    pDevice->Device->active = 1;
 
-    /* set the id as slot number/function number */
-    snprintf(id_name, sizeof(id_name) - 1, "SD_%02X%02X",
-             pDevice->pHcd->SlotNumber, (UINT)SDDEVICE_GET_SDIO_FUNCNO(pDevice));
     DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_InitializeDevice adding id: %s\n",
                              id_name));
-    pnp_add_id(&pDevice->Device, id_name);
-
-        /* deal with DMA settings */
+    /* deal with DMA settings */
     if (pDevice->pHcd->pDmaDescription != NULL) {
-        pDevice->Device.dev.dma_mask = &pDevice->pHcd->pDmaDescription->Mask;
-        pDevice->Device.dev.coherent_dma_mask = pDevice->pHcd->pDmaDescription->Mask;
+        pDevice->Device->dev.dma_mask = &pDevice->pHcd->pDmaDescription->Mask;
+        pDevice->Device->dev.coherent_dma_mask = pDevice->pHcd->pDmaDescription->Mask;
     }
 
     return SDIO_STATUS_SUCCESS;
@@ -537,13 +535,13 @@ SDIO_STATUS OS_AddDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction)
     int error;
     DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_AddDevice adding function: %s\n",
                                pFunction->pName));
-    error = pnp_add_device(&pDevice->Device);
+    error = pnp_add_device(pDevice->Device);
     if (error < 0) {
         DBG_PRINT(SDDBG_ERROR, ("SDIO BusDriver - OS_AddDevice failed pnp_add_device: %d\n",
                                error));
     }
         /* replace the buggy pnp's release */
-    pDevice->Device.dev.release = release;
+    pDevice->Device->dev.release = release;
 
     return OSErrorToSDIOError(error);
 }
@@ -554,15 +552,17 @@ SDIO_STATUS OS_AddDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction)
 void OS_RemoveDevice(PSDDEVICE pDevice)
 {
     DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_RemoveDevice \n"));
-    pnp_remove_card_device(&pDevice->Device);
+    pnp_remove_card_device(pDevice->Device);
     spin_lock(&InUseDevicesLock);
-    ClearBit(&InUseDevices, pDevice->Device.number);
+    ClearBit(&InUseDevices, pDevice->Device->number);
     spin_unlock(&InUseDevicesLock);
 
-    if (pDevice->Device.id != NULL) {
-        KernelFree(pDevice->Device.id);
-        pDevice->Device.id = NULL;
+    if (pDevice->Device->id != NULL) {
+        KernelFree(pDevice->Device->id);
+        pDevice->Device->id = NULL;
     }
+
+    KernelFree(pDevice->Device);
 }
 
 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -612,20 +612,13 @@ void OS_RemoveDevice(PSDDEVICE pDevice)
   @see also: SDIO_BusRemoveOSDevice
 
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver, POS_PNPDEVICE pDevice)
+SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver, POS_PNPDEVICE *outDevice, const char* name)
 {
     int err;
     struct pnp_device_id *pFdid;
     static int slotNumber = 0; /* we just use an increasing count for the slots number */
-	char id_name[20];
+    struct pnp_dev* pDevice;
 
-    if (pDma != NULL) {
-        pDevice->dev.dma_mask = &pDma->Mask;
-        pDevice->dev.coherent_dma_mask = pDma->Mask;
-    }
-    DBG_PRINT(SDDBG_ERROR,
-            ("SDIO BusDriver - SDIO_GetBusOSDevice, registering driver: %s DMAmask: 0x%x\n",
-            pDriver->name, (UINT)*pDevice->dev.dma_mask));
     pFdid = KernelAlloc(sizeof(struct pnp_device_id)*2);
     /* set the id as slot number/function number */
     snprintf(pFdid[0].id, sizeof(pFdid[0].id), "SD_%02X08",
@@ -644,14 +637,22 @@ SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver,
         return OSErrorToSDIOError(err);
     }
 
+    pDevice = pnp_alloc_dev(&sdio_protocol, slotNumber - 1, pFdid[0].id);
+    if (!pDevice)
+        return -EINVAL;
+
+    if (pDma != NULL) {
+        pDevice->dev.dma_mask = &pDma->Mask;
+        pDevice->dev.coherent_dma_mask = pDma->Mask;
+    }
+    DBG_PRINT(SDDBG_ERROR,
+            ("SDIO BusDriver - SDIO_GetBusOSDevice, registering driver: %s DMAmask: 0x%x\n",
+            pDriver->name, (UINT)*pDevice->dev.dma_mask));
+
     pDevice->protocol = &sdio_protocol;
     pDevice->capabilities = PNP_REMOVABLE | PNP_DISABLE;
     pDevice->active = 1;
 
-    /* set the id as slot number/function number */
-    snprintf(id_name, sizeof(id_name) - 1, "SD_%02X08",
-             0); //??pDevice->pHcd->SlotNumber);//?????fix this, slotnumber isn't vaialble yet
-    pnp_add_id(pDevice, id_name);
 
     /* get a unique device number */
     spin_lock(&InUseDevicesLock);
@@ -667,6 +668,7 @@ SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver,
     }
     /* replace the buggy pnp's release */
     pDevice->dev.release = release;
+    *outDevice = pDevice;
     return OSErrorToSDIOError(err);
 }
 
diff --git a/include/linux/sdio/sdio_busdriver.h b/include/linux/sdio/sdio_busdriver.h
index b431d3d..35e3ebb 100644
--- a/include/linux/sdio/sdio_busdriver.h
+++ b/include/linux/sdio/sdio_busdriver.h
@@ -477,7 +477,7 @@ typedef struct _SDDEVICE {
     struct _SDHCD  *pHcd;           /* host controller this device is on (internal use) */
     SDDEVICE_INFO   DeviceInfo;     /* device info */
     SD_PNP_INFO pId[1];             /* id of this device  */
-    OS_PNPDEVICE Device;            /* device registration with base system */
+    OS_PNPDEVICE *Device;           /* device registration with base system */
     SD_SLOT_CURRENT  SlotCurrentAlloc; /* allocated slot current for this device/function (internal use) */
     SD_DEVICE_FLAGS Flags;          /* internal use flags */
     CT_VERSION_CODE Version;        /* version code of the bus driver */
diff --git a/include/linux/sdio/sdio_hcd_defs.h b/include/linux/sdio/sdio_hcd_defs.h
index 1782469..e6115a2 100644
--- a/include/linux/sdio/sdio_hcd_defs.h
+++ b/include/linux/sdio/sdio_hcd_defs.h
@@ -213,7 +213,7 @@ SDIO_STATUS SDIO_RegisterHostController(PSDHCD pHcd);
 SDIO_STATUS SDIO_UnregisterHostController(PSDHCD pHcd);
 SDIO_STATUS SDIO_HandleHcdEvent(PSDHCD pHcd, HCD_EVENT Event);
 SDIO_STATUS SDIO_CheckResponse(PSDHCD pHcd, PSDREQUEST pReq, SDHCD_RESPONSE_CHECK_MODE CheckMode);
-SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver, POS_PNPDEVICE pDevice);
+SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver, POS_PNPDEVICE *pDevice, const char* name);
 void SDIO_BusRemoveOSDevice(POS_PNPDRIVER pDriver, POS_PNPDEVICE pDevice);
 
 #endif /* __SDIO_BUSDRIVER_H___ */
-- 
1.5.6.3