1 /**************************************************************************/
3 /* IBM eServer i/pSeries Virtual Ethernet Device Driver */
4 /* Copyright (C) 2003 IBM Corp. */
5 /* Originally written by Dave Larson (larson1@us.ibm.com) */
6 /* Maintained by Santiago Leon (santil@us.ibm.com) */
8 /* This program is free software; you can redistribute it and/or modify */
9 /* it under the terms of the GNU General Public License as published by */
10 /* the Free Software Foundation; either version 2 of the License, or */
11 /* (at your option) any later version. */
13 /* This program is distributed in the hope that it will be useful, */
14 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
15 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
16 /* GNU General Public License for more details. */
18 /* You should have received a copy of the GNU General Public License */
19 /* along with this program; if not, write to the Free Software */
20 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */
23 /* This module contains the implementation of a virtual ethernet device */
24 /* for use with IBM i/pSeries LPAR Linux. It utilizes the logical LAN */
25 /* option of the RS/6000 Platform Architechture to interface with virtual */
26 /* ethernet NICs that are presented to the partition by the hypervisor. */
28 /**************************************************************************/
31 - remove frag processing code - no longer needed
32 - add support for sysfs
33 - possibly remove procfs support
36 #include <linux/config.h>
37 #include <linux/module.h>
38 #include <linux/version.h>
39 #include <linux/types.h>
40 #include <linux/errno.h>
41 #include <linux/ioport.h>
42 #include <linux/dma-mapping.h>
43 #include <linux/kernel.h>
44 #include <linux/netdevice.h>
45 #include <linux/etherdevice.h>
46 #include <linux/skbuff.h>
47 #include <linux/init.h>
48 #include <linux/delay.h>
50 #include <linux/ethtool.h>
51 #include <linux/proc_fs.h>
52 #include <asm/semaphore.h>
53 #include <asm/hvcall.h>
54 #include <asm/atomic.h>
55 #include <asm/iommu.h>
57 #include <asm/uaccess.h>
58 #include <linux/seq_file.h>
64 #define ibmveth_printk(fmt, args...) \
65 printk(KERN_INFO "%s: " fmt, __FILE__, ## args)
67 #define ibmveth_error_printk(fmt, args...) \
68 printk(KERN_ERR "(%s:%3.3d ua:%x) ERROR: " fmt, __FILE__, __LINE__ , adapter->vdev->unit_address, ## args)
71 #define ibmveth_debug_printk_no_adapter(fmt, args...) \
72 printk(KERN_DEBUG "(%s:%3.3d): " fmt, __FILE__, __LINE__ , ## args)
73 #define ibmveth_debug_printk(fmt, args...) \
74 printk(KERN_DEBUG "(%s:%3.3d ua:%x): " fmt, __FILE__, __LINE__ , adapter->vdev->unit_address, ## args)
75 #define ibmveth_assert(expr) \
77 printk(KERN_DEBUG "assertion failed (%s:%3.3d ua:%x): %s\n", __FILE__, __LINE__, adapter->vdev->unit_address, #expr); \
81 #define ibmveth_debug_printk_no_adapter(fmt, args...)
82 #define ibmveth_debug_printk(fmt, args...)
83 #define ibmveth_assert(expr)
86 static int ibmveth_open(struct net_device
*dev
);
87 static int ibmveth_close(struct net_device
*dev
);
88 static int ibmveth_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
);
89 static int ibmveth_poll(struct net_device
*dev
, int *budget
);
90 static int ibmveth_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
);
91 static struct net_device_stats
*ibmveth_get_stats(struct net_device
*dev
);
92 static void ibmveth_set_multicast_list(struct net_device
*dev
);
93 static int ibmveth_change_mtu(struct net_device
*dev
, int new_mtu
);
94 static void ibmveth_proc_register_driver(void);
95 static void ibmveth_proc_unregister_driver(void);
96 static void ibmveth_proc_register_adapter(struct ibmveth_adapter
*adapter
);
97 static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter
*adapter
);
98 static irqreturn_t
ibmveth_interrupt(int irq
, void *dev_instance
, struct pt_regs
*regs
);
100 #ifdef CONFIG_PROC_FS
101 #define IBMVETH_PROC_DIR "ibmveth"
102 static struct proc_dir_entry
*ibmveth_proc_dir
;
105 static const char ibmveth_driver_name
[] = "ibmveth";
106 static const char ibmveth_driver_string
[] = "IBM i/pSeries Virtual Ethernet Driver";
107 #define ibmveth_driver_version "1.02"
109 MODULE_AUTHOR("Santiago Leon <santil@us.ibm.com>");
110 MODULE_DESCRIPTION("IBM i/pSeries Virtual Ethernet Driver");
111 MODULE_LICENSE("GPL");
112 MODULE_VERSION(ibmveth_driver_version
);
114 /* simple methods of getting data from the current rxq entry */
115 static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter
*adapter
)
117 return (adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].toggle
== adapter
->rx_queue
.toggle
);
120 static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter
*adapter
)
122 return (adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].valid
);
125 static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter
*adapter
)
127 return (adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].offset
);
130 static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter
*adapter
)
132 return (adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].length
);
135 /* setup the initial settings for a buffer pool */
136 static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool
*pool
, u32 pool_index
, u32 pool_size
, u32 buff_size
)
138 pool
->size
= pool_size
;
139 pool
->index
= pool_index
;
140 pool
->buff_size
= buff_size
;
141 pool
->threshold
= pool_size
/ 2;
144 /* allocate and setup an buffer pool - called during open */
145 static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool
*pool
)
149 pool
->free_map
= kmalloc(sizeof(u16
) * pool
->size
, GFP_KERNEL
);
151 if(!pool
->free_map
) {
155 pool
->dma_addr
= kmalloc(sizeof(dma_addr_t
) * pool
->size
, GFP_KERNEL
);
156 if(!pool
->dma_addr
) {
157 kfree(pool
->free_map
);
158 pool
->free_map
= NULL
;
162 pool
->skbuff
= kmalloc(sizeof(void*) * pool
->size
, GFP_KERNEL
);
165 kfree(pool
->dma_addr
);
166 pool
->dma_addr
= NULL
;
168 kfree(pool
->free_map
);
169 pool
->free_map
= NULL
;
173 memset(pool
->skbuff
, 0, sizeof(void*) * pool
->size
);
174 memset(pool
->dma_addr
, 0, sizeof(dma_addr_t
) * pool
->size
);
176 for(i
= 0; i
< pool
->size
; ++i
) {
177 pool
->free_map
[i
] = i
;
180 atomic_set(&pool
->available
, 0);
181 pool
->producer_index
= 0;
182 pool
->consumer_index
= 0;
187 /* replenish the buffers for a pool. note that we don't need to
188 * skb_reserve these since they are used for incoming...
190 static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter
*adapter
, struct ibmveth_buff_pool
*pool
)
193 u32 count
= pool
->size
- atomic_read(&pool
->available
);
194 u32 buffers_added
= 0;
198 for(i
= 0; i
< count
; ++i
) {
200 unsigned int free_index
, index
;
202 union ibmveth_buf_desc desc
;
203 unsigned long lpar_rc
;
206 skb
= alloc_skb(pool
->buff_size
, GFP_ATOMIC
);
209 ibmveth_debug_printk("replenish: unable to allocate skb\n");
210 adapter
->replenish_no_mem
++;
214 free_index
= pool
->consumer_index
++ % pool
->size
;
215 index
= pool
->free_map
[free_index
];
217 ibmveth_assert(index
!= IBM_VETH_INVALID_MAP
);
218 ibmveth_assert(pool
->skbuff
[index
] == NULL
);
220 dma_addr
= vio_map_single(adapter
->vdev
, skb
->data
, pool
->buff_size
, DMA_FROM_DEVICE
);
222 pool
->free_map
[free_index
] = IBM_VETH_INVALID_MAP
;
223 pool
->dma_addr
[index
] = dma_addr
;
224 pool
->skbuff
[index
] = skb
;
226 correlator
= ((u64
)pool
->index
<< 32) | index
;
227 *(u64
*)skb
->data
= correlator
;
230 desc
.fields
.valid
= 1;
231 desc
.fields
.length
= pool
->buff_size
;
232 desc
.fields
.address
= dma_addr
;
234 lpar_rc
= h_add_logical_lan_buffer(adapter
->vdev
->unit_address
, desc
.desc
);
236 if(lpar_rc
!= H_Success
) {
237 pool
->free_map
[free_index
] = IBM_VETH_INVALID_MAP
;
238 pool
->skbuff
[index
] = NULL
;
239 pool
->consumer_index
--;
240 vio_unmap_single(adapter
->vdev
, pool
->dma_addr
[index
], pool
->buff_size
, DMA_FROM_DEVICE
);
241 dev_kfree_skb_any(skb
);
242 adapter
->replenish_add_buff_failure
++;
246 adapter
->replenish_add_buff_success
++;
251 atomic_add(buffers_added
, &(pool
->available
));
254 /* check if replenishing is needed. */
255 static inline int ibmveth_is_replenishing_needed(struct ibmveth_adapter
*adapter
)
257 return ((atomic_read(&adapter
->rx_buff_pool
[0].available
) < adapter
->rx_buff_pool
[0].threshold
) ||
258 (atomic_read(&adapter
->rx_buff_pool
[1].available
) < adapter
->rx_buff_pool
[1].threshold
) ||
259 (atomic_read(&adapter
->rx_buff_pool
[2].available
) < adapter
->rx_buff_pool
[2].threshold
));
262 /* replenish tasklet routine */
263 static void ibmveth_replenish_task(struct ibmveth_adapter
*adapter
)
265 adapter
->replenish_task_cycles
++;
267 ibmveth_replenish_buffer_pool(adapter
, &adapter
->rx_buff_pool
[0]);
268 ibmveth_replenish_buffer_pool(adapter
, &adapter
->rx_buff_pool
[1]);
269 ibmveth_replenish_buffer_pool(adapter
, &adapter
->rx_buff_pool
[2]);
271 adapter
->rx_no_buffer
= *(u64
*)(((char*)adapter
->buffer_list_addr
) + 4096 - 8);
273 atomic_inc(&adapter
->not_replenishing
);
276 /* kick the replenish tasklet if we need replenishing and it isn't already running */
277 static inline void ibmveth_schedule_replenishing(struct ibmveth_adapter
*adapter
)
279 if(ibmveth_is_replenishing_needed(adapter
) &&
280 (atomic_dec_if_positive(&adapter
->not_replenishing
) == 0)) {
281 schedule_work(&adapter
->replenish_task
);
285 /* empty and free ana buffer pool - also used to do cleanup in error paths */
286 static void ibmveth_free_buffer_pool(struct ibmveth_adapter
*adapter
, struct ibmveth_buff_pool
*pool
)
291 kfree(pool
->free_map
);
292 pool
->free_map
= NULL
;
295 if(pool
->skbuff
&& pool
->dma_addr
) {
296 for(i
= 0; i
< pool
->size
; ++i
) {
297 struct sk_buff
*skb
= pool
->skbuff
[i
];
299 vio_unmap_single(adapter
->vdev
,
303 dev_kfree_skb_any(skb
);
304 pool
->skbuff
[i
] = NULL
;
310 kfree(pool
->dma_addr
);
311 pool
->dma_addr
= NULL
;
320 /* remove a buffer from a pool */
321 static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter
*adapter
, u64 correlator
)
323 unsigned int pool
= correlator
>> 32;
324 unsigned int index
= correlator
& 0xffffffffUL
;
325 unsigned int free_index
;
328 ibmveth_assert(pool
< IbmVethNumBufferPools
);
329 ibmveth_assert(index
< adapter
->rx_buff_pool
[pool
].size
);
331 skb
= adapter
->rx_buff_pool
[pool
].skbuff
[index
];
333 ibmveth_assert(skb
!= NULL
);
335 adapter
->rx_buff_pool
[pool
].skbuff
[index
] = NULL
;
337 vio_unmap_single(adapter
->vdev
,
338 adapter
->rx_buff_pool
[pool
].dma_addr
[index
],
339 adapter
->rx_buff_pool
[pool
].buff_size
,
342 free_index
= adapter
->rx_buff_pool
[pool
].producer_index
++ % adapter
->rx_buff_pool
[pool
].size
;
343 adapter
->rx_buff_pool
[pool
].free_map
[free_index
] = index
;
347 atomic_dec(&(adapter
->rx_buff_pool
[pool
].available
));
350 /* get the current buffer on the rx queue */
351 static inline struct sk_buff
*ibmveth_rxq_get_buffer(struct ibmveth_adapter
*adapter
)
353 u64 correlator
= adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
;
354 unsigned int pool
= correlator
>> 32;
355 unsigned int index
= correlator
& 0xffffffffUL
;
357 ibmveth_assert(pool
< IbmVethNumBufferPools
);
358 ibmveth_assert(index
< adapter
->rx_buff_pool
[pool
].size
);
360 return adapter
->rx_buff_pool
[pool
].skbuff
[index
];
363 /* recycle the current buffer on the rx queue */
364 static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter
*adapter
)
366 u32 q_index
= adapter
->rx_queue
.index
;
367 u64 correlator
= adapter
->rx_queue
.queue_addr
[q_index
].correlator
;
368 unsigned int pool
= correlator
>> 32;
369 unsigned int index
= correlator
& 0xffffffffUL
;
370 union ibmveth_buf_desc desc
;
371 unsigned long lpar_rc
;
373 ibmveth_assert(pool
< IbmVethNumBufferPools
);
374 ibmveth_assert(index
< adapter
->rx_buff_pool
[pool
].size
);
377 desc
.fields
.valid
= 1;
378 desc
.fields
.length
= adapter
->rx_buff_pool
[pool
].buff_size
;
379 desc
.fields
.address
= adapter
->rx_buff_pool
[pool
].dma_addr
[index
];
381 lpar_rc
= h_add_logical_lan_buffer(adapter
->vdev
->unit_address
, desc
.desc
);
383 if(lpar_rc
!= H_Success
) {
384 ibmveth_debug_printk("h_add_logical_lan_buffer failed during recycle rc=%ld", lpar_rc
);
385 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
388 if(++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
389 adapter
->rx_queue
.index
= 0;
390 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
394 static inline void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter
*adapter
)
396 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
398 if(++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
399 adapter
->rx_queue
.index
= 0;
400 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
404 static void ibmveth_cleanup(struct ibmveth_adapter
*adapter
)
406 if(adapter
->buffer_list_addr
!= NULL
) {
407 if(!dma_mapping_error(adapter
->buffer_list_dma
)) {
408 vio_unmap_single(adapter
->vdev
, adapter
->buffer_list_dma
, 4096, DMA_BIDIRECTIONAL
);
409 adapter
->buffer_list_dma
= DMA_ERROR_CODE
;
411 free_page((unsigned long)adapter
->buffer_list_addr
);
412 adapter
->buffer_list_addr
= NULL
;
415 if(adapter
->filter_list_addr
!= NULL
) {
416 if(!dma_mapping_error(adapter
->filter_list_dma
)) {
417 vio_unmap_single(adapter
->vdev
, adapter
->filter_list_dma
, 4096, DMA_BIDIRECTIONAL
);
418 adapter
->filter_list_dma
= DMA_ERROR_CODE
;
420 free_page((unsigned long)adapter
->filter_list_addr
);
421 adapter
->filter_list_addr
= NULL
;
424 if(adapter
->rx_queue
.queue_addr
!= NULL
) {
425 if(!dma_mapping_error(adapter
->rx_queue
.queue_dma
)) {
426 vio_unmap_single(adapter
->vdev
, adapter
->rx_queue
.queue_dma
, adapter
->rx_queue
.queue_len
, DMA_BIDIRECTIONAL
);
427 adapter
->rx_queue
.queue_dma
= DMA_ERROR_CODE
;
429 kfree(adapter
->rx_queue
.queue_addr
);
430 adapter
->rx_queue
.queue_addr
= NULL
;
433 ibmveth_free_buffer_pool(adapter
, &adapter
->rx_buff_pool
[0]);
434 ibmveth_free_buffer_pool(adapter
, &adapter
->rx_buff_pool
[1]);
435 ibmveth_free_buffer_pool(adapter
, &adapter
->rx_buff_pool
[2]);
438 static int ibmveth_open(struct net_device
*netdev
)
440 struct ibmveth_adapter
*adapter
= netdev
->priv
;
443 unsigned long lpar_rc
;
445 union ibmveth_buf_desc rxq_desc
;
447 ibmveth_debug_printk("open starting\n");
450 adapter
->rx_buff_pool
[0].size
+
451 adapter
->rx_buff_pool
[1].size
+
452 adapter
->rx_buff_pool
[2].size
+ 1;
454 adapter
->buffer_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
455 adapter
->filter_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
457 if(!adapter
->buffer_list_addr
|| !adapter
->filter_list_addr
) {
458 ibmveth_error_printk("unable to allocate filter or buffer list pages\n");
459 ibmveth_cleanup(adapter
);
463 adapter
->rx_queue
.queue_len
= sizeof(struct ibmveth_rx_q_entry
) * rxq_entries
;
464 adapter
->rx_queue
.queue_addr
= kmalloc(adapter
->rx_queue
.queue_len
, GFP_KERNEL
);
466 if(!adapter
->rx_queue
.queue_addr
) {
467 ibmveth_error_printk("unable to allocate rx queue pages\n");
468 ibmveth_cleanup(adapter
);
472 adapter
->buffer_list_dma
= vio_map_single(adapter
->vdev
, adapter
->buffer_list_addr
, 4096, DMA_BIDIRECTIONAL
);
473 adapter
->filter_list_dma
= vio_map_single(adapter
->vdev
, adapter
->filter_list_addr
, 4096, DMA_BIDIRECTIONAL
);
474 adapter
->rx_queue
.queue_dma
= vio_map_single(adapter
->vdev
, adapter
->rx_queue
.queue_addr
, adapter
->rx_queue
.queue_len
, DMA_BIDIRECTIONAL
);
476 if((dma_mapping_error(adapter
->buffer_list_dma
) ) ||
477 (dma_mapping_error(adapter
->filter_list_dma
)) ||
478 (dma_mapping_error(adapter
->rx_queue
.queue_dma
))) {
479 ibmveth_error_printk("unable to map filter or buffer list pages\n");
480 ibmveth_cleanup(adapter
);
484 adapter
->rx_queue
.index
= 0;
485 adapter
->rx_queue
.num_slots
= rxq_entries
;
486 adapter
->rx_queue
.toggle
= 1;
488 if(ibmveth_alloc_buffer_pool(&adapter
->rx_buff_pool
[0]) ||
489 ibmveth_alloc_buffer_pool(&adapter
->rx_buff_pool
[1]) ||
490 ibmveth_alloc_buffer_pool(&adapter
->rx_buff_pool
[2]))
492 ibmveth_error_printk("unable to allocate buffer pools\n");
493 ibmveth_cleanup(adapter
);
497 memcpy(&mac_address
, netdev
->dev_addr
, netdev
->addr_len
);
498 mac_address
= mac_address
>> 16;
501 rxq_desc
.fields
.valid
= 1;
502 rxq_desc
.fields
.length
= adapter
->rx_queue
.queue_len
;
503 rxq_desc
.fields
.address
= adapter
->rx_queue
.queue_dma
;
505 ibmveth_debug_printk("buffer list @ 0x%p\n", adapter
->buffer_list_addr
);
506 ibmveth_debug_printk("filter list @ 0x%p\n", adapter
->filter_list_addr
);
507 ibmveth_debug_printk("receive q @ 0x%p\n", adapter
->rx_queue
.queue_addr
);
510 lpar_rc
= h_register_logical_lan(adapter
->vdev
->unit_address
,
511 adapter
->buffer_list_dma
,
513 adapter
->filter_list_dma
,
516 if(lpar_rc
!= H_Success
) {
517 ibmveth_error_printk("h_register_logical_lan failed with %ld\n", lpar_rc
);
518 ibmveth_error_printk("buffer TCE:0x%x filter TCE:0x%x rxq desc:0x%lx MAC:0x%lx\n",
519 adapter
->buffer_list_dma
,
520 adapter
->filter_list_dma
,
523 ibmveth_cleanup(adapter
);
527 ibmveth_debug_printk("registering irq 0x%x\n", netdev
->irq
);
528 if((rc
= request_irq(netdev
->irq
, &ibmveth_interrupt
, 0, netdev
->name
, netdev
)) != 0) {
529 ibmveth_error_printk("unable to request irq 0x%x, rc %d\n", netdev
->irq
, rc
);
531 rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
532 } while (H_isLongBusy(rc
) || (rc
== H_Busy
));
534 ibmveth_cleanup(adapter
);
538 netif_start_queue(netdev
);
540 ibmveth_debug_printk("scheduling initial replenish cycle\n");
541 ibmveth_schedule_replenishing(adapter
);
543 ibmveth_debug_printk("open complete\n");
548 static int ibmveth_close(struct net_device
*netdev
)
550 struct ibmveth_adapter
*adapter
= netdev
->priv
;
553 ibmveth_debug_printk("close starting\n");
555 netif_stop_queue(netdev
);
557 free_irq(netdev
->irq
, netdev
);
559 cancel_delayed_work(&adapter
->replenish_task
);
560 flush_scheduled_work();
563 lpar_rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
564 } while (H_isLongBusy(lpar_rc
) || (lpar_rc
== H_Busy
));
566 if(lpar_rc
!= H_Success
)
568 ibmveth_error_printk("h_free_logical_lan failed with %lx, continuing with close\n",
572 adapter
->rx_no_buffer
= *(u64
*)(((char*)adapter
->buffer_list_addr
) + 4096 - 8);
574 ibmveth_cleanup(adapter
);
576 ibmveth_debug_printk("close complete\n");
581 static int netdev_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
) {
582 cmd
->supported
= (SUPPORTED_1000baseT_Full
| SUPPORTED_Autoneg
| SUPPORTED_FIBRE
);
583 cmd
->advertising
= (ADVERTISED_1000baseT_Full
| ADVERTISED_Autoneg
| ADVERTISED_FIBRE
);
584 cmd
->speed
= SPEED_1000
;
585 cmd
->duplex
= DUPLEX_FULL
;
586 cmd
->port
= PORT_FIBRE
;
587 cmd
->phy_address
= 0;
588 cmd
->transceiver
= XCVR_INTERNAL
;
589 cmd
->autoneg
= AUTONEG_ENABLE
;
595 static void netdev_get_drvinfo (struct net_device
*dev
, struct ethtool_drvinfo
*info
) {
596 strncpy(info
->driver
, ibmveth_driver_name
, sizeof(info
->driver
) - 1);
597 strncpy(info
->version
, ibmveth_driver_version
, sizeof(info
->version
) - 1);
600 static u32
netdev_get_link(struct net_device
*dev
) {
604 static struct ethtool_ops netdev_ethtool_ops
= {
605 .get_drvinfo
= netdev_get_drvinfo
,
606 .get_settings
= netdev_get_settings
,
607 .get_link
= netdev_get_link
,
608 .get_sg
= ethtool_op_get_sg
,
609 .get_tx_csum
= ethtool_op_get_tx_csum
,
612 static int ibmveth_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
617 #define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1))
619 static int ibmveth_start_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
621 struct ibmveth_adapter
*adapter
= netdev
->priv
;
622 union ibmveth_buf_desc desc
[IbmVethMaxSendFrags
];
623 unsigned long lpar_rc
;
624 int nfrags
= 0, curfrag
;
625 unsigned long correlator
;
626 unsigned int retry_count
;
628 if ((skb_shinfo(skb
)->nr_frags
+ 1) > IbmVethMaxSendFrags
) {
629 adapter
->stats
.tx_dropped
++;
634 memset(&desc
, 0, sizeof(desc
));
636 /* nfrags = number of frags after the initial fragment */
637 nfrags
= skb_shinfo(skb
)->nr_frags
;
640 adapter
->tx_multidesc_send
++;
642 /* map the initial fragment */
643 desc
[0].fields
.length
= nfrags
? skb
->len
- skb
->data_len
: skb
->len
;
644 desc
[0].fields
.address
= vio_map_single(adapter
->vdev
, skb
->data
,
645 desc
[0].fields
.length
, DMA_TO_DEVICE
);
646 desc
[0].fields
.valid
= 1;
648 if(dma_mapping_error(desc
[0].fields
.address
)) {
649 ibmveth_error_printk("tx: unable to map initial fragment\n");
650 adapter
->tx_map_failed
++;
651 adapter
->stats
.tx_dropped
++;
658 /* map fragments past the initial portion if there are any */
660 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[curfrag
];
661 desc
[curfrag
+1].fields
.address
662 = vio_map_single(adapter
->vdev
,
663 page_address(frag
->page
) + frag
->page_offset
,
664 frag
->size
, DMA_TO_DEVICE
);
665 desc
[curfrag
+1].fields
.length
= frag
->size
;
666 desc
[curfrag
+1].fields
.valid
= 1;
668 if(dma_mapping_error(desc
[curfrag
+1].fields
.address
)) {
669 ibmveth_error_printk("tx: unable to map fragment %d\n", curfrag
);
670 adapter
->tx_map_failed
++;
671 adapter
->stats
.tx_dropped
++;
672 /* Free all the mappings we just created */
673 while(curfrag
< nfrags
) {
674 vio_unmap_single(adapter
->vdev
,
675 desc
[curfrag
+1].fields
.address
,
676 desc
[curfrag
+1].fields
.length
,
685 /* send the frame. Arbitrarily set retrycount to 1024 */
689 lpar_rc
= h_send_logical_lan(adapter
->vdev
->unit_address
,
697 } while ((lpar_rc
== H_Busy
) && (retry_count
--));
699 if(lpar_rc
!= H_Success
&& lpar_rc
!= H_Dropped
) {
701 ibmveth_error_printk("tx: h_send_logical_lan failed with rc=%ld\n", lpar_rc
);
702 for(i
= 0; i
< 6; i
++) {
703 ibmveth_error_printk("tx: desc[%i] valid=%d, len=%d, address=0x%d\n", i
,
704 desc
[i
].fields
.valid
, desc
[i
].fields
.length
, desc
[i
].fields
.address
);
706 adapter
->tx_send_failed
++;
707 adapter
->stats
.tx_dropped
++;
709 adapter
->stats
.tx_packets
++;
710 adapter
->stats
.tx_bytes
+= skb
->len
;
714 vio_unmap_single(adapter
->vdev
, desc
[nfrags
].fields
.address
, desc
[nfrags
].fields
.length
, DMA_TO_DEVICE
);
715 } while(--nfrags
>= 0);
721 static int ibmveth_poll(struct net_device
*netdev
, int *budget
)
723 struct ibmveth_adapter
*adapter
= netdev
->priv
;
724 int max_frames_to_process
= netdev
->quota
;
725 int frames_processed
= 0;
727 unsigned long lpar_rc
;
731 struct net_device
*netdev
= adapter
->netdev
;
733 if(ibmveth_rxq_pending_buffer(adapter
)) {
738 if(!ibmveth_rxq_buffer_valid(adapter
)) {
739 wmb(); /* suggested by larson1 */
740 adapter
->rx_invalid_buffer
++;
741 ibmveth_debug_printk("recycling invalid buffer\n");
742 ibmveth_rxq_recycle_buffer(adapter
);
744 int length
= ibmveth_rxq_frame_length(adapter
);
745 int offset
= ibmveth_rxq_frame_offset(adapter
);
746 skb
= ibmveth_rxq_get_buffer(adapter
);
748 ibmveth_rxq_harvest_buffer(adapter
);
750 skb_reserve(skb
, offset
);
751 skb_put(skb
, length
);
753 skb
->protocol
= eth_type_trans(skb
, netdev
);
755 netif_receive_skb(skb
); /* send it up */
757 adapter
->stats
.rx_packets
++;
758 adapter
->stats
.rx_bytes
+= length
;
764 } while(more_work
&& (frames_processed
< max_frames_to_process
));
766 ibmveth_schedule_replenishing(adapter
);
769 /* more work to do - return that we are not done yet */
770 netdev
->quota
-= frames_processed
;
771 *budget
-= frames_processed
;
775 /* we think we are done - reenable interrupts, then check once more to make sure we are done */
776 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_ENABLE
);
778 ibmveth_assert(lpar_rc
== H_Success
);
780 netif_rx_complete(netdev
);
782 if(ibmveth_rxq_pending_buffer(adapter
) && netif_rx_reschedule(netdev
, frames_processed
))
784 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
785 ibmveth_assert(lpar_rc
== H_Success
);
790 netdev
->quota
-= frames_processed
;
791 *budget
-= frames_processed
;
793 /* we really are done */
797 static irqreturn_t
ibmveth_interrupt(int irq
, void *dev_instance
, struct pt_regs
*regs
)
799 struct net_device
*netdev
= dev_instance
;
800 struct ibmveth_adapter
*adapter
= netdev
->priv
;
801 unsigned long lpar_rc
;
803 if(netif_rx_schedule_prep(netdev
)) {
804 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
805 ibmveth_assert(lpar_rc
== H_Success
);
806 __netif_rx_schedule(netdev
);
811 static struct net_device_stats
*ibmveth_get_stats(struct net_device
*dev
)
813 struct ibmveth_adapter
*adapter
= dev
->priv
;
814 return &adapter
->stats
;
817 static void ibmveth_set_multicast_list(struct net_device
*netdev
)
819 struct ibmveth_adapter
*adapter
= netdev
->priv
;
820 unsigned long lpar_rc
;
822 if((netdev
->flags
& IFF_PROMISC
) || (netdev
->mc_count
> adapter
->mcastFilterSize
)) {
823 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
824 IbmVethMcastEnableRecv
|
825 IbmVethMcastDisableFiltering
,
827 if(lpar_rc
!= H_Success
) {
828 ibmveth_error_printk("h_multicast_ctrl rc=%ld when entering promisc mode\n", lpar_rc
);
831 struct dev_mc_list
*mclist
= netdev
->mc_list
;
833 /* clear the filter table & disable filtering */
834 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
835 IbmVethMcastEnableRecv
|
836 IbmVethMcastDisableFiltering
|
837 IbmVethMcastClearFilterTable
,
839 if(lpar_rc
!= H_Success
) {
840 ibmveth_error_printk("h_multicast_ctrl rc=%ld when attempting to clear filter table\n", lpar_rc
);
842 /* add the addresses to the filter table */
843 for(i
= 0; i
< netdev
->mc_count
; ++i
, mclist
= mclist
->next
) {
844 // add the multicast address to the filter table
845 unsigned long mcast_addr
= 0;
846 memcpy(((char *)&mcast_addr
)+2, mclist
->dmi_addr
, 6);
847 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
848 IbmVethMcastAddFilter
,
850 if(lpar_rc
!= H_Success
) {
851 ibmveth_error_printk("h_multicast_ctrl rc=%ld when adding an entry to the filter table\n", lpar_rc
);
855 /* re-enable filtering */
856 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
857 IbmVethMcastEnableFiltering
,
859 if(lpar_rc
!= H_Success
) {
860 ibmveth_error_printk("h_multicast_ctrl rc=%ld when enabling filtering\n", lpar_rc
);
865 static int ibmveth_change_mtu(struct net_device
*dev
, int new_mtu
)
867 if ((new_mtu
< 68) || (new_mtu
> (1<<20)))
873 static int __devinit
ibmveth_probe(struct vio_dev
*dev
, const struct vio_device_id
*id
)
876 struct net_device
*netdev
;
877 struct ibmveth_adapter
*adapter
;
879 unsigned char *mac_addr_p
;
880 unsigned int *mcastFilterSize_p
;
883 ibmveth_debug_printk_no_adapter("entering ibmveth_probe for UA 0x%x\n",
886 mac_addr_p
= (unsigned char *) vio_get_attribute(dev
, VETH_MAC_ADDR
, 0);
888 ibmveth_error_printk("Can't find VETH_MAC_ADDR attribute\n");
892 mcastFilterSize_p
= (unsigned int *) vio_get_attribute(dev
, VETH_MCAST_FILTER_SIZE
, 0);
893 if(!mcastFilterSize_p
) {
894 ibmveth_error_printk("Can't find VETH_MCAST_FILTER_SIZE attribute\n");
898 netdev
= alloc_etherdev(sizeof(struct ibmveth_adapter
));
903 SET_MODULE_OWNER(netdev
);
905 adapter
= netdev
->priv
;
906 memset(adapter
, 0, sizeof(adapter
));
907 dev
->dev
.driver_data
= netdev
;
910 adapter
->netdev
= netdev
;
911 adapter
->mcastFilterSize
= *mcastFilterSize_p
;
913 /* Some older boxes running PHYP non-natively have an OF that
914 returns a 8-byte local-mac-address field (and the first
915 2 bytes have to be ignored) while newer boxes' OF return
916 a 6-byte field. Note that IEEE 1275 specifies that
917 local-mac-address must be a 6-byte field.
918 The RPA doc specifies that the first byte must be 10b, so
919 we'll just look for it to solve this 8 vs. 6 byte field issue */
921 if ((*mac_addr_p
& 0x3) != 0x02)
924 adapter
->mac_addr
= 0;
925 memcpy(&adapter
->mac_addr
, mac_addr_p
, 6);
927 adapter
->liobn
= dev
->iommu_table
->it_index
;
929 netdev
->irq
= dev
->irq
;
930 netdev
->open
= ibmveth_open
;
931 netdev
->poll
= ibmveth_poll
;
933 netdev
->stop
= ibmveth_close
;
934 netdev
->hard_start_xmit
= ibmveth_start_xmit
;
935 netdev
->get_stats
= ibmveth_get_stats
;
936 netdev
->set_multicast_list
= ibmveth_set_multicast_list
;
937 netdev
->do_ioctl
= ibmveth_ioctl
;
938 netdev
->ethtool_ops
= &netdev_ethtool_ops
;
939 netdev
->change_mtu
= ibmveth_change_mtu
;
940 SET_NETDEV_DEV(netdev
, &dev
->dev
);
942 memcpy(&netdev
->dev_addr
, &adapter
->mac_addr
, netdev
->addr_len
);
944 ibmveth_init_buffer_pool(&adapter
->rx_buff_pool
[0], 0, IbmVethPool0DftCnt
, IbmVethPool0DftSize
);
945 ibmveth_init_buffer_pool(&adapter
->rx_buff_pool
[1], 1, IbmVethPool1DftCnt
, IbmVethPool1DftSize
);
946 ibmveth_init_buffer_pool(&adapter
->rx_buff_pool
[2], 2, IbmVethPool2DftCnt
, IbmVethPool2DftSize
);
948 ibmveth_debug_printk("adapter @ 0x%p\n", adapter
);
950 INIT_WORK(&adapter
->replenish_task
, (void*)ibmveth_replenish_task
, (void*)adapter
);
952 adapter
->buffer_list_dma
= DMA_ERROR_CODE
;
953 adapter
->filter_list_dma
= DMA_ERROR_CODE
;
954 adapter
->rx_queue
.queue_dma
= DMA_ERROR_CODE
;
956 atomic_set(&adapter
->not_replenishing
, 1);
958 ibmveth_debug_printk("registering netdev...\n");
960 rc
= register_netdev(netdev
);
963 ibmveth_debug_printk("failed to register netdev rc=%d\n", rc
);
968 ibmveth_debug_printk("registered\n");
970 ibmveth_proc_register_adapter(adapter
);
975 static int __devexit
ibmveth_remove(struct vio_dev
*dev
)
977 struct net_device
*netdev
= dev
->dev
.driver_data
;
978 struct ibmveth_adapter
*adapter
= netdev
->priv
;
980 unregister_netdev(netdev
);
982 ibmveth_proc_unregister_adapter(adapter
);
988 #ifdef CONFIG_PROC_FS
989 static void ibmveth_proc_register_driver(void)
991 ibmveth_proc_dir
= create_proc_entry(IBMVETH_PROC_DIR
, S_IFDIR
, proc_net
);
992 if (ibmveth_proc_dir
) {
993 SET_MODULE_OWNER(ibmveth_proc_dir
);
997 static void ibmveth_proc_unregister_driver(void)
999 remove_proc_entry(IBMVETH_PROC_DIR
, proc_net
);
1002 static void *ibmveth_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1011 static void *ibmveth_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1017 static void ibmveth_seq_stop(struct seq_file
*seq
, void *v
)
1021 static int ibmveth_seq_show(struct seq_file
*seq
, void *v
)
1023 struct ibmveth_adapter
*adapter
= seq
->private;
1024 char *current_mac
= ((char*) &adapter
->netdev
->dev_addr
);
1025 char *firmware_mac
= ((char*) &adapter
->mac_addr
) ;
1027 seq_printf(seq
, "%s %s\n\n", ibmveth_driver_string
, ibmveth_driver_version
);
1029 seq_printf(seq
, "Unit Address: 0x%x\n", adapter
->vdev
->unit_address
);
1030 seq_printf(seq
, "LIOBN: 0x%lx\n", adapter
->liobn
);
1031 seq_printf(seq
, "Current MAC: %02X:%02X:%02X:%02X:%02X:%02X\n",
1032 current_mac
[0], current_mac
[1], current_mac
[2],
1033 current_mac
[3], current_mac
[4], current_mac
[5]);
1034 seq_printf(seq
, "Firmware MAC: %02X:%02X:%02X:%02X:%02X:%02X\n",
1035 firmware_mac
[0], firmware_mac
[1], firmware_mac
[2],
1036 firmware_mac
[3], firmware_mac
[4], firmware_mac
[5]);
1038 seq_printf(seq
, "\nAdapter Statistics:\n");
1039 seq_printf(seq
, " TX: skbuffs linearized: %ld\n", adapter
->tx_linearized
);
1040 seq_printf(seq
, " multi-descriptor sends: %ld\n", adapter
->tx_multidesc_send
);
1041 seq_printf(seq
, " skb_linearize failures: %ld\n", adapter
->tx_linearize_failed
);
1042 seq_printf(seq
, " vio_map_single failres: %ld\n", adapter
->tx_map_failed
);
1043 seq_printf(seq
, " send failures: %ld\n", adapter
->tx_send_failed
);
1044 seq_printf(seq
, " RX: replenish task cycles: %ld\n", adapter
->replenish_task_cycles
);
1045 seq_printf(seq
, " alloc_skb_failures: %ld\n", adapter
->replenish_no_mem
);
1046 seq_printf(seq
, " add buffer failures: %ld\n", adapter
->replenish_add_buff_failure
);
1047 seq_printf(seq
, " invalid buffers: %ld\n", adapter
->rx_invalid_buffer
);
1048 seq_printf(seq
, " no buffers: %ld\n", adapter
->rx_no_buffer
);
1052 static struct seq_operations ibmveth_seq_ops
= {
1053 .start
= ibmveth_seq_start
,
1054 .next
= ibmveth_seq_next
,
1055 .stop
= ibmveth_seq_stop
,
1056 .show
= ibmveth_seq_show
,
1059 static int ibmveth_proc_open(struct inode
*inode
, struct file
*file
)
1061 struct seq_file
*seq
;
1062 struct proc_dir_entry
*proc
;
1065 rc
= seq_open(file
, &ibmveth_seq_ops
);
1067 /* recover the pointer buried in proc_dir_entry data */
1068 seq
= file
->private_data
;
1070 seq
->private = proc
->data
;
1075 static struct file_operations ibmveth_proc_fops
= {
1076 .owner
= THIS_MODULE
,
1077 .open
= ibmveth_proc_open
,
1079 .llseek
= seq_lseek
,
1080 .release
= seq_release
,
1083 static void ibmveth_proc_register_adapter(struct ibmveth_adapter
*adapter
)
1085 struct proc_dir_entry
*entry
;
1086 if (ibmveth_proc_dir
) {
1087 entry
= create_proc_entry(adapter
->netdev
->name
, S_IFREG
, ibmveth_proc_dir
);
1089 ibmveth_error_printk("Cannot create adapter proc entry");
1091 entry
->data
= (void *) adapter
;
1092 entry
->proc_fops
= &ibmveth_proc_fops
;
1093 SET_MODULE_OWNER(entry
);
1099 static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter
*adapter
)
1101 if (ibmveth_proc_dir
) {
1102 remove_proc_entry(adapter
->netdev
->name
, ibmveth_proc_dir
);
1106 #else /* CONFIG_PROC_FS */
1107 static void ibmveth_proc_register_adapter(struct ibmveth_adapter
*adapter
)
1111 static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter
*adapter
)
1114 static void ibmveth_proc_register_driver(void)
1118 static void ibmveth_proc_unregister_driver(void)
1121 #endif /* CONFIG_PROC_FS */
1123 static struct vio_device_id ibmveth_device_table
[] __devinitdata
= {
1124 { "network", "IBM,l-lan"},
1128 MODULE_DEVICE_TABLE(vio
, ibmveth_device_table
);
1130 static struct vio_driver ibmveth_driver
= {
1131 .name
= (char *)ibmveth_driver_name
,
1132 .id_table
= ibmveth_device_table
,
1133 .probe
= ibmveth_probe
,
1134 .remove
= ibmveth_remove
1137 static int __init
ibmveth_module_init(void)
1139 ibmveth_printk("%s: %s %s\n", ibmveth_driver_name
, ibmveth_driver_string
, ibmveth_driver_version
);
1141 ibmveth_proc_register_driver();
1143 return vio_register_driver(&ibmveth_driver
);
1146 static void __exit
ibmveth_module_exit(void)
1148 vio_unregister_driver(&ibmveth_driver
);
1149 ibmveth_proc_unregister_driver();
1152 module_init(ibmveth_module_init
);
1153 module_exit(ibmveth_module_exit
);