blob: 4b564eda5bd932ef67f8b850c4b947761da31628 [file] [log] [blame]
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001/*
2 * PS3 gelic network driver.
3 *
4 * Copyright (C) 2007 Sony Computer Entertainment Inc.
5 * Copyright 2006, 2007 Sony Corporation
6 *
7 * This file is based on: spider_net.c
8 *
9 * (C) Copyright IBM Corp. 2005
10 *
11 * Authors : Utz Bacher <utz.bacher@de.ibm.com>
12 * Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
17 * any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 */
28
29#undef DEBUG
30
31#include <linux/kernel.h>
32#include <linux/module.h>
33
34#include <linux/etherdevice.h>
35#include <linux/ethtool.h>
36#include <linux/if_vlan.h>
37
38#include <linux/in.h>
39#include <linux/ip.h>
40#include <linux/tcp.h>
41
42#include <linux/dma-mapping.h>
43#include <net/checksum.h>
44#include <asm/firmware.h>
45#include <asm/ps3.h>
46#include <asm/lv1call.h>
47
48#include "ps3_gelic_net.h"
Masakazu Mokuno09dde542008-02-07 19:58:57 +090049#include "ps3_gelic_wireless.h"
Masakazu Mokuno02c18892007-07-05 20:11:16 +090050
51#define DRV_NAME "Gelic Network Driver"
Masakazu Mokuno09dde542008-02-07 19:58:57 +090052#define DRV_VERSION "2.0"
Masakazu Mokuno02c18892007-07-05 20:11:16 +090053
54MODULE_AUTHOR("SCE Inc.");
55MODULE_DESCRIPTION("Gelic Network driver");
56MODULE_LICENSE("GPL");
57
Masakazu Mokuno589866f2008-02-07 19:58:42 +090058
59static inline void gelic_card_enable_rxdmac(struct gelic_card *card);
60static inline void gelic_card_disable_rxdmac(struct gelic_card *card);
61static inline void gelic_card_disable_txdmac(struct gelic_card *card);
62static inline void gelic_card_reset_chain(struct gelic_card *card,
63 struct gelic_descr_chain *chain,
64 struct gelic_descr *start_descr);
Masakazu Mokuno02c18892007-07-05 20:11:16 +090065
66/* set irq_mask */
Masakazu Mokuno589866f2008-02-07 19:58:42 +090067int gelic_card_set_irq_mask(struct gelic_card *card, u64 mask)
Masakazu Mokuno02c18892007-07-05 20:11:16 +090068{
69 int status;
70
71 status = lv1_net_set_interrupt_mask(bus_id(card), dev_id(card),
72 mask, 0);
73 if (status)
74 dev_info(ctodev(card),
Masakazu Mokuno589866f2008-02-07 19:58:42 +090075 "%s failed %d\n", __func__, status);
Masakazu Mokuno02c18892007-07-05 20:11:16 +090076 return status;
77}
Masakazu Mokuno589866f2008-02-07 19:58:42 +090078
Masakazu Mokuno59e97322008-02-07 19:58:08 +090079static inline void gelic_card_rx_irq_on(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +090080{
Masakazu Mokuno589866f2008-02-07 19:58:42 +090081 card->irq_mask |= GELIC_CARD_RXINT;
82 gelic_card_set_irq_mask(card, card->irq_mask);
Masakazu Mokuno02c18892007-07-05 20:11:16 +090083}
Masakazu Mokuno59e97322008-02-07 19:58:08 +090084static inline void gelic_card_rx_irq_off(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +090085{
Masakazu Mokuno589866f2008-02-07 19:58:42 +090086 card->irq_mask &= ~GELIC_CARD_RXINT;
87 gelic_card_set_irq_mask(card, card->irq_mask);
Masakazu Mokuno02c18892007-07-05 20:11:16 +090088}
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +090089
Masakazu Mokuno589866f2008-02-07 19:58:42 +090090static void gelic_card_get_ether_port_status(struct gelic_card *card,
91 int inform)
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +090092{
93 u64 v2;
94 struct net_device *ether_netdev;
95
96 lv1_net_control(bus_id(card), dev_id(card),
97 GELIC_LV1_GET_ETH_PORT_STATUS,
98 GELIC_LV1_VLAN_TX_ETHERNET, 0, 0,
99 &card->ether_port_status, &v2);
100
101 if (inform) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900102 ether_netdev = card->netdev[GELIC_PORT_ETHERNET];
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +0900103 if (card->ether_port_status & GELIC_LV1_ETHER_LINK_UP)
104 netif_carrier_on(ether_netdev);
105 else
106 netif_carrier_off(ether_netdev);
107 }
108}
109
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900110void gelic_card_up(struct gelic_card *card)
111{
112 pr_debug("%s: called\n", __func__);
Daniel Walker2914f3e2008-05-22 00:00:03 -0700113 mutex_lock(&card->updown_lock);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900114 if (atomic_inc_return(&card->users) == 1) {
115 pr_debug("%s: real do\n", __func__);
116 /* enable irq */
117 gelic_card_set_irq_mask(card, card->irq_mask);
118 /* start rx */
119 gelic_card_enable_rxdmac(card);
120
121 napi_enable(&card->napi);
122 }
Daniel Walker2914f3e2008-05-22 00:00:03 -0700123 mutex_unlock(&card->updown_lock);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900124 pr_debug("%s: done\n", __func__);
125}
126
127void gelic_card_down(struct gelic_card *card)
128{
129 u64 mask;
130 pr_debug("%s: called\n", __func__);
Daniel Walker2914f3e2008-05-22 00:00:03 -0700131 mutex_lock(&card->updown_lock);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900132 if (atomic_dec_if_positive(&card->users) == 0) {
133 pr_debug("%s: real do\n", __func__);
134 napi_disable(&card->napi);
135 /*
136 * Disable irq. Wireless interrupts will
137 * be disabled later if any
138 */
139 mask = card->irq_mask & (GELIC_CARD_WLAN_EVENT_RECEIVED |
140 GELIC_CARD_WLAN_COMMAND_COMPLETED);
141 gelic_card_set_irq_mask(card, mask);
142 /* stop rx */
143 gelic_card_disable_rxdmac(card);
144 gelic_card_reset_chain(card, &card->rx_chain,
145 card->descr + GELIC_NET_TX_DESCRIPTORS);
146 /* stop tx */
147 gelic_card_disable_txdmac(card);
148 }
Daniel Walker2914f3e2008-05-22 00:00:03 -0700149 mutex_unlock(&card->updown_lock);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900150 pr_debug("%s: done\n", __func__);
151}
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +0900152
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900153/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900154 * gelic_descr_get_status -- returns the status of a descriptor
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900155 * @descr: descriptor to look at
156 *
157 * returns the status as in the dmac_cmd_status field of the descriptor
158 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900159static enum gelic_descr_dma_status
160gelic_descr_get_status(struct gelic_descr *descr)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900161{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900162 return be32_to_cpu(descr->dmac_cmd_status) & GELIC_DESCR_DMA_STAT_MASK;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900163}
164
165/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900166 * gelic_descr_set_status -- sets the status of a descriptor
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900167 * @descr: descriptor to change
168 * @status: status to set in the descriptor
169 *
170 * changes the status to the specified value. Doesn't change other bits
171 * in the status
172 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900173static void gelic_descr_set_status(struct gelic_descr *descr,
174 enum gelic_descr_dma_status status)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900175{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900176 descr->dmac_cmd_status = cpu_to_be32(status |
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900177 (be32_to_cpu(descr->dmac_cmd_status) &
178 ~GELIC_DESCR_DMA_STAT_MASK));
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900179 /*
180 * dma_cmd_status field is used to indicate whether the descriptor
181 * is valid or not.
182 * Usually caller of this function wants to inform that to the
183 * hardware, so we assure here the hardware sees the change.
184 */
185 wmb();
186}
187
188/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900189 * gelic_card_free_chain - free descriptor chain
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900190 * @card: card structure
191 * @descr_in: address of desc
192 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900193static void gelic_card_free_chain(struct gelic_card *card,
194 struct gelic_descr *descr_in)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900195{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900196 struct gelic_descr *descr;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900197
198 for (descr = descr_in; descr && descr->bus_addr; descr = descr->next) {
199 dma_unmap_single(ctodev(card), descr->bus_addr,
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900200 GELIC_DESCR_SIZE, DMA_BIDIRECTIONAL);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900201 descr->bus_addr = 0;
202 }
203}
204
205/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900206 * gelic_card_init_chain - links descriptor chain
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900207 * @card: card structure
208 * @chain: address of chain
209 * @start_descr: address of descriptor array
210 * @no: number of descriptors
211 *
212 * we manage a circular list that mirrors the hardware structure,
213 * except that the hardware uses bus addresses.
214 *
215 * returns 0 on success, <0 on failure
216 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900217static int gelic_card_init_chain(struct gelic_card *card,
218 struct gelic_descr_chain *chain,
219 struct gelic_descr *start_descr, int no)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900220{
221 int i;
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900222 struct gelic_descr *descr;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900223
224 descr = start_descr;
225 memset(descr, 0, sizeof(*descr) * no);
226
227 /* set up the hardware pointers in each descriptor */
228 for (i = 0; i < no; i++, descr++) {
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900229 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900230 descr->bus_addr =
231 dma_map_single(ctodev(card), descr,
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900232 GELIC_DESCR_SIZE,
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900233 DMA_BIDIRECTIONAL);
234
235 if (!descr->bus_addr)
236 goto iommu_error;
237
238 descr->next = descr + 1;
239 descr->prev = descr - 1;
240 }
241 /* make them as ring */
242 (descr - 1)->next = start_descr;
243 start_descr->prev = (descr - 1);
244
245 /* chain bus addr of hw descriptor */
246 descr = start_descr;
247 for (i = 0; i < no; i++, descr++) {
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900248 descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900249 }
250
251 chain->head = start_descr;
252 chain->tail = start_descr;
253
254 /* do not chain last hw descriptor */
255 (descr - 1)->next_descr_addr = 0;
256
257 return 0;
258
259iommu_error:
260 for (i--, descr--; 0 <= i; i--, descr--)
261 if (descr->bus_addr)
262 dma_unmap_single(ctodev(card), descr->bus_addr,
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900263 GELIC_DESCR_SIZE,
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900264 DMA_BIDIRECTIONAL);
265 return -ENOMEM;
266}
267
268/**
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900269 * gelic_card_reset_chain - reset status of a descriptor chain
270 * @card: card structure
271 * @chain: address of chain
272 * @start_descr: address of descriptor array
273 *
274 * Reset the status of dma descriptors to ready state
275 * and re-initialize the hardware chain for later use
276 */
277static void gelic_card_reset_chain(struct gelic_card *card,
278 struct gelic_descr_chain *chain,
279 struct gelic_descr *start_descr)
280{
281 struct gelic_descr *descr;
282
283 for (descr = start_descr; start_descr != descr->next; descr++) {
284 gelic_descr_set_status(descr, GELIC_DESCR_DMA_CARDOWNED);
285 descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr);
286 }
287
288 chain->head = start_descr;
289 chain->tail = (descr - 1);
290
291 (descr - 1)->next_descr_addr = 0;
292}
293/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900294 * gelic_descr_prepare_rx - reinitializes a rx descriptor
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900295 * @card: card structure
296 * @descr: descriptor to re-init
297 *
298 * return 0 on succes, <0 on failure
299 *
300 * allocates a new rx skb, iommu-maps it and attaches it to the descriptor.
301 * Activate the descriptor state-wise
302 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900303static int gelic_descr_prepare_rx(struct gelic_card *card,
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900304 struct gelic_descr *descr)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900305{
306 int offset;
307 unsigned int bufsize;
308
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900309 if (gelic_descr_get_status(descr) != GELIC_DESCR_DMA_NOT_IN_USE)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900310 dev_info(ctodev(card), "%s: ERROR status \n", __func__);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900311 /* we need to round up the buffer size to a multiple of 128 */
312 bufsize = ALIGN(GELIC_NET_MAX_MTU, GELIC_NET_RXBUF_ALIGN);
313
314 /* and we need to have it 128 byte aligned, therefore we allocate a
315 * bit more */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900316 descr->skb = dev_alloc_skb(bufsize + GELIC_NET_RXBUF_ALIGN - 1);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900317 if (!descr->skb) {
318 descr->buf_addr = 0; /* tell DMAC don't touch memory */
319 dev_info(ctodev(card),
320 "%s:allocate skb failed !!\n", __func__);
321 return -ENOMEM;
322 }
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900323 descr->buf_size = cpu_to_be32(bufsize);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900324 descr->dmac_cmd_status = 0;
325 descr->result_size = 0;
326 descr->valid_size = 0;
327 descr->data_error = 0;
328
329 offset = ((unsigned long)descr->skb->data) &
330 (GELIC_NET_RXBUF_ALIGN - 1);
331 if (offset)
332 skb_reserve(descr->skb, GELIC_NET_RXBUF_ALIGN - offset);
333 /* io-mmu-map the skb */
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900334 descr->buf_addr = cpu_to_be32(dma_map_single(ctodev(card),
335 descr->skb->data,
336 GELIC_NET_MAX_MTU,
337 DMA_FROM_DEVICE));
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900338 if (!descr->buf_addr) {
339 dev_kfree_skb_any(descr->skb);
340 descr->skb = NULL;
341 dev_info(ctodev(card),
342 "%s:Could not iommu-map rx buffer\n", __func__);
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900343 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900344 return -ENOMEM;
345 } else {
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900346 gelic_descr_set_status(descr, GELIC_DESCR_DMA_CARDOWNED);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900347 return 0;
348 }
349}
350
351/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900352 * gelic_card_release_rx_chain - free all skb of rx descr
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900353 * @card: card structure
354 *
355 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900356static void gelic_card_release_rx_chain(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900357{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900358 struct gelic_descr *descr = card->rx_chain.head;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900359
360 do {
361 if (descr->skb) {
362 dma_unmap_single(ctodev(card),
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900363 be32_to_cpu(descr->buf_addr),
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900364 descr->skb->len,
365 DMA_FROM_DEVICE);
366 descr->buf_addr = 0;
367 dev_kfree_skb_any(descr->skb);
368 descr->skb = NULL;
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900369 gelic_descr_set_status(descr,
370 GELIC_DESCR_DMA_NOT_IN_USE);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900371 }
372 descr = descr->next;
373 } while (descr != card->rx_chain.head);
374}
375
376/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900377 * gelic_card_fill_rx_chain - fills descriptors/skbs in the rx chains
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900378 * @card: card structure
379 *
380 * fills all descriptors in the rx chain: allocates skbs
381 * and iommu-maps them.
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900382 * returns 0 on success, < 0 on failure
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900383 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900384static int gelic_card_fill_rx_chain(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900385{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900386 struct gelic_descr *descr = card->rx_chain.head;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900387 int ret;
388
389 do {
390 if (!descr->skb) {
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900391 ret = gelic_descr_prepare_rx(card, descr);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900392 if (ret)
393 goto rewind;
394 }
395 descr = descr->next;
396 } while (descr != card->rx_chain.head);
397
398 return 0;
399rewind:
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900400 gelic_card_release_rx_chain(card);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900401 return ret;
402}
403
404/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900405 * gelic_card_alloc_rx_skbs - allocates rx skbs in rx descriptor chains
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900406 * @card: card structure
407 *
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900408 * returns 0 on success, < 0 on failure
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900409 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900410static int gelic_card_alloc_rx_skbs(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900411{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900412 struct gelic_descr_chain *chain;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900413 int ret;
414 chain = &card->rx_chain;
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900415 ret = gelic_card_fill_rx_chain(card);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900416 chain->tail = card->rx_top->prev; /* point to the last */
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900417 return ret;
418}
419
420/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900421 * gelic_descr_release_tx - processes a used tx descriptor
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900422 * @card: card structure
423 * @descr: descriptor to release
424 *
425 * releases a used tx descriptor (unmapping, freeing of skb)
426 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900427static void gelic_descr_release_tx(struct gelic_card *card,
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900428 struct gelic_descr *descr)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900429{
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900430 struct sk_buff *skb = descr->skb;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900431
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900432 BUG_ON(!(be32_to_cpu(descr->data_status) & GELIC_DESCR_TX_TAIL));
433
434 dma_unmap_single(ctodev(card), be32_to_cpu(descr->buf_addr), skb->len,
435 DMA_TO_DEVICE);
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900436 dev_kfree_skb_any(skb);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900437
438 descr->buf_addr = 0;
439 descr->buf_size = 0;
440 descr->next_descr_addr = 0;
441 descr->result_size = 0;
442 descr->valid_size = 0;
443 descr->data_status = 0;
444 descr->data_error = 0;
445 descr->skb = NULL;
446
447 /* set descr status */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900448 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900449}
450
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900451static void gelic_card_stop_queues(struct gelic_card *card)
452{
453 netif_stop_queue(card->netdev[GELIC_PORT_ETHERNET]);
454
455 if (card->netdev[GELIC_PORT_WIRELESS])
456 netif_stop_queue(card->netdev[GELIC_PORT_WIRELESS]);
457}
458static void gelic_card_wake_queues(struct gelic_card *card)
459{
460 netif_wake_queue(card->netdev[GELIC_PORT_ETHERNET]);
461
462 if (card->netdev[GELIC_PORT_WIRELESS])
463 netif_wake_queue(card->netdev[GELIC_PORT_WIRELESS]);
464}
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900465/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900466 * gelic_card_release_tx_chain - processes sent tx descriptors
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900467 * @card: adapter structure
468 * @stop: net_stop sequence
469 *
470 * releases the tx descriptors that gelic has finished with
471 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900472static void gelic_card_release_tx_chain(struct gelic_card *card, int stop)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900473{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900474 struct gelic_descr_chain *tx_chain;
475 enum gelic_descr_dma_status status;
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900476 struct net_device *netdev;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900477 int release = 0;
478
479 for (tx_chain = &card->tx_chain;
480 tx_chain->head != tx_chain->tail && tx_chain->tail;
481 tx_chain->tail = tx_chain->tail->next) {
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900482 status = gelic_descr_get_status(tx_chain->tail);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900483 netdev = tx_chain->tail->skb->dev;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900484 switch (status) {
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900485 case GELIC_DESCR_DMA_RESPONSE_ERROR:
486 case GELIC_DESCR_DMA_PROTECTION_ERROR:
487 case GELIC_DESCR_DMA_FORCE_END:
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900488 if (printk_ratelimit())
489 dev_info(ctodev(card),
490 "%s: forcing end of tx descriptor " \
491 "with status %x\n",
492 __func__, status);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900493 netdev->stats.tx_dropped++;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900494 break;
495
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900496 case GELIC_DESCR_DMA_COMPLETE:
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900497 if (tx_chain->tail->skb) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900498 netdev->stats.tx_packets++;
499 netdev->stats.tx_bytes +=
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900500 tx_chain->tail->skb->len;
501 }
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900502 break;
503
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900504 case GELIC_DESCR_DMA_CARDOWNED:
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900505 /* pending tx request */
506 default:
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900507 /* any other value (== GELIC_DESCR_DMA_NOT_IN_USE) */
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900508 if (!stop)
509 goto out;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900510 }
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900511 gelic_descr_release_tx(card, tx_chain->tail);
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900512 release ++;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900513 }
514out:
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900515 if (!stop && release)
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900516 gelic_card_wake_queues(card);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900517}
518
519/**
520 * gelic_net_set_multi - sets multicast addresses and promisc flags
521 * @netdev: interface device structure
522 *
523 * gelic_net_set_multi configures multicast addresses as needed for the
524 * netdev interface. It also sets up multicast, allmulti and promisc
525 * flags appropriately
526 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900527void gelic_net_set_multi(struct net_device *netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900528{
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900529 struct gelic_card *card = netdev_card(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900530 struct dev_mc_list *mc;
531 unsigned int i;
532 uint8_t *p;
533 u64 addr;
534 int status;
535
536 /* clear all multicast address */
537 status = lv1_net_remove_multicast_address(bus_id(card), dev_id(card),
538 0, 1);
539 if (status)
540 dev_err(ctodev(card),
541 "lv1_net_remove_multicast_address failed %d\n",
542 status);
543 /* set broadcast address */
544 status = lv1_net_add_multicast_address(bus_id(card), dev_id(card),
545 GELIC_NET_BROADCAST_ADDR, 0);
546 if (status)
547 dev_err(ctodev(card),
548 "lv1_net_add_multicast_address failed, %d\n",
549 status);
550
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900551 if ((netdev->flags & IFF_ALLMULTI) ||
552 (netdev->mc_count > GELIC_NET_MC_COUNT_MAX)) {
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900553 status = lv1_net_add_multicast_address(bus_id(card),
554 dev_id(card),
555 0, 1);
556 if (status)
557 dev_err(ctodev(card),
558 "lv1_net_add_multicast_address failed, %d\n",
559 status);
560 return;
561 }
562
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900563 /* set multicast addresses */
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900564 for (mc = netdev->mc_list; mc; mc = mc->next) {
565 addr = 0;
566 p = mc->dmi_addr;
567 for (i = 0; i < ETH_ALEN; i++) {
568 addr <<= 8;
569 addr |= *p++;
570 }
571 status = lv1_net_add_multicast_address(bus_id(card),
572 dev_id(card),
573 addr, 0);
574 if (status)
575 dev_err(ctodev(card),
576 "lv1_net_add_multicast_address failed, %d\n",
577 status);
578 }
579}
580
581/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900582 * gelic_card_enable_rxdmac - enables the receive DMA controller
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900583 * @card: card structure
584 *
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900585 * gelic_card_enable_rxdmac enables the DMA controller by setting RX_DMA_EN
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900586 * in the GDADMACCNTR register
587 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900588static inline void gelic_card_enable_rxdmac(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900589{
590 int status;
591
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900592#ifdef DEBUG
593 if (gelic_descr_get_status(card->rx_chain.head) !=
594 GELIC_DESCR_DMA_CARDOWNED) {
595 printk(KERN_ERR "%s: status=%x\n", __func__,
596 be32_to_cpu(card->rx_chain.head->dmac_cmd_status));
597 printk(KERN_ERR "%s: nextphy=%x\n", __func__,
598 be32_to_cpu(card->rx_chain.head->next_descr_addr));
599 printk(KERN_ERR "%s: head=%p\n", __func__,
600 card->rx_chain.head);
601 }
602#endif
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900603 status = lv1_net_start_rx_dma(bus_id(card), dev_id(card),
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900604 card->rx_chain.head->bus_addr, 0);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900605 if (status)
606 dev_info(ctodev(card),
607 "lv1_net_start_rx_dma failed, status=%d\n", status);
608}
609
610/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900611 * gelic_card_disable_rxdmac - disables the receive DMA controller
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900612 * @card: card structure
613 *
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900614 * gelic_card_disable_rxdmac terminates processing on the DMA controller by
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900615 * turing off DMA and issueing a force end
616 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900617static inline void gelic_card_disable_rxdmac(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900618{
619 int status;
620
621 /* this hvc blocks until the DMA in progress really stopped */
622 status = lv1_net_stop_rx_dma(bus_id(card), dev_id(card), 0);
623 if (status)
624 dev_err(ctodev(card),
625 "lv1_net_stop_rx_dma faild, %d\n", status);
626}
627
628/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900629 * gelic_card_disable_txdmac - disables the transmit DMA controller
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900630 * @card: card structure
631 *
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900632 * gelic_card_disable_txdmac terminates processing on the DMA controller by
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900633 * turing off DMA and issueing a force end
634 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900635static inline void gelic_card_disable_txdmac(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900636{
637 int status;
638
639 /* this hvc blocks until the DMA in progress really stopped */
640 status = lv1_net_stop_tx_dma(bus_id(card), dev_id(card), 0);
641 if (status)
642 dev_err(ctodev(card),
643 "lv1_net_stop_tx_dma faild, status=%d\n", status);
644}
645
646/**
647 * gelic_net_stop - called upon ifconfig down
648 * @netdev: interface device structure
649 *
650 * always returns 0
651 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900652int gelic_net_stop(struct net_device *netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900653{
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900654 struct gelic_card *card;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900655
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900656 pr_debug("%s: start\n", __func__);
657
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900658 netif_stop_queue(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900659 netif_carrier_off(netdev);
660
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900661 card = netdev_card(netdev);
662 gelic_card_down(card);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900663
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900664 pr_debug("%s: done\n", __func__);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900665 return 0;
666}
667
668/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900669 * gelic_card_get_next_tx_descr - returns the next available tx descriptor
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900670 * @card: device structure to get descriptor from
671 *
672 * returns the address of the next descriptor, or NULL if not available.
673 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900674static struct gelic_descr *
675gelic_card_get_next_tx_descr(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900676{
677 if (!card->tx_chain.head)
678 return NULL;
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900679 /* see if the next descriptor is free */
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900680 if (card->tx_chain.tail != card->tx_chain.head->next &&
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900681 gelic_descr_get_status(card->tx_chain.head) ==
682 GELIC_DESCR_DMA_NOT_IN_USE)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900683 return card->tx_chain.head;
684 else
685 return NULL;
686
687}
688
689/**
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900690 * gelic_net_set_txdescr_cmdstat - sets the tx descriptor command field
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900691 * @descr: descriptor structure to fill out
692 * @skb: packet to consider
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900693 *
694 * fills out the command and status field of the descriptor structure,
695 * depending on hardware checksum settings. This function assumes a wmb()
696 * has executed before.
697 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900698static void gelic_descr_set_tx_cmdstat(struct gelic_descr *descr,
699 struct sk_buff *skb)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900700{
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900701 if (skb->ip_summed != CHECKSUM_PARTIAL)
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900702 descr->dmac_cmd_status =
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900703 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM |
704 GELIC_DESCR_TX_DMA_FRAME_TAIL);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900705 else {
706 /* is packet ip?
707 * if yes: tcp? udp? */
708 if (skb->protocol == htons(ETH_P_IP)) {
709 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
710 descr->dmac_cmd_status =
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900711 cpu_to_be32(GELIC_DESCR_DMA_CMD_TCP_CHKSUM |
712 GELIC_DESCR_TX_DMA_FRAME_TAIL);
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900713
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900714 else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
715 descr->dmac_cmd_status =
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900716 cpu_to_be32(GELIC_DESCR_DMA_CMD_UDP_CHKSUM |
717 GELIC_DESCR_TX_DMA_FRAME_TAIL);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900718 else /*
719 * the stack should checksum non-tcp and non-udp
720 * packets on his own: NETIF_F_IP_CSUM
721 */
722 descr->dmac_cmd_status =
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900723 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM |
724 GELIC_DESCR_TX_DMA_FRAME_TAIL);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900725 }
726 }
727}
728
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900729static inline struct sk_buff *gelic_put_vlan_tag(struct sk_buff *skb,
730 unsigned short tag)
731{
732 struct vlan_ethhdr *veth;
733 static unsigned int c;
734
735 if (skb_headroom(skb) < VLAN_HLEN) {
736 struct sk_buff *sk_tmp = skb;
737 pr_debug("%s: hd=%d c=%ud\n", __func__, skb_headroom(skb), c);
738 skb = skb_realloc_headroom(sk_tmp, VLAN_HLEN);
739 if (!skb)
740 return NULL;
741 dev_kfree_skb_any(sk_tmp);
742 }
743 veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
744
745 /* Move the mac addresses to the top of buffer */
746 memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
747
748 veth->h_vlan_proto = __constant_htons(ETH_P_8021Q);
749 veth->h_vlan_TCI = htons(tag);
750
751 return skb;
752}
753
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900754/**
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900755 * gelic_descr_prepare_tx - setup a descriptor for sending packets
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900756 * @card: card structure
757 * @descr: descriptor structure
758 * @skb: packet to use
759 *
760 * returns 0 on success, <0 on failure.
761 *
762 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900763static int gelic_descr_prepare_tx(struct gelic_card *card,
764 struct gelic_descr *descr,
765 struct sk_buff *skb)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900766{
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900767 dma_addr_t buf;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900768
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900769 if (card->vlan_required) {
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900770 struct sk_buff *skb_tmp;
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900771 enum gelic_port_type type;
772
773 type = netdev_port(skb->dev)->type;
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900774 skb_tmp = gelic_put_vlan_tag(skb,
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900775 card->vlan[type].tx);
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900776 if (!skb_tmp)
777 return -ENOMEM;
778 skb = skb_tmp;
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900779 }
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900780
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900781 buf = dma_map_single(ctodev(card), skb->data, skb->len, DMA_TO_DEVICE);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900782
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900783 if (!buf) {
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900784 dev_err(ctodev(card),
785 "dma map 2 failed (%p, %i). Dropping packet\n",
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900786 skb->data, skb->len);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900787 return -ENOMEM;
788 }
789
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900790 descr->buf_addr = cpu_to_be32(buf);
791 descr->buf_size = cpu_to_be32(skb->len);
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900792 descr->skb = skb;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900793 descr->data_status = 0;
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900794 descr->next_descr_addr = 0; /* terminate hw descr */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900795 gelic_descr_set_tx_cmdstat(descr, skb);
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900796
797 /* bump free descriptor pointer */
Masakazu Mokuno173261e2007-08-31 22:22:32 +0900798 card->tx_chain.head = descr->next;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900799 return 0;
800}
801
802/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900803 * gelic_card_kick_txdma - enables TX DMA processing
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900804 * @card: card structure
805 * @descr: descriptor address to enable TX processing at
806 *
807 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900808static int gelic_card_kick_txdma(struct gelic_card *card,
809 struct gelic_descr *descr)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900810{
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900811 int status = 0;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900812
813 if (card->tx_dma_progress)
814 return 0;
815
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900816 if (gelic_descr_get_status(descr) == GELIC_DESCR_DMA_CARDOWNED) {
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900817 card->tx_dma_progress = 1;
Masakazu Mokunodc029ad2007-08-31 22:25:09 +0900818 status = lv1_net_start_tx_dma(bus_id(card), dev_id(card),
819 descr->bus_addr, 0);
820 if (status)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900821 dev_info(ctodev(card), "lv1_net_start_txdma failed," \
Masakazu Mokunodc029ad2007-08-31 22:25:09 +0900822 "status=%d\n", status);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900823 }
824 return status;
825}
826
827/**
828 * gelic_net_xmit - transmits a frame over the device
829 * @skb: packet to send out
830 * @netdev: interface device structure
831 *
832 * returns 0 on success, <0 on failure
833 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900834int gelic_net_xmit(struct sk_buff *skb, struct net_device *netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900835{
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900836 struct gelic_card *card = netdev_card(netdev);
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900837 struct gelic_descr *descr;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900838 int result;
839 unsigned long flags;
840
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900841 spin_lock_irqsave(&card->tx_lock, flags);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900842
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900843 gelic_card_release_tx_chain(card, 0);
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900844
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900845 descr = gelic_card_get_next_tx_descr(card);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900846 if (!descr) {
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900847 /*
848 * no more descriptors free
849 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900850 gelic_card_stop_queues(card);
851 spin_unlock_irqrestore(&card->tx_lock, flags);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900852 return NETDEV_TX_BUSY;
853 }
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900854
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900855 result = gelic_descr_prepare_tx(card, descr, skb);
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900856 if (result) {
857 /*
858 * DMA map failed. As chanses are that failure
859 * would continue, just release skb and return
860 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900861 netdev->stats.tx_dropped++;
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900862 dev_kfree_skb_any(skb);
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900863 spin_unlock_irqrestore(&card->tx_lock, flags);
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900864 return NETDEV_TX_OK;
865 }
866 /*
867 * link this prepared descriptor to previous one
868 * to achieve high performance
869 */
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900870 descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900871 /*
872 * as hardware descriptor is modified in the above lines,
873 * ensure that the hardware sees it
874 */
875 wmb();
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900876 if (gelic_card_kick_txdma(card, descr)) {
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900877 /*
878 * kick failed.
879 * release descriptors which were just prepared
880 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900881 netdev->stats.tx_dropped++;
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900882 gelic_descr_release_tx(card, descr);
883 gelic_descr_release_tx(card, descr->next);
Masakazu Mokuno48544cc262007-07-20 17:24:56 +0900884 card->tx_chain.tail = descr->next->next;
885 dev_info(ctodev(card), "%s: kick failure\n", __func__);
886 } else {
887 /* OK, DMA started/reserved */
888 netdev->trans_start = jiffies;
889 }
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900890
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900891 spin_unlock_irqrestore(&card->tx_lock, flags);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900892 return NETDEV_TX_OK;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900893}
894
895/**
896 * gelic_net_pass_skb_up - takes an skb from a descriptor and passes it on
897 * @descr: descriptor to process
898 * @card: card structure
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900899 * @netdev: net_device structure to be passed packet
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900900 *
901 * iommu-unmaps the skb, fills out skb structure and passes the data to the
902 * stack. The descriptor state is not changed.
903 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900904static void gelic_net_pass_skb_up(struct gelic_descr *descr,
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900905 struct gelic_card *card,
906 struct net_device *netdev)
907
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900908{
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900909 struct sk_buff *skb = descr->skb;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900910 u32 data_status, data_error;
911
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900912 data_status = be32_to_cpu(descr->data_status);
913 data_error = be32_to_cpu(descr->data_error);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900914 /* unmap skb buffer */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900915 dma_unmap_single(ctodev(card), be32_to_cpu(descr->buf_addr),
916 GELIC_NET_MAX_MTU,
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900917 DMA_FROM_DEVICE);
918
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900919 skb_put(skb, be32_to_cpu(descr->valid_size)?
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900920 be32_to_cpu(descr->valid_size) :
921 be32_to_cpu(descr->result_size));
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900922 if (!descr->valid_size)
923 dev_info(ctodev(card), "buffer full %x %x %x\n",
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900924 be32_to_cpu(descr->result_size),
925 be32_to_cpu(descr->buf_size),
926 be32_to_cpu(descr->dmac_cmd_status));
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900927
928 descr->skb = NULL;
929 /*
930 * the card put 2 bytes vlan tag in front
931 * of the ethernet frame
932 */
933 skb_pull(skb, 2);
934 skb->protocol = eth_type_trans(skb, netdev);
935
936 /* checksum offload */
937 if (card->rx_csum) {
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900938 if ((data_status & GELIC_DESCR_DATA_STATUS_CHK_MASK) &&
939 (!(data_error & GELIC_DESCR_DATA_ERROR_CHK_MASK)))
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900940 skb->ip_summed = CHECKSUM_UNNECESSARY;
941 else
942 skb->ip_summed = CHECKSUM_NONE;
943 } else
944 skb->ip_summed = CHECKSUM_NONE;
945
946 /* update netdevice statistics */
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900947 netdev->stats.rx_packets++;
948 netdev->stats.rx_bytes += skb->len;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900949
950 /* pass skb up to stack */
951 netif_receive_skb(skb);
952}
953
954/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900955 * gelic_card_decode_one_descr - processes an rx descriptor
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900956 * @card: card structure
957 *
958 * returns 1 if a packet has been sent to the stack, otherwise 0
959 *
960 * processes an rx descriptor by iommu-unmapping the data buffer and passing
961 * the packet up to the stack
962 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900963static int gelic_card_decode_one_descr(struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900964{
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900965 enum gelic_descr_dma_status status;
966 struct gelic_descr_chain *chain = &card->rx_chain;
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900967 struct gelic_descr *descr = chain->head;
968 struct net_device *netdev = NULL;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900969 int dmac_chain_ended;
970
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900971 status = gelic_descr_get_status(descr);
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900972 /* is this descriptor terminated with next_descr == NULL? */
973 dmac_chain_ended =
Masakazu Mokuno100e1d82008-02-07 19:57:54 +0900974 be32_to_cpu(descr->dmac_cmd_status) &
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900975 GELIC_DESCR_RX_DMA_CHAIN_END;
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900976
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900977 if (status == GELIC_DESCR_DMA_CARDOWNED)
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900978 return 0;
979
Masakazu Mokuno59e97322008-02-07 19:58:08 +0900980 if (status == GELIC_DESCR_DMA_NOT_IN_USE) {
Masakazu Mokuno02c18892007-07-05 20:11:16 +0900981 dev_dbg(ctodev(card), "dormant descr? %p\n", descr);
982 return 0;
983 }
984
Masakazu Mokuno589866f2008-02-07 19:58:42 +0900985 /* netdevice select */
986 if (card->vlan_required) {
987 unsigned int i;
988 u16 vid;
989 vid = *(u16 *)(descr->skb->data) & VLAN_VID_MASK;
990 for (i = 0; i < GELIC_PORT_MAX; i++) {
991 if (card->vlan[i].rx == vid) {
992 netdev = card->netdev[i];
993 break;
994 }
995 };
996 if (GELIC_PORT_MAX <= i) {
997 pr_info("%s: unknown packet vid=%x\n", __func__, vid);
998 goto refill;
999 }
1000 } else
1001 netdev = card->netdev[GELIC_PORT_ETHERNET];
1002
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001003 if ((status == GELIC_DESCR_DMA_RESPONSE_ERROR) ||
1004 (status == GELIC_DESCR_DMA_PROTECTION_ERROR) ||
1005 (status == GELIC_DESCR_DMA_FORCE_END)) {
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001006 dev_info(ctodev(card), "dropping RX descriptor with state %x\n",
1007 status);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001008 netdev->stats.rx_dropped++;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001009 goto refill;
1010 }
1011
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001012 if (status == GELIC_DESCR_DMA_BUFFER_FULL) {
Masakazu Mokunofe6d3a42007-07-20 17:39:25 +09001013 /*
1014 * Buffer full would occur if and only if
1015 * the frame length was longer than the size of this
1016 * descriptor's buffer. If the frame length was equal
1017 * to or shorter than buffer'size, FRAME_END condition
1018 * would occur.
1019 * Anyway this frame was longer than the MTU,
1020 * just drop it.
1021 */
1022 dev_info(ctodev(card), "overlength frame\n");
1023 goto refill;
1024 }
1025 /*
1026 * descriptoers any other than FRAME_END here should
1027 * be treated as error.
1028 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001029 if (status != GELIC_DESCR_DMA_FRAME_END) {
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001030 dev_dbg(ctodev(card), "RX descriptor with state %x\n",
1031 status);
1032 goto refill;
1033 }
1034
1035 /* ok, we've got a packet in descr */
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001036 gelic_net_pass_skb_up(descr, card, netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001037refill:
Masakazu Mokunofe6d3a42007-07-20 17:39:25 +09001038 /*
1039 * So that always DMAC can see the end
1040 * of the descriptor chain to avoid
1041 * from unwanted DMAC overrun.
1042 */
1043 descr->next_descr_addr = 0;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001044
1045 /* change the descriptor state: */
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001046 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001047
Masakazu Mokunofe6d3a42007-07-20 17:39:25 +09001048 /*
1049 * this call can fail, but for now, just leave this
1050 * decriptor without skb
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001051 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001052 gelic_descr_prepare_rx(card, descr);
Masakazu Mokunofe6d3a42007-07-20 17:39:25 +09001053
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001054 chain->tail = descr;
1055 chain->head = descr->next;
Masakazu Mokunofe6d3a42007-07-20 17:39:25 +09001056
1057 /*
1058 * Set this descriptor the end of the chain.
1059 */
Masakazu Mokuno100e1d82008-02-07 19:57:54 +09001060 descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001061
Masakazu Mokunofe6d3a42007-07-20 17:39:25 +09001062 /*
1063 * If dmac chain was met, DMAC stopped.
1064 * thus re-enable it
1065 */
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001066 if (dmac_chain_ended) {
Masakazu Mokuno583aae12007-07-20 17:35:54 +09001067 card->rx_dma_restart_required = 1;
1068 dev_dbg(ctodev(card), "reenable rx dma scheduled\n");
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001069 }
1070
1071 return 1;
1072}
1073
1074/**
1075 * gelic_net_poll - NAPI poll function called by the stack to return packets
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001076 * @napi: napi structure
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001077 * @budget: number of packets we can pass to the stack at most
1078 *
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001079 * returns the number of the processed packets
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001080 *
1081 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001082static int gelic_net_poll(struct napi_struct *napi, int budget)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001083{
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001084 struct gelic_card *card = container_of(napi, struct gelic_card, napi);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001085 int packets_done = 0;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001086
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001087 while (packets_done < budget) {
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001088 if (!gelic_card_decode_one_descr(card))
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001089 break;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001090
1091 packets_done++;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001092 }
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001093
1094 if (packets_done < budget) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001095 napi_complete(napi);
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001096 gelic_card_rx_irq_on(card);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001097 }
1098 return packets_done;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001099}
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001100/**
1101 * gelic_net_change_mtu - changes the MTU of an interface
1102 * @netdev: interface device structure
1103 * @new_mtu: new MTU value
1104 *
1105 * returns 0 on success, <0 on failure
1106 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001107int gelic_net_change_mtu(struct net_device *netdev, int new_mtu)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001108{
1109 /* no need to re-alloc skbs or so -- the max mtu is about 2.3k
1110 * and mtu is outbound only anyway */
1111 if ((new_mtu < GELIC_NET_MIN_MTU) ||
1112 (new_mtu > GELIC_NET_MAX_MTU)) {
1113 return -EINVAL;
1114 }
1115 netdev->mtu = new_mtu;
1116 return 0;
1117}
1118
1119/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001120 * gelic_card_interrupt - event handler for gelic_net
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001121 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001122static irqreturn_t gelic_card_interrupt(int irq, void *ptr)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001123{
1124 unsigned long flags;
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001125 struct gelic_card *card = ptr;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001126 u64 status;
1127
1128 status = card->irq_status;
1129
1130 if (!status)
1131 return IRQ_NONE;
1132
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001133 status &= card->irq_mask;
1134
Masakazu Mokuno583aae12007-07-20 17:35:54 +09001135 if (card->rx_dma_restart_required) {
1136 card->rx_dma_restart_required = 0;
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001137 gelic_card_enable_rxdmac(card);
Masakazu Mokuno583aae12007-07-20 17:35:54 +09001138 }
1139
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001140 if (status & GELIC_CARD_RXINT) {
1141 gelic_card_rx_irq_off(card);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001142 napi_schedule(&card->napi);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001143 }
1144
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001145 if (status & GELIC_CARD_TXINT) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001146 spin_lock_irqsave(&card->tx_lock, flags);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001147 card->tx_dma_progress = 0;
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001148 gelic_card_release_tx_chain(card, 0);
Masakazu Mokuno48544cc262007-07-20 17:24:56 +09001149 /* kick outstanding tx descriptor if any */
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001150 gelic_card_kick_txdma(card, card->tx_chain.tail);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001151 spin_unlock_irqrestore(&card->tx_lock, flags);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001152 }
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +09001153
1154 /* ether port status changed */
1155 if (status & GELIC_CARD_PORT_STATUS_CHANGED)
1156 gelic_card_get_ether_port_status(card, 1);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001157
Masakazu Mokuno09dde542008-02-07 19:58:57 +09001158#ifdef CONFIG_GELIC_WIRELESS
1159 if (status & (GELIC_CARD_WLAN_EVENT_RECEIVED |
1160 GELIC_CARD_WLAN_COMMAND_COMPLETED))
1161 gelic_wl_interrupt(card->netdev[GELIC_PORT_WIRELESS], status);
1162#endif
1163
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001164 return IRQ_HANDLED;
1165}
1166
1167#ifdef CONFIG_NET_POLL_CONTROLLER
1168/**
1169 * gelic_net_poll_controller - artificial interrupt for netconsole etc.
1170 * @netdev: interface device structure
1171 *
1172 * see Documentation/networking/netconsole.txt
1173 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001174void gelic_net_poll_controller(struct net_device *netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001175{
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001176 struct gelic_card *card = netdev_card(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001177
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001178 gelic_card_set_irq_mask(card, 0);
1179 gelic_card_interrupt(netdev->irq, netdev);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001180 gelic_card_set_irq_mask(card, card->irq_mask);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001181}
1182#endif /* CONFIG_NET_POLL_CONTROLLER */
1183
1184/**
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001185 * gelic_net_open - called upon ifonfig up
1186 * @netdev: interface device structure
1187 *
1188 * returns 0 on success, <0 on failure
1189 *
1190 * gelic_net_open allocates all the descriptors and memory needed for
1191 * operation, sets up multicast list and enables interrupts
1192 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001193int gelic_net_open(struct net_device *netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001194{
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001195 struct gelic_card *card = netdev_card(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001196
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001197 dev_dbg(ctodev(card), " -> %s %p\n", __func__, netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001198
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001199 gelic_card_up(card);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001200
1201 netif_start_queue(netdev);
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +09001202 gelic_card_get_ether_port_status(card, 1);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001203
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001204 dev_dbg(ctodev(card), " <- %s\n", __func__);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001205 return 0;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001206}
1207
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001208void gelic_net_get_drvinfo(struct net_device *netdev,
1209 struct ethtool_drvinfo *info)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001210{
1211 strncpy(info->driver, DRV_NAME, sizeof(info->driver) - 1);
1212 strncpy(info->version, DRV_VERSION, sizeof(info->version) - 1);
1213}
1214
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001215static int gelic_ether_get_settings(struct net_device *netdev,
1216 struct ethtool_cmd *cmd)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001217{
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001218 struct gelic_card *card = netdev_card(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001219
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +09001220 gelic_card_get_ether_port_status(card, 0);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001221
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +09001222 if (card->ether_port_status & GELIC_LV1_ETHER_FULL_DUPLEX)
1223 cmd->duplex = DUPLEX_FULL;
1224 else
1225 cmd->duplex = DUPLEX_HALF;
1226
1227 switch (card->ether_port_status & GELIC_LV1_ETHER_SPEED_MASK) {
1228 case GELIC_LV1_ETHER_SPEED_10:
1229 cmd->speed = SPEED_10;
1230 break;
1231 case GELIC_LV1_ETHER_SPEED_100:
1232 cmd->speed = SPEED_100;
1233 break;
1234 case GELIC_LV1_ETHER_SPEED_1000:
1235 cmd->speed = SPEED_1000;
1236 break;
1237 default:
1238 pr_info("%s: speed unknown\n", __func__);
1239 cmd->speed = SPEED_10;
1240 break;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001241 }
Masakazu Mokuno01fed4c2008-02-07 19:58:32 +09001242
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001243 cmd->supported = SUPPORTED_TP | SUPPORTED_Autoneg |
1244 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
1245 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
1246 SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full;
1247 cmd->advertising = cmd->supported;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001248 cmd->autoneg = AUTONEG_ENABLE; /* always enabled */
1249 cmd->port = PORT_TP;
1250
1251 return 0;
1252}
1253
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001254u32 gelic_net_get_rx_csum(struct net_device *netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001255{
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001256 struct gelic_card *card = netdev_card(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001257
1258 return card->rx_csum;
1259}
1260
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001261int gelic_net_set_rx_csum(struct net_device *netdev, u32 data)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001262{
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001263 struct gelic_card *card = netdev_card(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001264
1265 card->rx_csum = data;
1266 return 0;
1267}
1268
Masakazu Mokuno3faac212008-03-27 11:39:31 +11001269static void gelic_net_get_wol(struct net_device *netdev,
1270 struct ethtool_wolinfo *wol)
1271{
1272 if (0 <= ps3_compare_firmware_version(2, 2, 0))
1273 wol->supported = WAKE_MAGIC;
1274 else
1275 wol->supported = 0;
1276
1277 wol->wolopts = ps3_sys_manager_get_wol() ? wol->supported : 0;
1278 memset(&wol->sopass, 0, sizeof(wol->sopass));
1279}
1280static int gelic_net_set_wol(struct net_device *netdev,
1281 struct ethtool_wolinfo *wol)
1282{
1283 int status;
1284 struct gelic_card *card;
1285 u64 v1, v2;
1286
1287 if (ps3_compare_firmware_version(2, 2, 0) < 0 ||
1288 !capable(CAP_NET_ADMIN))
1289 return -EPERM;
1290
1291 if (wol->wolopts & ~WAKE_MAGIC)
1292 return -EINVAL;
1293
1294 card = netdev_card(netdev);
1295 if (wol->wolopts & WAKE_MAGIC) {
1296 status = lv1_net_control(bus_id(card), dev_id(card),
1297 GELIC_LV1_SET_WOL,
1298 GELIC_LV1_WOL_MAGIC_PACKET,
1299 0, GELIC_LV1_WOL_MP_ENABLE,
1300 &v1, &v2);
1301 if (status) {
1302 pr_info("%s: enabling WOL failed %d\n", __func__,
1303 status);
1304 status = -EIO;
1305 goto done;
1306 }
1307 status = lv1_net_control(bus_id(card), dev_id(card),
1308 GELIC_LV1_SET_WOL,
1309 GELIC_LV1_WOL_ADD_MATCH_ADDR,
1310 0, GELIC_LV1_WOL_MATCH_ALL,
1311 &v1, &v2);
1312 if (!status)
1313 ps3_sys_manager_set_wol(1);
1314 else {
1315 pr_info("%s: enabling WOL filter failed %d\n",
1316 __func__, status);
1317 status = -EIO;
1318 }
1319 } else {
1320 status = lv1_net_control(bus_id(card), dev_id(card),
1321 GELIC_LV1_SET_WOL,
1322 GELIC_LV1_WOL_MAGIC_PACKET,
1323 0, GELIC_LV1_WOL_MP_DISABLE,
1324 &v1, &v2);
1325 if (status) {
1326 pr_info("%s: disabling WOL failed %d\n", __func__,
1327 status);
1328 status = -EIO;
1329 goto done;
1330 }
1331 status = lv1_net_control(bus_id(card), dev_id(card),
1332 GELIC_LV1_SET_WOL,
1333 GELIC_LV1_WOL_DELETE_MATCH_ADDR,
1334 0, GELIC_LV1_WOL_MATCH_ALL,
1335 &v1, &v2);
1336 if (!status)
1337 ps3_sys_manager_set_wol(0);
1338 else {
1339 pr_info("%s: removing WOL filter failed %d\n",
1340 __func__, status);
1341 status = -EIO;
1342 }
1343 }
1344done:
1345 return status;
1346}
1347
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001348static struct ethtool_ops gelic_ether_ethtool_ops = {
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001349 .get_drvinfo = gelic_net_get_drvinfo,
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001350 .get_settings = gelic_ether_get_settings,
Masakazu Mokuno7bc56b92008-02-07 19:58:20 +09001351 .get_link = ethtool_op_get_link,
Masakazu Mokuno7bc56b92008-02-07 19:58:20 +09001352 .get_tx_csum = ethtool_op_get_tx_csum,
1353 .set_tx_csum = ethtool_op_set_tx_csum,
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001354 .get_rx_csum = gelic_net_get_rx_csum,
1355 .set_rx_csum = gelic_net_set_rx_csum,
Masakazu Mokuno3faac212008-03-27 11:39:31 +11001356 .get_wol = gelic_net_get_wol,
1357 .set_wol = gelic_net_set_wol,
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001358};
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001359
1360/**
1361 * gelic_net_tx_timeout_task - task scheduled by the watchdog timeout
1362 * function (to be called not under interrupt status)
1363 * @work: work is context of tx timout task
1364 *
1365 * called as task when tx hangs, resets interface (if interface is up)
1366 */
1367static void gelic_net_tx_timeout_task(struct work_struct *work)
1368{
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001369 struct gelic_card *card =
1370 container_of(work, struct gelic_card, tx_timeout_task);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001371 struct net_device *netdev = card->netdev[GELIC_PORT_ETHERNET];
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001372
1373 dev_info(ctodev(card), "%s:Timed out. Restarting... \n", __func__);
1374
1375 if (!(netdev->flags & IFF_UP))
1376 goto out;
1377
1378 netif_device_detach(netdev);
1379 gelic_net_stop(netdev);
1380
1381 gelic_net_open(netdev);
1382 netif_device_attach(netdev);
1383
1384out:
1385 atomic_dec(&card->tx_timeout_task_counter);
1386}
1387
1388/**
1389 * gelic_net_tx_timeout - called when the tx timeout watchdog kicks in.
1390 * @netdev: interface device structure
1391 *
1392 * called, if tx hangs. Schedules a task that resets the interface
1393 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001394void gelic_net_tx_timeout(struct net_device *netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001395{
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001396 struct gelic_card *card;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001397
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001398 card = netdev_card(netdev);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001399 atomic_inc(&card->tx_timeout_task_counter);
1400 if (netdev->flags & IFF_UP)
1401 schedule_work(&card->tx_timeout_task);
1402 else
1403 atomic_dec(&card->tx_timeout_task_counter);
1404}
1405
1406/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001407 * gelic_ether_setup_netdev_ops - initialization of net_device operations
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001408 * @netdev: net_device structure
1409 *
1410 * fills out function pointers in the net_device structure
1411 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001412static void gelic_ether_setup_netdev_ops(struct net_device *netdev,
1413 struct napi_struct *napi)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001414{
1415 netdev->open = &gelic_net_open;
1416 netdev->stop = &gelic_net_stop;
1417 netdev->hard_start_xmit = &gelic_net_xmit;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001418 netdev->set_multicast_list = &gelic_net_set_multi;
1419 netdev->change_mtu = &gelic_net_change_mtu;
1420 /* tx watchdog */
1421 netdev->tx_timeout = &gelic_net_tx_timeout;
1422 netdev->watchdog_timeo = GELIC_NET_WATCHDOG_TIMEOUT;
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001423 /* NAPI */
1424 netif_napi_add(netdev, napi,
1425 gelic_net_poll, GELIC_NET_NAPI_WEIGHT);
1426 netdev->ethtool_ops = &gelic_ether_ethtool_ops;
1427#ifdef CONFIG_NET_POLL_CONTROLLER
1428 netdev->poll_controller = gelic_net_poll_controller;
1429#endif
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001430}
1431
1432/**
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001433 * gelic_ether_setup_netdev - initialization of net_device
1434 * @netdev: net_device structure
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001435 * @card: card structure
1436 *
1437 * Returns 0 on success or <0 on failure
1438 *
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001439 * gelic_ether_setup_netdev initializes the net_device structure
1440 * and register it.
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001441 **/
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001442int gelic_net_setup_netdev(struct net_device *netdev, struct gelic_card *card)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001443{
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001444 int status;
1445 u64 v1, v2;
1446
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001447 netdev->features = NETIF_F_IP_CSUM;
1448
1449 status = lv1_net_control(bus_id(card), dev_id(card),
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001450 GELIC_LV1_GET_MAC_ADDRESS,
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001451 0, 0, 0, &v1, &v2);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001452 v1 <<= 16;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001453 if (status || !is_valid_ether_addr((u8 *)&v1)) {
1454 dev_info(ctodev(card),
1455 "%s:lv1_net_control GET_MAC_ADDR failed %d\n",
1456 __func__, status);
1457 return -EINVAL;
1458 }
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001459 memcpy(netdev->dev_addr, &v1, ETH_ALEN);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001460
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001461 if (card->vlan_required) {
Masakazu Mokuno173261e2007-08-31 22:22:32 +09001462 netdev->hard_header_len += VLAN_HLEN;
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001463 /*
1464 * As vlan is internally used,
1465 * we can not receive vlan packets
1466 */
1467 netdev->features |= NETIF_F_VLAN_CHALLENGED;
Masakazu Mokuno173261e2007-08-31 22:22:32 +09001468 }
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001469
1470 status = register_netdev(netdev);
1471 if (status) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001472 dev_err(ctodev(card), "%s:Couldn't register %s %d\n",
1473 __func__, netdev->name, status);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001474 return status;
1475 }
Johannes Berge1749612008-10-27 15:59:26 -07001476 dev_info(ctodev(card), "%s: MAC addr %pM\n",
1477 netdev->name, netdev->dev_addr);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001478
1479 return 0;
1480}
1481
1482/**
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001483 * gelic_alloc_card_net - allocates net_device and card structure
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001484 *
1485 * returns the card structure or NULL in case of errors
1486 *
1487 * the card and net_device structures are linked to each other
1488 */
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001489#define GELIC_ALIGN (32)
1490static struct gelic_card *gelic_alloc_card_net(struct net_device **netdev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001491{
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001492 struct gelic_card *card;
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001493 struct gelic_port *port;
1494 void *p;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001495 size_t alloc_size;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001496 /*
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001497 * gelic requires dma descriptor is 32 bytes aligned and
1498 * the hypervisor requires irq_status is 8 bytes aligned.
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001499 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001500 BUILD_BUG_ON(offsetof(struct gelic_card, irq_status) % 8);
1501 BUILD_BUG_ON(offsetof(struct gelic_card, descr) % 32);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001502 alloc_size =
1503 sizeof(struct gelic_card) +
1504 sizeof(struct gelic_descr) * GELIC_NET_RX_DESCRIPTORS +
1505 sizeof(struct gelic_descr) * GELIC_NET_TX_DESCRIPTORS +
1506 GELIC_ALIGN - 1;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001507
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001508 p = kzalloc(alloc_size, GFP_KERNEL);
1509 if (!p)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001510 return NULL;
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001511 card = PTR_ALIGN(p, GELIC_ALIGN);
1512 card->unalign = p;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001513
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001514 /*
1515 * alloc netdev
1516 */
1517 *netdev = alloc_etherdev(sizeof(struct gelic_port));
1518 if (!netdev) {
1519 kfree(card->unalign);
1520 return NULL;
1521 }
1522 port = netdev_priv(*netdev);
1523
1524 /* gelic_port */
1525 port->netdev = *netdev;
1526 port->card = card;
1527 port->type = GELIC_PORT_ETHERNET;
1528
1529 /* gelic_card */
1530 card->netdev[GELIC_PORT_ETHERNET] = *netdev;
1531
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001532 INIT_WORK(&card->tx_timeout_task, gelic_net_tx_timeout_task);
1533 init_waitqueue_head(&card->waitq);
1534 atomic_set(&card->tx_timeout_task_counter, 0);
Daniel Walker2914f3e2008-05-22 00:00:03 -07001535 mutex_init(&card->updown_lock);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001536 atomic_set(&card->users, 0);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001537
1538 return card;
1539}
1540
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001541static void gelic_card_get_vlan_info(struct gelic_card *card)
1542{
1543 u64 v1, v2;
1544 int status;
1545 unsigned int i;
1546 struct {
1547 int tx;
1548 int rx;
1549 } vlan_id_ix[2] = {
1550 [GELIC_PORT_ETHERNET] = {
1551 .tx = GELIC_LV1_VLAN_TX_ETHERNET,
1552 .rx = GELIC_LV1_VLAN_RX_ETHERNET
1553 },
1554 [GELIC_PORT_WIRELESS] = {
1555 .tx = GELIC_LV1_VLAN_TX_WIRELESS,
1556 .rx = GELIC_LV1_VLAN_RX_WIRELESS
1557 }
1558 };
1559
1560 for (i = 0; i < ARRAY_SIZE(vlan_id_ix); i++) {
1561 /* tx tag */
1562 status = lv1_net_control(bus_id(card), dev_id(card),
1563 GELIC_LV1_GET_VLAN_ID,
1564 vlan_id_ix[i].tx,
1565 0, 0, &v1, &v2);
1566 if (status || !v1) {
1567 if (status != LV1_NO_ENTRY)
1568 dev_dbg(ctodev(card),
1569 "get vlan id for tx(%d) failed(%d)\n",
1570 vlan_id_ix[i].tx, status);
1571 card->vlan[i].tx = 0;
1572 card->vlan[i].rx = 0;
1573 continue;
1574 }
1575 card->vlan[i].tx = (u16)v1;
1576
1577 /* rx tag */
1578 status = lv1_net_control(bus_id(card), dev_id(card),
1579 GELIC_LV1_GET_VLAN_ID,
1580 vlan_id_ix[i].rx,
1581 0, 0, &v1, &v2);
1582 if (status || !v1) {
1583 if (status != LV1_NO_ENTRY)
1584 dev_info(ctodev(card),
1585 "get vlan id for rx(%d) failed(%d)\n",
1586 vlan_id_ix[i].rx, status);
1587 card->vlan[i].tx = 0;
1588 card->vlan[i].rx = 0;
1589 continue;
1590 }
1591 card->vlan[i].rx = (u16)v1;
1592
1593 dev_dbg(ctodev(card), "vlan_id[%d] tx=%02x rx=%02x\n",
1594 i, card->vlan[i].tx, card->vlan[i].rx);
1595 }
1596
1597 if (card->vlan[GELIC_PORT_ETHERNET].tx) {
1598 BUG_ON(!card->vlan[GELIC_PORT_WIRELESS].tx);
1599 card->vlan_required = 1;
1600 } else
1601 card->vlan_required = 0;
1602
1603 /* check wirelss capable firmware */
1604 if (ps3_compare_firmware_version(1, 6, 0) < 0) {
1605 card->vlan[GELIC_PORT_WIRELESS].tx = 0;
1606 card->vlan[GELIC_PORT_WIRELESS].rx = 0;
1607 }
1608
1609 dev_info(ctodev(card), "internal vlan %s\n",
1610 card->vlan_required? "enabled" : "disabled");
1611}
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001612/**
1613 * ps3_gelic_driver_probe - add a device to the control of this driver
1614 */
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001615static int ps3_gelic_driver_probe(struct ps3_system_bus_device *dev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001616{
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001617 struct gelic_card *card;
1618 struct net_device *netdev;
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001619 int result;
1620
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001621 pr_debug("%s: called\n", __func__);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001622 result = ps3_open_hv_device(dev);
1623
1624 if (result) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001625 dev_dbg(&dev->core, "%s:ps3_open_hv_device failed\n",
1626 __func__);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001627 goto fail_open;
1628 }
1629
1630 result = ps3_dma_region_create(dev->d_region);
1631
1632 if (result) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001633 dev_dbg(&dev->core, "%s:ps3_dma_region_create failed(%d)\n",
1634 __func__, result);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001635 BUG_ON("check region type");
1636 goto fail_dma_region;
1637 }
1638
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001639 /* alloc card/netdevice */
1640 card = gelic_alloc_card_net(&netdev);
1641 if (!card) {
1642 dev_info(&dev->core, "%s:gelic_net_alloc_card failed\n",
1643 __func__);
1644 result = -ENOMEM;
1645 goto fail_alloc_card;
1646 }
1647 ps3_system_bus_set_driver_data(dev, card);
1648 card->dev = dev;
1649
1650 /* get internal vlan info */
1651 gelic_card_get_vlan_info(card);
1652
1653 /* setup interrupt */
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001654 result = lv1_net_set_interrupt_status_indicator(bus_id(card),
1655 dev_id(card),
1656 ps3_mm_phys_to_lpar(__pa(&card->irq_status)),
1657 0);
1658
1659 if (result) {
1660 dev_dbg(&dev->core,
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001661 "%s:set_interrupt_status_indicator failed: %s\n",
1662 __func__, ps3_result(result));
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001663 result = -EIO;
1664 goto fail_status_indicator;
1665 }
1666
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001667 result = ps3_sb_event_receive_port_setup(dev, PS3_BINDING_CPU_ANY,
1668 &card->irq);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001669
1670 if (result) {
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001671 dev_info(ctodev(card),
1672 "%s:gelic_net_open_device failed (%d)\n",
1673 __func__, result);
1674 result = -EPERM;
1675 goto fail_alloc_irq;
1676 }
1677 result = request_irq(card->irq, gelic_card_interrupt,
1678 IRQF_DISABLED, netdev->name, card);
1679
1680 if (result) {
1681 dev_info(ctodev(card), "%s:request_irq failed (%d)\n",
1682 __func__, result);
1683 goto fail_request_irq;
1684 }
1685
1686 /* setup card structure */
1687 card->irq_mask = GELIC_CARD_RXINT | GELIC_CARD_TXINT |
1688 GELIC_CARD_PORT_STATUS_CHANGED;
1689 card->rx_csum = GELIC_CARD_RX_CSUM_DEFAULT;
1690
1691
1692 if (gelic_card_init_chain(card, &card->tx_chain,
1693 card->descr, GELIC_NET_TX_DESCRIPTORS))
1694 goto fail_alloc_tx;
1695 if (gelic_card_init_chain(card, &card->rx_chain,
1696 card->descr + GELIC_NET_TX_DESCRIPTORS,
1697 GELIC_NET_RX_DESCRIPTORS))
1698 goto fail_alloc_rx;
1699
1700 /* head of chain */
1701 card->tx_top = card->tx_chain.head;
1702 card->rx_top = card->rx_chain.head;
1703 dev_dbg(ctodev(card), "descr rx %p, tx %p, size %#lx, num %#x\n",
1704 card->rx_top, card->tx_top, sizeof(struct gelic_descr),
1705 GELIC_NET_RX_DESCRIPTORS);
1706 /* allocate rx skbs */
1707 if (gelic_card_alloc_rx_skbs(card))
1708 goto fail_alloc_skbs;
1709
1710 spin_lock_init(&card->tx_lock);
1711 card->tx_dma_progress = 0;
1712
1713 /* setup net_device structure */
1714 netdev->irq = card->irq;
1715 SET_NETDEV_DEV(netdev, &card->dev->core);
1716 gelic_ether_setup_netdev_ops(netdev, &card->napi);
1717 result = gelic_net_setup_netdev(netdev, card);
1718 if (result) {
1719 dev_dbg(&dev->core, "%s: setup_netdev failed %d",
1720 __func__, result);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001721 goto fail_setup_netdev;
1722 }
1723
Masakazu Mokuno09dde542008-02-07 19:58:57 +09001724#ifdef CONFIG_GELIC_WIRELESS
1725 if (gelic_wl_driver_probe(card)) {
1726 dev_dbg(&dev->core, "%s: WL init failed\n", __func__);
1727 goto fail_setup_netdev;
1728 }
1729#endif
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001730 pr_debug("%s: done\n", __func__);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001731 return 0;
1732
1733fail_setup_netdev:
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001734fail_alloc_skbs:
1735 gelic_card_free_chain(card, card->rx_chain.head);
1736fail_alloc_rx:
1737 gelic_card_free_chain(card, card->tx_chain.head);
1738fail_alloc_tx:
1739 free_irq(card->irq, card);
1740 netdev->irq = NO_IRQ;
1741fail_request_irq:
1742 ps3_sb_event_receive_port_destroy(dev, card->irq);
1743fail_alloc_irq:
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001744 lv1_net_set_interrupt_status_indicator(bus_id(card),
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001745 bus_id(card),
1746 0, 0);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001747fail_status_indicator:
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001748 ps3_system_bus_set_driver_data(dev, NULL);
1749 kfree(netdev_card(netdev)->unalign);
1750 free_netdev(netdev);
1751fail_alloc_card:
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001752 ps3_dma_region_free(dev->d_region);
1753fail_dma_region:
1754 ps3_close_hv_device(dev);
1755fail_open:
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001756 return result;
1757}
1758
1759/**
1760 * ps3_gelic_driver_remove - remove a device from the control of this driver
1761 */
1762
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001763static int ps3_gelic_driver_remove(struct ps3_system_bus_device *dev)
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001764{
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001765 struct gelic_card *card = ps3_system_bus_get_driver_data(dev);
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001766 struct net_device *netdev0;
1767 pr_debug("%s: called\n", __func__);
1768
Masakazu Mokuno09dde542008-02-07 19:58:57 +09001769#ifdef CONFIG_GELIC_WIRELESS
1770 gelic_wl_driver_remove(card);
1771#endif
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001772 /* stop interrupt */
1773 gelic_card_set_irq_mask(card, 0);
1774
1775 /* turn off DMA, force end */
1776 gelic_card_disable_rxdmac(card);
1777 gelic_card_disable_txdmac(card);
1778
1779 /* release chains */
1780 gelic_card_release_tx_chain(card, 1);
1781 gelic_card_release_rx_chain(card);
1782
1783 gelic_card_free_chain(card, card->tx_top);
1784 gelic_card_free_chain(card, card->rx_top);
1785
1786 netdev0 = card->netdev[GELIC_PORT_ETHERNET];
1787 /* disconnect event port */
1788 free_irq(card->irq, card);
1789 netdev0->irq = NO_IRQ;
1790 ps3_sb_event_receive_port_destroy(card->dev, card->irq);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001791
1792 wait_event(card->waitq,
1793 atomic_read(&card->tx_timeout_task_counter) == 0);
1794
1795 lv1_net_set_interrupt_status_indicator(bus_id(card), dev_id(card),
1796 0 , 0);
1797
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001798 unregister_netdev(netdev0);
1799 kfree(netdev_card(netdev0)->unalign);
1800 free_netdev(netdev0);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001801
1802 ps3_system_bus_set_driver_data(dev, NULL);
1803
1804 ps3_dma_region_free(dev->d_region);
1805
1806 ps3_close_hv_device(dev);
1807
Masakazu Mokuno589866f2008-02-07 19:58:42 +09001808 pr_debug("%s: done\n", __func__);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001809 return 0;
1810}
1811
1812static struct ps3_system_bus_driver ps3_gelic_driver = {
1813 .match_id = PS3_MATCH_ID_GELIC,
1814 .probe = ps3_gelic_driver_probe,
1815 .remove = ps3_gelic_driver_remove,
1816 .shutdown = ps3_gelic_driver_remove,
1817 .core.name = "ps3_gelic_driver",
1818 .core.owner = THIS_MODULE,
1819};
1820
1821static int __init ps3_gelic_driver_init (void)
1822{
1823 return firmware_has_feature(FW_FEATURE_PS3_LV1)
1824 ? ps3_system_bus_driver_register(&ps3_gelic_driver)
1825 : -ENODEV;
1826}
1827
1828static void __exit ps3_gelic_driver_exit (void)
1829{
1830 ps3_system_bus_driver_unregister(&ps3_gelic_driver);
1831}
1832
Masakazu Mokuno59e97322008-02-07 19:58:08 +09001833module_init(ps3_gelic_driver_init);
1834module_exit(ps3_gelic_driver_exit);
Masakazu Mokuno02c18892007-07-05 20:11:16 +09001835
1836MODULE_ALIAS(PS3_MODULE_ALIAS_GELIC);
1837