tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

staging: use pci_zalloc_consistent

Remove the now unnecessary memset too.

Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Lior Dotan <liodot@gmail.com>
Cc: Christopher Harrer <charrer@alacritech.com>
Cc: Forest Bond <forest@alittletooquiet.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

authored by

Joe Perches and committed by
Linus Torvalds 8b983be5 7c845eb5

+44 -93
+5 -10
drivers/staging/rtl8192e/rtl8192e/rtl_core.c
··· 2065 2065 int i, rx_queue_idx; 2066 2066 2067 2067 for (rx_queue_idx = 0; rx_queue_idx < MAX_RX_QUEUE; rx_queue_idx++) { 2068 - priv->rx_ring[rx_queue_idx] = pci_alloc_consistent(priv->pdev, 2069 - sizeof(*priv->rx_ring[rx_queue_idx]) * 2070 - priv->rxringcount, 2071 - &priv->rx_ring_dma[rx_queue_idx]); 2072 - 2068 + priv->rx_ring[rx_queue_idx] = 2069 + pci_zalloc_consistent(priv->pdev, 2070 + sizeof(*priv->rx_ring[rx_queue_idx]) * priv->rxringcount, 2071 + &priv->rx_ring_dma[rx_queue_idx]); 2073 2072 if (!priv->rx_ring[rx_queue_idx] || 2074 2073 (unsigned long)priv->rx_ring[rx_queue_idx] & 0xFF) { 2075 2074 RT_TRACE(COMP_ERR, "Cannot allocate RX ring\n"); 2076 2075 return -ENOMEM; 2077 2076 } 2078 2077 2079 - memset(priv->rx_ring[rx_queue_idx], 0, 2080 - sizeof(*priv->rx_ring[rx_queue_idx]) * 2081 - priv->rxringcount); 2082 2078 priv->rx_idx[rx_queue_idx] = 0; 2083 2079 2084 2080 for (i = 0; i < priv->rxringcount; i++) { ··· 2114 2118 dma_addr_t dma; 2115 2119 int i; 2116 2120 2117 - ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma); 2121 + ring = pci_zalloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma); 2118 2122 if (!ring || (unsigned long)ring & 0xFF) { 2119 2123 RT_TRACE(COMP_ERR, "Cannot allocate TX ring (prio = %d)\n", 2120 2124 prio); 2121 2125 return -ENOMEM; 2122 2126 } 2123 2127 2124 - memset(ring, 0, sizeof(*ring)*entries); 2125 2128 priv->tx_ring[prio].desc = ring; 2126 2129 priv->tx_ring[prio].dma = dma; 2127 2130 priv->tx_ring[prio].idx = 0;
+12 -25
drivers/staging/rtl8192ee/pci.c
··· 1224 1224 1225 1225 /* alloc tx buffer desc for new trx flow*/ 1226 1226 if (rtlpriv->use_new_trx_flow) { 1227 - buffer_desc = pci_alloc_consistent(rtlpci->pdev, 1228 - sizeof(*buffer_desc) * entries, 1229 - &buffer_desc_dma); 1230 - 1227 + buffer_desc = 1228 + pci_zalloc_consistent(rtlpci->pdev, 1229 + sizeof(*buffer_desc) * entries, 1230 + &buffer_desc_dma); 1231 1231 if (!buffer_desc || (unsigned long)buffer_desc & 0xFF) { 1232 1232 RT_TRACE(COMP_ERR, DBG_EMERG, 1233 1233 ("Cannot allocate TX ring (prio = %d)\n", ··· 1235 1235 return -ENOMEM; 1236 1236 } 1237 1237 1238 - memset(buffer_desc, 0, sizeof(*buffer_desc) * entries); 1239 1238 rtlpci->tx_ring[prio].buffer_desc = buffer_desc; 1240 1239 rtlpci->tx_ring[prio].buffer_desc_dma = buffer_desc_dma; 1241 1240 ··· 1244 1245 } 1245 1246 1246 1247 /* alloc dma for this ring */ 1247 - desc = pci_alloc_consistent(rtlpci->pdev, 1248 - sizeof(*desc) * entries, &desc_dma); 1249 - 1248 + desc = pci_zalloc_consistent(rtlpci->pdev, sizeof(*desc) * entries, 1249 + &desc_dma); 1250 1250 if (!desc || (unsigned long)desc & 0xFF) { 1251 1251 RT_TRACE(COMP_ERR, DBG_EMERG, 1252 1252 ("Cannot allocate TX ring (prio = %d)\n", prio)); 1253 1253 return -ENOMEM; 1254 1254 } 1255 1255 1256 - memset(desc, 0, sizeof(*desc) * entries); 1257 1256 rtlpci->tx_ring[prio].desc = desc; 1258 1257 rtlpci->tx_ring[prio].dma = desc_dma; 1259 1258 ··· 1287 1290 struct rtl_rx_buffer_desc *entry = NULL; 1288 1291 /* alloc dma for this ring */ 1289 1292 rtlpci->rx_ring[rxring_idx].buffer_desc = 1290 - pci_alloc_consistent(rtlpci->pdev, 1291 - sizeof(*rtlpci->rx_ring[rxring_idx]. 1292 - buffer_desc) * 1293 - rtlpci->rxringcount, 1294 - &rtlpci->rx_ring[rxring_idx].dma); 1293 + pci_zalloc_consistent(rtlpci->pdev, 1294 + sizeof(*rtlpci->rx_ring[rxring_idx].buffer_desc) * rtlpci->rxringcount, 1295 + &rtlpci->rx_ring[rxring_idx].dma); 1295 1296 if (!rtlpci->rx_ring[rxring_idx].buffer_desc || 1296 1297 (unsigned long)rtlpci->rx_ring[rxring_idx].buffer_desc & 0xFF) { 1297 1298 RT_TRACE(COMP_ERR, DBG_EMERG, 1298 1299 ("Cannot allocate RX ring\n")); 1299 1300 return -ENOMEM; 1300 1301 } 1301 - 1302 - memset(rtlpci->rx_ring[rxring_idx].buffer_desc, 0, 1303 - sizeof(*rtlpci->rx_ring[rxring_idx].buffer_desc) * 1304 - rtlpci->rxringcount); 1305 1302 1306 1303 /* init every desc in this ring */ 1307 1304 rtlpci->rx_ring[rxring_idx].idx = 0; ··· 1311 1320 u8 tmp_one = 1; 1312 1321 /* alloc dma for this ring */ 1313 1322 rtlpci->rx_ring[rxring_idx].desc = 1314 - pci_alloc_consistent(rtlpci->pdev, 1315 - sizeof(*rtlpci->rx_ring[rxring_idx]. 1316 - desc) * rtlpci->rxringcount, 1317 - &rtlpci->rx_ring[rxring_idx].dma); 1323 + pci_zalloc_consistent(rtlpci->pdev, 1324 + sizeof(*rtlpci->rx_ring[rxring_idx].desc) * rtlpci->rxringcount, 1325 + &rtlpci->rx_ring[rxring_idx].dma); 1318 1326 if (!rtlpci->rx_ring[rxring_idx].desc || 1319 1327 (unsigned long)rtlpci->rx_ring[rxring_idx].desc & 0xFF) { 1320 1328 RT_TRACE(COMP_ERR, DBG_EMERG, 1321 1329 ("Cannot allocate RX ring\n")); 1322 1330 return -ENOMEM; 1323 1331 } 1324 - memset(rtlpci->rx_ring[rxring_idx].desc, 0, 1325 - sizeof(*rtlpci->rx_ring[rxring_idx].desc) * 1326 - rtlpci->rxringcount); 1327 1332 1328 1333 /* init every desc in this ring */ 1329 1334 rtlpci->rx_ring[rxring_idx].idx = 0;
+12 -24
drivers/staging/rtl8821ae/pci.c
··· 1248 1248 1249 1249 /* alloc tx buffer desc for new trx flow*/ 1250 1250 if (rtlpriv->use_new_trx_flow) { 1251 - buffer_desc = pci_alloc_consistent(rtlpci->pdev, 1252 - sizeof(*buffer_desc) * entries, 1253 - &buffer_desc_dma); 1251 + buffer_desc = 1252 + pci_zalloc_consistent(rtlpci->pdev, 1253 + sizeof(*buffer_desc) * entries, 1254 + &buffer_desc_dma); 1254 1255 1255 1256 if (!buffer_desc || (unsigned long)buffer_desc & 0xFF) { 1256 1257 RT_TRACE(COMP_ERR, DBG_EMERG, ··· 1260 1259 return -ENOMEM; 1261 1260 } 1262 1261 1263 - memset(buffer_desc, 0, sizeof(*buffer_desc) * entries); 1264 1262 rtlpci->tx_ring[prio].buffer_desc = buffer_desc; 1265 1263 rtlpci->tx_ring[prio].buffer_desc_dma = buffer_desc_dma; 1266 1264 ··· 1270 1270 } 1271 1271 1272 1272 /* alloc dma for this ring */ 1273 - desc = pci_alloc_consistent(rtlpci->pdev, 1274 - sizeof(*desc) * entries, &desc_dma); 1273 + desc = pci_zalloc_consistent(rtlpci->pdev, sizeof(*desc) * entries, 1274 + &desc_dma); 1275 1275 1276 1276 if (!desc || (unsigned long)desc & 0xFF) { 1277 1277 RT_TRACE(COMP_ERR, DBG_EMERG, ··· 1279 1279 return -ENOMEM; 1280 1280 } 1281 1281 1282 - memset(desc, 0, sizeof(*desc) * entries); 1283 1282 rtlpci->tx_ring[prio].desc = desc; 1284 1283 rtlpci->tx_ring[prio].dma = desc_dma; 1285 1284 ··· 1315 1316 struct rtl_rx_buffer_desc *entry = NULL; 1316 1317 /* alloc dma for this ring */ 1317 1318 rtlpci->rx_ring[rxring_idx].buffer_desc = 1318 - pci_alloc_consistent(rtlpci->pdev, 1319 - sizeof(*rtlpci->rx_ring[rxring_idx]. 1320 - buffer_desc) * 1321 - rtlpci->rxringcount, 1322 - &rtlpci->rx_ring[rxring_idx].dma); 1319 + pci_zalloc_consistent(rtlpci->pdev, 1320 + sizeof(*rtlpci->rx_ring[rxring_idx].buffer_desc) * rtlpci->rxringcount, 1321 + &rtlpci->rx_ring[rxring_idx].dma); 1323 1322 if (!rtlpci->rx_ring[rxring_idx].buffer_desc || 1324 1323 (unsigned long)rtlpci->rx_ring[rxring_idx].buffer_desc & 0xFF) { 1325 1324 RT_TRACE(COMP_ERR, DBG_EMERG, ("Cannot allocate RX ring\n")); 1326 1325 return -ENOMEM; 1327 1326 } 1328 - 1329 - memset(rtlpci->rx_ring[rxring_idx].buffer_desc, 0, 1330 - sizeof(*rtlpci->rx_ring[rxring_idx].buffer_desc) * 1331 - rtlpci->rxringcount); 1332 1327 1333 1328 /* init every desc in this ring */ 1334 1329 rtlpci->rx_ring[rxring_idx].idx = 0; ··· 1337 1344 u8 tmp_one = 1; 1338 1345 /* alloc dma for this ring */ 1339 1346 rtlpci->rx_ring[rxring_idx].desc = 1340 - pci_alloc_consistent(rtlpci->pdev, 1341 - sizeof(*rtlpci->rx_ring[rxring_idx]. 1342 - desc) * rtlpci->rxringcount, 1343 - &rtlpci->rx_ring[rxring_idx].dma); 1347 + pci_zalloc_consistent(rtlpci->pdev, 1348 + sizeof(*rtlpci->rx_ring[rxring_idx].desc) * rtlpci->rxringcount, 1349 + &rtlpci->rx_ring[rxring_idx].dma); 1344 1350 if (!rtlpci->rx_ring[rxring_idx].desc || 1345 1351 (unsigned long)rtlpci->rx_ring[rxring_idx].desc & 0xFF) { 1346 1352 RT_TRACE(COMP_ERR, DBG_EMERG, 1347 1353 ("Cannot allocate RX ring\n")); 1348 1354 return -ENOMEM; 1349 1355 } 1350 - 1351 - memset(rtlpci->rx_ring[rxring_idx].desc, 0, 1352 - sizeof(*rtlpci->rx_ring[rxring_idx].desc) * 1353 - rtlpci->rxringcount); 1354 1356 1355 1357 /* init every desc in this ring */ 1356 1358 rtlpci->rx_ring[rxring_idx].idx = 0;
+3 -6
drivers/staging/slicoss/slicoss.c
··· 1191 1191 rspq->num_pages = SLIC_RSPQ_PAGES_GB; 1192 1192 1193 1193 for (i = 0; i < rspq->num_pages; i++) { 1194 - rspq->vaddr[i] = pci_alloc_consistent(adapter->pcidev, 1195 - PAGE_SIZE, 1196 - &rspq->paddr[i]); 1194 + rspq->vaddr[i] = pci_zalloc_consistent(adapter->pcidev, 1195 + PAGE_SIZE, 1196 + &rspq->paddr[i]); 1197 1197 if (!rspq->vaddr[i]) { 1198 1198 dev_err(&adapter->pcidev->dev, 1199 1199 "pci_alloc_consistent failed\n"); 1200 1200 slic_rspqueue_free(adapter); 1201 1201 return -ENOMEM; 1202 1202 } 1203 - /* FIXME: 1204 - * do we really need this assertions (4K PAGE_SIZE aligned addr)? */ 1205 - memset(rspq->vaddr[i], 0, PAGE_SIZE); 1206 1203 1207 1204 if (paddrh == 0) { 1208 1205 slic_reg32_write(&slic_regs->slic_rbar,
+12 -28
drivers/staging/vt6655/device_main.c
··· 1111 1111 void *vir_pool; 1112 1112 1113 1113 /*allocate all RD/TD rings a single pool*/ 1114 - vir_pool = pci_alloc_consistent(pDevice->pcid, 1115 - pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1116 - pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1117 - pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1118 - pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc), 1119 - &pDevice->pool_dma); 1120 - 1114 + vir_pool = pci_zalloc_consistent(pDevice->pcid, 1115 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1116 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1117 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1118 + pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc), 1119 + &pDevice->pool_dma); 1121 1120 if (vir_pool == NULL) { 1122 1121 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name); 1123 1122 return false; 1124 1123 } 1125 - 1126 - memset(vir_pool, 0, 1127 - pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1128 - pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1129 - pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1130 - pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc) 1131 - ); 1132 1124 1133 1125 pDevice->aRD0Ring = vir_pool; 1134 1126 pDevice->aRD1Ring = vir_pool + ··· 1130 1138 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma + 1131 1139 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc); 1132 1140 1133 - pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid, 1134 - pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1135 - pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1136 - CB_BEACON_BUF_SIZE + 1137 - CB_MAX_BUF_SIZE, 1138 - &pDevice->tx_bufs_dma0); 1139 - 1141 + pDevice->tx0_bufs = pci_zalloc_consistent(pDevice->pcid, 1142 + pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1143 + pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1144 + CB_BEACON_BUF_SIZE + 1145 + CB_MAX_BUF_SIZE, 1146 + &pDevice->tx_bufs_dma0); 1140 1147 if (pDevice->tx0_bufs == NULL) { 1141 1148 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name); 1142 1149 pci_free_consistent(pDevice->pcid, ··· 1147 1156 ); 1148 1157 return false; 1149 1158 } 1150 - 1151 - memset(pDevice->tx0_bufs, 0, 1152 - pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1153 - pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1154 - CB_BEACON_BUF_SIZE + 1155 - CB_MAX_BUF_SIZE 1156 - ); 1157 1159 1158 1160 pDevice->td0_pool_dma = pDevice->rd1_pool_dma + 1159 1161 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);